def __init__(self):
self.id = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
self.logger = Logger()
self._cached_domain_values = dict(
) # Right cache: queries that actually return a domain value/code
self._cached_wrong_domain_queries = { # Wrong cache: queries that do not return anything from the domain
QueryNames.VALUE_KEY: dict(),
QueryNames.CODE_KEY: dict()
}
# To ease addition of new ili2db names (which must be done in several classes),
# we keep them together in a dict {variable_name: variable_key}
self.ili2db_names = {
"T_ID_F": T_ID_KEY,
"T_ILI_TID_F": T_ILI_TID_KEY,
"ILICODE_F": ILICODE_KEY,
"DESCRIPTION_F": DESCRIPTION_KEY,
"DISPLAY_NAME_F": DISPLAY_NAME_KEY,
"T_BASKET_F": T_BASKET_KEY,
"T_ILI2DB_BASKET_T": T_ILI2DB_BASKET_KEY,
"T_ILI2DB_DATASET_T": T_ILI2DB_DATASET_KEY,
"DATASET_T_DATASETNAME_F": DATASET_T_DATASETNAME_KEY,
"BASKET_T_DATASET_F": BASKET_T_DATASET_KEY,
"BASKET_T_TOPIC_F": BASKET_T_TOPIC_KEY,
"BASKET_T_ATTACHMENT_KEY_F": BASKET_T_ATTACHMENT_KEY
}
# Main mapping dictionary: {table_key: {variable: 'table_variable_name', field_dict:{field_key: 'field_variable'}}}
self.TABLE_DICT = dict()
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
self.app = AppInterface()
self._converter_registry = XTFModelConverterRegistry()
def show_plugin_help(module='', offline=False):
url = ''
section = MODULE_HELP_MAPPING[module]
# If we don't have Internet access check if the documentation is in the
# expected local dir and show it. Otherwise, show a warning message.
# web_url = "{}/{}/{}".format(HELP_URL, QGIS_LANG, PLUGIN_VERSION) # TODO: To be used when the documentation has been versioned
web_url = HELP_URL
_is_connected = is_connected(TEST_SERVER)
if offline or not _is_connected:
help_path = os.path.join(PLUGIN_DIR, HELP_DIR_NAME, QGIS_LANG)
if os.path.exists(help_path):
url = os.path.join("file://", help_path)
else:
if _is_connected:
Logger().warning_msg(
__name__,
QCoreApplication.translate(
"Utils",
"The local help could not be found in '{}' and cannot be open."
).format(help_path), 20)
else:
Logger().warning_msg(
__name__,
QCoreApplication.translate(
"Utils",
"Is your computer connected to Internet? If so, go to <a href=\"{}\">online help</a>."
).format(web_url), 20)
return
else:
url = web_url
webbrowser.open("{}/{}".format(url, section))
def __init__(self, db, rules, tolerance, output_path=''):
QObject.__init__(self)
self.logger = Logger()
self.app = AppInterface()
self.__qr_registry = QualityRuleRegistry()
self.__db = db
self.__db_qr = None
self.__rules = self.__get_dict_rules(rules)
self.__result_layers = list()
self.__with_gui = self.app.settings.with_gui
self.__timestamp = ""
self.__output_path = output_path
self.app.settings.tolerance = tolerance # Tolerance must be given, we don't want anything implicit about it
self.__tolerance = self.app.settings.tolerance # Tolerance input might be altered (e.g., if it comes negative)
self.__layer_manager = QualityRuleLayerManager(db, self.__rules,
self.__tolerance)
self.__layer_manager.progress_changed.connect(
self.__emit_prepare_layers_progress)
self.qr_logger = QualityRuleLogger(self.__db, self.__tolerance)
self.__current_progress = 0
self.__error_db_utils = QualityErrorDBUtils()
self.__error_db_utils.progress_changed.connect(
self.__emit_error_db_progress)
# Clear informality cache before executing QRs.
# Note: between creating an object of this class and calling validate_quality_rules() a lot
# of things could happen (like new caches being built!). It is your responsibility to create
# an instance of this class or initialize() a QREngine object just before calling validate_quality_rules().
self.app.core.clear_cached_informal_spatial_units()
def __init__(self):
self.logger = Logger()
self.app = AppInterface()
self.__quality_rules = dict() # {quality_rule_key1: QualityRule1, ...}
# Register default quality rules
self.register_quality_rule(QRValidateDataAgainstModel()) # QR_ILIVALIDATORR0001
self.register_quality_rule(QROverlappingBoundaryPoints()) # QR_IGACR1001
self.register_quality_rule(QRBoundaryPointsNotCoveredByBoundaryNodes()) # QR_IGACR1003
self.register_quality_rule(QROverlappingBoundaries()) # QR_IGACR2001
self.register_quality_rule(QROverlappingBuildings()) # QR_IGACR3002
self.register_quality_rule(QRGapsInPlots()) # QR_IGACR3006
self.register_quality_rule(QRMultiPartsInRightOfWay()) # QR_IGACR3007
self.register_quality_rule(QRParcelRightRelationship()) # QR_IGACR4001
self.register_quality_rule(QRParcelWithInvalidDepartmentCode()) # QR_IGACR4003
self.register_quality_rule(QRParcelWithInvalidMunicipalityCode()) # QR_IGACR4004
self.register_quality_rule(QRParcelWithInvalidParcelNumber()) # QR_IGACR4005
self.register_quality_rule(QRParcelWithInvalidPreviousParcelNumber()) # QR_IGACR4006
self.register_quality_rule(QRValidateNaturalParty()) # QR_IGACR4007
self.register_quality_rule(QRValidateLegalParty()) # QR_IGACR4008
self.register_quality_rule(QRDuplicateBoundaryPointRecords()) # QR_IGACR4011
self.register_quality_rule(QRDuplicateSurveyPointRecords()) # QR_IGACR4012
self.register_quality_rule(QRDuplicateControlPointRecords()) # QR_IGACR4013
self.register_quality_rule(QRDuplicateBoundaryRecords()) # QR_IGACR4014
self.register_quality_rule(QRDuplicateBuildingRecords()) # QR_IGACR4016
self.register_quality_rule(QRDuplicateBuildingUnitRecords()) # QR_IGACR4017
self.register_quality_rule(QRDuplicatePartyRecords()) # QR_IGACR4019
self.register_quality_rule(QRDuplicateRightRecords()) # QR_IGACR4020
self.register_quality_rule(QRDuplicateRestrictionRecords()) # QR_IGACR4021
self.register_quality_rule(QRDuplicateAdministrativeSourceRecords()) # QR_IGACR4022
def __init__(self, parent, controller):
QgsPanelWidget.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self._controller = controller
self.logger = Logger()
self.app = AppInterface()
self.setDockMode(True)
self.setPanelTitle(QCoreApplication.translate("AllocateParcelsFieldDataCapturePanelWidget", "Allocate parcels"))
self.parent.setWindowTitle(QCoreApplication.translate("AllocateParcelsFieldDataCapturePanelWidget", "Allocate parcels"))
self.tbl_parcels.resizeColumnsToContents()
self.txt_search.valueChanged.connect(self.search_value_changed)
self.tbl_parcels.itemSelectionChanged.connect(self.selection_changed)
self.btn_allocate.clicked.connect(self.call_allocate_parcels_to_receiver_panel)
self.btn_configure_receivers.clicked.connect(self.configure_receivers_panel_requested)
self.btn_show_summary.clicked.connect(self.split_data_for_receivers_panel_requested)
self.chk_show_only_not_allocated.stateChanged.connect(self.chk_check_state_changed)
self.btn_reallocate.clicked.connect(self.reallocate_clicked)
self.connect_to_plot_selection(True)
self.__parcel_data = dict() # {parcel_fid: (parcel_number, surveyor_name)}
self.__selected_items = dict() # {parcel_fid: parcel_number}
def __init__(self, uri, conn_dict=dict()):
QObject.__init__(self)
self.logger = Logger()
self.engine = ''
self.provider = '' # QGIS provider name. e.g., postgres
self._uri = None
self.schema = None
self.conn = None
self._dict_conn_params = None
self.names = DBMappingRegistry()
self.__db_mapping = None # To cache query response from the DB getting table and field names.
# Flag to control whether the DB connector should update the name registry. It should be True in two scenarios:
# 1) when the DB connector is created, and 2) when the plugin's active role has changed.
self._should_update_db_mapping_values = True
# Model parser instance. If it's None, it will be recreated.
# The ModelParser compares DB models vs. role supported models.
# It should be set to None in two scenarios:
# 1) when the DB connector is created, and 2) when the plugin's active role has changed.
self._model_parser = None
if uri is not None:
self.uri = uri
else:
self.dict_conn_params = conn_dict
self.__ladmcol_models = LADMColModelRegistry()
def __init__(self, uri, conn_dict=dict()):
QObject.__init__(self)
self.logger = Logger()
self.engine = ''
self.provider = '' # QGIS provider name. e.g., postgres
self._uri = None
self.schema = None
self.conn = None
self._dict_conn_params = None
self.names = DBMappingRegistry()
self.__db_mapping = None # To cache query response from the DB getting table and field names.
# Flag to control whether the DB connector should update the name registry. It should be True in two scenarios:
# 1) when the DB connector is created, and 2) when the plugin's active role has changed.
self._should_update_db_mapping_values = True
# Table/field names in the DB. Should be read only once per connector. Note: Only a list of names. No structure.
self.__flat_table_and_field_names_for_testing_names = list()
if uri is not None:
self.uri = uri
else:
self.dict_conn_params = conn_dict
self.model_parser = None
self.__ladmcol_models = LADMColModelRegistry()
def __init__(self, db):
QObject.__init__(self)
self.app = AppInterface()
self.logger = Logger()
self.__db = db
self.__tr_dict = TranslatableConfigStrings(
).get_translatable_config_strings()
# Hierarquical dict of qrs and qr groups
self.__qrs_tree_data = dict() # {type: {qr_key1: qr_obj1, ...}, ...}
# Hierarquical dict of qrs and qr groups with general results
self.__general_results_tree_data = dict(
) # {type: {qr_obj1: qr_results1, ...}, ...}
# Hierarchical dict of qrs and their corresponding error instances
# feature1: {uuids, rel_uuids, error_type, nombre_ili_obj, details, values, fixed, exception, geom_fks}
self.__error_results_data = dict() # {qr_key1: {t_id1: feature1}}
self.__qr_results_dir_path = '' # Dir path where results will be stored
self.__selected_qrs = list() # QRs to be validated (at least 1)
self.__selected_qr = None # QR selected by the user to show its corresponding errors (exactly 1)
self.__qr_engine = None # Once set, we can reuse it
self.__qrs_results = None # QualityRulesExecutionResult object
# To cache layers from QR DB
self.__error_layer = None
self.__point_layer = None
self.__line_layer = None
self.__polygon_layer = None
# Cache by t_id (built on demand): {t_id1: 'Error', t_id2: 'Corregido', t_id3: 'Exception'}
self.__error_state_dict = dict()
def __init__(self, parent, controller, parcels_to_be_allocated):
QgsPanelWidget.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self._controller = controller
self.logger = Logger()
# Main dicts to store parcels that are not yet allocated but were selected
# from the previous panel and parcels that are already allocated in the DB
self.__parcels_to_be_allocated = parcels_to_be_allocated # {parcel_fid: parcel_number}
self.__parcels_already_allocated = dict(
) # {parcel_fid: parcel_number}
self.setDockMode(True)
self.setPanelTitle(
QCoreApplication.translate(
"BaseAllocateParcelsToReceiverPanelWidget",
"Allocate parcels to receiver"))
self.panelAccepted.connect(self.panel_accepted)
self.btn_save_allocation.clicked.connect(self.save_allocation)
self.btn_discard_parcels.clicked.connect(self.discard_parcels)
self.cbo_receiver.currentIndexChanged.connect(self.receiver_changed)
self.__txt_already_allocated = QCoreApplication.translate(
"BaseAllocateParcelsToReceiverPanelWidget", "{} already allocated")
self.__txt_to_be_allocated = QCoreApplication.translate(
"BaseAllocateParcelsToReceiverPanelWidget", "{} to be allocated")
self.fill_table()
self.fill_receivers()
self.tbl_parcels.resizeColumnsToContents()
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setupUi(self)
self.logger = Logger()
self.help_strings = HelpStrings()
#self.txt_help_page.setHtml(self.help_strings.DLG_WELCOME_SCREEN)
#self.txt_help_page.anchorClicked.connect(self.save_template)
self.finished.connect(self.finish_dialog)
self.buttonBox.helpRequested.connect(self.show_help)
self.gbx_layout = QVBoxLayout()
self.roles = RoleRegistry()
self.dict_roles = self.roles.get_roles_info()
checked = False
active_role = self.roles.get_active_role()
# Initialize radio buttons
for k,v in self.dict_roles.items():
radio = QRadioButton(v)
if not checked:
if k == active_role:
radio.setChecked(True)
checked = True
self.show_description(self.roles.get_role_description(k), checked) # Initialize help page
radio.toggled.connect(partial(self.show_description, self.roles.get_role_description(k)))
self.gbx_layout.addWidget(radio)
self.gbx_options.setLayout(self.gbx_layout)
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
self.app = AppInterface()
self._right_of_way_line_layer = None
self.addedFeatures = None
def __init__(self, iface, db, ladm_data, allocate_mode=True):
super(BaseDockWidgetFieldDataCapture, self).__init__(None)
self.setupUi(self)
self.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.logger = Logger()
self.logger.clear_message_bar() # Clear QGIS message bar
self._controller = self._get_controller(iface, db, ladm_data)
self._controller.field_data_capture_layer_removed.connect(self.layer_removed)
# Configure panels
self.configure_receivers_panel = None
self.lst_configure_receivers_panel = list()
self.allocate_parcels_to_receiver_panel = None
self.lst_allocate_parcels_to_receiver_panel = list()
self.split_data_for_receivers_panel = None
self.lst_split_data_for_receivers_panel = list()
self.allocate_panel = None
if allocate_mode:
self._initialize_allocate_initial_panel()
else: # Synchronize mode
# self.synchronize_panel = ChangesPerParcelPanelWidget(self, self.utils)
# self.widget.setMainPanel(self.synchronize_panel)
# self.lst_parcel_panels.append(self.synchronize_panel)
self._initialize_synchronize_initial_panel()
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
self._downloading = False
self._show_cursor = True
self.dependency_name = ""
self.fetcher_task = None
def __init__(self):
self.logger = Logger()
self.app = AppInterface()
self.__converters = dict() # {converter_key1: LADMColModelConverter1, ...}
# Register default models
self.register_model_converter(Survey10To11Converter())
self.register_model_converter(Survey11To10Converter())
def __init__(self, iface, layer, feature_name):
QObject.__init__(self)
self._iface = iface
self._app = AppInterface()
self._layer = layer
self._logger = Logger()
self._feature_name = feature_name
def __init__(self,
parent,
utils,
parcel_number=None,
collected_parcel_t_id=None):
QgsPanelWidget.__init__(self, None)
self.setupUi(self)
self.parent = parent
self.utils = utils
self.logger = Logger()
self.app = AppInterface()
self.setDockMode(True)
self.setPanelTitle(
QCoreApplication.translate("ChangesPerParcelPanelWidget",
"Change detection per parcel"))
self._current_supplies_substring = ""
self._current_substring = ""
self.utils.add_layers()
self.fill_combos()
# Remove selection in plot layers
self.utils._layers[self.utils._db.names.LC_PLOT_T].removeSelection()
self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PLOT_T].removeSelection()
# Map tool before activate map swipe tool
self.init_map_tool = self.utils.canvas.mapTool()
self.active_map_tool_before_custom = None
self.btn_identify_plot.setIcon(
QIcon(":/Asistente-LADM-COL/resources/images/spatial_unit.png"))
self.btn_identify_plot.clicked.connect(self.btn_plot_toggled)
# Create maptool
self.maptool_identify = QgsMapToolIdentifyFeature(self.utils.canvas)
# Set connections
self.btn_alphanumeric_query.clicked.connect(self.alphanumeric_query)
self.chk_show_all_plots.toggled.connect(self.show_all_plots)
self.cbo_parcel_fields.currentIndexChanged.connect(
self.search_field_updated)
self.panelAccepted.connect(self.initialize_tools_and_layers)
self.tbl_changes_per_parcel.itemDoubleClicked.connect(
self.call_party_panel)
self.initialize_field_values_line_edit()
self.initialize_tools_and_layers()
if parcel_number is not None: # Do a search!
self.txt_alphanumeric_query.setValue(parcel_number)
if collected_parcel_t_id is not None: # Search data for a duplicated parcel_number, so, take the t_id into account!
self.search_data(parcel_number=parcel_number,
collected_parcel_t_id=collected_parcel_t_id)
else:
self.search_data(parcel_number=parcel_number)
def __init__(self, db, conn_manager, parent=None):
QWizard.__init__(self, parent)
self.setupUi(self)
self._db = db
self.conn_manager = conn_manager
self.parent = parent
self.logger = Logger()
self.app = AppInterface()
self.names = self._db.names
self.help_strings = HelpStrings()
self._data_source_widget = None
self.db_source = SUPPLIES_DB_SOURCE
self.tool_name = ""
self._running_tool = False
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
self.progress_configuration(0, 1) # start from: 0, number of steps: 1
self.wizardPage2.setButtonText(
QWizard.CustomButton1,
QCoreApplication.translate("SuppliesETLWizard", "Run ETL"))
self.wizardPage1.setButtonText(
QWizard.CancelButton,
QCoreApplication.translate("SuppliesETLWizard", "Close"))
self.wizardPage2.setButtonText(
QWizard.CancelButton,
QCoreApplication.translate("SuppliesETLWizard", "Close"))
# Auxiliary data to set nonlinear next pages
self.pages = [self.wizardPage1, self.wizardPage2, self.wizardPage3]
self.dict_pages_ids = {
self.pages[idx]: pid
for idx, pid in enumerate(self.pageIds())
}
# Set connections
self.rad_snc_data.toggled.connect(self.etl_option_changed)
self.etl_option_changed() # Initialize it
self.button(QWizard.CustomButton1).clicked.connect(
self.import_button_clicked)
self.button(QWizard.HelpButton).clicked.connect(self.show_help)
self.currentIdChanged.connect(self.current_page_changed)
self.finished.connect(self.finished_slot)
self.btn_browse_connection.clicked.connect(self.show_settings)
# Initialize
self.current_page_changed(1)
self.update_connection_info()
self.restore_settings()
self.initialize_feedback()
# Set MessageBar for QWizard
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.setLayout(QGridLayout())
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
self.ladm_col_provider = LADMCOLAlgorithmProvider()
self.__processing_resources_installed = list()
self.__processing_model_dirs_to_register = [PROCESSING_MODELS_DIR]
self.__processing_script_dirs_to_register = [PROCESSING_SCRIPTS_DIR]
class QualityRule:
def __init__(self, quality_rule_data):
self.__quality_rule_data = quality_rule_data
self.logger = Logger()
self._rule_id = None
self._rule_name = None
self._error_table_name = None
self._error_table_fields = None
self._error_codes = None
self._initialize_quality_rule()
def _initialize_quality_rule(self):
self.logger.debug(
__name__, "Registering quality rule '{}'...".format(
self.__quality_rule_data.get(QUALITY_RULE_ID)))
common_fields = [
QgsField(QCoreApplication.translate("QualityRule", "tipo_error"),
QVariant.String),
QgsField(QCoreApplication.translate("QualityRule", "codigo_error"),
QVariant.String)
]
if self.__quality_rule_data:
self._rule_id = self.__quality_rule_data.get(QUALITY_RULE_ID)
self._rule_name = self.__quality_rule_data.get(QUALITY_RULE_NAME)
self._error_table_name = self.__quality_rule_data.get(
QUALITY_RULE_TABLE_NAME)
self._error_table_fields = self.__quality_rule_data.get(
QUALITY_RULE_TABLE_FIELDS)
if self._error_table_fields:
self._error_table_fields.extend(common_fields)
self._error_codes = self.__quality_rule_data.get(
QUALITY_RULE_DOMAIN_ERROR_CODES)
@property
def rule_id(self):
return self._rule_id
@property
def rule_name(self):
return self._rule_name
@property
def error_table_name(self):
return self._error_table_name
@property
def error_table_fields(self):
return self._error_table_fields
@property
def error_codes(self):
return self._error_codes
def __init__(self, iface, multiple_features=True):
QObject.__init__(self)
self.__iface = iface
self.__canvas = self.__iface.mapCanvas()
self.__map_tool = self.__canvas.mapTool()
self.__select_maptool = None
self.__logger = Logger()
self.multiple_features = multiple_features
def __init__(self):
self.logger = Logger()
self.app = AppInterface()
self.__models = dict() # {model_key1: LADMColModel1, ...}
self.__model_config = ModelConfig()
# Register default models
for model_key, model_config in self.__model_config.get_models_config(
).items():
self.register_model(LADMColModel(model_key, model_config), False)
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
self.dbs_supported = ConfigDbSupported()
self._db_sources = { # Values are DB Connectors
COLLECTED_DB_SOURCE: None,
SUPPLIES_DB_SOURCE: None
}
self.encrypter_decrypter = EncrypterDecrypter()
def __init__(self, quality_rule_data):
self.__quality_rule_data = quality_rule_data
self.logger = Logger()
self._rule_id = None
self._rule_name = None
self._error_table_name = None
self._error_table_fields = None
self._error_codes = None
self._initialize_quality_rule()
def __init__(self, iface, db, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.iface = iface
self._db = db
self.logger = Logger()
self.app = AppInterface()
self.names = self._db.names
self.help_strings = HelpStrings()
self.data = {} # {t_id: [display_text, denominator, numerator]}
self.current_selected_parties = [] # [t_ids]
self.parties_to_group = {} # {t_id: [denominator, numerator]}
self._layers = {
self.names.LC_GROUP_PARTY_T: None,
self.names.LC_PARTY_T: None,
self.names.MEMBERS_T: None,
self.names.FRACTION_S: None,
self.names.COL_GROUP_PARTY_TYPE_D: None
}
# Fill combo of types
col_group_party_type_table = self.app.core.get_layer(self._db, self.names.COL_GROUP_PARTY_TYPE_D, True)
if not col_group_party_type_table:
return
for feature in col_group_party_type_table.getFeatures():
self.cbo_group_type.addItem(feature[self.names.DISPLAY_NAME_F], feature[self.names.T_ID_F])
self.txt_search_party.setText("")
self.btn_select.setEnabled(False)
self.btn_deselect.setEnabled(False)
self.tbl_selected_parties.setColumnCount(3)
self.tbl_selected_parties.setColumnWidth(0, 140)
self.tbl_selected_parties.setColumnWidth(1, 90)
self.tbl_selected_parties.setColumnWidth(2, 90)
self.tbl_selected_parties.sortItems(0, Qt.AscendingOrder)
self.txt_search_party.textEdited.connect(self.search)
self.lst_all_parties.itemSelectionChanged.connect(self.selection_changed_all)
self.tbl_selected_parties.itemSelectionChanged.connect(self.selection_changed_selected)
self.tbl_selected_parties.cellChanged.connect(self.valueEdited)
self.btn_select_all.clicked.connect(self.select_all)
self.btn_deselect_all.clicked.connect(self.deselect_all)
self.btn_select.clicked.connect(self.select)
self.btn_deselect.clicked.connect(self.deselect)
self.buttonBox.helpRequested.connect(self.show_help)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.rejected.connect(self.close_wizard)
def __init__(self, iface, controller, parent=None):
super(DockWidgetQueries, self).__init__(None)
self.setupUi(self)
self.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.iface = iface
self._controller = controller
self.logger = Logger()
self.app = AppInterface()
self.canvas = iface.mapCanvas()
self.active_map_tool_before_custom = None
self._identify_tool = None
self._fill_combos()
self.btn_identify_plot.setIcon(
QIcon(":/Asistente-LADM-COL/resources/images/spatial_unit.png"))
self.tab_results.setTabEnabled(
TAB_BASIC_INFO_INDEX,
False) # TODO: Remove when queries support LevCat 1.2
self.tab_results.setTabEnabled(
TAB_PHYSICAL_INFO_INDEX,
False) # TODO: Remove when queries support LevCat 1.2
self.tab_results.setTabEnabled(
TAB_ECONOMIC_INFO_INDEX,
False) # TODO: Remove when queries support LevCat 1.2
self.tab_results.setCurrentIndex(
TAB_LEGAL_INFO_INDEX
) # TODO: Remove when queries support LevCat 1.2
# Set connections
self._controller.close_view_requested.connect(self._close_dock_widget)
self.btn_alphanumeric_query.clicked.connect(self._alphanumeric_query)
self.cbo_parcel_fields.currentIndexChanged.connect(
self._search_field_updated)
self.btn_identify_plot.clicked.connect(self._btn_plot_toggled)
self.btn_query_informality.clicked.connect(self._query_informality)
self.btn_next_informal_parcel.clicked.connect(
self._query_next_informal_parcel)
self.btn_previous_informal_parcel.clicked.connect(
self._query_previous_informal_parcel)
# Context menu
self._set_context_menus()
# Create maptool
self.maptool_identify = QgsMapToolIdentifyFeature(self.canvas)
self._initialize_field_values_line_edit()
self._update_informal_controls()
def __init__(self, task):
QObject.__init__(self)
self.task = task
self.task_id = task.get_id()
self.task_type = task.get_type()
self.logger = Logger()
self.__steps = list()
self.task_steps_config = TaskStepsConfig()
self.__initialize_steps()
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
self.app = AppInterface()
self._registered_roles = dict()
self._default_role = BASIC_ROLE
# Register default roles
for role_key, role_config in get_role_config().items():
if ROLE_ENABLED in role_config and role_config[ROLE_ENABLED]:
self.register_role(role_key, role_config)
def __init__(self, db, basket_dict, export_dir):
QObject.__init__(self)
self._db = db
self._basket_dict = basket_dict # {t_ili_tids: receiver_name}
self._export_dir = export_dir
self.logger = Logger()
self.log = ''
self.java_dependency = JavaDependency()
self.java_dependency.download_dependency_completed.connect(self.download_java_complete)
self._dbs_supported = ConfigDBsSupported()
def __init__(self):
self.logger = Logger()
self.__quality_rules_data = QualityRuleConfig.get_quality_rules_config(
)
self.__translated_strings = TranslatableConfigStrings(
).get_translatable_config_strings()
self._quality_rule_groups = dict()
self.__quality_rules = dict()
self.role_registry = RoleRegistry()
self._initialize_quality_rule_manager()
