def __init__(self, iface, db, wizard_config,
product_factory: ProductFactory, observer):
QObject.__init__(self)
self._app = AppInterface()
self._db = db
self._wizard_config = wizard_config
self._iface = iface
self._logger = Logger()
self._layers = self._wizard_config[WIZARD_LAYERS]
self._editing_layer_name = self._wizard_config[
WIZARD_EDITING_LAYER_NAME]
self._editing_layer = self._layers[self._editing_layer_name]
self._WIZARD_TOOL_NAME = self._wizard_config[WIZARD_TOOL_NAME]
self.__settings_manager = WizardQSettingsManager(
self._wizard_config[WIZARD_QSETTINGS][WIZARD_QSETTINGS_PATH])
self._feature_manager = None
self._feature_selector_on_map = None
self._feature_selector_by_expression = None
self.__product_factory = product_factory
self._observer = observer
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):
QObject.__init__(self)
self.logger = Logger()
self.app = AppInterface()
self._converter_registry = XTFModelConverterRegistry()
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 setUpClass(cls):
print("\nINFO: Setting up copy CSV points to DB validation...")
print("INFO: Restoring databases to be used")
import_qgis_model_baker()
import_asistente_ladm_col()
cls.app = AppInterface()
cls.app.core.initialize_ctm12() # We need to initialize CTM12
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):
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):
QObject.__init__(self)
self.logger = Logger()
self.app = AppInterface()
self._right_of_way_line_layer = None
self.addedFeatures = None
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):
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 setUpClass(cls):
import_qgis_model_baker()
cls.db_gpkg = get_copy_gpkg_conn('test_ladm_survey_model_gpkg')
res, code, msg = cls.db_gpkg.test_connection()
cls.assertTrue(res, msg)
cls.app = AppInterface()
cls.ladm_data = LADMData()
def setUpClass(cls):
cls.app = AppInterface()
restore_schema('test_ladm_cadastral_manager_data')
cls.db = get_pg_conn('test_ladm_cadastral_manager_data')
res, code, msg = cls.db.test_connection()
cls.assertTrue(res, msg)
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 setUpClass(cls):
print("INFO: Restoring databases to be used")
restore_schema('test_change_detections')
cls.db_pg = get_pg_conn('test_change_detections')
res, code, msg = cls.db_pg.test_connection()
cls.assertTrue(res, msg)
cls.app = AppInterface()
cls.ladm_data = LADMData()
def setUpClass(cls):
print("\nINFO: Setting up copy layer With different Geometries to DB validation...")
print("INFO: Restoring databases to be used")
cls.app = AppInterface()
cls.base_test_path = tempfile.mkdtemp()
import_qgis_model_baker()
cls.ladmcol_models = LADMColModelRegistry()
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):
AbstractLADMColModelConverter.__init__(self)
self._key = "iliverrors-errores_calidad_0_1"
self._display_name = "IliVErrors a Errores Calidad 0.1"
self._from_models = ["IliVErrors"]
self._to_models = ["Errores_Calidad_V0_1"]
self.app = AppInterface()
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 setUpClass(cls):
cls.db_gpkg_empty = get_copy_gpkg_conn('test_empty_ladm_gpkg')
cls.db_gpkg_test = get_copy_gpkg_conn('test_export_data_qpkg')
cls.app = AppInterface()
res, code, msg = cls.db_gpkg_empty.test_connection()
cls.assertTrue(res, msg)
res, code, msg = cls.db_gpkg_test.test_connection()
cls.assertTrue(res, msg)
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):
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, 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 setUpClass(cls):
cls.app = AppInterface()
cls.db_gpkg = get_copy_gpkg_conn('test_ladm_survey_model_gpkg')
print("INFO: Restoring databases to be used")
restore_schema('test_ladm_col')
cls.db_pg = get_pg_conn('test_ladm_col')
schema = 'test_ladm_col'
reset_db_mssql(schema)
restore_schema_mssql(schema)
cls.db_mssql = get_mssql_conn(schema)
def setUpClass(cls):
# DB with single child model
cls.db_gpkg = get_copy_gpkg_conn('test_ladm_survey_model_gpkg')
res, code, msg = cls.db_gpkg.test_connection()
cls.assertTrue(res, msg)
# DB with multiple child models and domains
cls.db_multi_gpkg = get_copy_gpkg_conn('test_ladm_multiple_child_domains_gpkg')
res, code, msg = cls.db_multi_gpkg.test_connection()
cls.assertTrue(res, msg)
cls.app = AppInterface()
cls.ladm_data = LADMData()
def __init__(self, db, rules):
QObject.__init__(self)
self.logger = Logger()
self.app = AppInterface()
self.__tolerance = self.app.settings.tolerance
self.__layer_manager = QualityRuleLayerManager(db, rules.keys(), self.__tolerance)
self.__quality_rules = QualityRules()
self.quality_rule_logger = QualityRuleLogger(self.__tolerance)
self.__db = db
self.__rules = rules
self.__result_layers = list()
def selectFolder(line_edit_widget, title, parent, folder_setting_key=None):
folder = None
if folder_setting_key: # Get from settings
from asistente_ladm_col.app_interface import AppInterface # Here to avoid circular dependency
app = AppInterface()
folder = app.settings.get_setting(folder_setting_key) # None if key not found
if not folder:
folder = line_edit_widget.text()
foldername = QFileDialog.getExistingDirectory(parent, title, folder)
line_edit_widget.setText(foldername)
if folder_setting_key and foldername: # Save to settings
app.settings.set_setting(folder_setting_key, os.path.dirname(foldername))
def __init__(self, iface, db, ladm_data):
QObject.__init__(self)
self.iface = iface
self._db = db
self._ladm_data = ladm_data
self.app = AppInterface()
self.receiver_type = None # To be overwritten by children classes
self._layers = dict()
self.initialize_layers()
self.__parcel_data = dict() # {t_id: {parcel_number: t_id_receiver}}
def __init__(self, controller, parent=None):
QgsPanelWidget.__init__(self, None)
self.setupUi(self)
self.__controller = controller
self.parent = parent
self.app = AppInterface()
self.logger = Logger()
self.__mode = EnumQualityRulePanelMode.VALIDATE
self.__selected_items_list = list()
self.__icon_names = ['schema.png', 'points.png', 'lines.png', 'polygons.png', 'relationships.svg']
self.txt_search.addAction(QIcon(":/Asistente-LADM-COL/resources/images/search.png"), QLineEdit.LeadingPosition)
self.setDockMode(True)
self.setPanelTitle(QCoreApplication.translate("QualityRulesInitialPanelWidget", "Quality Rules"))
self.tab.setTabEnabled(TAB_READ_INDEX, False) # TODO: Remove when implemented
self.__restore_settings()
# TODO: uncomment the following block when implemented
self.lbl_presets.setEnabled(False)
self.cbo_presets.setEnabled(False)
self.btn_save_selection.setEnabled(False)
self.btn_delete_selection.setEnabled(False)
self.txt_search.textChanged.connect(self.__search_text_changed)
self.btn_validate.clicked.connect(self.__validate_clicked)
self.btn_read.clicked.connect(self.__read_clicked)
self.btn_help.clicked.connect(self.__show_help)
self.trw_qrs.itemSelectionChanged.connect(self.__selection_changed)
self.tab.currentChanged.connect(self.__tab_changed)
dir_selector = make_folder_selector(self.txt_dir_path,
title=QCoreApplication.translate("QualityRulesInitialPanelWidget",
"Select a folder to store quality errors"),
parent=None,
setting_property="qr_results_dir_path")
self.btn_dir_path.clicked.connect(dir_selector)
db_file_selector = make_file_selector(self.txt_db_path,
title=QCoreApplication.translate("QualityRulesInitialPanelWidget",
"Open GeoPackage database file with quality errors"),
file_filter=QCoreApplication.translate("QualityRulesInitialPanelWidget",
"GeoPackage Database (*.gpkg)"),
setting_property="qr_db_file_path")
self.btn_db_path.clicked.connect(db_file_selector)
self.__tab_changed(self.tab.currentIndex()) # Direct call to initialize controls
def __init__(self, db, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self._db = db
self.app = AppInterface()
self.names = self._db.names
self.models_tree = dict()
self.selected_items_dict = dict()
self.icon_names = [
'points.png', 'lines.png', 'polygons.png', 'tables.png',
'domains.png', 'structures.png', 'relationships.svg'
]
self.txt_search_text.addAction(
QIcon(":/Asistente-LADM-COL/resources/images/search.png"),
QLineEdit.LeadingPosition)
# Fill predefined tables combobox
self.cbo_select_predefined_tables.clear()
self.cbo_select_predefined_tables.setInsertPolicy(
QComboBox.InsertAlphabetically)
self.cbo_select_predefined_tables.addItem("", []) # By default
for name, layer_list in LayerConfig.get_layer_sets(
self.names,
self.app.core.get_active_models_per_db(db)).items():
self.cbo_select_predefined_tables.addItem(name, layer_list)
self.cbo_select_predefined_tables.currentIndexChanged.connect(
self.__select_predefined_changed)
# Set connections
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.rejected.connect(self.rejected)
self.buttonBox.helpRequested.connect(self.__show_help)
self.txt_search_text.textChanged.connect(self.__search_text_changed)
self.chk_show_domains.toggled.connect(self.__show_table_type_changed)
self.chk_show_structures.toggled.connect(
self.__show_table_type_changed)
self.chk_show_associations.toggled.connect(
self.__show_table_type_changed)
self.trw_layers.itemSelectionChanged.connect(self.__selection_changed)
# Reload latest settings
self.__restore_settings()
# Load layers from the db
self.__load_available_layers()
def setUpClass(cls):
print("\nINFO: Setting up copy layer With different Geometries to DB validation...")
cls.app = AppInterface()
import_qgis_model_baker()
# restore schemas
print("INFO: Restoring databases to be used")
restore_schema(SCHEMA_DISTINCT_GEOMS)
restore_schema(SCHEMA_LADM_COL_EMPTY)
cls.gpkg_path = get_test_copy_path(GPKG_PATH_DISTINCT_GEOMS)
cls.db_distinct_geoms = get_pg_conn(SCHEMA_DISTINCT_GEOMS)
cls.db_pg = get_pg_conn(SCHEMA_LADM_COL_EMPTY)
