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()