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)
