def ili_file_changed(self):
# If ili file is valid, models is optional
if self.ili_file_line_edit.text().strip() and \
self.ili_file_line_edit.validator().validate(self.ili_file_line_edit.text().strip(), 0)[0] == QValidator.Acceptable:
self.ili_models_line_edit.setValidator(None)
self.ili_models_line_edit.textChanged.emit(
self.ili_models_line_edit.text())
# Update completer to add models from given ili file
self.ilicache = IliCache(None,
self.ili_file_line_edit.text().strip())
self.refresh_ili_cache()
models = self.ilicache.process_ili_file(
self.ili_file_line_edit.text().strip())
self.ili_models_line_edit.setText(models[-1]['name'])
self.ili_models_line_edit.setPlaceholderText(models[-1]['name'])
else:
nonEmptyValidator = NonEmptyStringValidator()
self.ili_models_line_edit.setValidator(nonEmptyValidator)
self.ili_models_line_edit.textChanged.emit(
self.ili_models_line_edit.text())
# Update completer to add models from given ili file
self.ilicache = IliCache(self.base_configuration)
self.refresh_ili_cache()
self.ili_models_line_edit.setPlaceholderText(
self.tr('[Search model from repository]'))
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
self.layout().setSizeConstraint(QLayout.SetFixedSize)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
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.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
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 __init__(self, parent, title):
QWizardPage.__init__(self, parent)
self.workflow_wizard = parent
self.setupUi(self)
self.setTitle(title)
self.file_browse_button.clicked.connect(
make_file_selector(
self.input_line_edit,
title=self.tr(
"Open Interlis Model, Transfer or Catalogue File"),
file_filter=self.
tr("Interlis Model / Transfer / Catalogue File (*.ili *.xtf *.itf *.XTF *.ITF *.xml *.XML *.xls *.XLS *.xlsx *.XLSX)"
),
))
self.fileValidator = FileValidator(
pattern=["*." + ext for ext in self.ValidExtensions],
allow_empty=False)
self.ilicache = IliCache(
self.workflow_wizard.import_schema_configuration.base_configuration
)
self.model_delegate = ModelCompleterDelegate()
self._refresh_ili_models_cache()
self.input_line_edit.setPlaceholderText(
self.tr("[Browse for file or search model from repository]"))
# very unhappy about this behavior, but okay for prototype
self.first_time_punched = False
self.input_line_edit.punched.connect(self._first_time_punch)
self.source_list_view.setModel(self.workflow_wizard.source_model)
self.add_button.clicked.connect(self._add_row)
self.remove_button.clicked.connect(self._remove_selected_rows)
self.add_button.setEnabled(self._valid_source())
self.input_line_edit.textChanged.connect(
lambda: self.add_button.setEnabled(self._valid_source()))
self.remove_button.setEnabled(self._valid_selection())
self.source_list_view.clicked.connect(
lambda: self.remove_button.setEnabled(self._valid_selection()))
self.add_button.setIcon(
QgsApplication.getThemeIcon("/symbologyAdd.svg"))
self.remove_button.setIcon(
QgsApplication.getThemeIcon("/symbologyRemove.svg"))
self.source_list_view.files_dropped.connect(
self.workflow_wizard.append_dropped_files)
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
self.setupUi(self)
self.layout().setSizeConstraint(QLayout.SetFixedSize)
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"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportSchema", "Show log"))
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
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("DialogImportSchema",
"Create LADM-COL structure"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.restore_configuration()
def __init__(self, iface, qgis_utils, conn_manager,
selected_models=list()):
QDialog.__init__(self)
self.iface = iface
self.conn_manager = conn_manager
self.selected_models = selected_models
self.db = self.conn_manager.get_db_connector_from_source()
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
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"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportSchema", "Show log"))
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
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.update_connection_info()
self.restore_configuration()
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 __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
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 created]"))
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.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
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("DialogImportData", "Import data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.restore_configuration()
def refresh_model(self, source_model, db_connector=None, silent=False):
filtered_source_model = QSortFilterProxyModel()
filtered_source_model.setSourceModel(source_model)
filtered_source_model.setFilterRole(int(SourceModel.Roles.TYPE))
self.print_info.emit(self.tr("Refresh available models:"))
self.clear()
previously_checked_models = self._checked_models
self._checked_models = {}
# models from db
db_modelnames = self._db_modelnames(db_connector)
# models from the repos
filtered_source_model.setFilterFixedString("model")
for r in range(0, filtered_source_model.rowCount()):
filtered_source_model_index = filtered_source_model.index(
r, SourceModel.Columns.SOURCE)
modelname = filtered_source_model_index.data(
int(SourceModel.Roles.NAME))
if modelname:
enabled = modelname not in db_modelnames
self.add_source(
modelname,
filtered_source_model_index.data(
int(SourceModel.Roles.TYPE)),
filtered_source_model_index.data(
int(SourceModel.Roles.PATH)),
filtered_source_model_index.data(
int(SourceModel.Roles.ORIGIN_INFO)),
previously_checked_models.get(
(
modelname,
filtered_source_model_index.data(
int(SourceModel.Roles.PATH)),
),
Qt.Checked,
) if enabled and modelname not in self.checked_models()
else Qt.Unchecked,
enabled,
)
if not silent:
self.print_info.emit(
self.tr("- Append (repository) model {}{}").format(
modelname,
" (inactive because it already exists in the database)"
if not enabled else "",
))
# models from the files
filtered_source_model.setFilterFixedString("ili")
for r in range(0, filtered_source_model.rowCount()):
filtered_source_model_index = filtered_source_model.index(
r, SourceModel.Columns.SOURCE)
ili_file_path = filtered_source_model_index.data(
int(SourceModel.Roles.PATH))
self.ilicache = IliCache(None, ili_file_path)
models = self.ilicache.process_ili_file(ili_file_path)
for model in models:
if model["name"]:
enabled = model["name"] not in db_modelnames
self.add_source(
model["name"],
filtered_source_model_index.data(
int(SourceModel.Roles.TYPE)),
filtered_source_model_index.data(
int(SourceModel.Roles.PATH)),
filtered_source_model_index.data(
int(SourceModel.Roles.ORIGIN_INFO)),
previously_checked_models.get(
(
model["name"],
filtered_source_model_index.data(
int(SourceModel.Roles.PATH)),
),
Qt.Checked if model is models[-1] and enabled
and model["name"] not in self.checked_models() else
Qt.Unchecked,
),
enabled,
)
if not silent:
self.print_info.emit(
self.tr("- Append (file) model {}{} from {}").
format(
model["name"],
" (inactive because it already exists in the database)"
if not enabled else "",
ili_file_path,
))
# models from the transfer files
filtered_source_model.setFilterRegExp("|".join(TransferExtensions))
for r in range(0, filtered_source_model.rowCount()):
filtered_source_model_index = filtered_source_model.index(
r, SourceModel.Columns.SOURCE)
xtf_file_path = filtered_source_model_index.data(
int(SourceModel.Roles.PATH))
models = self._transfer_file_models(xtf_file_path)
for model in models:
if model["name"]:
enabled = model["name"] not in db_modelnames
self.add_source(
model["name"],
filtered_source_model_index.data(
int(SourceModel.Roles.TYPE)),
filtered_source_model_index.data(
int(SourceModel.Roles.PATH)),
filtered_source_model_index.data(
int(SourceModel.Roles.ORIGIN_INFO)),
previously_checked_models.get(
(
model["name"],
filtered_source_model_index.data(
int(SourceModel.Roles.PATH)),
),
Qt.Checked if enabled
and model["name"] not in self.checked_models() else
Qt.Unchecked,
),
enabled,
)
if not silent:
self.print_info.emit(
self.tr("- Append (xtf file) model {}{} from {}").
format(
model["name"],
" (inactive because it already exists in the database)"
if not enabled else "",
xtf_file_path,
))
return self.rowCount()
def __init__(self, iface, base_config, parent=None):
QDialog.__init__(self, parent)
self.iface = iface
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.db_simple_factory = DbSimpleFactory()
self.buttonBox.accepted.disconnect()
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.help_requested)
self.import_text = self.tr("Import Data")
self.set_button_to_import_action = QAction(self.import_text, None)
self.set_button_to_import_action.triggered.connect(
self.set_button_to_import)
self.import_without_validation_text = self.tr(
"Import without validation")
self.set_button_to_import_without_validation_action = QAction(
self.import_without_validation_text, None)
self.set_button_to_import_without_validation_action.triggered.connect(
self.set_button_to_import_without_validation)
self.edit_command_action = QAction(self.tr("Edit ili2db command"),
None)
self.edit_command_action.triggered.connect(self.edit_command)
self.import_tool_button.addAction(
self.set_button_to_import_without_validation_action)
self.import_tool_button.addAction(self.edit_command_action)
self.import_tool_button.setText(self.import_text)
self.import_tool_button.clicked.connect(self.accepted)
self.xtf_file_browse_button.clicked.connect(
make_file_selector(
self.xtf_file_line_edit,
title=self.tr("Open Transfer or Catalog File"),
file_filter=self.
tr("Transfer File (*.xtf *.itf *.XTF *.ITF);;Catalogue File (*.xml *.XML *.xls *.XLS *.xlsx *.XLSX)"
),
))
self.type_combo_box.clear()
self._lst_panel = dict()
for db_id in self.db_simple_factory.get_db_list(False):
self.type_combo_box.addItem(displayDbIliMode[db_id], db_id)
db_factory = self.db_simple_factory.create_factory(db_id)
item_panel = db_factory.get_config_panel(self,
DbActionType.IMPORT_DATA)
self._lst_panel[db_id] = item_panel
self.db_layout.addWidget(item_panel)
self.type_combo_box.currentIndexChanged.connect(self.type_changed)
self.ili2db_options = Ili2dbOptionsDialog(self, False)
self.ili2db_options_button.clicked.connect(self.ili2db_options.open)
self.ili2db_options.finished.connect(self.fill_toml_file_info_label)
self.multiple_models_dialog = MultipleModelsDialog(self)
self.multiple_models_button.clicked.connect(
self.multiple_models_dialog.open)
self.multiple_models_dialog.accepted.connect(
self.fill_models_line_edit)
self.validate_data = True # validates imported data by default, We use --disableValidation when is False
self.base_configuration = base_config
self.restore_configuration()
self.validators = Validators()
fileValidator = FileValidator(
pattern=["*." + ext for ext in self.ValidExtensions])
self.xtf_file_line_edit.setValidator(fileValidator)
self.ili_models_line_edit.setPlaceholderText(
self.tr("[Search model in repository]"))
self.ili_models_line_edit.textChanged.connect(
self.complete_models_completer)
self.ili_models_line_edit.punched.connect(
self.complete_models_completer)
self.xtf_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
# Reset to import as default text
self.xtf_file_line_edit.textChanged.connect(self.set_button_to_import)
settings = QSettings()
ilifile = settings.value("QgisModelBaker/ili2db/ilifile")
self.ilicache = IliCache(base_config, ilifile or None)
self.update_models_completer()
self.ilicache.refresh()
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.txtStdout.setLayout(QGridLayout())
self.txtStdout.layout().setContentsMargins(0, 0, 0, 0)
self.txtStdout.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
def __init__(self, base_config, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.db_simple_factory = DbSimpleFactory()
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self.buttonBox.addButton(self.tr('Import Data'),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.help_requested)
self.xtf_file_browse_button.clicked.connect(
make_file_selector(
self.xtf_file_line_edit,
title=self.tr('Open Transfer or Catalog File'),
file_filter=self.
tr('Transfer File (*.xtf *.itf);;Catalogue File (*.xml *.xls *.xlsx)'
)))
self.type_combo_box.clear()
self._lst_panel = dict()
for db_id in self.db_simple_factory.get_db_list(False):
self.type_combo_box.addItem(displayDbIliMode[db_id], db_id)
db_factory = self.db_simple_factory.create_factory(db_id)
item_panel = db_factory.get_config_panel(self,
DbActionType.IMPORT_DATA)
self._lst_panel[db_id] = item_panel
self.db_layout.addWidget(item_panel)
self.type_combo_box.currentIndexChanged.connect(self.type_changed)
self.ili2db_options = Ili2dbOptionsDialog()
self.ili2db_options_button.clicked.connect(self.ili2db_options.open)
self.ili2db_options.finished.connect(self.fill_toml_file_info_label)
self.multiple_models_dialog = MultipleModelsDialog(self)
self.multiple_models_button.clicked.connect(
self.multiple_models_dialog.open)
self.multiple_models_dialog.accepted.connect(
self.fill_models_line_edit)
self.base_configuration = base_config
self.restore_configuration()
self.validators = Validators()
fileValidator = FileValidator(
pattern=['*.xtf', '*.itf', '*.pdf', '*.xml', '*.xls', '*.xlsx'])
self.xtf_file_line_edit.setValidator(fileValidator)
self.ili_models_line_edit.setPlaceholderText(
self.tr('[Search model in repository]'))
self.ili_models_line_edit.textChanged.connect(
self.complete_models_completer)
self.ili_models_line_edit.punched.connect(
self.complete_models_completer)
self.xtf_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
settings = QSettings()
ilifile = settings.value('QgisModelBaker/ili2db/ilifile')
self.ilicache = IliCache(base_config, ilifile or None)
self.update_models_completer()
self.ilicache.refresh()
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.setupUi(self)
self.type_combo_box.clear()
self.type_combo_box.addItem(QCoreApplication.translate("DialogImportSchema", "PostgreSQL/PostGIS"), 'pg')
self.type_combo_box.addItem(QCoreApplication.translate("DialogImportSchema", "GeoPackage"), 'gpkg')
self.type_combo_box.setCurrentIndex(
self.type_combo_box.findData(QSettings().value('Asistente-LADM_COL/db_connection_source', 'pg')))
self.type_combo_box.currentIndexChanged.connect(self.type_changed)
self.type_changed()
self.schema_name_line_edit.setPlaceholderText(QCoreApplication.translate("DialogImportSchema", "[Name of the schema to be created]"))
self.validators = Validators()
# schema name mustn't have special characters
regex = QRegExp("[a-zA-Z0-9_]+")
validator = QRegExpValidator(regex)
self.schema_name_line_edit.setValidator(validator)
self.schema_name_line_edit.setMaxLength(63)
self.schema_name_line_edit.textChanged.connect(self.validators.validate_line_edits_lower_case)
self.schema_name_line_edit.textChanged.emit(self.schema_name_line_edit.text())
self.update_import_models()
self.previous_item = QListWidgetItem()
# PG
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(QCoreApplication.translate("DialogImportSchema", "Connection Settings"))
if self.type_combo_box.currentData() == 'pg':
self.db_connect_label.setText(self.db.dict_conn_params['database'])
# GPKG
self.gpkg_file_line_edit.setPlaceholderText(QCoreApplication.translate("DialogImportSchema", "[Name of the Geopackage to be created]"))
self.gpkg_file_browse_button.clicked.connect(make_file_selector(self.gpkg_file_line_edit,
title=QCoreApplication.translate("DialogImportSchema", "Open GeoPackage database file"),
file_filter=QCoreApplication.translate("DialogImportSchema", "GeoPackage Database (*.gpkg)")))
gpkgFileValidator = FileValidator(pattern='*.gpkg')
self.gpkg_file_line_edit.setValidator(gpkgFileValidator)
self.gpkgSaveFileValidator = FileValidator(pattern='*.gpkg', allow_non_existing=True)
self.gpkgOpenFileValidator = FileValidator(pattern='*.gpkg')
self.gpkg_file_line_edit.textChanged.connect(self.validators.validate_line_edits)
# LOG
self.log_config.setTitle(QCoreApplication.translate("DialogImportSchema", "Show log"))
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self.buttonBox.addButton(QCoreApplication.translate("DialogImportSchema", "Create LADM-COL structure"), QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
def __init__(self, iface, qgis_utils, conn_manager, context):
QDialog.__init__(self)
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.qgis_utils = qgis_utils
self.logger = Logger()
self.java_utils = JavaUtils()
self.java_utils.download_java_completed.connect(
self.download_java_complete)
self.java_utils.download_java_progress_changed.connect(
self.download_java_progress_change)
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._dbs_supported = ConfigDbSupported()
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 __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 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)
self.ilicache.refresh()
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.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 __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self.type_combo_box.clear()
self.type_combo_box.addItem(
QCoreApplication.translate("DialogExportData",
"PostgreSQL/PostGIS"), 'pg')
self.type_combo_box.addItem(
QCoreApplication.translate("DialogExportData", "GeoPackage"),
'gpkg')
self.type_combo_box.currentIndexChanged.connect(self.type_changed)
self.type_changed()
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())
# PG
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self.db_connect_label.setText(self.db.dict_conn_params["database"])
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogExportData",
"Connection Settings"))
# GPKG
self.gpkg_file_line_edit.setPlaceholderText(
QCoreApplication.translate(
"DialogExportData", "[Name of the Geopackage to be created]"))
self.gpkg_file_browse_button.clicked.connect(
make_file_selector(self.gpkg_file_line_edit,
title=QCoreApplication.translate(
"DialogExportData",
"Open GeoPackage database file"),
file_filter=QCoreApplication.translate(
"DialogExportData",
"GeoPackage Database (*.gpkg)")))
gpkgFileValidator = FileValidator(pattern='*.gpkg')
self.gpkg_file_line_edit.setValidator(gpkgFileValidator)
self.gpkg_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.gpkg_file_line_edit.textChanged.emit(
self.gpkg_file_line_edit.text())
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogExportData", "Show log"))
self.log_config.setFlat(True)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self.buttonBox.addButton(
QCoreApplication.translate("DialogExportData", "Export data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
def __init__(self, iface, base_config, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.iface = iface
self.db_simple_factory = DbSimpleFactory()
QgsGui.instance().enableAutoGeometryRestore(self)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
create_button = self.buttonBox.addButton(self.tr('Create'),
QDialogButtonBox.AcceptRole)
create_button.setDefault(True)
self.ili_file_browse_button.clicked.connect(
make_file_selector(
self.ili_file_line_edit,
title=self.tr('Open Interlis Model'),
file_filter=self.tr('Interlis Model File (*.ili *.ILI)')))
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.help_requested)
self.crs = QgsCoordinateReferenceSystem()
self.ili2db_options = Ili2dbOptionsDialog()
self.ili2db_options_button.clicked.connect(self.ili2db_options.open)
self.ili2db_options.finished.connect(self.fill_toml_file_info_label)
self.multiple_models_dialog = MultipleModelsDialog(self)
self.multiple_models_button.clicked.connect(
self.multiple_models_dialog.open)
self.multiple_models_dialog.accepted.connect(
self.fill_models_line_edit)
self.type_combo_box.clear()
self._lst_panel = dict()
for db_id in self.db_simple_factory.get_db_list(True):
self.type_combo_box.addItem(displayDbIliMode[db_id], db_id)
for db_id in self.db_simple_factory.get_db_list(False):
db_factory = self.db_simple_factory.create_factory(db_id)
item_panel = db_factory.get_config_panel(self,
DbActionType.GENERATE)
self._lst_panel[db_id] = item_panel
self.db_layout.addWidget(item_panel)
self.type_combo_box.currentIndexChanged.connect(self.type_changed)
self.txtStdout.anchorClicked.connect(self.link_activated)
self.crsSelector.crsChanged.connect(self.crs_changed)
self.base_configuration = base_config
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.txtStdout.setLayout(QGridLayout())
self.txtStdout.layout().setContentsMargins(0, 0, 0, 0)
self.txtStdout.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.validators = Validators()
nonEmptyValidator = NonEmptyStringValidator()
fileValidator = FileValidator(
pattern=['*.' + ext for ext in self.ValidExtensions],
allow_empty=True)
self.restore_configuration()
self.ili_models_line_edit.setValidator(nonEmptyValidator)
self.ili_file_line_edit.setValidator(fileValidator)
self.ili_models_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.ili_models_line_edit.textChanged.emit(
self.ili_models_line_edit.text())
self.ili_models_line_edit.textChanged.connect(self.on_model_changed)
self.ili_models_line_edit.textChanged.connect(
self.complete_models_completer)
self.ili_models_line_edit.punched.connect(
self.complete_models_completer)
self.ilicache = IliCache(self.base_configuration)
self.refresh_ili_cache()
self.ili_models_line_edit.setPlaceholderText(
self.tr('[Search model from repository]'))
self.ili_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.ili_file_line_edit.textChanged.connect(self.ili_file_changed)
self.ili_file_line_edit.textChanged.emit(
self.ili_file_line_edit.text())
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self.type_combo_box.clear()
self.type_combo_box.addItem(
QCoreApplication.translate("DialogImportData",
'PostgreSQL/PostGIS'), 'pg')
self.type_combo_box.addItem(
QCoreApplication.translate("DialogImportData", 'GeoPackage'),
'gpkg')
self.type_combo_box.currentIndexChanged.connect(self.type_changed)
self.type_changed()
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 created]"))
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())
# PG
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self.db_connect_label.setText(self.db.dict_conn_params["database"])
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportData",
'Connection Settings'))
# GPKG
self.gpkg_file_line_edit.setPlaceholderText(
QCoreApplication.translate(
"DialogImportData", "[Name of the Geopackage to be created]"))
self.gpkg_file_browse_button.clicked.connect(
make_save_file_selector(self.gpkg_file_line_edit,
title=QCoreApplication.translate(
"DialogImportData",
'Save in GeoPackage database file'),
file_filter=QCoreApplication.translate(
"DialogImportData",
'GeoPackage Database (*.gpkg)'),
extension='.gpkg'))
gpkgFileValidator = FileValidator(pattern='*.gpkg',
allow_non_existing=True)
self.gpkg_file_line_edit.setValidator(gpkgFileValidator)
self.gpkgSaveFileValidator = FileValidator(pattern='*.gpkg',
allow_non_existing=True)
self.gpkgOpenFileValidator = FileValidator(pattern='*.gpkg')
self.gpkg_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.gpkg_file_line_edit.textChanged.emit(
self.gpkg_file_line_edit.text())
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportData", "Show log"))
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self.buttonBox.addButton(
QCoreApplication.translate("DialogImportData", "Import data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)