def onAddSourceDocument(self,doctype):
'''
Slot raised when the user has selected to add a new source document.
'''
#Create a proxy source document manager for inserting documents.
srcDocManager = SourceDocumentManager(self.parentWidget())
vBoxProxy = QVBoxLayout(self._parentWidget)
self._parentWidget.connect(srcDocManager,SIGNAL("fileUploaded(PyQt_PyObject)"),
self._onSourceDocUploaded)
if doctype == TITLE_DEED:
dialogTitle = QApplication.translate("STRNode",
"Specify Title Deed File Location")
elif doctype == STATUTORY_REF_PAPER:
dialogTitle = QApplication.translate("STRNode",
"Specify Statutory Reference Paper File Location")
elif doctype == SURVEYOR_REF:
dialogTitle = QApplication.translate("STRNode",
"Specify Surveyor Reference File Location")
elif doctype == NOTARY_REF:
dialogTitle = QApplication.translate("STRNode",
"Specify Notary Reference File Location")
else:
return
docPath = self._selectSourceDocumentDialog(dialogTitle)
if not docPath.isNull():
#Register container then upload document
srcDocManager.registerContainer(vBoxProxy, doctype)
srcDocManager.insertDocumentFromFile(docPath,doctype)
def init_documents(self):
"""
Initializes the document type combobox by
populating data.
"""
self.supporting_doc_manager = SourceDocumentManager(
self.social_tenure.supporting_doc, self.str_doc_model,
self._parent)
self.create_doc_tab_populate_combobox()
self.doc_type_cbo.currentIndexChanged.connect(
self.match_doc_combo_to_tab)
self.docs_tab.currentChanged.connect(self.match_doc_tab_to_combo)
def __init__(self, entity_supporting_document, supporting_doc_model_cls,
parent=None):
"""
Class constructor.
:param entity_supporting_document: Object containing information
pertaining to document types, parent entity etc.
:type entity_supporting_document: EntitySupportingDocument
:param supporting_doc_model_cls: Class representing the data model
corresponding to the entity supporting document object.
:type supporting_doc_model_cls: object
:param parent: Parent container widget.
:type parent: QWidget
"""
QWidget.__init__(self, parent)
self._init_gui()
self._entity_supporting_doc = entity_supporting_document
#Container for document type widgets based on lookup id
self._doc_type_widgets = {}
#Init document manager
self.source_document_manager = SourceDocumentManager(
self._entity_supporting_doc,
supporting_doc_model_cls,
self
)
self._load_document_types()
#Connect signals
self._btn_add_document.clicked.connect(
self._on_add_supporting_document
)
self._cbo_doc_type.currentIndexChanged.connect(
self.on_doc_type_changed
)
self._doc_tab_container.currentChanged.connect(
self.on_tab_doc_type_changed
)
def dbmodel_from_entity(self):
"""
Format model attributes from passed entity attributes
:return:
"""
if self.entity_has_supporting_docs():
entity_object, self.doc_model = entity_model(self.entity, with_supporting_document=True)
entity_object_model = entity_object()
if hasattr(entity_object_model, 'documents'):
if self.entity.TYPE_INFO == 'SOCIAL_TENURE':
obj_doc_col = current_profile().social_tenure.supporting_doc
else:
obj_doc_col = self.entity.supporting_doc
self._doc_manager = SourceDocumentManager(
obj_doc_col, self.doc_model
)
else:
entity_object = entity_model(self.entity)
entity_object_model = entity_object()
return entity_object_model
def featToDb(self,
targettable,
columnmatch,
append,
parentdialog,
geomColumn=None,
geomCode=-1,
translator_manager=None):
"""
Performs the data import from the source layer to the STDM database.
:param targettable: Destination table name
:param columnmatch: Dictionary containing source columns as keys and target columns as the values.
:param append: True to append, false to overwrite by deleting previous records
:param parentdialog: A reference to the calling dialog.
:param translator_manager: Instance of 'stdm.data.importexport.ValueTranslatorManager'
containing value translators defined for the destination table columns.
:type translator_manager: ValueTranslatorManager
"""
# Check current profile
if self._current_profile is None:
msg = QApplication.translate(
'OGRReader',
'The current profile could not be determined.\nPlease set it '
'in the Options dialog or Configuration Wizard.')
raise ConfigurationException(msg)
if translator_manager is None:
translator_manager = ValueTranslatorManager()
# Delete existing rows in the target table if user has chosen to overwrite
if not append:
delete_table_data(targettable)
# Container for mapping column names to their corresponding values
lyr = self.getLayer()
lyr.ResetReading()
feat_defn = lyr.GetLayerDefn()
numFeat = lyr.GetFeatureCount()
# Configure progress dialog
init_val = 0
progress = QProgressDialog("", "&Cancel", init_val, numFeat,
parentdialog)
progress.setWindowModality(Qt.WindowModal)
lblMsgTemp = "Importing {0} of {1} to STDM..."
# Set entity for use in translators
destination_entity = self._data_source_entity(targettable)
for feat in lyr:
column_value_mapping = {}
column_count = 0
progress.setValue(init_val)
progressMsg = lblMsgTemp.format((init_val + 1), numFeat)
progress.setLabelText(progressMsg)
if progress.wasCanceled():
break
# Reset source document manager for new records
if destination_entity.supports_documents:
if not self._source_doc_manager is None:
self._source_doc_manager.reset()
for f in range(feat_defn.GetFieldCount()):
field_defn = feat_defn.GetFieldDefn(f)
field_name = field_defn.GetNameRef()
# Append value only if it has been defined by the user
if field_name in columnmatch:
dest_column = columnmatch[field_name]
field_value = feat.GetField(f)
# Create mapped class only once
if self._mapped_cls is None:
mapped_cls, mapped_doc_cls = self._get_mapped_class(
targettable)
if mapped_cls is None:
msg = QApplication.translate(
"OGRReader",
"Something happened that caused the "
"database table not to be mapped to the "
"corresponding model class. Please contact"
" your system administrator.")
raise RuntimeError(msg)
self._mapped_cls = mapped_cls
self._mapped_doc_cls = mapped_doc_cls
# Create source document manager if the entity supports them
if destination_entity.supports_documents:
self._source_doc_manager = SourceDocumentManager(
destination_entity.supporting_doc,
self._mapped_doc_cls)
if geomColumn is not None:
# Use geometry column SRID in the target table
self._geomType, self._targetGeomColSRID = \
geometryType(targettable, geomColumn)
'''
Check if there is a value translator defined for the
specified destination column.
'''
value_translator = translator_manager.translator(
dest_column)
if value_translator is not None:
# Set destination table entity
value_translator.entity = destination_entity
source_col_names = value_translator.source_column_names(
)
field_value_mappings = self._map_column_values(
feat, feat_defn, source_col_names)
# Set source document manager if required
if value_translator.requires_source_document_manager:
value_translator.source_document_manager = self._source_doc_manager
field_value = value_translator.referencing_column_value(
field_value_mappings)
if not isinstance(field_value, IgnoreType):
# Check column type and rename if multiple select for
# SQLAlchemy compatibility
col_obj = destination_entity.column(dest_column)
if col_obj.TYPE_INFO == 'MULTIPLE_SELECT':
lk_name = col_obj.value_list.name
dest_column = '{0}_collection'.format(lk_name)
column_value_mapping[dest_column] = field_value
# Set supporting documents
if destination_entity.supports_documents:
column_value_mapping['documents'] = \
self._source_doc_manager.model_objects()
column_count += 1
# Only insert geometry if it has been defined by the user
if geomColumn is not None:
geom = feat.GetGeometryRef()
if geom is not None:
# Check if the geometry types match
layerGeomType = geom.GetGeometryName()
# Convert polygon to multipolygon if the destination table is multi-polygon.
geom_wkb, geom_type = self.auto_fix_geom_type(
geom, layerGeomType, self._geomType)
column_value_mapping[geomColumn] = "SRID={0!s};{1}".format(
self._targetGeomColSRID, geom_wkb)
if geom_type.lower() != self._geomType.lower():
raise TypeError(
"The geometries of the source and destination columns do not match.\n" \
"Source Geometry Type: {0}, Destination Geometry Type: {1}".format(
geom_type,
self._geomType))
try:
# Insert the record
self._insertRow(targettable, column_value_mapping)
except:
progress.close()
raise
init_val += 1
progress.setValue(numFeat)
def __init__(self, plugin):
QMainWindow.__init__(self, plugin.iface.mainWindow())
self.setupUi(self)
self.btnSearch.setIcon(GuiUtils.get_icon('search.png'))
self.btnClearSearch.setIcon(GuiUtils.get_icon('reset.png'))
self._plugin = plugin
self.search_done = False
# self.tbPropertyPreview.set_iface(self._plugin.iface)
QTimer.singleShot(
100, lambda: self.tbPropertyPreview.set_iface(self._plugin.iface))
self.curr_profile = current_profile()
self.spatial_units = self.curr_profile.social_tenure.spatial_units
# Center me
self.move(QDesktopWidget().availableGeometry().center() -
self.frameGeometry().center())
self.sp_unit_manager = SpatialUnitManagerDockWidget(
self._plugin.iface, self._plugin)
self.geom_cols = []
for spatial_unit in self.spatial_units:
each_geom_col = self.sp_unit_manager.geom_columns(spatial_unit)
self.geom_cols.extend(each_geom_col)
# Configure notification bar
self._notif_search_config = NotificationBar(self.vl_notification)
# set whether currently logged in user has
# permissions to edit existing STR records
self._can_edit = self._plugin.STRCntGroup.canUpdate()
self._can_delete = self._plugin.STRCntGroup.canDelete()
self._can_create = self._plugin.STRCntGroup.canCreate()
# Variable used to store a reference to the
# currently selected social tenure relationship
# when displaying documents in the supporting documents tab window.
# This ensures that there are no duplicates
# when the same item is selected over and over again.
self._strID = None
self.removed_docs = None
# Used to store the root hash of the currently selected node.
self._curr_rootnode_hash = ""
self.str_model, self.str_doc_model = entity_model(
self.curr_profile.social_tenure, False, True)
self._source_doc_manager = SourceDocumentManager(
self.curr_profile.social_tenure.supporting_doc, self.str_doc_model,
self)
self._source_doc_manager.documentRemoved.connect(
self.onSourceDocumentRemoved)
self._source_doc_manager.setEditPermissions(False)
self.initGui()
self.add_spatial_unit_layer()
self.details_tree_view = DetailsTreeView(iface, self._plugin, self)
# else:
# self.details_tree_view = self._plugin.details_tree_view
self.details_tree_view.activate_feature_details(True)
self.details_tree_view.add_tree_view()
self.details_tree_view.model.clear()
count = pg_table_count(self.curr_profile.social_tenure.name)
self.setWindowTitle(
self.tr('{}{}'.format(self.windowTitle(),
'- ' + str(count) + ' rows')))
self.active_spu_id = -1
self.toolBox.setStyleSheet('''
QToolBox::tab {
background: qlineargradient(
x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #EDEDED, stop: 0.4 #EDEDED,
stop: 0.5 #EDEDED, stop: 1.0 #D3D3D3
);
border-radius: 2px;
border-style: outset;
border-width: 2px;
height: 100px;
border-color: #C3C3C3;
}
QToolBox::tab:selected {
font: italic;
}
''')
self.details_tree_view.view.setStyleSheet('''
QTreeView:!active {
selection-background-color: #72a6d9;
}
''')
