def __init__(self):
QObject.__init__(self)
self.logger = Logger()
from asistente_ladm_col.config.config_db_supported import ConfigDBsSupported
self._dbs_supported = ConfigDBsSupported()
self.__mb_lib = QgisModelBakerPluginLib()
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
self.dbs_supported = ConfigDBsSupported()
self._db_sources = { # Values are DB Connectors
COLLECTED_DB_SOURCE: None,
SUPPLIES_DB_SOURCE: None
}
self.encrypter_decrypter = EncrypterDecrypter()
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):
QObject.__init__(self)
self.logger = Logger()
self._java_path = ''
self._java_dependency = JavaDependency()
self.dbs_supported = ConfigDBsSupported()
self._base_configuration = None
self._ilicache = None
self._log = ''
def set_db_connection(self, db, test_conn_result=None):
"""
Set the DB connection info this class will use to build the GUI.
:param db: DBConnector object
:param test_conn_result: Can be True or False if test_connection was called, or None if we should call it.
:return:
"""
self._db = db
self._test_conn_result = test_conn_result if test_conn_result is not None else db.test_connection(
)[0]
db_factory = ConfigDBsSupported().get_db_factory(db.engine)
self._db_engine_actions = db_factory.get_db_engine_actions()
self._engine_name = db_factory.get_name()
def __init__(self, db, ladm_data):
QObject.__init__(self)
self._db = db
self._ladm_data = ladm_data
self.logger = Logger()
self.app = AppInterface()
self.clipboard = QApplication.clipboard()
self._layers = dict()
self._ladm_queries = ConfigDBsSupported().get_db_factory(
self._db.engine).get_ladm_queries()
self._restart_dict_of_layers()
self._add_layers()
# To cache informal parcels,
self._informal_parcels_info = tuple(
) # ([parcel_t_id: parcel_number], [,], [,], ...)
self._informal_index = -1
self._informal_parcels_len = 0 # To avoid calculating this each time
def set_db_connection(self, db, test_conn_result=None):
"""
Set the DB connection info this class will use to build the GUI.
:param db: DBConnector object
:param test_conn_result: Can be True or False if test_connection was called, or None if we should call it.
:return:
"""
self._db = db
if test_conn_result is not None:
self._test_conn_result = test_conn_result
else:
self._test_conn_result, code, msg = db.test_connection()
if not self._test_conn_result:
self.logger.warning(
__name__,
"Test connection is False! Details: {}".format(msg))
db_factory = ConfigDBsSupported().get_db_factory(db.engine)
self._db_engine_actions = db_factory.get_db_engine_actions()
self._engine_name = db_factory.get_name()
def _get_ladm_queries(self, engine):
return ConfigDBsSupported().get_db_factory(engine).get_ladm_queries()
class Ili2DB(QObject):
"""
Execute ili2db operations via Model Baker API
"""
stdout = pyqtSignal(str)
stderr = pyqtSignal(str)
process_started = pyqtSignal(str)
process_finished = pyqtSignal(int, int)
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
self._java_path = ''
self._java_dependency = JavaDependency()
self.dbs_supported = ConfigDBsSupported()
self._base_configuration = None
self._ilicache = None
self._log = ''
def get_full_java_exe_path(self):
if not self._java_path:
self._java_path = JavaDependency.get_full_java_exe_path()
return self._java_path
def configure_java(self):
if not self._java_dependency.set_java_home():
message_java = QCoreApplication.translate(
"Ili2DB",
"""Configuring Java {}...""").format(JAVA_REQUIRED_VERSION)
self.logger.status(message_java)
self._java_dependency.get_java_on_demand(asynchronous=False)
res = True
msg = 'Success!'
java_path = self.get_full_java_exe_path()
if not java_path:
res = False
msg = QCoreApplication.translate(
"Ili2DB",
"Java {} could not be confiured for you. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again."
).format(JAVA_REQUIRED_VERSION)
return res, msg
def _get_base_configuration(self):
"""
:return: BaseConfiguration object. If it's already configured, it returns the existing object, so that it can
be shared among chained operations (e.g., export DB1-->schema import DB2-->import DB2).
"""
if not self._base_configuration:
self._base_configuration = BaseConfiguration()
self._ilicache = IliCache(self._base_configuration)
self._base_configuration.java_path = self.get_full_java_exe_path(
) # It is well configured at this point!
# Check custom model directories
if QSettings().value(
'Asistente-LADM-COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool):
custom_model_directories = QSettings().value(
'Asistente-LADM-COL/models/custom_models',
DEFAULT_MODELS_DIR)
if not custom_model_directories:
self._base_configuration.custom_model_directories_enabled = False
else:
self._base_configuration.custom_model_directories = custom_model_directories
self._base_configuration.custom_model_directories_enabled = True
# Debug mode
self._base_configuration.debugging_enabled = \
QSettings().value('Asistente-LADM-COL/models/debug', DEFAULT_ILI2DB_DEBUG_MODE, type=bool)
self._base_configuration.logfile_path = QSettings().value(
'Asistente-LADM-COL/models/log_file_path', '')
self._ilicache.refresh(
) # Always call it after setting custom_model_directories
return self._base_configuration
def _get_ili_models(self, db):
ili_models = list()
model_names = db.get_models()
if model_names:
for model in LADMColModelRegistry().supported_models():
if not model.hidden() and model.full_name() in model_names:
ili_models.append(model.full_name())
return ili_models
def get_import_schema_configuration(self,
db,
ili_models=list(),
create_basket_col=False):
db_factory = self.dbs_supported.get_db_factory(db.engine)
configuration = SchemaImportConfiguration()
db_factory.set_ili2db_configuration_params(db.dict_conn_params,
configuration)
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = create_basket_col
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
configuration.tomlfile = TOML_FILE_DIR
configuration.base_configuration = self._get_base_configuration()
configuration.ilimodels = ';'.join(ili_models)
if db.engine == 'gpkg':
# EPSG:9377 support for GPKG (Ugly, I know) We need to send known parameters, we'll fix this in the post_script
configuration.srs_auth = 'EPSG'
configuration.srs_code = 3116
configuration.post_script = CTM12_GPKG_SCRIPT_PATH
elif db.engine == 'pg':
configuration.srs_auth = 'EPSG'
configuration.srs_code = 9377
configuration.pre_script = CTM12_PG_SCRIPT_PATH
return configuration
def get_import_data_configuration(self,
db,
xtf_path,
dataset='',
baskets=list(),
disable_validation=False):
db_factory = self.dbs_supported.get_db_factory(db.engine)
configuration = ImportDataConfiguration()
db_factory.set_ili2db_configuration_params(db.dict_conn_params,
configuration)
configuration.with_importtid = True
configuration.xtffile = xtf_path
configuration.disable_validation = disable_validation
configuration.dataset = dataset
configuration.baskets = baskets # list with basket UUIDs
configuration.base_configuration = self._get_base_configuration()
ili_models = self._get_ili_models(db)
if ili_models:
configuration.ilimodels = ';'.join(ili_models)
return configuration
def get_export_configuration(self,
db,
xtf_path,
dataset='',
baskets=list(),
disable_validation=False):
db_factory = self.dbs_supported.get_db_factory(db.engine)
configuration = ExportConfiguration()
db_factory.set_ili2db_configuration_params(db.dict_conn_params,
configuration)
configuration.with_exporttid = True
configuration.xtffile = xtf_path
configuration.disable_validation = disable_validation
configuration.dataset = dataset
configuration.baskets = baskets # List with basket UUIDs
configuration.base_configuration = self._get_base_configuration()
ili_models = self._get_ili_models(db)
if ili_models:
configuration.ilimodels = ';'.join(ili_models)
return configuration
def get_update_configuration(self, db_factory, db, xtf_path, dataset_name):
configuration = UpdateDataConfiguration()
db_factory.set_ili2db_configuration_params(db.dict_conn_params,
configuration)
configuration.base_configuration = self._get_base_configuration()
ili_models = self._get_ili_models(db)
if ili_models:
configuration.ilimodels = ';'.join(ili_models)
configuration.dataset = dataset_name
configuration.with_importbid = True
configuration.with_importtid = True
configuration.xtffile = xtf_path
return configuration
def get_validate_configuration(self, db_factory, db, model_names,
xtflog_path, configfile_path):
configuration = ValidateDataConfiguration()
db_factory.set_ili2db_configuration_params(db.dict_conn_params,
configuration)
configuration.base_configuration = self._get_base_configuration()
# Since BaseConfiguration can be shared, avoid a --trace in --validate operation (not supported by ili2db)
configuration.base_configuration.debugging_enabled = False
if model_names:
configuration.ilimodels = ';'.join(model_names)
if xtflog_path:
configuration.xtflogfile = xtflog_path
if configfile_path:
configuration.configfile = configfile_path
return configuration
@with_override_cursor
def import_schema(self, db, configuration: SchemaImportConfiguration):
# Check prerequisite
if not self.get_full_java_exe_path():
res_java, msg_java = self.configure_java()
if not res_java:
return res_java, msg_java
# Configure command parameters
db_factory = self.dbs_supported.get_db_factory(db.engine)
# Configure run
importer = iliimporter.Importer()
importer.tool = db_factory.get_model_baker_db_ili_mode()
importer.configuration = configuration
self._connect_ili_executable_signals(importer)
# Run!
res = True
msg = QCoreApplication.translate("Ili2DB",
"Schema import ran successfully!")
self._log = ''
self.logger.status(
QCoreApplication.translate(
"Ili2Db", "Creating LADM-COL structure into {}...").format(
db.engine.upper()))
try:
if importer.run() != iliimporter.Importer.SUCCESS:
msg = QCoreApplication.translate(
"Ili2DB",
"An error occurred when importing a schema into a DB (check the QGIS log panel)."
)
res = False
QgsMessageLog.logMessage(
self._log,
QCoreApplication.translate("Ili2DB", "DB Schema Import"),
Qgis.Critical)
except JavaNotFoundError:
msg = QCoreApplication.translate(
"Ili2DB",
"Java {} could not be found. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again."
).format(JAVA_REQUIRED_VERSION)
res = False
self._disconnect_ili_executable_signals(importer)
self.logger.clear_status()
return res, msg
@with_override_cursor
def import_data(self, db, configuration: ImportDataConfiguration):
# Check prerequisite
if not self.get_full_java_exe_path():
res_java, msg_java = self.configure_java()
if not res_java:
return res_java, msg_java
# Configure command parameters
db_factory = self.dbs_supported.get_db_factory(db.engine)
# Configure run
importer = iliimporter.Importer(dataImport=True)
importer.tool = db_factory.get_model_baker_db_ili_mode()
importer.configuration = configuration
self._connect_ili_executable_signals(importer)
# Run!
res = True
msg = QCoreApplication.translate(
"Ili2DB",
"XTF '{}' imported successfully!").format(configuration.xtffile)
self._log = ''
self.logger.status(
QCoreApplication.translate("Ili2Db",
"Importing XTF into {}...").format(
db.engine.upper()))
try:
if importer.run() != iliimporter.Importer.SUCCESS:
msg = QCoreApplication.translate(
"Ili2DB",
"An error occurred when importing from XTF (check the QGIS log panel)."
)
res = False
QgsMessageLog.logMessage(
self._log,
QCoreApplication.translate("Ili2DB", "Import from XTF"),
Qgis.Critical)
except JavaNotFoundError:
msg = QCoreApplication.translate(
"Ili2DB",
"Java {} could not be found. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again."
).format(JAVA_REQUIRED_VERSION)
res = False
self._disconnect_ili_executable_signals(importer)
self.logger.clear_status()
return res, msg
@with_override_cursor
def export(self, db, configuration: ExportConfiguration):
# Check prerequisite
if not self.get_full_java_exe_path():
res_java, msg_java = self.configure_java()
if not res_java:
return res_java, msg_java
# Configure command parameters
db_factory = self.dbs_supported.get_db_factory(db.engine)
# Configure run
exporter = iliexporter.Exporter()
exporter.tool = db_factory.get_model_baker_db_ili_mode()
exporter.configuration = configuration
self._connect_ili_executable_signals(exporter)
# Run!
res = True
msg = QCoreApplication.translate(
"Ili2DB",
"XTF '{}' exported successfully!").format(configuration.xtffile)
self._log = ''
self.logger.status(
QCoreApplication.translate("Ili2Db",
"Exporting from {} to XTF...").format(
db.engine.upper()))
try:
if exporter.run() != iliexporter.Exporter.SUCCESS:
msg = QCoreApplication.translate(
"Ili2DB",
"An error occurred when exporting data to XTF (check the QGIS log panel)."
)
res = False
QgsMessageLog.logMessage(
self._log,
QCoreApplication.translate("Ili2DB", "Export to XTF"),
Qgis.Critical)
else:
self.logger.info(__name__, msg)
except JavaNotFoundError:
msg = QCoreApplication.translate(
"Ili2DB",
"Java {} could not be found. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again."
).format(JAVA_REQUIRED_VERSION)
res = False
self._disconnect_ili_executable_signals(exporter)
self.logger.clear_status()
return res, msg
@with_override_cursor
def update(self, db, xtf_path, dataset_name):
# Check prerequisite
if not self.get_full_java_exe_path():
res_java, msg_java = self.configure_java()
if not res_java:
return res_java, msg_java
# Configure command parameters
db_factory = self.dbs_supported.get_db_factory(db.engine)
configuration = self.get_update_configuration(db_factory, db, xtf_path,
dataset_name)
# Configure run
updater = iliupdater.Updater()
updater.tool = db_factory.get_model_baker_db_ili_mode()
updater.configuration = configuration
self._connect_ili_executable_signals(updater)
# Run!
res = True
msg = QCoreApplication.translate(
"Ili2DB",
"DB updated successfully from XTF file '{}'!").format(xtf_path)
self._log = ''
self.logger.status(
QCoreApplication.translate(
"Ili2Db", "Updating {} DB from XTF '{}'...").format(
db.engine.upper(), xtf_path))
try:
if updater.run() != iliupdater.Updater.SUCCESS:
msg = QCoreApplication.translate(
"Ili2DB",
"An error occurred when updating the DB from an XTF (check the QGIS log panel)."
)
res = False
QgsMessageLog.logMessage(
self._log,
QCoreApplication.translate("Ili2DB", "Update DB from XTF"),
Qgis.Critical)
else:
self.logger.info(__name__, msg)
except JavaNotFoundError:
msg = QCoreApplication.translate(
"Ili2DB",
"Java {} could not be found. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again."
).format(JAVA_REQUIRED_VERSION)
res = False
self._disconnect_ili_executable_signals(updater)
self.logger.clear_status()
return res, msg
@with_override_cursor
def validate(self,
db,
model_names=list(),
xtflog_path='',
configfile_path=''):
# Check prerequisite
if not self.get_full_java_exe_path():
res_java, msg_java = self.configure_java()
if not res_java:
return res_java, msg_java
# Configure command parameters
db_factory = self.dbs_supported.get_db_factory(db.engine)
configuration = self.get_validate_configuration(
db_factory, db, model_names, xtflog_path, configfile_path)
# Configure run
validator = ili2dbvalidator.Ili2DBValidator()
validator.tool = db_factory.get_model_baker_db_ili_mode()
validator.process_started.connect(self.on_process_started)
validator.stderr.connect(self.on_stderr)
validator.configuration = configuration
# Run!
res = True
msg = QCoreApplication.translate(
"Ili2DB", "Data successfully validated from DB '{}'!").format(
db.get_description_conn_string())
self._log = ''
self.logger.status(
QCoreApplication.translate(
"Ili2Db", "Validating data from '{}' DB...").format(
db.get_description_conn_string()))
try:
res_validation = validator.run()
if (res_validation != ili2dbvalidator.Ili2DBValidator.SUCCESS
and res_validation != ili2dbvalidator.Ili2DBValidator.
SUCCESS_WITH_VALIDATION_ERRORS):
msg = QCoreApplication.translate(
"Ili2DB",
"An error occurred when validating data from a DB (check the QGIS log panel)."
)
res = False
QgsMessageLog.logMessage(
self._log,
QCoreApplication.translate("Ili2DB",
"Validate data from DB"),
Qgis.Critical)
else:
self.logger.info(__name__, msg)
except JavaNotFoundError:
msg = QCoreApplication.translate(
"Ili2DB",
"Java {} could not be found. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again."
).format(JAVA_REQUIRED_VERSION)
res = False
self.logger.clear_status()
return res, msg
def on_process_started(self, command):
self._log += command + '\n'
def on_stderr(self, text):
self._log += text
def _connect_ili_executable_signals(self, ili_executable: IliExecutable):
ili_executable.process_started.connect(self.process_started)
ili_executable.stderr.connect(self.stderr)
ili_executable.stdout.connect(self.stdout)
ili_executable.process_finished.connect(self.process_finished)
ili_executable.process_started.connect(self.on_process_started)
ili_executable.stderr.connect(self.on_stderr)
def _disconnect_ili_executable_signals(self,
ili_executable: IliExecutable):
ili_executable.process_started.disconnect(self.process_started)
ili_executable.stderr.disconnect(self.stderr)
ili_executable.stdout.disconnect(self.stdout)
ili_executable.process_finished.disconnect(self.process_finished)
ili_executable.process_started.disconnect(self.on_process_started)
ili_executable.stderr.disconnect(self.on_stderr)
def __init__(self, conn_manager=None, context=None, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self.logger = Logger()
self.conn_manager = conn_manager
self.app = AppInterface()
self.sbx_tolerance.setMaximum(TOLERANCE_MAX_VALUE)
self._valid_document_repository = False # Needs to be True if users want to enable doc repo (using test button)
context = context if context else SettingsContext()
self.db_source = context.db_source # default db source is COLLECTED_DB_SOURCE
self._required_models = context.required_models
self._tab_pages_list = context.tab_pages_list
self._blocking_mode = context.blocking_mode # Whether the dialog can only be accepted on valid DB connections or not
self._action_type = context.action_type # By default "config"
self.setWindowTitle(context.title)
self._db = None
self.init_db_engine = None
self.dbs_supported = ConfigDBsSupported()
self._open_dlg_import_schema = False # After accepting, if non-valid DB is configured, we can go to import schema
self.online_models_radio_button.setEnabled(
False) # This option is disabled until we have online models back!
self.online_models_radio_button.setChecked(True)
self.online_models_radio_button.toggled.connect(
self.model_provider_toggle)
self.custom_model_directories_line_edit.setText("")
self.custom_models_dir_button.clicked.connect(
self.show_custom_model_dir)
self.custom_model_directories_line_edit.setVisible(False)
self.custom_models_dir_button.setVisible(False)
# Set connections
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.helpRequested.connect(self.show_help)
self.finished.connect(self.finished_slot)
self.btn_test_connection.clicked.connect(self.test_connection)
self.btn_test_ladm_col_structure.clicked.connect(
self.test_ladm_col_structure)
self.btn_test_service.clicked.connect(self.test_service)
self.btn_test_service_transitional_system.clicked.connect(
self.test_service_transitional_system)
self.txt_service_endpoint.textEdited.connect(
self.source_service_endpoint_changed) # For manual changes only
self.btn_default_value_sources.clicked.connect(
self.set_default_value_source_service)
self.btn_default_value_transitional_system.clicked.connect(
self.set_default_value_transitional_system_service)
self.chk_use_roads.toggled.connect(self.update_images_state)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.cbo_db_engine.clear()
self._lst_db = self.dbs_supported.get_db_factories()
self._lst_panel = dict()
for key, value in self._lst_db.items():
self.cbo_db_engine.addItem(value.get_name(), key)
self._lst_panel[key] = value.get_config_panel(self)
self._lst_panel[key].notify_message_requested.connect(
self.show_message)
self.db_layout.addWidget(self._lst_panel[key])
self.db_engine_changed()
# Trigger some default behaviours
self.restore_db_source_settings(
) # restore settings with default db source
self.restore_settings()
self.roles = RoleRegistry()
self.load_roles()
self.cbo_db_engine.currentIndexChanged.connect(self.db_engine_changed)
self.rejected.connect(self.close_dialog)
self._update_tabs()
if context.tip:
self.show_tip(context.tip)
class DialogImportSchema(QDialog, DIALOG_UI):
open_dlg_import_data = pyqtSignal(dict) # dict with key-value params
on_result = pyqtSignal(
bool) # whether the tool was run successfully or not
BUTTON_NAME_CREATE_STRUCTURE = QCoreApplication.translate(
"DialogImportSchema", "Create LADM-COL structure")
BUTTON_NAME_GO_TO_IMPORT_DATA = QCoreApplication.translate(
"DialogImportData", "Go to Import Data...")
def __init__(self,
iface,
conn_manager,
context,
selected_models=list(),
link_to_import_data=True,
parent=None):
QDialog.__init__(self, parent)
self.iface = iface
self.conn_manager = conn_manager
self.selected_models = selected_models
self.link_to_import_data = link_to_import_data
self.logger = Logger()
self.app = AppInterface()
self.__ladmcol_models = LADMColModelRegistry()
self.java_dependency = JavaDependency()
self.java_dependency.download_dependency_completed.connect(
self.download_java_complete)
self.java_dependency.download_dependency_progress_changed.connect(
self.download_java_progress_change)
self.db_source = context.get_db_sources()[0]
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self._dbs_supported = ConfigDBsSupported()
self._running_tool = False
# There may be two cases where we need to emit a db_connection_changed from the Schema Import dialog:
# 1) Connection Settings was opened and the DB conn was changed.
# 2) Connection Settings was never opened but the Schema Import ran successfully, in a way that new models may
# convert a db/schema LADM-COL compliant.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in two cases:
# 1) If the SI dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
# 2) Not opening the Connection Settings, but running a successful Schema Import on the COLLECTED DB, which
# invalidates the cache as models change.
self._schedule_layers_and_relations_refresh = False
self.setupUi(self)
self.validators = Validators()
self.update_import_models()
self.previous_item = QListWidgetItem()
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportSchema",
"Connection Settings"))
# CRS Setting
self.srs_auth = DEFAULT_SRS_AUTH
self.srs_code = DEFAULT_SRS_CODE
self.crsSelector.crsChanged.connect(self.crs_changed)
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportSchema", "Show log"))
self.buttonBox.accepted.disconnect()
self.buttonBox.clicked.connect(self.accepted_import_schema)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
self.BUTTON_NAME_CREATE_STRUCTURE, QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.import_models_list_widget.setDisabled(bool(
selected_models)) # If we got models from params, disable panel
self.update_connection_info()
self.restore_configuration()
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
def accepted_import_schema(self, button):
if self.buttonBox.buttonRole(button) == QDialogButtonBox.AcceptRole:
if button.text() == self.BUTTON_NAME_CREATE_STRUCTURE:
self.accepted()
elif button.text() == self.BUTTON_NAME_GO_TO_IMPORT_DATA:
self.close(
) # Close import schema dialog and open import open dialog
self.open_dlg_import_data.emit({"db_source": self.db_source})
def reject(self):
if self._running_tool:
QMessageBox.information(
self,
QCoreApplication.translate("DialogImportSchema", "Warning"),
QCoreApplication.translate(
"DialogImportSchema",
"The Import Schema tool is still running. Please wait until it finishes."
))
else:
self.close_dialog()
def close_dialog(self):
"""
We use this method to be safe when emitting the db_connection_changed, otherwise we could trigger slots that
unload the plugin, destroying dialogs and thus, leading to crashes.
"""
if self._schedule_layers_and_relations_refresh:
self.conn_manager.db_connection_changed.connect(
self.app.core.cache_layers_and_relations)
if self._db_was_changed:
self.conn_manager.db_connection_changed.emit(
self.db,
self.db.test_connection()[0], self.db_source)
if self._schedule_layers_and_relations_refresh:
self.conn_manager.db_connection_changed.disconnect(
self.app.core.cache_layers_and_relations)
self.logger.info(__name__, "Dialog closed.")
self.done(QDialog.Accepted)
def update_connection_info(self):
db_description = self.db.get_description_conn_string()
if db_description:
self.db_connect_label.setText(db_description)
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self._accept_button.setEnabled(True)
else:
self.db_connect_label.setText(
QCoreApplication.translate("DialogImportSchema",
"The database is not defined!"))
self.db_connect_label.setToolTip('')
self._accept_button.setEnabled(False)
def update_import_models(self):
for model in self.__ladmcol_models.supported_models():
if not model.hidden():
item = QListWidgetItem(model.full_alias())
item.setData(Qt.UserRole, model.full_name())
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
if self.selected_models: # From parameters
item.setCheckState(Qt.Checked if model.id() in
self.selected_models else Qt.Unchecked)
else: # By default
item.setCheckState(
Qt.Checked if model.checked() else Qt.Unchecked)
self.import_models_list_widget.addItem(item)
self.import_models_list_widget.itemClicked.connect(
self.on_item_clicked_import_model)
self.import_models_list_widget.itemChanged.connect(
self.on_itemchanged_import_model)
def on_item_clicked_import_model(self, item):
# disconnect signal to do changes in the items
self.import_models_list_widget.itemChanged.disconnect(
self.on_itemchanged_import_model)
if self.previous_item.text() != item.text():
item.setCheckState(Qt.Unchecked if item.checkState() ==
Qt.Checked else Qt.Checked)
# connect signal to check when the items change
self.import_models_list_widget.itemChanged.connect(
self.on_itemchanged_import_model)
self.previous_item = item
def on_itemchanged_import_model(self, item):
if self.previous_item.text() != item.text():
item.setSelected(True)
self.previous_item = item
def get_checked_models(self):
checked_models = list()
for index in range(self.import_models_list_widget.count()):
item = self.import_models_list_widget.item(index)
if item.checkState() == Qt.Checked:
checked_models.append(item.data(Qt.UserRole))
return checked_models
def show_settings(self):
# We only need those tabs related to Model Baker/ili2db operations
dlg = SettingsDialog(self.conn_manager, parent=self)
dlg.setWindowTitle(
QCoreApplication.translate("DialogImportSchema",
"Target DB Connection Settings"))
dlg.show_tip(
QCoreApplication.translate(
"DialogImportSchema",
"Configure where do you want the LADM-COL structure to be created."
))
dlg.set_db_source(self.db_source)
dlg.set_tab_pages_list(
[SETTINGS_CONNECTION_TAB_INDEX, SETTINGS_MODELS_TAB_INDEX])
# Connect signals (DBUtils, Core)
dlg.db_connection_changed.connect(self.db_connection_changed)
if self.db_source == COLLECTED_DB_SOURCE:
self._schedule_layers_and_relations_refresh = True
dlg.set_action_type(EnumDbActionType.SCHEMA_IMPORT)
if dlg.exec_():
self.db = dlg.get_db_connection()
self.update_connection_info()
def db_connection_changed(self, db, ladm_col_db, db_source):
# We dismiss parameters here, after all, we already have the db, and the ladm_col_db may change from this moment
# until we close the import schema dialog
self._db_was_changed = True
self.clear_messages() # Clean GUI messages if db connection changed
def accepted(self):
self._running_tool = True
self.txtStdout.clear()
self.progress_bar.setValue(0)
self.bar.clearWidgets()
java_home_set = self.java_dependency.set_java_home()
if not java_home_set:
message_java = QCoreApplication.translate(
"DialogImportSchema",
"""Configuring Java {}...""").format(JAVA_REQUIRED_VERSION)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(message_java)
self.java_dependency.get_java_on_demand()
self.disable()
return
configuration = self.update_configuration()
configuration = self.apply_role_model_configuration(configuration)
if not self.get_checked_models():
self._running_tool = False
message_error = QCoreApplication.translate(
"DialogImportSchema",
"You should select a valid model(s) before creating the LADM-COL structure."
)
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.import_models_list_widget.setFocus()
return
self.save_configuration(configuration)
with OverrideCursor(Qt.WaitCursor):
self.progress_bar.show()
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
importer = iliimporter.Importer()
db_factory = self._dbs_supported.get_db_factory(self.db.engine)
importer.tool = db_factory.get_model_baker_db_ili_mode()
importer.configuration = configuration
importer.stdout.connect(self.print_info)
importer.stderr.connect(self.on_stderr)
importer.process_started.connect(self.on_process_started)
importer.process_finished.connect(self.on_process_finished)
try:
if importer.run() != iliimporter.Importer.SUCCESS:
self._running_tool = False
self.show_message(
QCoreApplication.translate(
"DialogImportSchema",
"An error occurred when creating the LADM-COL structure. For more information see the log..."
), Qgis.Warning)
self.on_result.emit(
False
) # Inform other classes that the execution was not successful
return
except JavaNotFoundError:
self._running_tool = False
message_error_java = QCoreApplication.translate(
"DialogImportSchema",
"Java {} could not be found. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again."
).format(JAVA_REQUIRED_VERSION)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(message_error_java)
self.show_message(message_error_java, Qgis.Warning)
return
self._running_tool = False
self.buttonBox.clear()
if self.link_to_import_data:
self.buttonBox.addButton(
self.BUTTON_NAME_GO_TO_IMPORT_DATA,
QDialogButtonBox.AcceptRole).setStyleSheet(
"color: #007208;")
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
self.progress_bar.setValue(100)
self.print_info(
QCoreApplication.translate("DialogImportSchema", "\nDone!"),
'#004905')
self.show_message(
QCoreApplication.translate(
"DialogImportSchema",
"LADM-COL structure was successfully created!"),
Qgis.Success)
self.on_result.emit(
True) # Inform other classes that the execution was successful
self._db_was_changed = True # Schema could become LADM compliant after a schema import
if self.db_source == COLLECTED_DB_SOURCE:
self.logger.info(
__name__,
"Schedule a call to refresh db relations cache since a Schema Import was run on the current 'collected' DB."
)
self._schedule_layers_and_relations_refresh = True
def download_java_complete(self):
self.accepted()
def download_java_progress_change(self, progress):
self.progress_bar.setValue(progress / 2)
if (progress % 20) == 0:
self.txtStdout.append('...')
def save_configuration(self, configuration):
settings = QSettings()
settings.setValue('Asistente-LADM-COL/QgisModelBaker/show_log',
not self.log_config.isCollapsed())
settings.setValue('Asistente-LADM-COL/QgisModelBaker/srs_auth',
self.srs_auth)
settings.setValue('Asistente-LADM-COL/QgisModelBaker/srs_code',
self.srs_code)
def restore_configuration(self):
settings = QSettings()
# CRS
srs_auth = settings.value('Asistente-LADM-COL/QgisModelBaker/srs_auth',
DEFAULT_SRS_AUTH, str)
srs_code = settings.value('Asistente-LADM-COL/QgisModelBaker/srs_code',
int(DEFAULT_SRS_CODE), int)
self.crsSelector.setCrs(get_crs_from_auth_and_code(srs_auth, srs_code))
self.crs_changed()
# Show log
value_show_log = settings.value(
'Asistente-LADM-COL/QgisModelBaker/show_log', False, type=bool)
self.log_config.setCollapsed(not value_show_log)
# set model repository
# if there is no option by default use online model repository
self.use_local_models = settings.value(
'Asistente-LADM-COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool)
if self.use_local_models:
self.custom_model_directories = settings.value(
'Asistente-LADM-COL/models/custom_models', DEFAULT_MODELS_DIR)
def crs_changed(self):
self.srs_auth, self.srs_code = get_crs_authid(
self.crsSelector.crs()).split(":")
if self.srs_code != DEFAULT_SRS_CODE or self.srs_auth != DEFAULT_SRS_AUTH:
self.crs_label.setStyleSheet('color: orange')
self.crs_label.setToolTip(
QCoreApplication.translate(
"DialogImportSchema",
"The {} (Colombian National Origin) is recommended,<br>since official models were created for that projection."
).format(DEFAULT_SRS_AUTHID))
else:
self.crs_label.setStyleSheet('')
self.crs_label.setToolTip(
QCoreApplication.translate("DialogImportSchema",
"Coordinate Reference System"))
def update_configuration(self):
db_factory = self._dbs_supported.get_db_factory(self.db.engine)
configuration = SchemaImportConfiguration()
db_factory.set_ili2db_configuration_params(self.db.dict_conn_params,
configuration)
# set custom toml file
configuration.tomlfile = TOML_FILE_DIR
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = ILI2DBNames.CREATE_BASKET_COL
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
# CTM12 support
configuration.srs_auth = self.srs_auth
configuration.srs_code = self.srs_code
if self.srs_auth == DEFAULT_SRS_AUTH and self.srs_code == DEFAULT_SRS_CODE:
if self.db.engine == 'pg':
configuration.pre_script = CTM12_PG_SCRIPT_PATH
elif self.db.engine == 'gpkg':
# (Ugly, I know) We need to send known parameters, we'll fix this in the post_script
configuration.srs_auth = 'EPSG'
configuration.srs_code = 3116
configuration.post_script = CTM12_GPKG_SCRIPT_PATH
full_java_exe_path = JavaDependency.get_full_java_exe_path()
if full_java_exe_path:
self.base_configuration.java_path = full_java_exe_path
# User could have changed the default values
self.use_local_models = QSettings().value(
'Asistente-LADM-COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool)
self.custom_model_directories = QSettings().value(
'Asistente-LADM-COL/models/custom_models', DEFAULT_MODELS_DIR)
# Check custom model directories
if self.use_local_models:
if not self.custom_model_directories:
self.base_configuration.custom_model_directories_enabled = False
else:
self.base_configuration.custom_model_directories = self.custom_model_directories
self.base_configuration.custom_model_directories_enabled = True
configuration.base_configuration = self.base_configuration
if self.get_checked_models():
configuration.ilimodels = ';'.join(self.get_checked_models())
return configuration
def apply_role_model_configuration(self, configuration):
"""
Applies the configuration that the active role has set over checked models.
Important:
Note that this works better if the checked models are limited to one (e.g. Field Data Capture) or limited to
a group of related models (e.g., the 3 supplies models). When the checked models are heterogeneous, results
start to be unpredictable, as the configuration for a single model may affect the others.
:param configuration: SchemaImportConfiguration object
:return: configuration object updated
"""
for checked_model in self.get_checked_models():
model = self.__ladmcol_models.model_by_full_name(checked_model)
params = model.get_ili2db_params()
if ILI2DB_SCHEMAIMPORT in params:
for param in params[ILI2DB_SCHEMAIMPORT]: # List of tuples
if param[
0] == ILI2DB_CREATE_BASKET_COL_KEY: # param: (option, value)
configuration.create_basket_col = True
self.logger.debug(
__name__,
"Schema Import createBasketCol enabled! (taken from role config)"
)
return configuration
def print_info(self, text, text_color='#000000', clear=False):
self.txtStdout.setTextColor(QColor(text_color))
self.txtStdout.append(text)
QCoreApplication.processEvents()
def on_stderr(self, text):
color_log_text(text, self.txtStdout)
self.advance_progress_bar_by_text(text)
def on_process_started(self, command):
self.txtStdout.setText(command)
QCoreApplication.processEvents()
def on_process_finished(self, exit_code, result):
if exit_code == 0:
color = '#004905'
message = QCoreApplication.translate(
"DialogImportSchema",
"Model(s) successfully imported into the database!")
else:
color = '#aa2222'
message = QCoreApplication.translate("DialogImportSchema",
"Finished with errors!")
# Open log
if self.log_config.isCollapsed():
self.log_config.setCollapsed(False)
self.txtStdout.setTextColor(QColor(color))
self.txtStdout.append(message)
def advance_progress_bar_by_text(self, text):
if text.strip() == 'Info: compile models…':
self.progress_bar.setValue(20)
QCoreApplication.processEvents()
elif text.strip() == 'Info: create table structure…':
self.progress_bar.setValue(70)
QCoreApplication.processEvents()
def clear_messages(self):
self.bar.clearWidgets(
) # Remove previous messages before showing a new one
self.txtStdout.clear() # Clear previous log messages
self.progress_bar.setValue(0) # Initialize progress bar
def show_help(self):
show_plugin_help("import_schema")
def disable(self):
self.db_config.setEnabled(False)
self.ili_config.setEnabled(False)
self.buttonBox.setEnabled(False)
def enable(self):
self.db_config.setEnabled(True)
self.ili_config.setEnabled(True)
self.buttonBox.setEnabled(True)
def show_message(self, message, level):
if level == Qgis.Warning:
self.enable()
self.bar.clearWidgets(
) # Remove previous messages before showing a new one
self.bar.pushMessage("Asistente LADM-COL", message, level, duration=0)
class BasketExporter(QObject):
total_progress_updated = pyqtSignal(int) # percentage
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 export_baskets(self):
java_home_set = self.java_dependency.set_java_home()
if not java_home_set:
message_java = QCoreApplication.translate("BasketExporter", """Configuring Java {}...""").format(
JAVA_REQUIRED_VERSION)
self.logger.status(message_java)
self.java_dependency.get_java_on_demand()
return
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
db_factory = self._dbs_supported.get_db_factory(self._db.engine)
self.configuration = ExportConfiguration()
db_factory.set_ili2db_configuration_params(self._db.dict_conn_params, self.configuration)
self.configuration.with_exporttid = True
full_java_exe_path = JavaDependency.get_full_java_exe_path()
if full_java_exe_path:
self.base_configuration.java_path = full_java_exe_path
# Check custom model directories
if QSettings().value('Asistente-LADM-COL/models/custom_model_directories_is_checked', DEFAULT_USE_CUSTOM_MODELS, type=bool):
custom_model_directories = QSettings().value('Asistente-LADM-COL/models/custom_models', DEFAULT_MODELS_DIR)
if not custom_model_directories:
self.base_configuration.custom_model_directories_enabled = False
else:
self.base_configuration.custom_model_directories = custom_model_directories
self.base_configuration.custom_model_directories_enabled = True
self.ilicache.refresh() # Always call it after setting custom_model_directories
self.configuration.base_configuration = self.base_configuration
if self.get_ili_models():
self.configuration.ilimodels = ';'.join(self.get_ili_models())
self.exporter = iliexporter.Exporter()
self.exporter.tool = db_factory.get_model_baker_db_ili_mode()
self.exporter.process_started.connect(self.on_process_started)
self.exporter.stderr.connect(self.on_stderr)
#self.exporter.process_finished.connect(self.on_process_finished)
res = dict()
count = 0
total = len(self._basket_dict)
with OverrideCursor(Qt.WaitCursor):
for basket,name in self._basket_dict.items():
self.log = ''
self.configuration.xtffile = os.path.join(self._export_dir, "{}.xtf".format(name))
self.configuration.baskets = basket
self.exporter.configuration = self.configuration
try:
if self.exporter.run() != iliexporter.Exporter.SUCCESS:
msg = QCoreApplication.translate("BasketExporter", "An error occurred when exporting the data for '{}' (check the QGIS log panel).").format(name)
res[basket] = (False, msg)
QgsMessageLog.logMessage(self.log, QCoreApplication.translate("BasketExporter", "Allocate to coordinators"), Qgis.Critical)
else:
res[basket] = (True, QCoreApplication.translate("BasketExporter", "XTF export for '{}' successful!").format(name) )
except JavaNotFoundError:
msg = QCoreApplication.translate("BasketExporter", "Java {} could not be found. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again.").format(JAVA_REQUIRED_VERSION)
res[basket] = (False, msg)
count += 1
self.total_progress_updated.emit(count/total*100)
return res
def get_ili_models(self):
ili_models = list()
model_names = self._db.get_models()
if model_names:
for model in LADMColModelRegistry().supported_models():
if not model.hidden() and model.full_name() in model_names:
ili_models.append(model.full_name())
return ili_models
def download_java_complete(self):
self.export_baskets()
#def on_process_finished(self):
# self.run_export()
#if self._basket_dict:
# basket, = self._basket_dict.popitem()
def on_process_started(self, command):
self.log += command + '\n'
def on_stderr(self, text):
self.log += text
class ConnectionManager(QObject):
"""
Access point to get and set DB Connectors used by the plugin.
The plugin uses a DB Connector for Cadastral data collection (barrido) and one for the Supplies cadastral data.
Other connections might be needed (e.g., while retrieving databases for the server in the settings dialog, but they
are not handled by this class).
"""
db_connection_changed = pyqtSignal(DBConnector, bool, str) # dbconn, ladm_col_db, db_source
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
self.dbs_supported = ConfigDBsSupported()
self._db_sources = { # Values are DB Connectors
COLLECTED_DB_SOURCE: None,
SUPPLIES_DB_SOURCE: None
}
self.encrypter_decrypter = EncrypterDecrypter()
def get_db_connection_from_qsettings(self, db_source=COLLECTED_DB_SOURCE):
db_connection_engine = QSettings().value('Asistente-LADM-COL/db/{db_source}/db_connection_engine'.format(db_source=db_source))
if db_connection_engine:
db_factory = self.dbs_supported.get_db_factory(db_connection_engine)
dict_conn = db_factory.get_parameters_conn(db_source)
db = db_factory.get_db_connector(dict_conn)
db.open_connection() # Open db connection
else:
# Use the default connector
db_factory = self.dbs_supported.get_db_factory(self.dbs_supported.id_default_db)
db = db_factory.get_db_connector() # When the connection parameters are not filled we use empty values
return db
def update_db_connector_for_source(self, db_source=COLLECTED_DB_SOURCE):
db = self.get_db_connection_from_qsettings(db_source)
self.set_db_connector_for_source(db, db_source)
def get_db_connector_from_source(self, db_source=COLLECTED_DB_SOURCE):
if self._db_sources[db_source] is None:
# Obtain the connection of the database on demand
self.update_db_connector_for_source(db_source)
return self._db_sources[db_source]
def set_db_connector_for_source(self, db_connector, db_source=COLLECTED_DB_SOURCE):
try:
if self._db_sources[db_source]:
self._db_sources[db_source].close_connection()
self._db_sources[db_source] = db_connector
except:
self.logger.info(__name__, QCoreApplication.translate("ConnectionManager", "An error occurred while trying to close the connection."))
def close_db_connections(self):
for _db_source in self._db_sources:
if self._db_sources[_db_source]:
self._db_sources[_db_source].close_connection()
def get_opened_db_connector_for_tests(self, db_engine, conn_dict):
"""
This function is implemented for tests. Connection to non-LADM databases.
"""
db_factory = self.dbs_supported.get_db_factory(db_engine)
db = db_factory.get_db_connector(conn_dict)
db.open_connection()
return db
def get_encrypted_db_connector(self, db_engine, conn_dict):
"""
Receives encrypted connection parameters and returns a DB connector from them.
:param db_engine: Example: 'pg' or 'gpkg'
:param conn_dict: Connection dict with Encrypted values.
:return: DB Connector object
"""
decrypted_conn_dict = {}
for k, v in conn_dict.items():
decrypted_conn_dict[k] = self.encrypter_decrypter.decrypt_with_AES(v)
db_factory = self.dbs_supported.get_db_factory(db_engine)
db = db_factory.get_db_connector(decrypted_conn_dict)
return db
def save_parameters_conn(self, db, db_source):
"""
Save db connection parameters from a DB connector to QSettings
:param db: DB Connector
:param db_source:
"""
self.dbs_supported.get_db_factory(db.engine).save_parameters_conn(db.dict_conn_params, db_source)
self.update_db_connector_for_source(db_source) # Update db connection with new parameters
def __init__(self, iface, conn_manager, context, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.conn_manager = conn_manager
self.db_source = context.get_db_sources()[0]
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.logger = Logger()
self.app = AppInterface()
self.java_dependency = JavaDependency()
self.java_dependency.download_dependency_completed.connect(
self.download_java_complete)
self.java_dependency.download_dependency_progress_changed.connect(
self.download_java_progress_change)
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._dbs_supported = ConfigDBsSupported()
self._running_tool = False
# There may be 1 case where we need to emit a db_connection_changed from the Export Data dialog:
# 1) Connection Settings was opened and the DB conn was changed.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in 1 case:
# 1) If the ED dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
self._schedule_layers_and_relations_refresh = False
# We need bar definition above calling clear_messages
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.xtf_file_browse_button.clicked.connect(
make_save_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate("DialogExportData",
"Save in XTF Transfer File"),
file_filter=QCoreApplication.translate(
"DialogExportData",
"XTF Transfer File (*.xtf);;Interlis 1 Transfer File (*.itf);;XML (*.xml);;GML (*.gml)"
),
extension='.xtf',
extensions=['.' + ext for ext in self.ValidExtensions]))
self.xtf_file_browse_button.clicked.connect(
self.xtf_browser_opened_to_true)
self.xtf_browser_was_opened = False
self.validators = Validators()
fileValidator = FileValidator(
pattern=['*.' + ext for ext in self.ValidExtensions],
allow_non_existing=True)
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogExportData",
"[Name of the XTF to be created]"))
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.xtf_file_line_edit.textChanged.connect(
self.xtf_browser_opened_to_false)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogExportData",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogExportData", "Show log"))
self.log_config.setFlat(True)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
QCoreApplication.translate("DialogExportData", "Export data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.update_model_names()
self.restore_configuration()
class DialogExportData(QDialog, DIALOG_UI):
on_result = pyqtSignal(
bool) # whether the tool was run successfully or not
ValidExtensions = ['xtf', 'itf', 'gml', 'xml']
current_row_schema = 0
def __init__(self, iface, conn_manager, context, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.conn_manager = conn_manager
self.db_source = context.get_db_sources()[0]
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.logger = Logger()
self.app = AppInterface()
self.java_dependency = JavaDependency()
self.java_dependency.download_dependency_completed.connect(
self.download_java_complete)
self.java_dependency.download_dependency_progress_changed.connect(
self.download_java_progress_change)
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._dbs_supported = ConfigDBsSupported()
self._running_tool = False
# There may be 1 case where we need to emit a db_connection_changed from the Export Data dialog:
# 1) Connection Settings was opened and the DB conn was changed.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in 1 case:
# 1) If the ED dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
self._schedule_layers_and_relations_refresh = False
# We need bar definition above calling clear_messages
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.xtf_file_browse_button.clicked.connect(
make_save_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate("DialogExportData",
"Save in XTF Transfer File"),
file_filter=QCoreApplication.translate(
"DialogExportData",
"XTF Transfer File (*.xtf);;Interlis 1 Transfer File (*.itf);;XML (*.xml);;GML (*.gml)"
),
extension='.xtf',
extensions=['.' + ext for ext in self.ValidExtensions]))
self.xtf_file_browse_button.clicked.connect(
self.xtf_browser_opened_to_true)
self.xtf_browser_was_opened = False
self.validators = Validators()
fileValidator = FileValidator(
pattern=['*.' + ext for ext in self.ValidExtensions],
allow_non_existing=True)
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogExportData",
"[Name of the XTF to be created]"))
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.xtf_file_line_edit.textChanged.connect(
self.xtf_browser_opened_to_false)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogExportData",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogExportData", "Show log"))
self.log_config.setFlat(True)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
QCoreApplication.translate("DialogExportData", "Export data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.update_model_names()
self.restore_configuration()
def update_connection_info(self):
db_description = self.db.get_description_conn_string()
if db_description:
self.db_connect_label.setText(db_description)
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self._accept_button.setEnabled(True)
else:
self.db_connect_label.setText(
QCoreApplication.translate("DialogExportData",
"The database is not defined!"))
self.db_connect_label.setToolTip('')
self._accept_button.setEnabled(False)
def update_model_names(self):
self.export_models_qmodel = QStandardItemModel()
model_names = self.db.get_models()
if model_names:
for model in LADMColModelRegistry().supported_models():
if not model.hidden() and model.full_name() in model_names:
item = QStandardItem(model.full_alias())
item.setData(model.full_name(), Qt.UserRole)
item.setCheckable(False)
item.setEditable(False)
self.export_models_qmodel.appendRow(item)
self.export_models_list_view.setModel(self.export_models_qmodel)
def reject(self):
if self._running_tool:
QMessageBox.information(
self, QCoreApplication.translate("DialogExportData",
"Warning"),
QCoreApplication.translate(
"DialogExportData",
"The Export Data tool is still running. Please wait until it finishes."
))
else:
self.close_dialog()
def close_dialog(self):
"""
We use this method to be safe when emitting the db_connection_changed, otherwise we could trigger slots that
unload the plugin, destroying dialogs and thus, leading to crashes.
"""
if self._schedule_layers_and_relations_refresh:
self.conn_manager.db_connection_changed.connect(
self.app.core.cache_layers_and_relations)
if self._db_was_changed:
# If the db was changed, it implies it complies with ladm_col, hence the second parameter
self.conn_manager.db_connection_changed.emit(
self.db, True, self.db_source)
if self._schedule_layers_and_relations_refresh:
self.conn_manager.db_connection_changed.disconnect(
self.app.core.cache_layers_and_relations)
self.logger.info(__name__, "Dialog closed.")
self.done(QDialog.Accepted)
def get_ili_models(self):
ili_models = list()
for index in range(self.export_models_qmodel.rowCount()):
item = self.export_models_qmodel.item(index)
ili_models.append(item.data(Qt.UserRole))
return ili_models
def show_settings(self):
# We only need those tabs related to Model Baker/ili2db operations
dlg = SettingsDialog(self.conn_manager, parent=self)
dlg.setWindowTitle(
QCoreApplication.translate("DialogExportData",
"Source DB Connection Settings"))
dlg.show_tip(
QCoreApplication.translate(
"DialogExportData",
"Configure which DB you want to export data from."))
dlg.set_db_source(self.db_source)
dlg.set_tab_pages_list(
[SETTINGS_CONNECTION_TAB_INDEX, SETTINGS_MODELS_TAB_INDEX])
# Connect signals (DBUtils, Core)
dlg.db_connection_changed.connect(self.db_connection_changed)
if self.db_source == COLLECTED_DB_SOURCE:
self._schedule_layers_and_relations_refresh = True
dlg.set_action_type(EnumDbActionType.EXPORT)
if dlg.exec_():
self.db = dlg.get_db_connection()
self.update_model_names()
self.update_connection_info()
def db_connection_changed(self, db, ladm_col_db, db_source):
self._db_was_changed = True
self.clear_messages()
def accepted(self):
self._running_tool = True
self.txtStdout.clear()
self.progress_bar.setValue(0)
self.bar.clearWidgets()
java_home_set = self.java_dependency.set_java_home()
if not java_home_set:
message_java = QCoreApplication.translate(
"DialogExportData",
"""Configuring Java {}...""").format(JAVA_REQUIRED_VERSION)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(message_java)
self.java_dependency.get_java_on_demand()
self.disable()
return
configuration = self.update_configuration()
if configuration.disable_validation: # If data validation at export is disabled, we ask for confirmation
self.msg = QMessageBox()
self.msg.setIcon(QMessageBox.Question)
self.msg.setText(
QCoreApplication.translate(
"DialogExportData",
"Are you sure you want to export your data without validation?"
))
self.msg.setWindowTitle(
QCoreApplication.translate("DialogExportData",
"Export XTF without validation?"))
self.msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
res = self.msg.exec_()
if res == QMessageBox.No:
self._running_tool = False
return
if not self.xtf_file_line_edit.validator().validate(
configuration.xtffile, 0)[0] == QValidator.Acceptable:
self._running_tool = False
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set a valid XTF file before exporting data.")
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
return
if not self.get_ili_models():
self._running_tool = False
message_error = QCoreApplication.translate(
"DialogExportData",
"Please set a valid schema to export. This schema does not have information to export."
)
self.txtStdout.setText(message_error)
self.show_message(message_error, Qgis.Warning)
self.export_models_list_view.setFocus()
return
# If xtf browser was opened and the file exists, the user already chose
# to overwrite the file
if os.path.isfile(self.xtf_file_line_edit.text().strip()
) and not self.xtf_browser_was_opened:
self.msg = QMessageBox()
self.msg.setIcon(QMessageBox.Warning)
self.msg.setText(
QCoreApplication.translate(
"DialogExportData",
"{filename} already exists.\nDo you want to replace it?").
format(filename=os.path.basename(
self.xtf_file_line_edit.text().strip())))
self.msg.setWindowTitle(
QCoreApplication.translate("DialogExportData",
"Save in XTF Transfer File"))
self.msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
msg_box = self.msg.exec_()
if msg_box == QMessageBox.No:
self._running_tool = False
return
with OverrideCursor(Qt.WaitCursor):
self.progress_bar.show()
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
exporter = iliexporter.Exporter()
db_factory = self._dbs_supported.get_db_factory(self.db.engine)
exporter.tool = db_factory.get_model_baker_db_ili_mode()
exporter.configuration = configuration
self.save_configuration(configuration)
exporter.stdout.connect(self.print_info)
exporter.stderr.connect(self.on_stderr)
exporter.process_started.connect(self.on_process_started)
exporter.process_finished.connect(self.on_process_finished)
self.progress_bar.setValue(25)
try:
if exporter.run() != iliexporter.Exporter.SUCCESS:
self._running_tool = False
self.show_message(
QCoreApplication.translate(
"DialogExportData",
"An error occurred when exporting the data. For more information see the log..."
), Qgis.Warning)
self.on_result.emit(
False
) # Inform other classes that the execution was not successful
return
except JavaNotFoundError:
self._running_tool = False
message_error_java = QCoreApplication.translate(
"DialogExportData",
"Java {} could not be found. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again."
).format(JAVA_REQUIRED_VERSION)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(message_error_java)
self.show_message(message_error_java, Qgis.Warning)
return
self._running_tool = False
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
self.progress_bar.setValue(100)
self.show_message(
QCoreApplication.translate(
"DialogExportData",
"Export of the data was successfully completed."),
Qgis.Success)
self.on_result.emit(
True) # Inform other classes that the execution was successful
def download_java_complete(self):
self.accepted()
def download_java_progress_change(self, progress):
self.progress_bar.setValue(progress / 2)
if (progress % 20) == 0:
self.txtStdout.append('...')
def save_configuration(self, configuration):
settings = QSettings()
settings.setValue(
'Asistente-LADM-COL/QgisModelBaker/ili2pg/xtffile_export',
configuration.xtffile)
settings.setValue('Asistente-LADM-COL/QgisModelBaker/show_log',
not self.log_config.isCollapsed())
def restore_configuration(self):
settings = QSettings()
self.xtf_file_line_edit.setText(
settings.value(
'Asistente-LADM-COL/QgisModelBaker/ili2pg/xtffile_export'))
# Show log
value_show_log = settings.value(
'Asistente-LADM-COL/QgisModelBaker/show_log', False, type=bool)
self.log_config.setCollapsed(not value_show_log)
# set model repository
# if there is no option by default use online model repository
custom_model_is_checked = settings.value(
'Asistente-LADM-COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool)
if custom_model_is_checked:
self.custom_model_directories = settings.value(
'Asistente-LADM-COL/models/custom_models', DEFAULT_MODELS_DIR)
def update_configuration(self):
"""
Get the configuration that is updated with the user configuration changes on the dialog.
:return: Configuration
"""
db_factory = self._dbs_supported.get_db_factory(self.db.engine)
configuration = ExportConfiguration()
db_factory.set_ili2db_configuration_params(self.db.dict_conn_params,
configuration)
configuration.xtffile = self.xtf_file_line_edit.text().strip()
configuration.with_exporttid = True
full_java_exe_path = JavaDependency.get_full_java_exe_path()
if full_java_exe_path:
self.base_configuration.java_path = full_java_exe_path
# User could have changed the default values
self.use_local_models = QSettings().value(
'Asistente-LADM-COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool)
self.custom_model_directories = QSettings().value(
'Asistente-LADM-COL/models/custom_models', DEFAULT_MODELS_DIR)
# Check custom model directories
if self.use_local_models:
if not self.custom_model_directories:
self.base_configuration.custom_model_directories_enabled = False
else:
self.base_configuration.custom_model_directories = self.custom_model_directories
self.base_configuration.custom_model_directories_enabled = True
configuration.base_configuration = self.base_configuration
if self.get_ili_models():
configuration.ilimodels = ';'.join(self.get_ili_models())
configuration.disable_validation = not QSettings().value(
'Asistente-LADM-COL/models/validate_data_importing_exporting',
True, bool)
return configuration
def print_info(self, text, text_color='#000000', clear=False):
self.txtStdout.setTextColor(QColor(text_color))
self.txtStdout.append(text)
QCoreApplication.processEvents()
def on_stderr(self, text):
color_log_text(text, self.txtStdout)
self.advance_progress_bar_by_text(text)
def on_process_started(self, command):
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(command)
QCoreApplication.processEvents()
def on_process_finished(self, exit_code, result):
color = '#004905' if exit_code == 0 else '#aa2222'
self.txtStdout.setTextColor(QColor(color))
self.txtStdout.append(
QCoreApplication.translate("DialogExportData",
"Finished ({})").format(exit_code))
if result == iliexporter.Exporter.SUCCESS:
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
else:
self.enable()
# Open log
if self.log_config.isCollapsed():
self.log_config.setCollapsed(False)
def advance_progress_bar_by_text(self, text):
if text.strip() == 'Info: compile models...':
self.progress_bar.setValue(50)
QCoreApplication.processEvents()
elif text.strip() == 'Info: process data...':
self.progress_bar.setValue(55)
QCoreApplication.processEvents()
elif text.strip() == 'Info: first validation pass...':
self.progress_bar.setValue(70)
QCoreApplication.processEvents()
elif text.strip() == 'Info: second validation pass...':
self.progress_bar.setValue(85)
QCoreApplication.processEvents()
def clear_messages(self):
self.bar.clearWidgets(
) # Remove previous messages before showing a new one
self.txtStdout.clear() # Clear previous log messages
self.progress_bar.setValue(0) # Initialize progress bar
def show_help(self):
show_plugin_help("export_data")
def disable(self):
self.source_config.setEnabled(False)
self.target_config.setEnabled(False)
self.buttonBox.setEnabled(False)
def enable(self):
self.source_config.setEnabled(True)
self.target_config.setEnabled(True)
self.buttonBox.setEnabled(True)
def show_message(self, message, level):
if level == Qgis.Warning:
self.enable()
self.bar.clearWidgets(
) # Remove previous messages before showing a new one
self.bar.pushMessage("Asistente LADM-COL", message, level, duration=0)
def xtf_browser_opened_to_true(self):
"""
Slot. Sets a flag to true to eventually avoid asking a user whether to overwrite a file.
"""
self.xtf_browser_was_opened = True
def xtf_browser_opened_to_false(self):
"""
Slot. Sets a flag to false to eventually ask a user whether to overwrite a file.
"""
self.xtf_browser_was_opened = False
self.clear_messages()
class LADMQueryController(QObject):
close_view_requested = pyqtSignal()
zoom_to_features_requested = pyqtSignal(QgsVectorLayer, list,
dict) # layer, ids, t_ids
def __init__(self, db, ladm_data):
QObject.__init__(self)
self._db = db
self._ladm_data = ladm_data
self.logger = Logger()
self.app = AppInterface()
self.clipboard = QApplication.clipboard()
self._layers = dict()
self._ladm_queries = ConfigDBsSupported().get_db_factory(
self._db.engine).get_ladm_queries()
self._restart_dict_of_layers()
self._add_layers()
# To cache informal parcels,
self._informal_parcels_info = tuple(
) # ([parcel_t_id: parcel_number], [,], [,], ...)
self._informal_index = -1
self._informal_parcels_len = 0 # To avoid calculating this each time
def _add_layers(self):
self.app.core.get_layers(self._db, self._layers, load=True)
if not self._layers:
self._restart_dict_of_layers() # Let it ready for the next call
return None
# Layer was found, listen to its removal so that we can deactivate the custom tool when that occurs
self.disconnect_plot_layer()
self._layers[self._db.names.LC_PLOT_T].willBeDeleted.connect(
self._plot_layer_removed)
# Layer was found, listen to its removal so that we can update the variable properly
self.disconnect_parcel_layer()
self._layers[self._db.names.LC_PARCEL_T].willBeDeleted.connect(
self._parcel_layer_removed)
# Layer was found, listen to its removal so that we can update the variable properly
try:
self._layers[
self._db.names.COL_UE_BAUNIT_T].willBeDeleted.disconnect(
self._uebaunit_table_removed)
except:
pass
self._layers[self._db.names.COL_UE_BAUNIT_T].willBeDeleted.connect(
self._uebaunit_table_removed)
def _restart_dict_of_layers(self):
self._layers = {
self._db.names.LC_PLOT_T: None,
self._db.names.LC_PARCEL_T: None,
self._db.names.COL_UE_BAUNIT_T: None
}
def plot_layer(self):
if self._layers[self._db.names.LC_PLOT_T] is None:
self._add_layers()
return self._layers[self._db.names.LC_PLOT_T]
def parcel_layer(self):
if self._layers[self._db.names.LC_PARCEL_T] is None:
self._add_layers()
return self._layers[self._db.names.LC_PARCEL_T]
def uebaunit_table(self):
if self._layers[self._db.names.COL_UE_BAUNIT_T] is None:
self._add_layers()
return self._layers[self._db.names.COL_UE_BAUNIT_T]
def _plot_layer_removed(self):
# The required layer was removed
self.close_view_requested.emit()
self._layers[self._db.names.LC_PLOT_T] = None
def _parcel_layer_removed(self):
self._layers[self._db.names.LC_PARCEL_T] = None
def _uebaunit_table_removed(self):
self._layers[self._db.names.COL_UE_BAUNIT_T] = None
def disconnect_plot_layer(self):
try:
self._layers[self._db.names.LC_PLOT_T].willBeDeleted.disconnect(
self._plot_layer_removed)
except:
pass
def disconnect_parcel_layer(self):
try:
self._layers[self._db.names.LC_PARCEL_T].willBeDeleted.disconnect(
self._parcel_layer_removed)
except:
pass
def parcel_layer_name(self):
return self._db.names.LC_PARCEL_T
def t_id_name(self):
return self._db.names.T_ID_F
def parcel_number_name(self):
return self._db.names.LC_PARCEL_T_PARCEL_NUMBER_F
def previous_parcel_number_name(self):
return self._db.names.LC_PARCEL_T_PREVIOUS_PARCEL_NUMBER_F
def fmi_name(self):
return self._db.names.LC_PARCEL_T_FMI_F
def create_model(self, records):
return TreeModel(self._db.names, data=records)
def update_db_connection(self, db, ladm_col_db, db_source):
self.close_view_requested.emit()
def copy_value(self, value):
self.clipboard.setText(str(value))
def open_url(self, url):
webbrowser.open(url)
def zoom_to_feature(self, layer, t_id):
self.zoom_to_features_requested.emit(layer, list(),
{self._db.names.T_ID_F: [t_id]})
def zoom_to_plots(self, plot_ids):
self.zoom_to_features_requested.emit(self.plot_layer(), plot_ids,
dict())
def zoom_to_resulting_plots(self, records):
# Zoom to plots retrieved from a search
plot_t_ids = self._get_plot_t_ids_from_basic_info(records)
if plot_t_ids:
features = self._ladm_data.get_features_from_t_ids(
self._layers[self._db.names.LC_PLOT_T], self._db.names.T_ID_F,
plot_t_ids, True, True)
plot_ids = [feature.id() for feature in features]
self.zoom_to_features_requested.emit(self.plot_layer(), plot_ids,
dict())
self.plot_layer().selectByIds(plot_ids)
def _get_plot_t_ids_from_basic_info(self, records):
res = []
if records:
if self._db.names.LC_PLOT_T in records:
for element in records[self._db.names.LC_PLOT_T]:
res.append(element['id'])
return res
def open_feature_form(self, layer, t_id):
# Note that it is important to fetch all feature attributes from the next call
features = self._ladm_data.get_features_from_t_ids(
layer, self._db.names.T_ID_F, [t_id], no_geometry=True)
if features:
self.app.gui.open_feature_form(layer, features[0])
else:
self.logger.warning(
__name__,
"No feature found in layer '{}' with t_id '{}'!!!".format(
layer.name(), t_id))
def download_image(self, url):
res = False
img = None
msg = {'text': '', 'level': Qgis.Warning}
if url:
self.logger.info(__name__, "Downloading file from {}".format(url))
msg_status_bar = "Downloading image from document repository (this might take a while)..."
with ProcessWithStatus(msg_status_bar):
if is_connected(TEST_SERVER):
nam = QNetworkAccessManager()
request = QNetworkRequest(QUrl(url))
reply = nam.get(request)
loop = QEventLoop()
reply.finished.connect(loop.quit)
loop.exec_()
status = reply.attribute(
QNetworkRequest.HttpStatusCodeAttribute)
if status == 200:
res = True
img = reply.readAll()
else:
res = False
msg['text'] = QCoreApplication.translate(
"SettingsDialog",
"There was a problem connecting to the server. The server might be down or the service cannot be reached at the given URL."
)
else:
res = False
msg['text'] = QCoreApplication.translate(
"SettingsDialog",
"There was a problem connecting to Internet.")
else:
res = False
msg['text'] = QCoreApplication.translate("SettingsDialog",
"Not valid URL")
if not res:
self.logger.log_message(__name__, msg['text'], msg['level'])
return res, img
def get_plots_related_to_parcel(self, parcel_t_id):
return self._ladm_data.get_plots_related_to_parcels(
self._db, [parcel_t_id], None, self.plot_layer(),
self.uebaunit_table())
def get_layer(self, table_name):
return self.app.core.get_layer(self._db, table_name, True)
def search_data_basic_info(self, **kwargs):
return self._ladm_queries.get_igac_basic_info(self._db, **kwargs)
def search_data_legal_info(self, **kwargs):
return self._ladm_queries.get_igac_legal_info(self._db, **kwargs)
def search_data_physical_info(self, **kwargs):
return self._ladm_queries.get_igac_physical_info(self._db, **kwargs)
def search_data_economic_info(self, **kwargs):
return self._ladm_queries.get_igac_economic_info(self._db, **kwargs)
def query_informal_parcels(self):
"""
:return: Triple --> parcel_number, current, total
"""
# We always go to the DB to get informality info
parcel_layer = self.app.core.get_layer(self._db,
self._db.names.LC_PARCEL_T,
True)
informal_parcel_t_ids = self._ladm_data.get_informal_parcel_tids(
self._db, parcel_layer)
# Overwrite cache
self._informal_parcels_info = tuple()
self._informal_index = -1
self._informal_parcels_len = 0
if informal_parcel_t_ids:
# Get parcel info ordered by parcel number
parcels = self._ladm_data.get_features_from_t_ids(
self.parcel_layer(),
self._db.names.T_ID_F,
informal_parcel_t_ids,
no_attributes=False,
no_geometry=False,
only_attributes=[self._db.names.LC_PARCEL_T_PARCEL_NUMBER_F],
order_by=self._db.names.LC_PARCEL_T_PARCEL_NUMBER_F)
# Create a tuple of lists ([t_id: parcel_number], ...)
self._informal_parcels_info = tuple([
p[self._db.names.T_ID_F], p[
self._db.names.LC_PARCEL_T_PARCEL_NUMBER_F]
] for p in parcels)
self._informal_parcels_len = len(self._informal_parcels_info)
return self.get_next_informal_parcel()
def get_next_informal_parcel(self):
return self._traverse_informal_parcel_info()
def get_previous_informal_parcel(self):
return self._traverse_informal_parcel_info(False)
def _traverse_informal_parcel_info(self, next=True):
"""
Get a triple corresponding to an informal parcel number, the current index and the total of parcels.
Note that if we get to the end and ask for the next parcel, we start over again. Similarly. if we are in the 1st
parcel and ask for the previous one, then we get the latest one.
:param next: Whether we need the next parcel's info or the previous one.
:return: Triple --> parcel_number, current_idx, total_parcels (the current_idx returned is for display purposes)
"""
if not self._informal_parcels_len:
return '', 0, 0
index = self._informal_index # Get current index
if next: # Now set the current index
self._informal_index = index + 1 if index + 1 < self._informal_parcels_len else 0
else: # Previous
self._informal_index = index - 1 if index >= 1 else self._informal_parcels_len - 1
return self._informal_parcels_info[self._informal_index][
1], self._informal_index + 1, self._informal_parcels_len
def __init__(self,
iface,
conn_manager,
context,
selected_models=list(),
link_to_import_data=True,
parent=None):
QDialog.__init__(self, parent)
self.iface = iface
self.conn_manager = conn_manager
self.selected_models = selected_models
self.link_to_import_data = link_to_import_data
self.logger = Logger()
self.app = AppInterface()
self.__ladmcol_models = LADMColModelRegistry()
self.java_dependency = JavaDependency()
self.java_dependency.download_dependency_completed.connect(
self.download_java_complete)
self.java_dependency.download_dependency_progress_changed.connect(
self.download_java_progress_change)
self.db_source = context.get_db_sources()[0]
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self._dbs_supported = ConfigDBsSupported()
self._running_tool = False
# There may be two cases where we need to emit a db_connection_changed from the Schema Import dialog:
# 1) Connection Settings was opened and the DB conn was changed.
# 2) Connection Settings was never opened but the Schema Import ran successfully, in a way that new models may
# convert a db/schema LADM-COL compliant.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in two cases:
# 1) If the SI dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
# 2) Not opening the Connection Settings, but running a successful Schema Import on the COLLECTED DB, which
# invalidates the cache as models change.
self._schedule_layers_and_relations_refresh = False
self.setupUi(self)
self.validators = Validators()
self.update_import_models()
self.previous_item = QListWidgetItem()
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportSchema",
"Connection Settings"))
# CRS Setting
self.srs_auth = DEFAULT_SRS_AUTH
self.srs_code = DEFAULT_SRS_CODE
self.crsSelector.crsChanged.connect(self.crs_changed)
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportSchema", "Show log"))
self.buttonBox.accepted.disconnect()
self.buttonBox.clicked.connect(self.accepted_import_schema)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
self.BUTTON_NAME_CREATE_STRUCTURE, QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.import_models_list_widget.setDisabled(bool(
selected_models)) # If we got models from params, disable panel
self.update_connection_info()
self.restore_configuration()
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
class QgisModelBakerUtils(QObject):
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
from asistente_ladm_col.config.config_db_supported import ConfigDBsSupported
self._dbs_supported = ConfigDBsSupported()
self.translatable_config_strings = TranslatableConfigStrings()
def get_generator(self, db):
if 'QgisModelBaker' in qgis.utils.plugins:
tool = self._dbs_supported.get_db_factory(
db.engine).get_model_baker_db_ili_mode()
QgisModelBaker = qgis.utils.plugins["QgisModelBaker"]
generator = QgisModelBaker.get_generator()(
tool, db.uri, "smart2", db.schema, pg_estimated_metadata=False)
return generator
else:
self.logger.critical(
__name__,
QCoreApplication.translate(
"AsistenteLADMCOLPlugin",
"The QGIS Model Baker plugin is a prerequisite, install it before using LADM-COL Assistant."
))
return None
def get_model_baker_db_connection(self, db):
generator = self.get_generator(db)
if generator is not None:
return generator._db_connector
return None
def load_layers(self, db, layer_list):
"""
Load a selected list of layers from qgis model baker.
This call should configure relations and bag of enums
between layers being loaded, but not when a layer already
loaded has a relation or is part of a bag of enum. For
that case, we use a cached set of relations and bags of
enums that we get only once per session and configure in
the Asistente LADM-COL.
"""
translated_strings = self.translatable_config_strings.get_translatable_config_strings(
)
if 'QgisModelBaker' in qgis.utils.plugins:
QgisModelBaker = qgis.utils.plugins["QgisModelBaker"]
tool = self._dbs_supported.get_db_factory(
db.engine).get_model_baker_db_ili_mode()
generator = QgisModelBaker.get_generator()(
tool, db.uri, "smart2", db.schema, pg_estimated_metadata=False)
layers = generator.layers(layer_list)
relations, bags_of_enum = generator.relations(layers, layer_list)
legend = generator.legend(
layers,
ignore_node_names=[translated_strings[ERROR_LAYER_GROUP]])
QgisModelBaker.create_project(layers,
relations,
bags_of_enum,
legend,
auto_transaction=False)
else:
self.logger.critical(
__name__,
QCoreApplication.translate(
"AsistenteLADMCOLPlugin",
"The QGIS Model Baker plugin is a prerequisite, install it before using LADM-COL Assistant."
))
def get_required_layers_without_load(self, layer_list, db):
"""
Gets a list of layers from a list of layer names using QGIS Model Baker.
Layers are register in QgsProject, but not loaded to the canvas!
:param layer_list: list of layers names (e.g., ['lc_terreno', 'lc_lindero'])
:param db: db connection
:return: list of QgsVectorLayers registered in the project
"""
layers = list()
if 'QgisModelBaker' in qgis.utils.plugins:
QgisModelBaker = qgis.utils.plugins["QgisModelBaker"]
tool = self._dbs_supported.get_db_factory(
db.engine).get_model_baker_db_ili_mode()
generator = QgisModelBaker.get_generator()(
tool, db.uri, "smart2", db.schema, pg_estimated_metadata=False)
model_baker_layers = generator.layers(layer_list)
for model_baker_layer in model_baker_layers:
layer = model_baker_layer.create(
) # Convert Model Baker layer to QGIS layer
QgsProject.instance().addMapLayer(
layer, False) # Do not load it to canvas
layers.append(layer)
else:
self.logger.critical(
__name__,
QCoreApplication.translate(
"AsistenteLADMCOLPlugin",
"The QGIS Model Baker plugin is a prerequisite, install it before using LADM-COL Assistant."
))
return layers
def get_layers_and_relations_info(self, db):
"""
Called once per session, this is used to get information
of all relations and bags of enums in the DB and cache it
in the Asistente LADM-COL.
"""
if 'QgisModelBaker' in qgis.utils.plugins:
generator = self.get_generator(db)
layers = generator.get_tables_info_without_ignored_tables()
relations = [
relation for relation in generator.get_relations_info()
]
self.logger.debug(
__name__,
"Relationships before filter: {}".format(len(relations)))
self.filter_relations(relations)
self.logger.debug(
__name__,
"Relationships after filter: {}".format(len(relations)))
return (layers, relations, {})
else:
self.logger.critical(
__name__,
QCoreApplication.translate(
"AsistenteLADMCOLPlugin",
"The QGIS Model Baker plugin is a prerequisite, install it before using LADM-COL Assistant."
))
return (list(), list(), dict())
def filter_relations(self, relations):
"""
Modifies the input list of relations, removing elements that meet a condition.
:param relations: List of a dict of relations.
:return: Nothing, changes the input list of relations.
"""
to_delete = list()
for relation in relations:
if relation[QueryNames.REFERENCING_FIELD].startswith(
'uej2_') or relation[
QueryNames.REFERENCING_FIELD].startswith('ue_'):
to_delete.append(relation)
for idx in to_delete:
relations.remove(idx)
def get_tables_info_without_ignored_tables(self, db):
if 'QgisModelBaker' in qgis.utils.plugins:
generator = self.get_generator(db)
return generator.get_tables_info_without_ignored_tables()
else:
self.logger.critical(
__name__,
QCoreApplication.translate(
"AsistenteLADMCOLPlugin",
"The QGIS Model Baker plugin is a prerequisite, install it before using LADM-COL Assistant."
))
def get_first_index_for_layer_type(
self, layer_type, group=QgsProject.instance().layerTreeRoot()):
if 'QgisModelBaker' in qgis.utils.plugins:
import QgisModelBaker
return QgisModelBaker.utils.qgis_utils.get_first_index_for_layer_type(
layer_type, group)
return None
@staticmethod
def get_suggested_index_for_layer(layer, group):
if 'QgisModelBaker' in qgis.utils.plugins:
import QgisModelBaker
return QgisModelBaker.utils.qgis_utils.get_suggested_index_for_layer(
layer, group)
return None
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
from asistente_ladm_col.config.config_db_supported import ConfigDBsSupported
self._dbs_supported = ConfigDBsSupported()
self.translatable_config_strings = TranslatableConfigStrings()
class DialogImportData(QDialog, DIALOG_UI):
open_dlg_import_schema = pyqtSignal(dict) # dict with key-value params
BUTTON_NAME_IMPORT_DATA = QCoreApplication.translate(
"DialogImportData", "Import data")
BUTTON_NAME_GO_TO_CREATE_STRUCTURE = QCoreApplication.translate(
"DialogImportData", "Go to Create Structure...")
def __init__(self,
iface,
conn_manager,
context,
link_to_import_schema=True,
parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.conn_manager = conn_manager
self.db_source = context.get_db_sources()[0]
self.link_to_import_schema = link_to_import_schema
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.base_configuration = BaseConfiguration()
self.logger = Logger()
self.app = AppInterface()
self.__ladmcol_models = LADMColModelRegistry()
self.java_dependency = JavaDependency()
self.java_dependency.download_dependency_completed.connect(
self.download_java_complete)
self.java_dependency.download_dependency_progress_changed.connect(
self.download_java_progress_change)
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._dbs_supported = ConfigDBsSupported()
self._running_tool = False
# There may be 1 case where we need to emit a db_connection_changed from the Import Data dialog:
# 1) Connection Settings was opened and the DB conn was changed.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in 1 case:
# 1) If the ID dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
self._schedule_layers_and_relations_refresh = False
# We need bar definition above calling clear_messages
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.xtf_file_browse_button.clicked.connect(
make_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate(
"DialogImportData", "Open Transfer or Catalog File"),
file_filter=QCoreApplication.translate(
"DialogImportData",
'Transfer File (*.xtf *.itf);;Catalogue File (*.xml *.xls *.xlsx)'
)))
self.validators = Validators()
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogImportData",
"[Name of the XTF to be imported]"))
fileValidator = FileValidator(pattern=['*.xtf', '*.itf', '*.xml'])
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(self.update_import_models)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
# db
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportData",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportData", "Show log"))
self.buttonBox.accepted.disconnect()
self.buttonBox.clicked.connect(self.accepted_import_data)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
self.BUTTON_NAME_IMPORT_DATA, QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.restore_configuration()
def accepted_import_data(self, button):
if self.buttonBox.buttonRole(button) == QDialogButtonBox.AcceptRole:
if button.text() == self.BUTTON_NAME_IMPORT_DATA:
self.accepted()
elif button.text() == self.BUTTON_NAME_GO_TO_CREATE_STRUCTURE:
self.close() # Close import data dialog
self.open_dlg_import_schema.emit({
'selected_models':
self.get_ili_models()
}) # Emit signal to open import schema dialog
def reject(self):
if self._running_tool:
QMessageBox.information(
self, QCoreApplication.translate("DialogImportData",
"Warning"),
QCoreApplication.translate(
"DialogImportData",
"The Import Data tool is still running. Please wait until it finishes."
))
else:
self.close_dialog()
def close_dialog(self):
"""
We use this method to be safe when emitting the db_connection_changed, otherwise we could trigger slots that
unload the plugin, destroying dialogs and thus, leading to crashes.
"""
if self._schedule_layers_and_relations_refresh:
self.conn_manager.db_connection_changed.connect(
self.app.core.cache_layers_and_relations)
if self._db_was_changed:
# If the db was changed, it implies it complies with ladm_col, hence the second parameter
self.conn_manager.db_connection_changed.emit(
self.db, True, self.db_source)
if self._schedule_layers_and_relations_refresh:
self.conn_manager.db_connection_changed.disconnect(
self.app.core.cache_layers_and_relations)
self.logger.info(__name__, "Dialog closed.")
self.done(QDialog.Accepted)
def update_connection_info(self):
db_description = self.db.get_description_conn_string()
if db_description:
self.db_connect_label.setText(db_description)
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self._accept_button.setEnabled(True)
else:
self.db_connect_label.setText(
QCoreApplication.translate("DialogImportData",
"The database is not defined!"))
self.db_connect_label.setToolTip('')
self._accept_button.setEnabled(False)
def update_import_models(self):
self.clear_messages()
error_msg = None
if not self.xtf_file_line_edit.text().strip():
color = '#ffd356' # Light orange
self.import_models_qmodel = QStandardItemModel()
self.import_models_list_view.setModel(self.import_models_qmodel)
else:
if os.path.isfile(self.xtf_file_line_edit.text().strip()):
color = '#fff' # White
self.import_models_qmodel = QStandardItemModel()
model_names = get_models_from_xtf(
self.xtf_file_line_edit.text().strip())
for model in self.__ladmcol_models.supported_models():
if not model.hidden() and model.full_name() in model_names:
item = QStandardItem(model.full_alias())
item.setData(model.full_name(), Qt.UserRole)
item.setCheckable(False)
item.setEditable(False)
self.import_models_qmodel.appendRow(item)
if self.import_models_qmodel.rowCount() > 0:
self.import_models_list_view.setModel(
self.import_models_qmodel)
else:
error_msg = QCoreApplication.translate(
"DialogImportData",
"No models were found in the XTF. Is it a valid file?")
color = '#ffd356' # Light orange
self.import_models_qmodel = QStandardItemModel()
self.import_models_list_view.setModel(
self.import_models_qmodel)
else:
error_msg = QCoreApplication.translate(
"DialogImportData", "Please set a valid XTF file")
color = '#ffd356' # Light orange
self.import_models_qmodel = QStandardItemModel()
self.import_models_list_view.setModel(
self.import_models_qmodel)
self.xtf_file_line_edit.setStyleSheet(
'QLineEdit {{ background-color: {} }}'.format(color))
if error_msg:
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.import_models_list_view.setFocus()
return
def get_ili_models(self):
ili_models = list()
for index in range(self.import_models_qmodel.rowCount()):
item = self.import_models_qmodel.item(index)
ili_models.append(item.data(Qt.UserRole))
return ili_models
def show_settings(self):
# We only need those tabs related to Model Baker/ili2db operations
dlg = SettingsDialog(self.conn_manager, parent=self)
dlg.setWindowTitle(
QCoreApplication.translate("DialogImportData",
"Target DB Connection Settings"))
dlg.show_tip(
QCoreApplication.translate(
"DialogImportData",
"Configure where do you want the XTF data to be imported."))
dlg.set_db_source(self.db_source)
dlg.set_tab_pages_list(
[SETTINGS_CONNECTION_TAB_INDEX, SETTINGS_MODELS_TAB_INDEX])
# Connect signals (DBUtils, Core)
dlg.db_connection_changed.connect(self.db_connection_changed)
if self.db_source == COLLECTED_DB_SOURCE:
self._schedule_layers_and_relations_refresh = True
dlg.set_action_type(EnumDbActionType.IMPORT)
if dlg.exec_():
self.db = dlg.get_db_connection()
self.update_connection_info()
def db_connection_changed(self, db, ladm_col_db, db_source):
self._db_was_changed = True
self.clear_messages()
def accepted(self):
self._running_tool = True
self.txtStdout.clear()
self.progress_bar.setValue(0)
self.bar.clearWidgets()
if not os.path.isfile(self.xtf_file_line_edit.text().strip()):
self._running_tool = False
error_msg = QCoreApplication.translate(
"DialogImportData",
"Please set a valid XTF file before importing data. XTF file does not exist."
)
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
return
java_home_set = self.java_dependency.set_java_home()
if not java_home_set:
message_java = QCoreApplication.translate(
"DialogImportData",
"""Configuring Java {}...""").format(JAVA_REQUIRED_VERSION)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(message_java)
self.java_dependency.get_java_on_demand()
self.disable()
return
configuration = self.update_configuration()
if configuration.disable_validation: # If data validation at import is disabled, we ask for confirmation
self.msg = QMessageBox()
self.msg.setIcon(QMessageBox.Question)
self.msg.setText(
QCoreApplication.translate(
"DialogImportData",
"Are you sure you want to import your data without validation?"
))
self.msg.setWindowTitle(
QCoreApplication.translate("DialogImportData",
"Import XTF without validation?"))
self.msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
res = self.msg.exec_()
if res == QMessageBox.No:
self._running_tool = False
return
if not self.xtf_file_line_edit.validator().validate(
configuration.xtffile, 0)[0] == QValidator.Acceptable:
self._running_tool = False
error_msg = QCoreApplication.translate(
"DialogImportData",
"Please set a valid XTF before importing data.")
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
return
if not self.get_ili_models():
self._running_tool = False
error_msg = QCoreApplication.translate(
"DialogImportData",
"The selected XTF file does not have information according to the LADM-COL model to import."
)
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.import_models_list_view.setFocus()
return
# Get list of models present in the XTF file, in the DB and in the list of required models (by the plugin)
ili_models = set([ili_model for ili_model in self.get_ili_models()])
supported_models_in_ili = set([
m.full_name() for m in self.__ladmcol_models.supported_models()
]).intersection(ili_models)
if not supported_models_in_ili:
self._running_tool = False
error_msg = QCoreApplication.translate("DialogImportData",
"The selected XTF file does not have data from any LADM-COL model supported by the LADM-COL Assistant. " \
"Therefore, you cannot import it! These are the models supported:\n\n * {}").format(" \n * ".join([m.full_alias() for m in self.__ladmcol_models.supported_models()]))
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.import_models_list_view.setFocus()
return
db_models = set(self.db.get_models())
suggested_models = sorted(ili_models.difference(db_models))
if not ili_models.issubset(db_models):
self._running_tool = False
error_msg = QCoreApplication.translate("DialogImportData",
"IMPORT ERROR: The XTF file to import does not have the same models as the target database schema. " \
"Please create a schema that also includes the following missing modules:\n\n * {}").format(
" \n * ".join(suggested_models))
self.txtStdout.clear()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.setText(error_msg)
self.show_message(error_msg, Qgis.Warning)
self.xtf_file_line_edit.setFocus()
# button is removed to define order in GUI
for button in self.buttonBox.buttons():
if button.text() == self.BUTTON_NAME_IMPORT_DATA:
self.buttonBox.removeButton(button)
# Check if button was previously added
self.remove_create_structure_button()
if self.link_to_import_schema:
self.buttonBox.addButton(
self.BUTTON_NAME_GO_TO_CREATE_STRUCTURE,
QDialogButtonBox.AcceptRole).setStyleSheet(
"color: #aa2222;")
self.buttonBox.addButton(self.BUTTON_NAME_IMPORT_DATA,
QDialogButtonBox.AcceptRole)
return
with OverrideCursor(Qt.WaitCursor):
self.progress_bar.show()
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
dataImporter = iliimporter.Importer(dataImport=True)
db_factory = self._dbs_supported.get_db_factory(self.db.engine)
dataImporter.tool = db_factory.get_model_baker_db_ili_mode()
dataImporter.configuration = configuration
self.save_configuration(configuration)
dataImporter.stdout.connect(self.print_info)
dataImporter.stderr.connect(self.on_stderr)
dataImporter.process_started.connect(self.on_process_started)
dataImporter.process_finished.connect(self.on_process_finished)
self.progress_bar.setValue(25)
try:
if dataImporter.run() != iliimporter.Importer.SUCCESS:
self._running_tool = False
self.show_message(
QCoreApplication.translate(
"DialogImportData",
"An error occurred when importing the data. For more information see the log..."
), Qgis.Warning)
return
except JavaNotFoundError:
self._running_tool = False
error_msg_java = QCoreApplication.translate(
"DialogImportData",
"Java {} could not be found. You can configure the JAVA_HOME environment variable manually, restart QGIS and try again."
).format(JAVA_REQUIRED_VERSION)
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(error_msg_java)
self.show_message(error_msg_java, Qgis.Warning)
return
self._running_tool = False
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
self.progress_bar.setValue(100)
self.show_message(
QCoreApplication.translate(
"DialogImportData",
"Import of the data was successfully completed"),
Qgis.Success)
def download_java_complete(self):
self.accepted()
def download_java_progress_change(self, progress):
self.progress_bar.setValue(progress / 2)
if (progress % 20) == 0:
self.txtStdout.append('...')
def remove_create_structure_button(self):
for button in self.buttonBox.buttons():
if button.text() == self.BUTTON_NAME_GO_TO_CREATE_STRUCTURE:
self.buttonBox.removeButton(button)
def save_configuration(self, configuration):
settings = QSettings()
settings.setValue(
'Asistente-LADM-COL/QgisModelBaker/ili2pg/xtffile_import',
configuration.xtffile)
settings.setValue('Asistente-LADM-COL/QgisModelBaker/show_log',
not self.log_config.isCollapsed())
def restore_configuration(self):
settings = QSettings()
self.xtf_file_line_edit.setText(
settings.value(
'Asistente-LADM-COL/QgisModelBaker/ili2pg/xtffile_import'))
# Show log
value_show_log = settings.value(
'Asistente-LADM-COL/QgisModelBaker/show_log', False, type=bool)
self.log_config.setCollapsed(not value_show_log)
# set model repository
# if there is no option by default use online model repository
self.use_local_models = settings.value(
'Asistente-LADM-COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool)
if self.use_local_models:
self.custom_model_directories = settings.value(
'Asistente-LADM-COL/models/custom_models', DEFAULT_MODELS_DIR)
def update_configuration(self):
"""
Get the configuration that is updated with the user configuration changes on the dialog.
:return: Configuration
"""
db_factory = self._dbs_supported.get_db_factory(self.db.engine)
configuration = ImportDataConfiguration()
db_factory.set_ili2db_configuration_params(self.db.dict_conn_params,
configuration)
configuration.xtffile = self.xtf_file_line_edit.text().strip()
configuration.delete_data = False
configuration.srs_auth = QSettings().value(
'Asistente-LADM-COL/QgisModelBaker/srs_auth', DEFAULT_SRS_AUTH,
str)
configuration.srs_code = QSettings().value(
'Asistente-LADM-COL/QgisModelBaker/srs_code',
int(DEFAULT_SRS_CODE), int)
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = ILI2DBNames.CREATE_BASKET_COL
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
configuration.with_importtid = True
full_java_exe_path = JavaDependency.get_full_java_exe_path()
if full_java_exe_path:
self.base_configuration.java_path = full_java_exe_path
# User could have changed the default values
self.use_local_models = QSettings().value(
'Asistente-LADM-COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool)
self.custom_model_directories = QSettings().value(
'Asistente-LADM-COL/models/custom_models', DEFAULT_MODELS_DIR)
# Check custom model directories
if self.use_local_models:
if not self.custom_model_directories:
self.base_configuration.custom_model_directories_enabled = False
else:
self.base_configuration.custom_model_directories = self.custom_model_directories
self.base_configuration.custom_model_directories_enabled = True
configuration.base_configuration = self.base_configuration
if self.get_ili_models():
configuration.ilimodels = ';'.join(self.get_ili_models())
configuration.disable_validation = not QSettings().value(
'Asistente-LADM-COL/models/validate_data_importing_exporting',
True, bool)
return configuration
def print_info(self, text, text_color='#000000', clear=False):
self.txtStdout.setTextColor(QColor(text_color))
self.txtStdout.append(text)
QCoreApplication.processEvents()
def on_stderr(self, text):
color_log_text(text, self.txtStdout)
self.advance_progress_bar_by_text(text)
def on_process_started(self, command):
self.disable()
self.txtStdout.setTextColor(QColor('#000000'))
self.txtStdout.clear()
self.txtStdout.setText(command)
QCoreApplication.processEvents()
def on_process_finished(self, exit_code, result):
color = '#004905' if exit_code == 0 else '#aa2222'
self.txtStdout.setTextColor(QColor(color))
self.txtStdout.append('Finished ({})'.format(exit_code))
if result == iliimporter.Importer.SUCCESS:
self.buttonBox.clear()
self.buttonBox.setEnabled(True)
self.buttonBox.addButton(QDialogButtonBox.Close)
else:
self.show_message(
QCoreApplication.translate("DialogImportData",
"Error when importing data"),
Qgis.Warning)
# Open log
if self.log_config.isCollapsed():
self.log_config.setCollapsed(False)
def advance_progress_bar_by_text(self, text):
if text.strip() == 'Info: compile models...':
self.progress_bar.setValue(50)
QCoreApplication.processEvents()
elif text.strip() == 'Info: create table structure...':
self.progress_bar.setValue(55)
QCoreApplication.processEvents()
elif text.strip() == 'Info: first validation pass...':
self.progress_bar.setValue(60)
QCoreApplication.processEvents()
elif text.strip() == 'Info: second validation pass...':
self.progress_bar.setValue(80)
QCoreApplication.processEvents()
def clear_messages(self):
self.bar.clearWidgets(
) # Remove previous messages before showing a new one
self.txtStdout.clear() # Clear previous log messages
self.progress_bar.setValue(0) # Initialize progress bar
def show_help(self):
show_plugin_help("import_data")
def disable(self):
self.source_config.setEnabled(False)
self.target_config.setEnabled(False)
self.buttonBox.setEnabled(False)
def enable(self):
self.source_config.setEnabled(True)
self.target_config.setEnabled(True)
self.buttonBox.setEnabled(True)
def show_message(self, message, level):
if level == Qgis.Warning:
self.enable()
self.bar.clearWidgets(
) # Remove previous messages before showing a new one
self.bar.pushMessage("Asistente LADM-COL", message, level, duration=0)
class SettingsDialog(QDialog, DIALOG_UI):
"""
Customizable dialog to configure LADM-COL Assistant.
It can be created passing a SettingsContext with specific params
or it can be instantiated and then set params one by one.
"""
db_connection_changed = pyqtSignal(DBConnector, bool,
str) # dbconn, ladm_col_db, source
open_dlg_import_schema = pyqtSignal(
Context) # Context for the import schema dialog
def __init__(self, conn_manager=None, context=None, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self.logger = Logger()
self.conn_manager = conn_manager
self.app = AppInterface()
self.sbx_tolerance.setMaximum(TOLERANCE_MAX_VALUE)
self._valid_document_repository = False # Needs to be True if users want to enable doc repo (using test button)
context = context if context else SettingsContext()
self.db_source = context.db_source # default db source is COLLECTED_DB_SOURCE
self._required_models = context.required_models
self._tab_pages_list = context.tab_pages_list
self._blocking_mode = context.blocking_mode # Whether the dialog can only be accepted on valid DB connections or not
self._action_type = context.action_type # By default "config"
self.setWindowTitle(context.title)
self._db = None
self.init_db_engine = None
self.dbs_supported = ConfigDBsSupported()
self._open_dlg_import_schema = False # After accepting, if non-valid DB is configured, we can go to import schema
self.online_models_radio_button.setEnabled(
False) # This option is disabled until we have online models back!
self.online_models_radio_button.setChecked(True)
self.online_models_radio_button.toggled.connect(
self.model_provider_toggle)
self.custom_model_directories_line_edit.setText("")
self.custom_models_dir_button.clicked.connect(
self.show_custom_model_dir)
self.custom_model_directories_line_edit.setVisible(False)
self.custom_models_dir_button.setVisible(False)
# Set connections
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.helpRequested.connect(self.show_help)
self.finished.connect(self.finished_slot)
self.btn_test_connection.clicked.connect(self.test_connection)
self.btn_test_ladm_col_structure.clicked.connect(
self.test_ladm_col_structure)
self.btn_test_service.clicked.connect(self.test_service)
self.btn_test_service_transitional_system.clicked.connect(
self.test_service_transitional_system)
self.txt_service_endpoint.textEdited.connect(
self.source_service_endpoint_changed) # For manual changes only
self.btn_default_value_sources.clicked.connect(
self.set_default_value_source_service)
self.btn_default_value_transitional_system.clicked.connect(
self.set_default_value_transitional_system_service)
self.chk_use_roads.toggled.connect(self.update_images_state)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.cbo_db_engine.clear()
self._lst_db = self.dbs_supported.get_db_factories()
self._lst_panel = dict()
for key, value in self._lst_db.items():
self.cbo_db_engine.addItem(value.get_name(), key)
self._lst_panel[key] = value.get_config_panel(self)
self._lst_panel[key].notify_message_requested.connect(
self.show_message)
self.db_layout.addWidget(self._lst_panel[key])
self.db_engine_changed()
# Trigger some default behaviours
self.restore_db_source_settings(
) # restore settings with default db source
self.restore_settings()
self.roles = RoleRegistry()
self.load_roles()
self.cbo_db_engine.currentIndexChanged.connect(self.db_engine_changed)
self.rejected.connect(self.close_dialog)
self._update_tabs()
if context.tip:
self.show_tip(context.tip)
def set_db_source(self, db_source):
self.db_source = db_source
self.restore_db_source_settings()
def set_tab_pages_list(self, tab_pages_list):
self._tab_pages_list = tab_pages_list
self._update_tabs()
def set_required_models(self, required_models):
self._required_models = required_models
def set_blocking_mode(self, block):
self._blocking_mode = block
def _update_tabs(self):
"""
Show only those tabs that are listed in tab_pages_list, if any. If it's an empty list, show all tabs.
"""
if self._tab_pages_list:
for i in reversed(range(self.tabWidget.count())):
if i not in self._tab_pages_list:
self.tabWidget.removeTab(i)
def load_roles(self):
"""
Initialize group box for selecting the active role
"""
self.gbx_active_role_layout = QVBoxLayout()
dict_roles = self.roles.get_roles_info()
checked = False
active_role = self.roles.get_active_role()
# Initialize radio buttons
for k, v in dict_roles.items():
radio = QRadioButton(v)
radio.setToolTip(self.roles.get_role_description(k))
if not checked:
if k == active_role:
radio.setChecked(True)
checked = True
self.gbx_active_role_layout.addWidget(radio)
self.gbx_active_role.setLayout(self.gbx_active_role_layout)
def close_dialog(self):
self.close()
def showEvent(self, event):
# It is necessary to reload the variables
# to load the database and schema name
self.restore_settings()
self.btn_test_ladm_col_structure.setVisible(
self._action_type != EnumDbActionType.SCHEMA_IMPORT)
def model_provider_toggle(self):
if self.offline_models_radio_button.isChecked():
self.custom_model_directories_line_edit.setVisible(True)
self.custom_models_dir_button.setVisible(True)
else:
self.custom_model_directories_line_edit.setVisible(False)
self.custom_models_dir_button.setVisible(False)
self.custom_model_directories_line_edit.setText("")
def _get_db_connector_from_gui(self):
current_db_engine = self.cbo_db_engine.currentData()
params = self._lst_panel[current_db_engine].read_connection_parameters(
)
db = self._lst_db[current_db_engine].get_db_connector(params)
return db
def get_db_connection(self):
if self._db is not None:
self.logger.info(__name__, "Returning existing db connection...")
else:
self.logger.info(__name__, "Getting new db connection...")
self._db = self._get_db_connector_from_gui()
self._db.open_connection()
return self._db
def show_custom_model_dir(self):
dlg = CustomModelDirDialog(
self.custom_model_directories_line_edit.text(), self)
dlg.exec_()
def accepted(self):
"""
We start checking the document repository configuration and only allow to continue if we have a valid repo or
if the repo won't be used.
Then, check if connection to DB/schema is valid, if not, block the dialog.
If valid, check it complies with LADM. If not, block the dialog. If it complies, we have two options: To emit
db_connection changed or not. Finally, we store options in QSettings.
"""
res_doc_repo, msg_doc_repo = self.check_document_repository_before_saving_settings(
)
if not res_doc_repo:
self.show_message(msg_doc_repo, Qgis.Warning, 0)
return # Do not close the dialog
ladm_col_schema = False
db = self._get_db_connector_from_gui()
test_level = EnumTestLevel.DB_SCHEMA
if self._action_type == EnumDbActionType.SCHEMA_IMPORT:
# Limit the validation (used in GeoPackage)
test_level |= EnumTestLevel.SCHEMA_IMPORT
res, code, msg = db.test_connection(
test_level
) # No need to pass required_models, we don't test that much
if res:
if self._action_type != EnumDbActionType.SCHEMA_IMPORT:
# Only check LADM-schema if we are not in an SCHEMA IMPORT.
# We know in an SCHEMA IMPORT, at this point the schema is still not LADM.
ladm_col_schema, code, msg = db.test_connection(
EnumTestLevel.LADM, required_models=self._required_models)
if not ladm_col_schema and self._action_type != EnumDbActionType.SCHEMA_IMPORT:
if self._blocking_mode:
self.show_message(msg, Qgis.Warning)
return # Do not close the dialog
else:
if self._blocking_mode:
self.show_message(msg, Qgis.Warning)
return # Do not close the dialog
# Connection is valid and complies with LADM
current_db_engine = self.cbo_db_engine.currentData()
if self._lst_panel[current_db_engine].state_changed(
) or self.init_db_engine != current_db_engine:
# Emit db_connection_changed
if self._db is not None:
self._db.close_connection()
self._db = db
# Update db connect with new db conn
self.conn_manager.set_db_connector_for_source(
self._db, self.db_source)
# Emmit signal when db source changes
self.db_connection_changed.emit(self._db, ladm_col_schema,
self.db_source)
self.logger.debug(
__name__, "Settings dialog emitted a db_connection_changed.")
if not ladm_col_schema and self._action_type == EnumDbActionType.CONFIG:
msg_box = QMessageBox(self)
msg_box.setIcon(QMessageBox.Question)
msg_box.setText(
QCoreApplication.translate(
"SettingsDialog",
"No LADM-COL DB has been configured! You'll continue with limited functionality until you configure a LADM-COL DB.\n\nDo you want to go to 'Create LADM-COL structure' dialog?"
))
msg_box.setWindowTitle(
QCoreApplication.translate("SettingsDialog", "Important"))
msg_box.setStandardButtons(QMessageBox.Yes | QMessageBox.Ignore)
msg_box.setDefaultButton(QMessageBox.Ignore)
msg_box.button(QMessageBox.Yes).setText(
QCoreApplication.translate("SettingsDialog",
"Yes, go to create structure"))
msg_box.button(QMessageBox.Ignore).setText(
QCoreApplication.translate("SettingsDialog",
"No, I'll do it later"))
reply = msg_box.exec_()
if reply == QMessageBox.Yes:
self._open_dlg_import_schema = True # We will open it when we've closed this Settings dialog
# If active role is changed (a check and confirmation may be needed), refresh the GUI
# Note: Better to leave this check as the last one in the accepted() method.
selected_role = self.get_selected_role()
if self.roles.get_active_role() != selected_role:
b_change_role = True
if STSession().is_user_logged():
reply = QMessageBox.question(
self.parent,
QCoreApplication.translate("SettingsDialog", "Warning"),
QCoreApplication.translate(
"SettingsDialog",
"You have a ST connection opened and you want to change your role.\nIf you confirm that you want to change your role, you'll be logged out from the ST.\n\nDo you really want to change your role?"
), QMessageBox.Yes | QMessageBox.Cancel,
QMessageBox.Cancel)
if reply == QMessageBox.Yes:
STSession().logout()
elif reply == QMessageBox.Cancel:
# No need to switch back selected role, the Settings Dialog gets it from role registry
b_change_role = False
if b_change_role:
self.logger.info(
__name__,
"The active role has changed from '{}' to '{}'.".format(
self.roles.get_active_role(), selected_role))
self.roles.set_active_role(
selected_role
) # Emits signal that refreshed the plugin for this role
self.save_settings(db)
QDialog.accept(self)
self.close()
if self._open_dlg_import_schema:
# After Settings dialog has been closed, we could call Import Schema depending on user's answer above
self.open_dlg_import_schema.emit(Context())
self.logger.debug(
__name__,
"Settings dialog emitted a show Import Schema dialog.")
def check_document_repository_before_saving_settings(self):
# Check if source service is checked (active). If so, check if either status or endpoint changed. If so,
# check if self._valid_document_repository is False. If so, we need to test the service and only allow to save
# if such test is successful.
res, msg = True, ''
if self.connection_box.isChecked(
): # The user wants to have the source service enabled
initial_config = QSettings().value(
'Asistente-LADM-COL/sources/use_service',
DEFAULT_USE_SOURCE_SERVICE_SETTING, bool)
initial_endpoint = QSettings().value(
'Asistente-LADM-COL/sources/service_endpoint',
DEFAULT_ENDPOINT_SOURCE_SERVICE)
# Config changed or Endpoint changed?
if initial_config != self.connection_box.isChecked(
) or initial_endpoint.strip() != self.txt_service_endpoint.text(
).strip():
if not self._valid_document_repository: # A test service has not been run, so we need to do it now
self.logger.debug(
__name__,
"The user wants to enable the source service but the 'test service' has not been run on the current URL. Testing it..."
)
res_test, msg_test = self.test_service()
if not res_test:
res = False
msg = QCoreApplication.translate(
"SettingsDialog",
"The source service is not valid, so it cannot be activated! Adjust such configuration before saving settings."
)
return res, msg
def source_service_endpoint_changed(self, new_text):
# Source service endpoint was changed, so a test_service is required to make the valid variable True
self._valid_document_repository = False
def get_selected_role(self):
selected_role = None
radio_checked = None
for i in range(self.gbx_active_role_layout.count()):
radio = self.gbx_active_role_layout.itemAt(i).widget()
if radio.isChecked():
radio_checked = radio.text()
break
for k, v in self.roles.get_roles_info().items():
if v == radio_checked:
selected_role = k
break
return selected_role # Role key
def reject(self):
self.done(0)
def finished_slot(self, result):
self.bar.clearWidgets()
def save_settings(self, db):
settings = QSettings()
current_db_engine = self.cbo_db_engine.currentData()
settings.setValue(
'Asistente-LADM-COL/db/{db_source}/db_connection_engine'.format(
db_source=self.db_source), current_db_engine)
dict_conn = self._lst_panel[
current_db_engine].read_connection_parameters()
self._lst_db[current_db_engine].save_parameters_conn(
dict_conn=dict_conn, db_source=self.db_source)
settings.setValue(
'Asistente-LADM-COL/models/custom_model_directories_is_checked',
self.offline_models_radio_button.isChecked())
if self.offline_models_radio_button.isChecked():
settings.setValue('Asistente-LADM-COL/models/custom_models',
self.custom_model_directories_line_edit.text())
self.app.settings.tolerance = self.sbx_tolerance.value()
settings.setValue('Asistente-LADM-COL/quality/use_roads',
self.chk_use_roads.isChecked())
settings.setValue(
'Asistente-LADM-COL/models/validate_data_importing_exporting',
self.chk_validate_data_importing_exporting.isChecked())
endpoint_transitional_system = self.txt_service_transitional_system.text(
).strip()
settings.setValue(
'Asistente-LADM-COL/sources/service_transitional_system',
(endpoint_transitional_system[:-1]
if endpoint_transitional_system.endswith('/') else
endpoint_transitional_system)
or TransitionalSystemConfig().ST_DEFAULT_DOMAIN)
settings.setValue('Asistente-LADM-COL/sources/use_service',
self.connection_box.isChecked())
endpoint = self.txt_service_endpoint.text().strip()
settings.setValue(
'Asistente-LADM-COL/sources/service_endpoint',
(endpoint[:-1] if endpoint.endswith('/') else endpoint)
or DEFAULT_ENDPOINT_SOURCE_SERVICE)
settings.setValue(
'Asistente-LADM-COL/automatic_values/automatic_values_in_batch_mode',
self.chk_automatic_values_in_batch_mode.isChecked())
# Changes in automatic namespace, local_id or t_ili_tid configuration?
current_namespace_enabled = settings.value(
'Asistente-LADM-COL/automatic_values/namespace_enabled', True,
bool)
current_namespace_prefix = settings.value(
'Asistente-LADM-COL/automatic_values/namespace_prefix', "")
current_local_id_enabled = settings.value(
'Asistente-LADM-COL/automatic_values/local_id_enabled', True, bool)
current_t_ili_tid_enabled = settings.value(
'Asistente-LADM-COL/automatic_values/t_ili_tid_enabled', True,
bool)
settings.setValue(
'Asistente-LADM-COL/automatic_values/namespace_enabled',
self.namespace_collapsible_group_box.isChecked())
if self.namespace_collapsible_group_box.isChecked():
settings.setValue(
'Asistente-LADM-COL/automatic_values/namespace_prefix',
self.txt_namespace.text())
settings.setValue(
'Asistente-LADM-COL/automatic_values/local_id_enabled',
self.chk_local_id.isChecked())
settings.setValue(
'Asistente-LADM-COL/automatic_values/t_ili_tid_enabled',
self.chk_t_ili_tid.isChecked())
if current_namespace_enabled != self.namespace_collapsible_group_box.isChecked() or \
current_namespace_prefix != self.txt_namespace.text() or \
current_local_id_enabled != self.chk_local_id.isChecked() or \
current_t_ili_tid_enabled != self.chk_t_ili_tid.isChecked():
if db is not None:
self.logger.info(
__name__,
"Automatic values changed in Settings dialog. All LADM-COL layers are being updated..."
)
self.app.core.automatic_fields_settings_changed(db)
def restore_db_source_settings(self):
settings = QSettings()
default_db_engine = self.dbs_supported.id_default_db
self.init_db_engine = settings.value(
'Asistente-LADM-COL/db/{db_source}/db_connection_engine'.format(
db_source=self.db_source), default_db_engine)
index_db_engine = self.cbo_db_engine.findData(self.init_db_engine)
if index_db_engine == -1:
index_db_engine = self.cbo_db_engine.findData(default_db_engine)
self.cbo_db_engine.setCurrentIndex(index_db_engine)
self.db_engine_changed()
# restore db settings for all panels
for db_engine, db_factory in self._lst_db.items():
dict_conn = db_factory.get_parameters_conn(self.db_source)
self._lst_panel[db_engine].write_connection_parameters(dict_conn)
self._lst_panel[db_engine].save_state()
def restore_settings(self):
# Restore QSettings
settings = QSettings()
custom_model_directories_is_checked = settings.value(
'Asistente-LADM-COL/models/custom_model_directories_is_checked',
DEFAULT_USE_CUSTOM_MODELS,
type=bool)
if custom_model_directories_is_checked:
self.offline_models_radio_button.setChecked(True)
self.custom_model_directories_line_edit.setText(
settings.value('Asistente-LADM-COL/models/custom_models',
DEFAULT_MODELS_DIR))
self.custom_model_directories_line_edit.setVisible(True)
self.custom_models_dir_button.setVisible(True)
else:
self.online_models_radio_button.setChecked(True)
self.custom_model_directories_line_edit.setText("")
self.custom_model_directories_line_edit.setVisible(False)
self.custom_models_dir_button.setVisible(False)
self.sbx_tolerance.setValue(self.app.settings.tolerance)
use_roads = settings.value('Asistente-LADM-COL/quality/use_roads',
True, bool)
self.chk_use_roads.setChecked(use_roads)
self.update_images_state(use_roads)
self.chk_automatic_values_in_batch_mode.setChecked(
settings.value(
'Asistente-LADM-COL/automatic_values/automatic_values_in_batch_mode',
DEFAULT_AUTOMATIC_VALUES_IN_BATCH_MODE, bool))
self.connection_box.setChecked(
settings.value('Asistente-LADM-COL/sources/use_service',
DEFAULT_USE_SOURCE_SERVICE_SETTING, bool))
self.namespace_collapsible_group_box.setChecked(
settings.value(
'Asistente-LADM-COL/automatic_values/namespace_enabled', True,
bool))
self.chk_local_id.setChecked(
settings.value(
'Asistente-LADM-COL/automatic_values/local_id_enabled', True,
bool))
self.chk_t_ili_tid.setChecked(
settings.value(
'Asistente-LADM-COL/automatic_values/t_ili_tid_enabled', True,
bool))
self.txt_namespace.setText(
str(
settings.value(
'Asistente-LADM-COL/automatic_values/namespace_prefix',
"")))
self.chk_validate_data_importing_exporting.setChecked(
settings.value(
'Asistente-LADM-COL/models/validate_data_importing_exporting',
True, bool))
self.txt_service_transitional_system.setText(
settings.value(
'Asistente-LADM-COL/sources/service_transitional_system',
TransitionalSystemConfig().ST_DEFAULT_DOMAIN))
self.txt_service_endpoint.setText(
settings.value('Asistente-LADM-COL/sources/service_endpoint',
DEFAULT_ENDPOINT_SOURCE_SERVICE))
def db_engine_changed(self):
if self._db is not None:
self._db.close_connection()
self._db = None # Reset db connection
for key, value in self._lst_panel.items():
value.setVisible(False)
current_db_engine = self.cbo_db_engine.currentData()
self._lst_panel[current_db_engine].setVisible(True)
def test_connection(self):
db = self._get_db_connector_from_gui()
test_level = EnumTestLevel.DB_SCHEMA
if self._action_type == EnumDbActionType.SCHEMA_IMPORT:
test_level |= EnumTestLevel.SCHEMA_IMPORT
res, code, msg = db.test_connection(
test_level
) # No need to pass required_models, we don't test that much
if db is not None:
db.close_connection()
self.show_message(msg, Qgis.Info if res else Qgis.Warning)
self.logger.info(__name__, "Test connection!")
self.logger.debug(
__name__,
"Test connection ({}): {}, {}".format(test_level, res, msg))
def test_ladm_col_structure(self):
db = self._get_db_connector_from_gui()
res, code, msg = db.test_connection(
test_level=EnumTestLevel.LADM,
required_models=self._required_models)
if db is not None:
db.close_connection()
self.show_message(msg, Qgis.Info if res else Qgis.Warning)
self.logger.info(__name__, "Test LADM structure!")
self.logger.debug(
__name__,
"Test connection ({}): {}, {}".format(EnumTestLevel.LADM, res,
msg))
def test_service(self):
self.setEnabled(False)
QCoreApplication.processEvents()
res, msg = self.app.core.is_source_service_valid(
self.txt_service_endpoint.text().strip())
self._valid_document_repository = res # Required to be True if the user wants to enable the source service
self.setEnabled(True)
self.show_message(msg['text'], msg['level'], 0)
return res, msg
def test_service_transitional_system(self):
self.setEnabled(False)
QCoreApplication.processEvents()
res, msg = self.app.core.is_transitional_system_service_valid(
self.txt_service_transitional_system.text().strip())
self.setEnabled(True)
self.show_message(msg['text'], msg['level'])
def set_default_value_source_service(self):
self.txt_service_endpoint.setText(DEFAULT_ENDPOINT_SOURCE_SERVICE)
def set_default_value_transitional_system_service(self):
self.txt_service_transitional_system.setText(
TransitionalSystemConfig().ST_DEFAULT_DOMAIN)
def show_message(self, message, level, duration=10):
self.bar.clearWidgets(
) # Remove previous messages before showing a new one
self.bar.pushMessage(message, level, duration)
def show_tip(self, tip):
self.show_message(tip, Qgis.Info,
0) # Don't show counter for the tip message
def update_images_state(self, checked):
self.img_with_roads.setEnabled(checked)
self.img_with_roads.setToolTip(
QCoreApplication.translate(
"SettingsDialog", "Missing roads will be marked as errors."
) if checked else '')
self.img_without_roads.setEnabled(not checked)
self.img_without_roads.setToolTip(
'' if checked else QCoreApplication.translate(
"SettingsDialog", "Missing roads will not be marked as errors."
))
def show_help(self):
show_plugin_help("settings")
def set_action_type(self, action_type):
self._action_type = action_type
for key, value in self._lst_panel.items():
value.set_action(action_type)
def get_ladm_queries(self, engine):
if engine not in self._ladm_queries:
self._ladm_queries[engine] = ConfigDBsSupported().get_db_factory(
engine).get_ladm_queries()
return self._ladm_queries[engine]
def __init__(self,
iface,
conn_manager,
context,
link_to_import_schema=True,
parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.conn_manager = conn_manager
self.db_source = context.get_db_sources()[0]
self.link_to_import_schema = link_to_import_schema
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.base_configuration = BaseConfiguration()
self.logger = Logger()
self.app = AppInterface()
self.__ladmcol_models = LADMColModelRegistry()
self.java_dependency = JavaDependency()
self.java_dependency.download_dependency_completed.connect(
self.download_java_complete)
self.java_dependency.download_dependency_progress_changed.connect(
self.download_java_progress_change)
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._dbs_supported = ConfigDBsSupported()
self._running_tool = False
# There may be 1 case where we need to emit a db_connection_changed from the Import Data dialog:
# 1) Connection Settings was opened and the DB conn was changed.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in 1 case:
# 1) If the ID dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
self._schedule_layers_and_relations_refresh = False
# We need bar definition above calling clear_messages
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.xtf_file_browse_button.clicked.connect(
make_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate(
"DialogImportData", "Open Transfer or Catalog File"),
file_filter=QCoreApplication.translate(
"DialogImportData",
'Transfer File (*.xtf *.itf);;Catalogue File (*.xml *.xls *.xlsx)'
)))
self.validators = Validators()
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogImportData",
"[Name of the XTF to be imported]"))
fileValidator = FileValidator(pattern=['*.xtf', '*.itf', '*.xml'])
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(self.update_import_models)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
# db
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportData",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportData", "Show log"))
self.buttonBox.accepted.disconnect()
self.buttonBox.clicked.connect(self.accepted_import_data)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
self.BUTTON_NAME_IMPORT_DATA, QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.restore_configuration()
class QgisModelBakerUtils(QObject):
def __init__(self):
QObject.__init__(self)
self.logger = Logger()
from asistente_ladm_col.config.config_db_supported import ConfigDBsSupported
self._dbs_supported = ConfigDBsSupported()
self.__mb_lib = QgisModelBakerPluginLib()
def get_generator(self, db):
tool = self._dbs_supported.get_db_factory(
db.engine).get_model_baker_db_ili_mode()
return self.__mb_lib.get_generator()(tool,
db.uri,
"smart2",
db.schema,
pg_estimated_metadata=False)
def load_layers(self, db, layer_list, group=None):
"""
Load a selected list of layers from qgis model baker.
This call should configure relations and bag of enums
between layers being loaded, but not when a layer already
loaded has a relation or is part of a bag of enum. For
that case, we use a cached set of relations and bags of
enums that we get only once per session and configure in
the Asistente LADM-COL.
"""
generator = self.get_generator(db)
layers = generator.layers(layer_list)
layers = self._filter_layers(layers)
relations, bags_of_enum = generator.relations(layers, layer_list)
legend = generator.legend(layers,
ignore_node_names=QualityErrorDBUtils.
get_quality_error_group_names())
self.__mb_lib.create_project(layers,
relations,
bags_of_enum,
legend,
auto_transaction=False,
group=group)
def get_required_layers_without_load(self, layer_list, db):
"""
Gets a list of layers from a list of layer names using QGIS Model Baker.
Layers are register in QgsProject, but not loaded to the canvas!
:param layer_list: list of layers names (e.g., ['lc_terreno', 'lc_lindero'])
:param db: db connection
:return: list of QgsVectorLayers registered in the project
"""
layers = list()
tool = self._dbs_supported.get_db_factory(
db.engine).get_model_baker_db_ili_mode()
generator = self.get_generator(db)
model_baker_layers = generator.layers(layer_list)
model_baker_layers = self._filter_layers(model_baker_layers)
for model_baker_layer in model_baker_layers:
layer = model_baker_layer.create(
) # Convert Model Baker layer to QGIS layer
QgsProject.instance().addMapLayer(
layer, False) # Do not load it to canvas
layers.append(layer)
return layers
@staticmethod
def _filter_layers(layers):
"""
Modifies the input list of MB layers, removing elements that meet a condition.
:param layers: List of Model Baker Layer objects of list of layer info dicts.
:return: Filtered list of layers.
"""
if layers:
if isinstance(layers[0], dict):
layers = [
layer for layer in layers
if not "_nu_" in layer["tablename"].lower()
]
elif isinstance(layers[0], list):
layers = [
layer for layer in layers
if not "_nu_" in layer.name.lower()
]
return layers
def get_layers_and_relations_info(self, db):
"""
Called once per session, this is used to get information
of all relations and bags of enums in the DB and cache it
in the Asistente LADM-COL.
"""
generator = self.get_generator(db)
layers = generator.get_tables_info_without_ignored_tables()
layers = self._filter_layers(layers)
relations = [relation for relation in generator.get_relations_info()]
QgisModelBakerUtils._filter_relations(relations)
return (layers, relations, {})
@staticmethod
def _filter_relations(relations):
"""
Modifies the input list of relations, removing elements that meet a condition.
:param relations: List of a dict of relations.
:return: Nothing, changes the input list of relations.
"""
to_delete = list()
for relation in relations:
if relation[QueryNames.REFERENCING_FIELD].startswith('uej2_') or \
relation[QueryNames.REFERENCING_FIELD].startswith('ue_') or \
'_nu_' in relation[QueryNames.REFERENCING_LAYER].lower() or \
'_nu_' in relation[QueryNames.REFERENCED_LAYER].lower():
to_delete.append(relation)
for idx in to_delete:
relations.remove(idx)
def get_tables_info_without_ignored_tables(self, db):
generator = self.get_generator(db)
return generator.get_tables_info_without_ignored_tables()
@staticmethod
def get_suggested_index_for_layer(layer, group):
return get_suggested_index_for_layer(layer, group)