def on_btnProjectName_clicked(self): """Check wether the project (=database schema) already exists. """ project_name = self.lineEditDbSchema.text().strip() if len(project_name) <= 0: self.lineEditDbSchema.setPlaceholderText(tr('Enter a valid name')) else: project_found = self.check_project_name(project_name) if project_found == -1: message = "An error occured while connecting the database." self.message_bar.pushMessage("VeriSO", tr(message), QgsMessageBar.CRITICAL, duration=0) return elif project_found == 1: message = "Project name already exists." self.message_bar.pushWarning("VeriSO", tr(message)) return elif project_found == 0: message = "Project name is valid." self.message_bar.pushSuccess("VeriSO", tr(message)) return True
def ask_url(self, default_text=None): text, ok = QInputDialog.getText( self, tr("Add new model repository"), tr("Repository URL:"), QLineEdit.Normal, default_text) return text, ok
def btnBrowseDefectsFile_clicked(self): file_path = QFileDialog.getOpenFileName(self, tr("Choose defects file"), self.input_xlsx_path, "Defects layer (*.shp)")[0] file_info = QFileInfo(file_path) self.lineEditDefectsFile.setText(file_info.absoluteFilePath())
def btnBrowseImportJar_clicked(self): file_path = QFileDialog.getOpenFileName( self, tr("Open import jar file"), self.import_jar_path, "jar (*.jar *.JAR)")[0] file_info = QFileInfo(file_path) self.lineEditImportJar.setText(file_info.absoluteFilePath())
def btnBrowseProjectsDatabase_clicked(self): file_path = QFileDialog.getOpenFileName(self, tr( "Choose projects definitions database"), self.projects_database_path, "SQLite (*.sqlite *.db *.DB)")[0] file_info = QFileInfo(file_path) self.lineEditProjectsDatabase.setText(file_info.absoluteFilePath())
def btnAddLocalModelRepo_clicked(self): path = QFileDialog.getExistingDirectory( self, tr("Open Directory"), os.path.expanduser("~"), QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks) if path: self.listWidgetModelRepos.addItem(path)
def import_shp(self, shp): shp = self.lineEditDefectsFile.text().strip() lr = QgsProject.instance() error = False tmp_layer = self.iface.addVectorLayer(shp, 'tmp_imported_shp', 'ogr') self.application_module.do_load_defects_wrapper() tr_tag = 'VeriBE (EE/EN)' # TODO: translate in global context as well defect_layers = [ lr.mapLayersByName(tr(u"Mängelliste (Punkte)", tr_tag))[0], lr.mapLayersByName(tr(u'Mängelliste (Linien)', tr_tag))[0], lr.mapLayersByName(tr(u'Mängelliste (Polygone)', tr_tag))[0] ] for feat in tmp_layer.getFeatures(): feat.setAttribute('ogc_fid', None) if feat.attribute( 'erledigt') == 1 or feat.attribute('erledigt') is True: feat.setAttribute('erledigt', True) else: feat.setAttribute('erledigt', False) # Workaround for old exports with lowercase ja/nein if str(feat.attribute('verifikati')).lower() == 'ja': feat.setAttribute('verifikati', 'Ja') if str(feat.attribute('verifikati')).lower() == 'nein': feat.setAttribute('verifikati', 'Nein') try: with edit(defect_layers[tmp_layer.geometryType()]): defect_layers[tmp_layer.geometryType()].addFeature(feat) except: error = True continue QgsProject.instance().removeMapLayers([tmp_layer.id()]) if error: self.iface.messageBar().pushCritical( "VeriSo", "Not all features could be imported from Shapefile") return self.iface.messageBar().pushInfo("VeriSo", "Defects imported from Shapefile")
def accept(self): current_index = self.cBoxProject.currentIndex() if current_index == 0: return db_schema = str(self.cBoxProject.itemData(current_index)) self.db_schema = db_schema # Get the connections parameters from the projects list we created in # the init_gui method. Only when using sqlite projects.db if not self.settings.value( "options/general/use_pg_projects_database", False, type=bool): i = 0 for project in self.projects: if db_schema == str(project["dbschema"]): self.db_host = str(project["dbhost"]) self.db_name = str(project["dbname"]) self.db_port = str(project["dbport"]) self.db_admin = str(project["dbadmin"]) self.db_admin_pwd = str(project["dbadminpwd"]) self.project_index = i break i += 1 QApplication.setOverrideCursor(Qt.WaitCursor) self.buttonBox.setEnabled(False) try: self.delete_data_in_database() self.update_project_database() self.delete_project_directory() except VerisoError as e: self.restore_cursor() self.message_bar.pushMessage("VeriSO", tr(str(e)), Qgis.Critical, duration=0) else: self.projectsDatabaseHasChanged.emit() self.init_gui() message = "Project deleted succesfully" self.message_bar.pushSuccess("VeriSO", tr(message)) self.restore_cursor()
def btnBrowseOutputFile_clicked(self): file_path = QFileDialog.getSaveFileName( self, tr("Choose interlis transfer file"), "", # self.input_itf_path, "ITF (*.itf *.ITF)")[0] file_info = QFileInfo(file_path) self.lineEditOutputFile.setText(file_info.absoluteFilePath())
def finish_import(self, exit_code): """ Check if import was successful. :param exitCode: the exit code of the process :return: None """ try: # read the output of ili2pg self.read_import_output() except VerisoError as e: self.message_bar.pushMessage("VeriSO", tr(str(e)), Qgis.Critical, duration=0) return finally: self.restore_cursor() # When we reach here we can claim a successful import. message = "Export process finished." self.report_progress(message, 'green') self.message_bar.pushInfo("VeriSO", tr(message))
def write_file(self, project_dir, shp_filename, layer): filename = QDir.toNativeSeparators( QDir.cleanPath(os.path.join(project_dir, shp_filename))) error = QgsVectorFileWriter.writeAsVectorFormat( layer, filename, layer.dataProvider().encoding(), driverName="ESRI Shapefile") if error[0] == QgsVectorFileWriter.NoError: self.message_bar.pushInfo( "Information", tr("Defect(s) written: ", self.tr_tag, None) + str(filename))
def accept(self): QApplication.setOverrideCursor(Qt.WaitCursor) file_to_import = self.lineEditDefectsFile.text().strip() if file_to_import == '': self.message_bar.pushWarning("VeriSO", tr("No Defects file set.")) QApplication.restoreOverrideCursor() return extension = os.path.splitext(file_to_import)[1] if (extension == '.xlsx'): self.import_xlsx(file_to_import) elif (extension == '.shp'): self.import_shp(file_to_import) else: self.message_bar.pushWarning("VeriSO", tr("File must be .xlsx or .shp")) QApplication.restoreOverrideCursor() return QApplication.restoreOverrideCursor() self.close()
def init_gui(self): """Initialize the dialog: Set the current date. Accept only lower characters as project name (= database schema). Fill modules combobox. """ today = QDateTime.currentDateTime() self.dateTimeEdit.setDateTime(today) self.dateTimeEdit.setCalendarPopup(True) # You are only allowed to use lower case characters as project name ( # = database schema). self.lineEditDbSchema.setValidator( QRegExpValidator(QRegExp("^[a-z][a-z0-9_]+"), self.lineEditDbSchema)) # Fill out the modules combobox. try: modules_dir = os.path.join(get_modules_dir()) modules = [] for module_name in get_subdirs(modules_dir): module_file = os.path.join(modules_dir, module_name, 'module.yml') if os.path.isfile(module_file): module = yaml_load_file(module_file) module['dirname'] = module_name modules.append(module) if modules: sorted_modules_list = sorted(modules, key=lambda k: k['displayname']) self.cmbBoxAppModule.clear() for module in sorted_modules_list: self.cmbBoxAppModule.addItem(str(module["displayname"]), module) self.cmbBoxAppModule.insertItem(0, "", None) self.cmbBoxAppModule.setCurrentIndex(0) except Exception as e: message = "Error while parsing the available modules." self.message_bar.pushMessage("VeriSO", tr(message), QgsMessageBar.CRITICAL, duration=0) QgsMessageLog.logMessage(str(e), "VeriSO", QgsMessageLog.CRITICAL) return self.cmbBoxIliModelName.insertItem(0, "", None) return True
def finish_import(self, exit_code): """ Check if import was successful. :param exitCode: the exit code of the process :return: None """ try: # read the output of ili2pg self.read_import_output() # Get the postprocessing queries that are stored in a sqlite # database. # Placeholder (e.g. $$DBSCHEMA, $$EPSG etc ) will be replaced. sql_queries = self.get_postprocessing_queries() # Do the postprocessing in the postgresql database. self.postprocess_data(sql_queries) # Update the projects database self.update_projects_database() # Create the project directory in the root directory. directory = self.create_project_directory() except VerisoError as e: self.message_bar.pushMessage("VeriSO", tr(str(e)), QgsMessageBar.CRITICAL, duration=0) return finally: self.restore_cursor() # When we reach here we can claim a successful import. message = "Import process finished." self.report_progress(message, 'green') self.message_bar.pushInfo("VeriSO", tr(message))
def _load(self, epsg, layer_definition): if layer_definition["type"] == "postgres": loaded_layer = self._load_pg_layer(layer_definition) elif layer_definition["type"] in ["wms", "wmts"]: loaded_layer = self._load_wms_layer(layer_definition, epsg) elif layer_definition["type"] in ["gdal", "ogr"]: loaded_layer = self._load_gdal_ogr_layer(layer_definition) else: error = tr("Data provider not yet supported: ") + str( layer_definition["type"]) raise VerisoErrorWithBar(self.message_bar, error) return loaded_layer
def set_transparency(self, loaded_layer, layer_definition): try: transparency = layer_definition["transparency"] if 0 <= transparency <= 100: opacity = (100 - transparency) / 100.0 else: message = tr( 'Ignoring invalid transparency value. 0 is full ' 'opaque, 100 is full transparent. Found %s for ' 'layer %s') % (transparency, layer_definition['title']) self.message_bar.pushMessage("Invalid transparency", message, Qgis.Warning, duration=5) opacity = 1 loaded_layer.renderer().setOpacity(opacity) except KeyError: # layer["transparency"] doesn't exist pass
def do_init_forest_defects_menu(self): tr_tag = self.module_name forest_defects_menu_name = "VeriSO.Main.LoadForestDefectsMenu" menubar = self.toolbar.findChild(QMenuBar, 'VeriSO.Main.LoadDefectsMenuBar') for action in menubar.actions(): if action.menu().objectName() == forest_defects_menu_name: menubar.removeAction(action) break # Check whether the forest tables exists try: db = get_default_db() for table_name in self.get_defects_table_names()["forest"].values( ): query = db.exec_( """ SELECT ogc_fid FROM %s.%s; """ % (self.settings.value("project/displayname"), table_name)) if query.record().indexOf("ogc_fid") == -1: return except: return # Specialized defects menu only for forest points menu = QMenu(menubar) menu.setObjectName(forest_defects_menu_name) menu.setTitle(tr("Forest Defects", tr_tag)) # Add defects dock action from default defects menu default_menu = menubar.findChild(QMenu, 'VeriSO.Main.LoadDefectsMenu') for action in default_menu.actions(): if action.objectName( ) == "VeriSO.Main.LoadDefectsMenuBar.ShowDock": menu.addAction(action) break self.add_defects_actions(menu, "forest") menubar.addMenu(menu)
def postprocess_data(self, queries): """Does the postprocessing in the postgresql/postgis database. Returns: -1: If the process fails (e.g. no db connection etc.). Otherwise number of errors occured while postprocessing. """ try: db = open_psql_db(self.db_host, self.db_name, self.db_port, self.db_admin, self.db_admin_pwd) errors = 0 self.report_progress("\n\nInfo: Starting postprocessing...") for sql in queries: self.report_progress("\n\n%s" % sql) query = db.exec_(str(sql)) if not query.isActive(): errors += 1 message = "Error while postprocessing data:" QgsMessageLog.logMessage(tr(message), "VeriSO", Qgis.Critical) QgsMessageLog.logMessage( str(QSqlQuery.lastError(query).text()) + str(sql), "VeriSO", Qgis.Critical) self.report_progress("--> error, see log", 'orange') if errors > 0: self.report_progress( "Error: ...postprocessing completed with errors", "red") if not self.ignore_postprocessing_errors: raise Exception() self.report_progress("Info: ...postprocessing completed") db.close del db except Exception as e: message = "Something went wrong while postprocessing data. You " \ "need to delete the database schema manually." raise VerisoError(message, e)
def _load_defect_layer(self, layer): combo_box_code = (" if {0}.currentIndex() == -1:\n" " i = {0}.findText('{1}')\n" " {0}.setCurrentIndex(i)\n") line_edit_code = (" if {0}.text() in ['', 'NULL']:\n" " {0}.setText('{1}')\n") text_edit_code = (" if {0}.toPlainText() in ['', 'NULL']:\n" " {0}.setPlainText('{1}')\n") widget_type_map = { 'Enumeration': ['QComboBox', combo_box_code], 'TextEdit': ['QLineEdit', line_edit_code], 'PlainTextEdit': ['QPlainTextEdit', text_edit_code] } code_imports = [] generated_code = '' loaded_layer = self.layer_loader.load(layer) if loaded_layer: loaded_layer.editFormConfig().setLayout( QgsEditFormConfig.GeneratedLayout) edit_form_config = loaded_layer.editFormConfig() for field_name in layer['fields']: field = layer['fields'][field_name] idx = loaded_layer.fields().indexFromName(field_name) if 'alias' in field: loaded_layer.setFieldAlias( idx, tr(field['alias'], self.tr_tag, None)) if 'default' in field: default = QgsDefaultValue(field['default']) loaded_layer.setDefaultValueDefinition(idx, default) if 'readonly' in field: edit_form_config.setReadOnly(idx, field['readonly']) if 'writable_only_by' in field: if not db_user_has_role(self.dbuser, field['writable_only_by']): edit_form_config.setReadOnly(idx, True) return loaded_layer
def load(self, layer, visible=True, collapsed_legend=False, collapsed_group=True): settings = QSettings("CatAIS", "VeriSO") module_name = settings.value("project/appmodule") provider = settings.value("project/provider") db_host = settings.value("project/dbhost") db_port = settings.value("project/dbport") db_name = settings.value("project/dbname") db_schema = settings.value("project/dbschema") db_user = settings.value("project/dbuser") db_pwd = settings.value("project/dbpwd") db_admin = settings.value("project/dbadmin") db_admin_pwd = settings.value("project/dbadminpwd") epsg = settings.value("project/epsg") if not db_schema: self.message_bar.pushMessage("Error", tr( "Missing database schema parameter."), QgsMessageBar.CRITICAL, duration=0) return if not db_host: self.message_bar.pushMessage("Error", tr( "Missing database host parameter."), QgsMessageBar.CRITICAL, duration=0) return if not db_name: self.message_bar.pushMessage("Error", tr( "Missing database name parameter."), QgsMessageBar.CRITICAL, duration=0) return if not db_port: self.message_bar.pushMessage("Error", tr( "Missing database port parameter."), QgsMessageBar.CRITICAL, duration=0) return if not db_user: self.message_bar.pushMessage("Error", tr( "Missing database user parameter."), QgsMessageBar.CRITICAL, duration=0) return if not db_pwd: self.message_bar.pushMessage("Error", tr( "Missing database user password parameter."), QgsMessageBar.CRITICAL, duration=0) return if not db_admin: self.message_bar.pushMessage("Error", tr( "Missing database administrator parameter."), QgsMessageBar.CRITICAL, duration=0) return if not db_admin_pwd: self.message_bar.pushMessage("Error", tr( "Missing database administrator password parameter."), QgsMessageBar.CRITICAL, duration=0) return if not provider: self.message_bar.pushMessage("Error", tr( "Missing provider parameter. Cannot load layer."), QgsMessageBar.CRITICAL, duration=0) return if not module_name: self.message_bar.pushMessage("Error", tr( "Missing module name parameter. Cannot load layer."), QgsMessageBar.CRITICAL, duration=0) return try: # Postgres if layer["type"] == "postgres": featuretype = str(layer["featuretype"]) title = layer["title"] key = str(layer["key"]) try: readonly = (layer["readonly"]) except: readonly = True try: geom = str(layer["geom"]) if geom == "": geom = None except: geom = None try: style = str(layer["style"]) except: style = "" try: group = str(layer["group"]) except: group = None try: sql = str(layer["sql"]) except: sql = "" # Overwrite the active project settings/parameters to add # *any* postgres layers. try: params = layer["params"] provider = layer["type"] db_host = params["dbhost"] db_port = str(params["dbport"]) db_name = params["dbname"] db_schema = params["dbschema"] db_user = params["dbuser"] db_pwd = params["dbpwd"] db_admin = params["dbadmin"] db_admin_pwd = params["dbadminpwd"] except: pass uri = QgsDataSourceURI() if readonly: uri.setConnection(db_host, db_port, db_name, db_user, db_pwd) else: uri.setConnection(db_host, db_port, db_name, db_admin, db_admin_pwd) uri.setDataSource(db_schema, featuretype, geom, sql, key) my_layer = QgsVectorLayer(uri.uri(), title, provider) # WMS / WMTS: # WMTS is a bit ugly since we need to know the tileMatrixSet: # Load layer manually in QGIS once an look for the tileMatrixSet # in the layer properties. elif layer["type"] in["wms", "wmts"]: url = layer["url"] title = layer["title"] layers = layer["layers"] format = layer["format"] try: tilematrixset = layer["tilematrixset"] except: tilematrixset = None try: crs = layer["crs"] except: crs = "EPSG:" + str(epsg) try: styles = layer["styles"] except: styles = "" try: group = layer["group"] except: group = None try: style = layer["style"] except: style = "" my_layers = layers.split(",") my_styles = styles.split(",") layer_string = "" style_string = "" for my_layer in my_layers: layer_string += "&layers=" + my_layer # So werden einfach leere Styles requested. # Korrekterweise wäre style=qml und wmsstyle = Style der # vom WMS requested wird. style_string += "&styles=" if layer["type"] == "wms": uri = "IgnoreGetMapUrl=1&crs=" + crs + layer_string + \ style_string + "&format=" + format + "&url=" + url else: uri = "crs=" + crs + layer_string + style_string + \ "&format=" + format + "&tileMatrixSet=" + \ tilematrixset + "&url=" + url my_layer = QgsRasterLayer(uri, title, "wms", False) # local ogr and gdal formats elif layer["type"] in ["gdal", "ogr"]: title = layer["title"] url = layer["url"] try: style = str(layer["style"]) except: style = "" try: group = str(layer["group"]) except: group = None if layer["type"] == 'ogr': my_layer = QgsVectorLayer(url, title, layer["type"]) else: my_layer = QgsRasterLayer(url, title) else: self.message_bar.pushMessage( "Error", tr( "Data provider not yet supported: ") + str( layer["type"]), QgsMessageBar.CRITICAL, duration=0) return if style != "": if style.startswith('global_qml'): qml_dir = "/plugins/veriso/" else: qml_dir = "/plugins/veriso/modules/%s/qml/" % \ module_name """qml_path = QDir.convertSeparators(QDir.cleanPath( QgsApplication.qgisSettingsDirPath() + qml_dir + style))""" qml_path=QDir.convertSeparators(QDir.cleanPath( (os.path.realpath(__file__)).split("plugins")[0] +qml_dir + style)) qml = QDir.convertSeparators(QDir.cleanPath(qml_path)) my_layer.loadNamedStyle(qml) if not my_layer.isValid(): # str(title) throws some ascii out of range error... self.message_bar.pushMessage("Error", title + tr( " is not valid layer."), QgsMessageBar.CRITICAL, duration=0) return else: # QgsMapLayerRegistry.instance().addMapLayer(my_layer) if group: # Layer soll in eine bestimmte Gruppe hinzugefügt # werden. QgsMapLayerRegistry.instance().addMapLayer(my_layer, False) my_group_node = self.root.findGroup(group) if not my_group_node: # Gruppe noch nicht vorhanden. my_group_node = self.root.addGroup(group) # Achtung: Das ist eher ein Workaround. Meines # Erachtens hats noch einen Bug. # Mit QgsMapLayerRegistry.instance().addMapLayer( # my_layer, False) wird # ein Layer noch nicht in die Legende gehängt. # Anschliessend kann man ihn # mit my_layer_node = self.root.addLayer(my_layer) # der Legende hinzufügen. # Das führt aber dazu, dass was mit dem MapCanvas # nicht mehr stimmt, dh. # .setExtent() funktioniert nicht mehr richtig. Wird # der Layer jedoch direkt # in die Legende gehängt, funktioniert .setExtent() # tadellos. Jetzt wird halt # momentan der Layer direkt eingehängt und # anschliessend in die gewünschte # Gruppe verschoben. # Kleiner (positiver) Nebeneffekt: Der Layer ist # defaultmässig ausgeschaltet. # # NEIN: Anscheinend ist es ein Problem wenn man dann # layer_node.setVisible(Qt.Checked) # macht. Dann funktionierts nicht mehr. -> Wieder # zurückändern auf einfachere Methode. # "Umweg": Hat Probleme gemacht, falls ein Gruppe # "active" war. Dann wurden der neue # Layer ebenfalls (zusätzlich) ihr hinzugefügt. # print my_layer.id() # my_layer_node = self.root.findLayer( # my_layer.id()) # print my_layer_node # cloned_layer = my_layer_node.clone() # print cloned_layer # my_group_node.insertChildNode(0, # cloned_layer) # self.root.removeChildNode( # my_layer_node) # my_layer_node = self.root.findLayer( # my_layer.id()) # Layer bekommt neuen layer_node. # "Direkt(er)" my_layer_node = my_group_node.insertLayer(0, my_layer) else: QgsMapLayerRegistry.instance().addMapLayer(my_layer, False) my_layer_node = self.root.addLayer(my_layer) my_layer_node.setVisible(Qt.Unchecked) my_layer_node.setCustomProperty("showFeatureCount",True) if visible: my_layer_node.setVisible(Qt.Checked) if collapsed_legend: my_layer_node.setExpanded(False) else: my_layer_node.setExpanded(True) if 'my_group_node' in locals(): if collapsed_group: my_group_node.setExpanded(False) else: my_group_node.setExpanded(True) return my_layer except Exception as e: self.message_bar.pushMessage("Error", str(e), QgsMessageBar.CRITICAL, duration=0) QgsMessageLog.logMessage(str(e), "VeriSO", QgsMessageLog.CRITICAL) return
def run(self): try: self.project_id = self.settings.value("project/id") self.epsg = self.settings.value("project/epsg") group = tr(u"Mängel", self.tr_tag, None) group += " (" + str(self.project_id) + ")" layer = { "type": "postgres", "title": tr(u"Mängelliste (Punkte)", self.tr_tag, None), "featuretype": "t_maengel", "geom": "the_geom", "key": "ogc_fid", "readonly": False, "sql": "", "group": group, "style": "global_qml/maengel/maengel_punkt.qml" } vlayer = self.layer_loader.load(layer) if vlayer: vlayer.setEditorLayout(QgsVectorLayer.GeneratedLayout) ogc_fid_idx = vlayer.fieldNameIndex("ogc_fid") topic_idx = vlayer.fieldNameIndex("topic") bemerkung_idx = vlayer.fieldNameIndex("bemerkung") datum_idx = vlayer.fieldNameIndex("datum") vlayer.addAttributeAlias(topic_idx, tr("Topic:", self.tr_tag, None)) vlayer.addAttributeAlias(bemerkung_idx, tr("bemekung:", self.tr_tag, None)) vlayer.setEditorWidgetV2(ogc_fid_idx, "Hidden") vlayer.setEditorWidgetV2(topic_idx, "Enumeration") vlayer.setEditorWidgetV2(bemerkung_idx, "TextEdit") vlayer.setEditorWidgetV2Config( bemerkung_idx, {"IsMultiline": True }) # See gui/editorwidgets/qgstexteditwrapper.cpp for all # the parameters. vlayer.setEditorWidgetV2(datum_idx, "Hidden") layer = { "type": "postgres", "title": tr(u"Mängelliste (Linien)", self.tr_tag, None), "featuretype": "t_maengel_linie", "geom": "the_geom", "key": "ogc_fid", "readonly": False, "sql": "", "group": group, "style": "global_qml/maengel/maengel_linie.qml" } vlayer = self.layer_loader.load(layer) if vlayer: vlayer.setEditorLayout(QgsVectorLayer.GeneratedLayout) ogc_fid_idx = vlayer.fieldNameIndex("ogc_fid") topic_idx = vlayer.fieldNameIndex("topic") bemerkung_idx = vlayer.fieldNameIndex("bemerkung") datum_idx = vlayer.fieldNameIndex("datum") vlayer.addAttributeAlias(topic_idx, tr("Topic:", self.tr_tag, None)) vlayer.addAttributeAlias(bemerkung_idx, tr("Bemerkung:", self.tr_tag, None)) vlayer.setEditorWidgetV2(ogc_fid_idx, "Hidden") vlayer.setEditorWidgetV2(topic_idx, "Enumeration") vlayer.setEditorWidgetV2(bemerkung_idx, "TextEdit") vlayer.setEditorWidgetV2Config( bemerkung_idx, {"IsMultiline": True }) # See gui/editorwidgets/qgstexteditwrapper.cpp for all # the parameters. vlayer.setEditorWidgetV2(datum_idx, "Hidden") """layer = { "type": "postgres", "title": tr(u"Mängelliste (Polygone)", self.tr_tag, None), "featuretype": "t_maengel_polygon", "geom": "the_geom", "key": "ogc_fid", "readonly": False, "sql": "", "group": group, "style": "global_qml/maengel/maengel_polygon.qml" } vlayer = self.layer_loader.load(layer) if vlayer: vlayer.setEditorLayout(QgsVectorLayer.GeneratedLayout) ogc_fid_idx = vlayer.fieldNameIndex("ogc_fid") topic_idx = vlayer.fieldNameIndex("topic") bemerkung_idx = vlayer.fieldNameIndex("bemerkung") datum_idx = vlayer.fieldNameIndex("datum") vlayer.addAttributeAlias(topic_idx, tr("Topic:", self.tr_tag, None)) vlayer.addAttributeAlias(bemerkung_idx, tr("Bemerkung:", self.tr_tag, None)) vlayer.setEditorWidgetV2(ogc_fid_idx, "Hidden") vlayer.setEditorWidgetV2(topic_idx, "Enumeration") vlayer.setEditorWidgetV2(bemerkung_idx, "TextEdit") vlayer.setEditorWidgetV2Config(bemerkung_idx, { "IsMultiline": True }) # See gui/editorwidgets/qgstexteditwrapper.cpp for all # the parameters. vlayer.setEditorWidgetV2(datum_idx, "Hidden")""" except Exception: QApplication.restoreOverrideCursor() exc_type, exc_value, exc_traceback = sys.exc_info() self.message_bar.pushMessage( "Error", str(traceback.format_exc(exc_traceback)), level=QgsMessageBar.CRITICAL, duration=0) QApplication.restoreOverrideCursor()
def on_btnBrowseInputFile_clicked(self): file_path = QFileDialog.getOpenFileName( self, tr("Choose interlis transfer file"), self.input_itf_path, "ITF (*.itf *.ITF)") file_info = QFileInfo(file_path) self.lineEditInputFile.setText(file_info.absoluteFilePath())
def accept(self): """Collecting all the stuff we need to know to start the import process. """ # Save the settings. self.settings.setValue("file/import/input_itf_path", self.lineEditInputFile.text()) self.settings.setValue("file/import/ili", self.ili) # Check if project name (db schema) already exists. project_name = self.lineEditDbSchema.text().strip() if len(project_name) > 0: project_found = self.check_project_name(project_name) if project_found == -1: message = "An error occured while connecting the database." self.message_bar.pushMessage("VeriSO", tr(message), QgsMessageBar.CRITICAL, duration=0) return elif project_found == 1: message = "Project name already exists." self.message_bar.pushWarning("VeriSO", tr(message)) QgsMessageLog.logMessage(tr(message), "VeriSO", QgsMessageLog.WARNING) return # Gather all data/information for ili2pg arguments. self.itf = self.lineEditInputFile.text().strip() self.db_schema = self.lineEditDbSchema.text().strip() self.data_date = self.dateTimeEdit.date().toString("yyyy-MM-dd") self.notes = self.textEditNotes.toPlainText().strip() if len(self.notes) > 10000: message = "Notes are to big (allowed 10000 characters): " self.message_bar.pushMessage("VeriSO", tr(message) + str(len(self.notes)), QgsMessageBar.CRITICAL, duration=0) QgsMessageLog.logMessage( str(message) + str(len(self.notes)), "VeriSO", QgsMessageLog.WARNING) return self.projects_database = self.settings.value( "options/general/projects_database", "") self.projects_root_directory = self.settings.value( "options/general/projects_root_directory", "") import_jar = self.settings.value("options/import/jar", "") import_vm_arguments = self.settings.value( "options/import/vm_arguments", "") # Check if we have everything we need. if not os.path.isfile( self.projects_database) and self.projects_database != "": self.message_bar.pushWarning( "VeriSO", tr("Projects database not " "found: ") + str(self.projects_database)) return if self.itf == "": self.message_bar.pushWarning( "VeriSO", tr("No Interlis transfer file " "set.")) return if self.ili == "": self.message_bar.pushWarning("VeriSO", tr("No Interlis model name set.")) return if self.db_schema == "": self.message_bar.pushWarning("VeriSO", tr("No project name set.")) return if self.cmbBoxAppModule.currentIndex() == 0: self.message_bar.pushWarning( "VeriSO", tr("No application module " "chosen.")) return if not self.db_host: self.message_bar.pushWarning( "VeriSO", tr("Missing database host " "parameter.")) return if not self.db_name: self.message_bar.pushWarning( "VeriSO", tr("Missing database name " "parameter.")) return if not self.db_port: self.message_bar.pushWarning( "VeriSO", tr("Missing database port " "parameter.")) return if not self.db_user: self.message_bar.pushWarning( "VeriSO", tr("Missing database user " "parameter.")) return if not self.db_pwd: self.message_bar.pushWarning( "VeriSO", tr("Missing database password " "parameter.")) return if not self.db_admin: self.message_bar.pushWarning( "VeriSO", tr("Missing database administrator parameter.")) return if not self.db_admin_pwd: self.message_bar.pushWarning( "VeriSO", tr("Missing database administrator password parameter.")) return if self.projects_root_directory == "": self.message_bar.pushWarning( "VeriSO", tr("No root directory for " "projects " "set.")) return if self.projects_database == "": self.message_bar.pushInfo( "VeriSO", tr("No projects database found. Will create one in the " "project root directory.")) if import_jar == "": self.message_bar.pushWarning("VeriSO", tr("No jar file set for import.")) return self.textEditImportOutput.clear() # Set all the arguments for ili2pg. arguments = [] vm_arguments_list = import_vm_arguments.split(" ") for arg in vm_arguments_list: arguments.append(arg) arguments.append("-jar") arguments.append(import_jar) arguments.append("--import") arguments.append("--dbhost") arguments.append(self.db_host) arguments.append("--dbport") arguments.append(self.db_port) arguments.append("--dbdatabase") arguments.append(self.db_name) arguments.append("--dbschema") arguments.append(self.db_schema) arguments.append("--dbusr") arguments.append(self.db_admin) arguments.append("--dbpwd") arguments.append(self.db_admin_pwd) arguments.append("--modeldir") model_dir = ';'.join( self.settings.value("options/model_repositories/repositories")) arguments.append(model_dir) arguments.append("--models") arguments.append(self.ili) arguments.append("--defaultSrsAuth") arguments.append("EPSG") arguments.append("--defaultSrsCode") arguments.append(self.epsg) # TODO: ili2pg has a lot of options. At least some of them should be # exposed to the user. arguments.append("--t_id_Name") arguments.append("ogc_fid") arguments.append("--importTid") arguments.append("--createGeomIdx") arguments.append("--createEnumTabs") arguments.append("--createEnumTxtCol") arguments.append("--createEnumColAsItfCode") arguments.append("--nameByTopic") arguments.append("--strokeArcs") arguments.append(self.itf) self.process = QProcess() self.process.readyReadStandardOutput.connect(self.read_output) self.process.readyReadStandardError.connect(self.read_error) self.process.finished.connect(self.finish_import) QApplication.setOverrideCursor(Qt.WaitCursor) self.buttonBox.setEnabled(False) self.report_progress("Info: Starting ili2pg") self.report_progress("Info: java %s" % ' '.join(arguments)) try: self.process.start("java", arguments) except Exception as e: self.restore_cursor() message = "Could not start import process." self.message_bar.pushMessage("VeriSO", tr(message), QgsMessageBar.CRITICAL, duration=0) QgsMessageLog.logMessage(str(e), "VeriSO", QgsMessageLog.CRITICAL)
def tr(self, context, text, disambig): try: _encoding = QApplication.UnicodeUTF8 return tr(context, text, disambig, _encoding) except AttributeError: return tr(context, text, disambig)
def run(self): try: import xlsxwriter except Exception as e: self.message_bar.pushMessage("Error", str(e), level=QgsMessageBar.CRITICAL, duration=0) return try: settings = QSettings("CatAIS", "VeriSO") module_name = settings.value("project/appmodule") provider = settings.value("project/provider") db_host = settings.value("project/dbhost") db_port = settings.value("project/dbport") db_name = settings.value("project/dbname") db_schema = settings.value("project/dbschema") db_user = settings.value("project/dbuser") db_pwd = settings.value("project/dbpwd") # db_admin = settings.value("project/dbadmin") # db_admin_pwd = settings.value("project/dbadminpwd") project_id = settings.value("project/id") project_dir = settings.value("project/projectdir") if not db_schema: self.message_bar.pushCritical( "Error", self.tr("Missing database schema parameter.")) return if not db_host: self.message_bar.pushCritical( "Error", self.tr("Missing database host parameter.")) return if not db_name: self.message_bar.pushCritical( "Error", self.tr("Missing database name parameter.")) return if not db_port: self.message_bar.pushCritical( "Error", self.tr("Missing database port parameter.")) return if not db_user: self.message_bar.pushCritical( "Error", self.tr("Missing database user parameter.")) return if not db_pwd: self.message_bar.pushCritical( "Error", self.tr("Missing database user password parameter.")) return if not provider: self.message_bar.pushCritical( "Error", self.tr("Missing provider parameter. Cannot load " "layer.")) return if not module_name: self.message_bar.pushCritical( "Error", self.tr("Missing module name parameter. Cannot load " "layer.")) return uri = QgsDataSourceURI() uri.setConnection(db_host, db_port, db_name, db_user, db_pwd) uri.setDataSource(db_schema, "t_maengel", "the_geom", "", "ogc_fid") vlayer_points = QgsVectorLayer(uri.uri(), "Maengel (Punkte)", "postgres") uri = QgsDataSourceURI() uri.setConnection(db_host, db_port, db_name, db_user, db_pwd) uri.setDataSource(db_schema, "t_maengel_linie", "the_geom", "", "ogc_fid") vlayer_lines = QgsVectorLayer(uri.uri(), "Maengel (Linien)", "postgres") """uri = QgsDataSourceURI() uri.setConnection(db_host, db_port, db_name, db_user, db_pwd) uri.setDataSource(db_schema, "t_maengel_polygon", "the_geom", "", "ogc_fid") vlayer_polygons = QgsVectorLayer(uri.uri(), "Maengel (Polygon)", "postgres")""" if not vlayer_points.isValid(): self.message_bar.pushMessage( "Error", tr("Could not load defects layer.", self.tr_tag, None), level=QgsMessageBar.CRITICAL, duration=0) return if not vlayer_lines.isValid(): self.message_bar.pushMessage( "Error", tr("Could not load defects layer.", self.tr_tag, None), level=QgsMessageBar.CRITICAL, duration=0) return """if not vlayer_polygons.isValid(): self.message_bar.pushMessage("Error", tr("Could not load defects layer.", self.tr_tag, None), level=QgsMessageBar.CRITICAL, duration=0) return""" """if (vlayer_points.featureCount() == 0 and vlayer_lines.featureCount() == 0 and vlayer_polygons.featureCount() == 0)""" if (vlayer_points.featureCount() == 0 and vlayer_lines.featureCount() == 0): self.message_bar.pushInfo( "Information", tr("Defects layer are empty.", self.tr_tag, None)) return # Create excel file. filename = QDir.convertSeparators( QDir.cleanPath(os.path.join(project_dir, "maengel.xlsx"))) workbook = xlsxwriter.Workbook(filename) fmt_bold = workbook.add_format({'bold': True}) fmt_italic = workbook.add_format({'italic': True}) fmt_2dec = workbook.add_format({'num_format': '0.00'}) fmt_3dec = workbook.add_format({'num_format': '0.000'}) # 28/02/13 12:00 fmt_date = workbook.add_format({'num_format': 'dd/mm/yy hh:mm'}) # Create the worksheet for the points defects. worksheet_points = workbook.add_worksheet( tr(u'Mängelliste (Punkte)', self.tr_tag, None)) worksheet_points.set_paper(9) worksheet_points.set_portrait() # Write project name into worksheet. worksheet_points.write_string(0, 0, tr("Operat: ", self.tr_tag, None), fmt_bold) worksheet_points.write_string(0, 1, project_id, fmt_bold) # Write defects. Loop through field to write header. # Then loop through features. provider = vlayer_points.dataProvider() attrs = provider.fields() # types = [] i = 0 for i in range(len(attrs)): worksheet_points.write_string(4, i, str(attrs.at(i).name()), fmt_italic) # types.append(attrs.at(i).type()) worksheet_points.write_string( 4, i + 1, tr("Y-Koordinate", self.tr_tag, None), fmt_italic) worksheet_points.write_string( 4, i + 2, tr("X-Koordinate", self.tr_tag, None), fmt_italic) iterator = vlayer_points.getFeatures() j = 0 for feat in iterator: geom = feat.geometry() point = geom.asPoint() attrs = feat.attributes() k = 0 for attr in attrs: fmt = None if type(attr) is QDate: # this is to avoid: # Unsupported type # <class 'PyQt4.QtCore.QDateTime'> in write() fmt = fmt_date attr = attr.toPyDate() worksheet_points.write_string(5 + j, k, str(attr), fmt) k += 1 worksheet_points.write_number(5 + j, k, point.x(), fmt_3dec) worksheet_points.write_number(5 + j, k + 1, point.y(), fmt_3dec) j += 1 # Create the worksheet for the line defects. worksheet_lines = workbook.add_worksheet( tr(u'Mängelliste (Linien)', self.tr_tag, None)) worksheet_lines.set_paper(9) worksheet_lines.set_portrait() # Write project name into worksheet. worksheet_lines.write_string(0, 0, tr("Operat: ", self.tr_tag, None), fmt_bold) worksheet_lines.write_string(0, 1, project_id, fmt_bold) # Write defects. Loop through field to write header. # Then loop through features. provider = vlayer_lines.dataProvider() attrs = provider.fields() # types = [] for i in range(len(attrs)): worksheet_lines.write_string(4, i, str(attrs.at(i).name()), fmt_italic) # types.append(attrs.at(i).type()) worksheet_lines.write_string(4, i + 1, tr("Y-Koordinate", self.tr_tag, None), fmt_italic) worksheet_lines.write_string(4, i + 2, tr("X-Koordinate", self.tr_tag, None), fmt_italic) worksheet_lines.write_string(4, i + 3, tr(u"Länge [hm]", self.tr_tag, None), fmt_italic) iterator = vlayer_lines.getFeatures() j = 0 for feat in iterator: geom = feat.geometry() point = geom.vertexAt(0) attrs = feat.attributes() k = 0 for attr in attrs: fmt = None if type(attr) == QDate: # this is to avoid: # Unsupported type # <class 'PyQt4.QtCore.QDateTime'> in write() fmt = fmt_date attr = attr.toPyDate() worksheet_lines.write_string(5 + j, k, str(attr), fmt) k += 1 worksheet_lines.write_number(5 + j, k, point.x(), fmt_3dec) worksheet_lines.write_number(5 + j, k + 1, point.y(), fmt_3dec) worksheet_lines.write_number(5 + j, k + 2, geom.length(), fmt_2dec) j += 1 """# Create the worksheet for the polygon defects. worksheet_polygons = workbook.add_worksheet( tr(u'Mängelliste (Polygone)', self.tr_tag, None)) worksheet_polygons.set_paper(9) worksheet_polygons.set_portrait() # Write project name into worksheet. worksheet_polygons.write(0, 0, tr("Operat: ", self.tr_tag, None), fmt_bold) worksheet_polygons.write(0, 1, project_id, fmt_bold) # Write defects. Loop through field to write header. # Then loop through features. provider = vlayer_polygons.dataProvider() attrs = provider.fields() # types = [] for i in range(len(attrs)): worksheet_polygons.write(4, i, str(attrs.at(i).name()), fmt_italic) # types.append(attrs.at(i).type()) worksheet_polygons.write(4, i + 1, tr("Y-Koordinate", self.tr_tag, None), fmt_italic) worksheet_polygons.write(4, i + 2, tr("X-Koordinate", self.tr_tag, None), fmt_italic) worksheet_polygons.write(4, i + 3, tr(u"Fläche [m2]", self.tr_tag, None), fmt_italic) worksheet_polygons.write(4, i + 4, tr(u"Umfang [hm]", self.tr_tag, None), fmt_italic) iterator = vlayer_polygons.getFeatures() j = 0 for feat in iterator: geom = feat.geometry() point = geom.vertexAt(0) attrs = feat.attributes() k = 0 for attr in attrs: fmt = None if type(attr) == QDateTime: # this is to avoid: # Unsupported type # <class 'PyQt4.QtCore.QDateTime'> in write() fmt = fmt_date attr = attr.toPyDateTime() worksheet_polygons.write(5 + j, k, attr, fmt) k += 1 worksheet_polygons.write(5 + j, k, point.x(), fmt_3dec) worksheet_polygons.write(5 + j, k + 1, point.y(), fmt_3dec) worksheet_polygons.write(5 + j, k + 2, geom.area(), fmt_2dec) worksheet_polygons.write(5 + j, k + 3, geom.length(), fmt_2dec) j += 1""" # Close excel file. workbook.close() self.message_bar.pushInfo( "Information", tr("Defect(s) written: ", self.tr_tag, None) + str(filename)) except Exception as e: message = "Error while writing defects file." self.message_bar.pushMessage("Error", tr(self.tr_tag, message, None), level=QgsMessageBar.CRITICAL, duration=0) QgsMessageLog.logMessage(str(e), "VeriSO", QgsMessageLog.CRITICAL) return
def load(self, layer_definition, visible=True, collapsed_legend=False, collapsed_group=False): settings = QSettings("CatAIS", "VeriSO") module_name = settings.value("project/appmodule") self.check_parameter('module name', module_name) epsg = settings.value("project/epsg") self.check_parameter('epsg', epsg) try: loaded_layer = self._load(epsg, layer_definition) if not loaded_layer.isValid(): # str(layer['title']) throws some ascii out of range error... error = layer_definition['title'] + tr(" is not valid layer.") raise VerisoErrorWithBar(self.message_bar, error) else: try: group = str(layer_definition["group"]) except KeyError: group = None # QgsProject.instance().addMapLayer(loaded_layer) if group: # Layer soll in eine bestimmte Gruppe hinzugefügt # werden. QgsProject.instance().addMapLayer(loaded_layer, False) my_group_node = self.root.findGroup(group) if not my_group_node: # Gruppe noch nicht vorhanden. my_group_node = self.root.addGroup(group) """ Achtung: Das ist eher ein Workaround. Meines # Erachtens hats noch einen Bug. # Mit QgsProject.instance().addMapLayer( # loaded_layer, False) wird # ein Layer noch nicht in die Legende gehängt. # Anschliessend kann man ihn # mit my_layer_node = self.root.addLayer(loaded_layer) # der Legende hinzufügen. # Das führt aber dazu, dass was mit dem MapCanvas # nicht mehr stimmt, dh. # .setExtent() funktioniert nicht mehr richtig. Wird # der Layer jedoch direkt # in die Legende gehängt, funktioniert .setExtent() # tadellos. Jetzt wird halt # momentan der Layer direkt eingehängt und # anschliessend in die gewünschte # Gruppe verschoben. # Kleiner (positiver) Nebeneffekt: Der Layer ist # defaultmässig ausgeschaltet. # # NEIN: Anscheinend ist es ein Problem wenn man dann # layer_node.setVisible(Qt.Checked) # macht. Dann funktionierts nicht mehr. -> Wieder # zurückändern auf einfachere Methode. # "Umweg": Hat Probleme gemacht, falls ein Gruppe # "active" war. Dann wurden der neue # Layer ebenfalls (zusätzlich) ihr hinzugefügt. # print loaded_layer.id() # my_layer_node = self.root.findLayer( # loaded_layer.id()) # print my_layer_node # cloned_layer = my_layer_node.clone() # print cloned_layer # my_group_node.insertChildNode(0, # cloned_layer) # self.root.removeChildNode( # my_layer_node) # my_layer_node = self.root.findLayer( # loaded_layer.id()) # Layer bekommt neuen layer_node. # "Direkt(er)" """ my_layer_node = my_group_node.insertLayer(0, loaded_layer) else: QgsProject.instance().addMapLayer(loaded_layer, False) my_layer_node = self.root.addLayer(loaded_layer) my_layer_node.setItemVisibilityChecked(Qt.Unchecked) if visible: my_layer_node.setItemVisibilityChecked(Qt.Checked) if collapsed_legend: my_layer_node.setExpanded(False) else: my_layer_node.setExpanded(True) self.set_style(module_name, loaded_layer, layer_definition) self.set_transparency(loaded_layer, layer_definition) # Workaround for wrong raster layer legends self.iface.layerTreeView().refreshLayerSymbology( loaded_layer.id()) return loaded_layer except VerisoErrorWithBar: return except Exception as e: raise VerisoErrorWithBar(self.message_bar, str(e), e)
def check_parameter(self, parameter_name, parameter): error_message = tr("Missing %s parameter. Cannot load " "layer.") % parameter_name if not parameter: raise VerisoErrorWithBar(self.message_bar, error_message)
def btnBrowseProjectsRootDir_clicked(self): dir_path = QFileDialog.getExistingDirectory(self, tr( "Choose projects root directory"), self.projects_root_directory) dir_info = QFileInfo(dir_path) self.lineEditProjectsRootDir.setText(dir_info.absoluteFilePath())
def tr(self, context, text, disambig): return tr(context, text, disambig)
def accept(self): """Collecting all the stuff we need to know to start the import process. """ # Save the settings. self.settings.value("file/export/output_itf_path", self.lineEditOutputFile.text()) # Gather all data/information for ili2pg arguments. self.itf = self.lineEditOutputFile.text().strip() current_index = self.cBoxProject.currentIndex() if current_index == 0: return db_schema = str(self.cBoxProject.itemData(current_index)) # Get the connections parameters from the projects list we created in # the init_gui method. i = 0 for project in self.projects: if db_schema == str(project["dbschema"]): self.db_host = str(project["dbhost"]) self.db_name = str(project["dbname"]) self.db_port = str(project["dbport"]) self.db_schema = db_schema self.db_admin = str(project["dbadmin"]) self.db_admin_pwd = str(project["dbadminpwd"]) self.app_module = str(project["appmodule"]) self.app_module_name = str(project["appmodulename"]) self.db_user = str(project["dbuser"]) self.db_pwd = str(project["dbpwd"]) self.ili = str(project["ilimodelname"]) self.project_index = i break i += 1 import_vm_arguments = self.settings.value( "options/import/vm_arguments", "") # Check if we have everything we need. if self.itf == "": self.message_bar.pushWarning("VeriSO", tr("No Interlis transfer file " "set.")) return if self.ili == "": self.message_bar.pushWarning("VeriSO", tr("No Interlis model name set.")) return if self.db_schema == "": self.message_bar.pushWarning("VeriSO", tr("No project name set.")) return if self.app_module == "": self.message_bar.pushWarning("VeriSO", tr("No application module " "set.")) return if not self.db_host: self.message_bar.pushWarning("VeriSO", tr("Missing database host " "parameter.")) return if not self.db_name: self.message_bar.pushWarning("VeriSO", tr("Missing database name " "parameter.")) return if not self.db_port: self.message_bar.pushWarning("VeriSO", tr("Missing database port " "parameter.")) return if not self.db_user: self.message_bar.pushWarning("VeriSO", tr("Missing database user " "parameter.")) return if not self.db_pwd: self.message_bar.pushWarning("VeriSO", tr("Missing database password " "parameter.")) return if not self.db_admin: self.message_bar.pushWarning("VeriSO", tr( "Missing database administrator parameter.")) return if not self.db_admin_pwd: self.message_bar.pushWarning("VeriSO", tr( "Missing database administrator password parameter.")) return if jre_version() is None: self.message_bar.pushWarning("VeriSO", tr("No java runtime detected.")) return self.textEditExportOutput.clear() # Set all the arguments for ili2pg. arguments = [] vm_arguments_list = import_vm_arguments.split(" ") for arg in vm_arguments_list: arguments.append(arg) import_jar = os.path.dirname(__file__) + '/../../lib/ili2pg-3.6.1/ili2pg.jar' arguments.append("-Duser.country=CH") arguments.append("-Duser.language=de") arguments.append("-jar") arguments.append(import_jar) arguments.append("--export") arguments.append("--dbhost") arguments.append(self.db_host) arguments.append("--dbport") arguments.append(self.db_port) arguments.append("--dbdatabase") arguments.append(self.db_name) arguments.append("--dbschema") arguments.append(self.db_schema) arguments.append("--dbusr") arguments.append(self.db_admin) arguments.append("--dbpwd") arguments.append(self.db_admin_pwd) arguments.append("--modeldir") model_dir = ';'.join(self.settings.value( "options/model_repositories/repositories")) arguments.append(model_dir) arguments.append("--models") arguments.append(self.ili) arguments.append("--defaultSrsAuth") arguments.append("EPSG") arguments.append(self.itf) self.process = QProcess() self.process.readyReadStandardOutput.connect(self.read_output) self.process.readyReadStandardError.connect(self.read_error) self.process.finished.connect(self.finish_import) QApplication.setOverrideCursor(Qt.WaitCursor) self.buttonBox.setEnabled(False) self.report_progress("Info: Starting ili2pg") self.report_progress("Info: java %s" % ' '.join(arguments)) try: if(sys.platform == 'win32'): j = win_which('java.exe') self.process.start(j, arguments) else: self.process.start("java", arguments) except Exception as e: self.restore_cursor() message = "Could not start export process." self.message_bar.pushMessage("VeriSO", tr(message), Qgis.Critical, duration=0) QgsMessageLog.logMessage(str(e), tag="VeriSO", level=Qgis.Critical)