def run_managegroups(self):
"""Speichern und Wiederherstellen von Teilgebietszuordnungen als Gruppe"""
# Check, ob die relevanten Layer nicht editable sind.
if len({u'flaechen', u'haltungen', u'schaechte', u'linksw', u'einleit',
u'linkfl', u'teilgebiete', u'tezg'} & get_editable_layers()) > 0:
iface.messageBar().pushMessage(u"Bedienerfehler: ",
u'Die zu verarbeitenden Layer dürfen nicht im Status "bearbeitbar" sein. Abbruch!',
level=QgsMessageBar.CRITICAL)
return False
database_QKan = u''
database_QKan, epsg = get_database_QKan()
if not database_QKan:
fehlermeldung(u"Fehler in LinkFl.run_managegroups",
u"database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
logger.error(u"CreateUnbefFl: database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
return False
self.dbQK = DBConnection(dbname=database_QKan) # Datenbankobjekt der QKan-Datenbank zum Lesen
if self.dbQK is None:
fehlermeldung(u"Fehler in LinkFl.run_managegroups",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format(database_QKan))
iface.messageBar().pushMessage(u"Fehler in LinkFl.run_managegroups",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format( \
database_QKan), level=QgsMessageBar.CRITICAL)
return None
self.showgroups()
self.dlg_mg.lw_gruppen.setCurrentRow(0)
# Anzeige initialisieren
self.listGroupAttr()
# show the dialog
self.dlg_mg.show()
# Run the dialog event loop
result = self.dlg_mg.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
pass
# Start der Verarbeitung
# Nur Formular schließen
# ----------------------------------------------------------------------------------------------
# Datenbankverbindungen schliessen
del self.dbQK
def run(self):
"""Run method that performs all the real work"""
database_QKan, epsg = get_database_QKan()
if not database_QKan:
fehlermeldung(
u"Fehler in CreateUnbefFl",
u"database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!"
)
logger.error(
u"CreateUnbefFl: database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!"
)
return False
# Abfragen der Tabelle tezg nach verwendeten Abflussparametern
self.dbQK = DBConnection(
dbname=database_QKan
) # Datenbankobjekt der QKan-Datenbank zum Lesen
if self.dbQK is None:
fehlermeldung(
u"Fehler in QKan_CreateUnbefFl",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format(
database_QKan))
iface.messageBar().pushMessage(u"Fehler in QKan_Import_from_HE",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format( \
database_QKan), level=QgsMessageBar.CRITICAL)
return None
# Kontrolle, ob in Tabelle "abflussparameter" ein Datensatz für unbefestigte Flächen vorhanden ist
# (Standard: apnam = '$Default_Unbef')
sql = u"""SELECT apnam
FROM abflussparameter
WHERE bodenklasse IS NOT NULL AND trim(bodenklasse) <> ''"""
if not self.dbQK.sql(sql, u'createunbeffl.run (1)'):
return False
data = self.dbQK.fetchone()
if data is None:
if autokorrektur:
daten = [
u"'$Default_Unbef', u'von QKan ergänzt', 0.5, 0.5, 2, 5, 0, 0, 'LehmLoess', '13.01.2011 08:44:50'"
]
for ds in daten:
sql = u"""INSERT INTO abflussparameter
( 'apnam', 'kommentar', 'anfangsabflussbeiwert', 'endabflussbeiwert', 'benetzungsverlust',
'muldenverlust', 'benetzung_startwert', 'mulden_startwert', 'bodenklasse',
'createdat') Values ({})""".format(ds)
if not self.dbQK.sql(sql, u'createunbeffl.run (2)'):
return False
else:
fehlermeldung(
u'Datenfehler: ',
u'Bitte ergänzen Sie in der Tabelle "abflussparameter" einen Datensatz für unbefestigte Flächen ("bodenklasse" darf nicht leer oder NULL sein)'
)
# # Kontrolle, ob noch Flächen in Tabelle "tezg" ohne Zuordnung zu einem Abflussparameter oder zu einem
# # Abflussparameter, bei dem keine Bodenklasse definiert ist (Kennzeichen für undurchlässige Flächen).
# sql = u"""SELECT te.abflussparameter, te.teilgebiet, count(*) AS anz
# FROM tezg AS te
# LEFT JOIN abflussparameter AS ap
# ON te.abflussparameter = ap.apnam
# WHERE ap.bodenklasse IS NULL
# GROUP BY abflussparameter, teilgebiet"""
# if not self.dbQK.sql(sql, u'createunbeffl.run (3)'):
# return False
# data = self.dbQK.fetchall()
# if len(data) > 0:
# liste = [u'{}\t{}\t{}'.format(el1, el2, el3) for el1, el2, el3 in data]
# liste.insert(0, u'\nAbflussparameter\tTeilgebiet\tAnzahl')
# fehlermeldung(u'In Tabelle "tezg" fehlen Abflussparameter oder gehören zu befestigten Flächen (Bodenklasse = NULL):\n',
# u'\n'.join(liste))
# return False
sql = u"""SELECT te.abflussparameter, te.teilgebiet, bk.bknam, count(*) AS anz,
CASE WHEN te.abflussparameter ISNULL THEN 'Fehler: Kein Abflussparameter angegeben' ELSE
CASE WHEN bk.infiltrationsrateanfang ISNULL THEN 'Fehler: Keine Bodenklasse angegeben'
WHEN bk.infiltrationsrateanfang < 0.00001 THEN 'Fehler: undurchlässige Bodenart'
ELSE ''
END
END AS status
FROM tezg AS te
LEFT JOIN abflussparameter AS ap
ON te.abflussparameter = ap.apnam
LEFT JOIN bodenklassen AS bk
ON bk.bknam = ap.bodenklasse
GROUP BY abflussparameter, teilgebiet"""
if not self.dbQK.sql(sql, u'createunbeffl.run (4)'):
return None
self.listetezg = self.dbQK.fetchall()
nzeilen = len(self.listetezg)
self.dlg.tw_selAbflparamTeilgeb.setRowCount(nzeilen)
self.dlg.tw_selAbflparamTeilgeb.setHorizontalHeaderLabels([
u"Abflussparameter", u"Teilgebiet", u"Bodenklasse", u"Anzahl",
u"Anmerkungen"
])
self.dlg.tw_selAbflparamTeilgeb.setColumnWidth(
0, 144) # 17 Pixel für Rand und Nummernspalte (und je Spalte?)
self.dlg.tw_selAbflparamTeilgeb.setColumnWidth(1, 140)
self.dlg.tw_selAbflparamTeilgeb.setColumnWidth(2, 90)
self.dlg.tw_selAbflparamTeilgeb.setColumnWidth(3, 50)
self.dlg.tw_selAbflparamTeilgeb.setColumnWidth(4, 200)
for i, elem in enumerate(self.listetezg):
for j, item in enumerate(elem):
cell = u'{}'.format(elem[j])
self.dlg.tw_selAbflparamTeilgeb.setItem(
i, j, QTableWidgetItem(cell))
self.dlg.tw_selAbflparamTeilgeb.setRowHeight(i, 20)
# config in Dialog übernehmen
# Autokorrektur
if 'autokorrektur' in self.config:
autokorrektur = self.config['autokorrektur']
else:
autokorrektur = True
self.dlg.cb_autokorrektur.setChecked(autokorrektur)
self.countselection()
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
logger.debug('\n\nresult = {}'.format(repr(result)))
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
# pass
# Start der Verarbeitung
liste_selAbflparamTeilgeb = self.listselectedTabitems(
self.dlg.tw_selAbflparamTeilgeb)
logger.debug(u'\nliste_selAbflparamTeilgeb (1): {}'.format(
liste_selAbflparamTeilgeb))
autokorrektur = self.dlg.cb_autokorrektur.isChecked()
self.config['autokorrektur'] = autokorrektur
with open(self.configfil, 'w') as fileconfig:
fileconfig.write(json.dumps(self.config))
createUnbefFlaechen(self.dbQK, liste_selAbflparamTeilgeb,
autokorrektur)
def run_runoffparams(self):
"""Berechnen und Eintragen der Oberflächenabflussparameter in die Tabelle flaechen"""
# Check, ob die relevanten Layer nicht editable sind.
if len({'flaechen'} & get_editable_layers()) > 0:
iface.messageBar().pushMessage(u"Bedienerfehler: ",
u'Die zu verarbeitenden Layer dürfen nicht im Status "bearbeitbar" sein. Abbruch!',
level=QgsMessageBar.CRITICAL)
return False
# Übernahme der Quelldatenbank:
# Wenn ein Projekt geladen ist, wird die Quelldatenbank daraus übernommen.
# Wenn dies nicht der Fall ist, wird die Quelldatenbank aus der
# json-Datei übernommen.
database_QKan = ''
database_QKan, epsg = get_database_QKan()
if not database_QKan:
if 'database_QKan' in self.config:
database_QKan = self.config['database_QKan']
else:
database_QKan = ''
self.dlgro.tf_QKanDB.setText(database_QKan)
# Datenbankverbindung für Abfragen
if database_QKan != '':
self.dbQK = DBConnection(dbname=database_QKan) # Datenbankobjekt der QKan-Datenbank zum Lesen
if self.dbQK is None:
fehlermeldung("Fehler in tools.runoffparams",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format(database_QKan))
iface.messageBar().pushMessage("Fehler in tools.runoffparams",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format( \
database_QKan), level=QgsMessageBar.CRITICAL)
return None
# Check, ob alle Teilgebiete in Flächen auch in Tabelle "teilgebiete" enthalten
sql = u"""INSERT INTO teilgebiete (tgnam)
SELECT teilgebiet FROM flaechen
WHERE teilgebiet IS NOT NULL AND
teilgebiet NOT IN (SELECT tgnam FROM teilgebiete)
GROUP BY teilgebiet"""
if not self.dbQK.sql(sql, u"QKan_Tools.application.run (1) "):
return False
# Check, ob alle Abflussparameter in Flächen auch in Tabelle "abflussparameter" enthalten
sql = u"""INSERT INTO abflussparameter (apnam)
SELECT abflussparameter FROM flaechen
WHERE abflussparameter IS NOT NULL AND
abflussparameter NOT IN (SELECT apnam FROM abflussparameter)
GROUP BY abflussparameter"""
if not self.dbQK.sql(sql, u"QKan_Tools.application.run (2) "):
return False
self.dbQK.commit()
# Anlegen der Tabelle zur Auswahl der Teilgebiete
# Zunächst wird die Liste der beim letzten Mal gewählten Teilgebiete aus config gelesen
liste_teilgebiete = []
if 'liste_teilgebiete' in self.config:
liste_teilgebiete = self.config['liste_teilgebiete']
# Abfragen der Tabelle teilgebiete nach Teilgebieten
sql = '''SELECT "tgnam" FROM "teilgebiete" GROUP BY "tgnam"'''
if not self.dbQK.sql(sql, u"QKan_Tools.application.run (4) "):
return False
daten = self.dbQK.fetchall()
self.dlgro.lw_teilgebiete.clear()
for ielem, elem in enumerate(daten):
self.dlgro.lw_teilgebiete.addItem(QListWidgetItem(elem[0]))
try:
if elem[0] in liste_teilgebiete:
self.dlgro.lw_teilgebiete.setCurrentRow(ielem)
except BaseException as err:
fehlermeldung(u'QKan_Tools (6), Fehler in elem = {}\n'.format(elem), repr(err))
# if len(daten) == 1:
# self.dlgro.lw_teilgebiete.setCurrentRow(0)
# Anlegen der Tabelle zur Auswahl der Abflussparameter
# Zunächst wird die Liste der beim letzten Mal gewählten Abflussparameter aus config gelesen
liste_abflussparameter = []
if 'liste_abflussparameter' in self.config:
liste_abflussparameter = self.config['liste_abflussparameter']
# Abfragen der Tabelle abflussparameter nach Abflussparametern
sql = '''SELECT "apnam" FROM "abflussparameter" GROUP BY "apnam"'''
if not self.dbQK.sql(sql, u"QKan_Tools.application.run (4) "):
return False
daten = self.dbQK.fetchall()
self.dlgro.lw_abflussparameter.clear()
for ielem, elem in enumerate(daten):
self.dlgro.lw_abflussparameter.addItem(QListWidgetItem(elem[0]))
try:
if elem[0] in liste_abflussparameter:
self.dlgro.lw_abflussparameter.setCurrentRow(ielem)
except BaseException as err:
fehlermeldung(u'QKan_Tools (6), Fehler in elem = {}\n'.format(elem), repr(err))
# if len(daten) == 1:
# self.dlgro.lw_abflussparameter.setCurrentRow(0)
self.dlgro_countselection()
# Optionen zur Berechnung der befestigten Flächen
if 'runoffparamstype_choice' in self.config:
runoffparamstype_choice = self.config['runoffparamstype_choice']
else:
runoffparamstype_choice = u'itwh'
if runoffparamstype_choice == u'itwh':
self.dlgro.rb_runoffparamsitwh.setChecked(True)
elif runoffparamstype_choice == u'dyna':
self.dlgro.rb_runoffparamsdyna.setChecked(True)
if 'datenbanktyp' in self.config:
datenbanktyp = self.config['datenbanktyp']
else:
datenbanktyp = 'spatialite'
# Formular anzeigen
self.dlgro.show()
# Run the dialog event loop
result = self.dlgro.exec_()
# See if OK was pressed
if result:
# Abrufen der ausgewählten Elemente in den Listen
liste_teilgebiete = self.dlgro_listselecteditems(self.dlgro.lw_teilgebiete)
liste_abflussparameter = self.dlgro_listselecteditems(self.dlgro.lw_abflussparameter)
# Eingaben aus Formular übernehmen
database_QKan = self.dlgro.tf_QKanDB.text()
if self.dlgro.rb_runoffparamsitwh.isChecked():
runoffparamstype_choice = u'itwh'
elif self.dlgro.rb_runoffparamsdyna.isChecked():
runoffparamstype_choice = u'dyna'
else:
fehlermeldung(u"tools.runoffparams.run_runoffparams",
u"Fehlerhafte Option: \nrunoffparamstype_choice = {}".format(repr(runoffparamstype_choice)))
# Konfigurationsdaten schreiben
self.config['database_QKan'] = database_QKan
self.config['liste_teilgebiete'] = liste_teilgebiete
self.config['liste_abflussparameter'] = liste_abflussparameter
self.config['runoffparamstype_choice'] = runoffparamstype_choice
with open(self.configfil, 'w') as fileconfig:
# logger.debug(u"Config-Dictionary: {}".format(self.config))
fileconfig.write(json.dumps(self.config))
setRunoffparams(self.dbQK, runoffparamstype_choice, liste_teilgebiete, liste_abflussparameter, datenbanktyp)
def run_qgsadapt(self):
'''Erstellen einer Projektdatei aus einer Vorlage'''
# Formularfelder setzen -------------------------------------------------------------------------
# Formularfeld Datenbank
# Falls eine Datenbank angebunden ist, wird diese zunächst in das Formular eingetragen.
self.database_QKan, epsg = get_database_QKan(silent = True)
if self.database_QKan:
self.default_dir = os.path.dirname(self.database_QKan) # bereits geladene QKan-Datenbank übernehmen
elif 'database_QKan' in self.config:
self.database_QKan = self.config['database_QKan']
self.dlgpr.tf_qkanDB.setText(self.database_QKan)
self.default_dir = os.path.dirname(self.database_QKan)
else:
self.database_QKan = ''
self.default_dir = '.'
self.dlgpr.tf_qkanDB.setText(self.database_QKan)
# Formularfeld Vorlagedatei
if 'projectTemplate' in self.config:
projectTemplate = self.config['projectTemplate']
else:
projectTemplate = ''
# Formularfeld Projektdatei
if 'projectfile' in self.config:
projectfile = self.config['projectfile']
else:
projectfile = ''
# Option: Suchpfad für Vorlagedatei auf template-Verzeichnis setzen
if 'setPathToTemplateDir' in self.config:
self.setPathToTemplateDir = self.config['setPathToTemplateDir']
else:
self.setPathToTemplateDir = True
self.dlgpr.cb_setPathToTemplateDir.setChecked(self.setPathToTemplateDir)
# Option: QKan-Datenbank aktualisieren
if 'qkanDBUpdate' in self.config:
qkanDBUpdate = self.config['qkanDBUpdate']
else:
qkanDBUpdate = True
self.dlgpr.cb_qkanDBUpdate.setChecked(qkanDBUpdate)
# show the dialog
self.dlgpr.show()
# Run the dialog event loop
result = self.dlgpr.exec_()
# See if OK was pressed
if result:
# Inhalte aus Formular lesen --------------------------------------------------------------
projectTemplate = self.dlgpr.tf_projectTemplate.text()
self.database_QKan = self.dlgpr.tf_qkanDB.text()
projectfile = self.dlgpr.tf_projectFile.text()
self.setPathToTemplateDir = self.dlgpr.cb_setPathToTemplateDir.isChecked()
qkanDBUpdate = self.dlgpr.cb_qkanDBUpdate.isChecked()
# Konfigurationsdaten schreiben -----------------------------------------------------------
self.config['projectTemplate'] = projectTemplate
self.config['database_QKan'] = self.database_QKan
self.config['projectfile'] = projectfile
self.config['setPathToTemplateDir'] = self.setPathToTemplateDir
self.config['qkanDBUpdate'] = qkanDBUpdate
with open(self.configfil, 'w') as fileconfig:
fileconfig.write(json.dumps(self.config))
qgsadapt(projectTemplate, self.database_QKan, epsg, projectfile, self.setPathToTemplateDir,
u'SpatiaLite')
def run_results(self):
"""Öffnen des Formulars zum Einlesen der Simulationsergebnisse aus HE"""
database_QKan, epsg = get_database_QKan()
# Auswahl der HE-Ergebnisdatenbank zum Laden
if 'database_ErgHE' in self.config:
database_ErgHE = self.config['database_ErgHE']
else:
database_ErgHE = ''
self.dlg_lz.tf_heDB.setText(database_ErgHE)
# Option für Stildatei
if 'qml_choice' in self.config:
qml_choice = self.config['qml_choice']
else:
qml_choice = u'uebh'
# Standard: User-qml-File ist deaktiviert
self.disable_tf_qmlfile()
if qml_choice == u'uebh':
self.dlg_lz.rb_uebh.setChecked(True)
elif qml_choice == u'uebvol':
self.dlg_lz.rb_uebvol.setChecked(True)
elif qml_choice == u'userqml':
self.dlg_lz.rb_userqml.setChecked(True)
# User-qml-File ist aktivieren
self.enable_tf_qmlfile()
elif qml_choice == u'none':
self.dlg_lz.rb_none.setChecked(True)
else:
fehlermeldung(u"Fehler im Programmcode (1)",
u"Nicht definierte Option")
return False
# Individuelle Stildatei
if 'qmlfileResults' in self.config:
qmlfileResults = self.config['qmlfileResults']
else:
qmlfileResults = ''
self.dlg_lz.tf_qmlfile.setText(qmlfileResults)
# show the dialog
self.dlg_lz.show()
# Run the dialog event loop
result = self.dlg_lz.exec_()
# See if OK was pressed
if result:
# Daten aus Formular übernehmen
database_ErgHE = self.dlg_lz.tf_heDB.text()
qmlfileResults = self.dlg_lz.tf_qmlfile.text()
if self.dlg_lz.rb_uebh.isChecked():
qml_choice = u'uebh'
elif self.dlg_lz.rb_uebvol.isChecked():
qml_choice = u'uebvol'
elif self.dlg_lz.rb_userqml.isChecked():
qml_choice = u'userqml'
elif self.dlg_lz.rb_none.isChecked():
qml_choice = u'none'
else:
fehlermeldung(u"Fehler im Programmcode (2)",
u"Nicht definierte Option")
return False
# Konfigurationsdaten schreiben
self.config['database_QKan'] = database_QKan
self.config['database_ErgHE'] = database_ErgHE
self.config['qmlfileResults'] = qmlfileResults
self.config['qml_choice'] = qml_choice
with open(self.configfil, 'w') as fileconfig:
fileconfig.write(json.dumps(self.config))
# Start der Verarbeitung
importResults(database_ErgHE, database_QKan, qml_choice,
qmlfileResults, epsg)
def run(self):
"""Run method that performs all the real work"""
# show the dialog
# Check, ob die relevanten Layer nicht editable sind.
if len({'flaechen', 'haltungen', 'linkfl', 'tezg', 'schaechte'} & get_editable_layers()) > 0:
iface.messageBar().pushMessage(u"Bedienerfehler: ",
u'Die zu verarbeitenden Layer dürfen nicht im Status "bearbeitbar" sein. Abbruch!',
level=QgsMessageBar.CRITICAL)
return False
if 'dynafile' in self.config:
dynafile = self.config['dynafile']
else:
dynafile = ''
self.dlg.tf_KP_dest.setText(dynafile)
if 'template_dyna' in self.config:
template_dyna = self.config['template_dyna']
else:
template_dyna = ''
self.dlg.tf_KP_template.setText(template_dyna)
if 'datenbanktyp' in self.config:
datenbanktyp = self.config['datenbanktyp']
else:
datenbanktyp = 'spatialite'
pass # Es gibt noch keine Wahlmöglichkeit
# Übernahme der Quelldatenbank:
# Wenn ein Projekt geladen ist, wird die Quelldatenbank daraus übernommen.
# Wenn dies nicht der Fall ist, wird die Quelldatenbank aus der
# json-Datei übernommen.
database_QKan = ''
database_QKan, epsg = get_database_QKan()
if not database_QKan:
if 'database_QKan' in self.config:
database_QKan = self.config['database_QKan']
else:
database_QKan = ''
self.dlg.tf_QKanDB.setText(database_QKan)
# Datenbankverbindung für Abfragen
if database_QKan != '':
# Nur wenn schon eine Projekt geladen oder eine QKan-Datenbank ausgewählt
self.dbQK = DBConnection(dbname=database_QKan) # Datenbankobjekt der QKan-Datenbank zum Lesen
if self.dbQK is None:
fehlermeldung("Fehler in QKan_CreateUnbefFl",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format(database_QKan))
iface.messageBar().pushMessage("Fehler in QKan_Import_from_HE",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format( \
database_QKan), level=QgsMessageBar.CRITICAL)
return None
# Check, ob alle Teilgebiete in Flächen, Schächten und Haltungen auch in Tabelle "teilgebiete" enthalten
sql = u"""INSERT INTO teilgebiete (tgnam)
SELECT teilgebiet FROM flaechen
WHERE teilgebiet IS NOT NULL AND
teilgebiet NOT IN (SELECT tgnam FROM teilgebiete)
GROUP BY teilgebiet"""
if not self.dbQK.sql(sql, u"QKan_ExportDYNA.application.run (1) "):
return False
sql = u"""INSERT INTO teilgebiete (tgnam)
SELECT teilgebiet FROM haltungen
WHERE teilgebiet IS NOT NULL AND
teilgebiet NOT IN (SELECT tgnam FROM teilgebiete)
GROUP BY teilgebiet"""
if not self.dbQK.sql(sql, u"QKan_ExportDYNA.application.run (2) "):
return False
sql = u"""INSERT INTO teilgebiete (tgnam)
SELECT teilgebiet FROM schaechte
WHERE teilgebiet IS NOT NULL AND
teilgebiet NOT IN (SELECT tgnam FROM teilgebiete)
GROUP BY teilgebiet"""
if not self.dbQK.sql(sql, u"QKan_ExportDYNA.application.run (3) "):
return False
self.dbQK.commit()
# Anlegen der Tabelle zur Auswahl der Teilgebiete
# Zunächst wird die Liste der beim letzten Mal gewählten Teilgebiete aus config gelesen
liste_teilgebiete = []
if 'liste_teilgebiete' in self.config:
liste_teilgebiete = self.config['liste_teilgebiete']
# Abfragen der Tabelle teilgebiete nach Teilgebieten
sql = 'SELECT "tgnam" FROM "teilgebiete" GROUP BY "tgnam"'
if not self.dbQK.sql(sql, u"QKan_ExportDYNA.application.run (4) "):
return False
daten = self.dbQK.fetchall()
self.dlg.lw_teilgebiete.clear()
for ielem, elem in enumerate(daten):
self.dlg.lw_teilgebiete.addItem(QListWidgetItem(elem[0]))
try:
if elem[0] in liste_teilgebiete:
self.dlg.lw_teilgebiete.setCurrentRow(ielem)
except BaseException as err:
fehlermeldung(u'QKan_ExportDYNA (6), Fehler in elem = {}\n'.format(elem), repr(err))
# if len(daten) == 1:
# self.dlg.lw_teilgebiete.setCurrentRow(0)
# Ereignis bei Auswahländerung in Liste Teilgebiete
self.countselection()
# Autokorrektur
if 'autokorrektur' in self.config:
autokorrektur = self.config['autokorrektur']
else:
autokorrektur = True
self.dlg.cb_autokorrektur.setChecked(autokorrektur)
if 'autonummerierung_dyna' in self.config:
autonummerierung_dyna = self.config['autonummerierung_dyna']
else:
autonummerierung_dyna = False
self.dlg.cb_autonummerierung_dyna.setChecked(autonummerierung_dyna)
# Festlegung des Fangradius
# Kann über Menü "Optionen" eingegeben werden
if 'fangradius' in self.config:
fangradius = self.config['fangradius']
else:
fangradius = u'0.1'
# Mindestflächengröße
# Kann über Menü "Optionen" eingegeben werden
if 'mindestflaeche' in self.config:
mindestflaeche = self.config['mindestflaeche']
else:
mindestflaeche = u'0.5'
# Maximalzahl Schleifendurchläufe
if 'max_loops' in self.config:
max_loops = self.config['max_loops']
else:
max_loops = 1000
# Optionen zur Berechnung der befestigten Flächen
if 'dynabef_choice' in self.config:
dynabef_choice = self.config['dynabef_choice']
else:
dynabef_choice = u'flaechen'
if dynabef_choice == u'flaechen':
self.dlg.rb_flaechen.setChecked(True)
elif dynabef_choice == u'tezg':
self.dlg.rb_tezg.setChecked(True)
# Optionen zur Zuordnung des Profilschlüssels
if 'dynaprof_choice' in self.config:
dynaprof_choice = self.config['dynaprof_choice']
else:
dynaprof_choice = u'profilname'
if dynaprof_choice == u'profilname':
self.dlg.rb_profnam.setChecked(True)
elif dynaprof_choice == u'profilkey':
self.dlg.rb_profkey.setChecked(True)
# Formular anzeigen
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Abrufen der ausgewählten Elemente in beiden Listen
liste_teilgebiete = self.listselecteditems(self.dlg.lw_teilgebiete)
# Eingaben aus Formular übernehmen
database_QKan = self.dlg.tf_QKanDB.text()
dynafile = self.dlg.tf_KP_dest.text()
template_dyna = self.dlg.tf_KP_template.text()
autokorrektur = self.dlg.cb_autokorrektur.isChecked()
autonummerierung_dyna = self.dlg.cb_autonummerierung_dyna.isChecked()
if self.dlg.rb_flaechen.isChecked():
dynabef_choice = u'flaechen'
elif self.dlg.rb_tezg.isChecked():
dynabef_choice = u'tezg'
else:
fehlermeldung(u"exportdyna.application.run",
u"Fehlerhafte Option: \ndynabef_choice = {}".format(repr(dynabef_choice)))
if self.dlg.rb_profnam.isChecked():
dynaprof_choice = u'profilname'
elif self.dlg.rb_profkey.isChecked():
dynaprof_choice = u'profilkey'
else:
fehlermeldung(u"exportdyna.application.run",
u"Fehlerhafte Option: \ndynaprof_choice = {}".format(repr(dynaprof_choice)))
# Konfigurationsdaten schreiben
self.config['dynafile'] = dynafile
self.config['template_dyna'] = template_dyna
self.config['database_QKan'] = database_QKan
self.config['liste_teilgebiete'] = liste_teilgebiete
self.config['autokorrektur'] = autokorrektur
self.config['autonummerierung_dyna'] = autonummerierung_dyna
self.config['fangradius'] = fangradius
self.config['mindestflaeche'] = mindestflaeche
self.config['max_loops'] = max_loops
self.config['dynabef_choice'] = dynabef_choice
self.config['dynaprof_choice'] = dynaprof_choice
with open(self.configfil, 'w') as fileconfig:
# logger.debug(u"Config-Dictionary: {}".format(self.config))
fileconfig.write(json.dumps(self.config))
exportKanaldaten(iface, dynafile, template_dyna, self.dbQK, dynabef_choice, dynaprof_choice,
liste_teilgebiete, autokorrektur, autonummerierung_dyna, fangradius,
mindestflaeche, max_loops, datenbanktyp)
def run_assigntgeb(self):
"""Öffnen des Formulars zur Zuordnung von Teilgebieten auf Haltungen und Flächen"""
# Check, ob die relevanten Layer nicht editable sind.
if len({u'flaechen', u'haltungen', u'linkfl', u'linksw', u'tezg',
u'einleit'} & get_editable_layers()) > 0:
iface.messageBar().pushMessage(u"Bedienerfehler: ",
u'Die zu verarbeitenden Layer dürfen nicht im Status "bearbeitbar" sein. Abbruch!',
level=QgsMessageBar.CRITICAL)
return False
database_QKan = u''
database_QKan, epsg = get_database_QKan()
if not database_QKan:
fehlermeldung(u"Fehler in k_link", u"database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
logger.error(u"k_link: database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
return False
# Datenbankverbindung für Abfragen
self.dbQK = DBConnection(dbname=database_QKan) # Datenbankobjekt der QKan-Datenbank zum Lesen
if self.dbQK is None:
fehlermeldung(u"Fehler in LinkFl.run_assigntgeb", u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format(database_QKan))
iface.messageBar().pushMessage(u"Fehler in LinkFl.run_assigntgeb", u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format( \
database_QKan), level=QgsMessageBar.CRITICAL)
return None
# config in Dialog übernehmen
# Autokorrektur
if 'autokorrektur' in self.config:
autokorrektur = self.config['autokorrektur']
else:
autokorrektur = True
self.dlg_at.cb_autokorrektur.setChecked(autokorrektur)
# Abfragen der Tabelle teilgebiete nach Teilgebieten
sql = u'SELECT "tgnam" FROM "teilgebiete" GROUP BY "tgnam"'
if not self.dbQK.sql(sql, u"QKan_LinkFlaechen.run_assigntgeb (1)"):
return False
daten = self.dbQK.fetchall()
self.dlg_at.lw_teilgebiete.clear()
for ielem, elem in enumerate(daten):
if elem[0] is not None:
self.dlg_at.lw_teilgebiete.addItem(QListWidgetItem(elem[0]))
if 'liste_teilgebiete' in self.config:
if elem[0] in self.config['liste_teilgebiete']:
self.dlg_at.lw_teilgebiete.setCurrentRow(ielem)
# Festlegung, ob die Auswahl nur Objekte innerhalb oder aller überlappenden berücksichtigt
if 'auswahltyp' in self.config:
auswahltyp = self.config['auswahltyp']
else:
auswahltyp = u'within'
if auswahltyp == u'within':
self.dlg_at.rb_within.setChecked(True)
self.enable_bufferradius(True)
elif auswahltyp == u'overlaps':
self.dlg_at.rb_overlaps.setChecked(True)
self.enable_bufferradius(False)
else:
fehlermeldung(u"Fehler im Programmcode (3)", u"Nicht definierte Option")
return False
# Festlegung des Pufferradius
if 'bufferradius' in self.config:
bufferradius = self.config['bufferradius']
else:
bufferradius = u'0'
self.dlg_at.tf_bufferradius.setText(bufferradius)
# show the dialog
self.dlg_at.show()
# Run the dialog event loop
result = self.dlg_at.exec_()
# See if OK was pressed
if result:
# Inhalte aus Formular lesen
liste_teilgebiete = self.listselecteditems(self.dlg_at.lw_teilgebiete)
if self.dlg_at.rb_within.isChecked():
auswahltyp = u'within'
elif self.dlg_at.rb_overlaps.isChecked():
auswahltyp = u'overlaps'
else:
fehlermeldung(u"Fehler im Programmcode (4)", u"Nicht definierte Option")
return False
autokorrektur = self.dlg_at.cb_autokorrektur.isChecked()
bufferradius = self.dlg_at.tf_bufferradius.text()
# config schreiben
self.config['liste_teilgebiete'] = liste_teilgebiete
self.config['auswahltyp'] = auswahltyp
self.config['epsg'] = epsg
self.config['bufferradius'] = bufferradius
self.config['autokorrektur'] = autokorrektur
with open(self.configfil, 'w') as fileconfig:
fileconfig.write(json.dumps(self.config))
# Start der Verarbeitung
assigntgeb(self.dbQK, auswahltyp, liste_teilgebiete,
[u'haltungen', u'flaechen', u'schaechte', u'einleit', u'tezg', u'linksw', u'linkfl'],
autokorrektur, bufferradius)
# --------------------------------------------------------------------------
# Datenbankverbindungen schliessen
del self.dbQK
def run_createlinesw(self):
"""Run method that performs all the real work"""
# Check, ob die relevanten Layer nicht editable sind.
if len({u'einleit', u'haltungen', u'linksw'} & get_editable_layers()) > 0:
iface.messageBar().pushMessage(u"Bedienerfehler: ",
u'Die zu verarbeitenden Layer dürfen nicht im Status "bearbeitbar" sein. Abbruch!',
level=QgsMessageBar.CRITICAL)
return False
database_QKan = u''
database_QKan, epsg = get_database_QKan()
if not database_QKan:
fehlermeldung(u"Fehler in LinkFl.run_createlinesw",
u"database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
logger.error(u"LinkFl.run_createlinesw: database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
return False
# Datenbankverbindung für Abfragen
self.dbQK = DBConnection(dbname=database_QKan) # Datenbankobjekt der QKan-Datenbank zum Lesen
if self.dbQK is None:
fehlermeldung(u"Fehler in LinkFl.run_createlinesw",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format(database_QKan))
iface.messageBar().pushMessage(u"Fehler in LinkFl.run_createlinesw",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format( \
database_QKan), level=QgsMessageBar.CRITICAL)
return None
# Check, ob alle Teilgebiete in Flächen und Haltungen auch in Tabelle "teilgebiete" enthalten
sql = u"""INSERT INTO teilgebiete (tgnam)
SELECT teilgebiet FROM einleit
WHERE teilgebiet IS NOT NULL AND teilgebiet <> '' AND
teilgebiet NOT IN (SELECT tgnam FROM teilgebiete)
GROUP BY teilgebiet"""
if not self.dbQK.sql(sql, u"LinkFl.run_createlinesw (1)"):
return False
sql = u"""INSERT INTO teilgebiete (tgnam)
SELECT teilgebiet FROM haltungen
WHERE teilgebiet IS NOT NULL AND teilgebiet <> '' AND
teilgebiet NOT IN (SELECT tgnam FROM teilgebiete)
GROUP BY teilgebiet"""
if not self.dbQK.sql(sql, u"LinkFl.run_createlinesw (2)"):
return False
self.dbQK.commit()
# Abfragen der Tabelle haltungen nach vorhandenen Entwässerungsarten
sql = u'SELECT "entwart" FROM "haltungen" GROUP BY "entwart"'
if not self.dbQK.sql(sql, u"QKan_LinkFlaechen.run_createlinesw (1)"):
return False
daten = self.dbQK.fetchall()
self.dlg_sw.lw_hal_entw.clear()
for ielem, elem in enumerate(daten):
if elem[0] is not None:
self.dlg_sw.lw_hal_entw.addItem(QListWidgetItem(elem[0]))
if 'liste_hal_entw' in self.config:
if elem[0] in self.config['liste_hal_entw']:
self.dlg_sw.lw_hal_entw.setCurrentRow(ielem)
self.dlg_sw.cb_selHalActive.setChecked(True) # Auswahlcheckbox aktivieren
# if len(daten) == 1:
# self.dlg_sw.lw_hal_entw.setCurrentRow(0)
# Abfragen der Tabelle teilgebiete nach Teilgebieten
sql = u'SELECT "tgnam" FROM "teilgebiete" GROUP BY "tgnam"'
if not self.dbQK.sql(sql, u"QKan_LinkFlaechen.run_createlinesw (2)"):
return False
daten = self.dbQK.fetchall()
self.dlg_sw.lw_teilgebiete.clear()
for ielem, elem in enumerate(daten):
if elem[0] is not None:
self.dlg_sw.lw_teilgebiete.addItem(QListWidgetItem(elem[0]))
if 'liste_teilgebiete' in self.config:
if elem[0] in self.config['liste_teilgebiete']:
self.dlg_sw.lw_teilgebiete.setCurrentRow(ielem)
self.dlg_sw.cb_selTgbActive.setChecked(True) # Auswahlcheckbox aktivieren
# if len(daten) == 1:
# self.dlg_sw.lw_teilgebiete.setCurrentRow(0)
# config in Dialog übernehmen
# Suchradius
if 'suchradius' in self.config:
suchradius = self.config['suchradius']
else:
suchradius = u'50'
self.dlg_sw.tf_suchradius.setText(str(suchradius))
# Haltungen direkt in einleit eintragen. Es kann wegen der längeren Zeitdauer sinnvoll
# sein, dies erst am Schluss der Bearbeitung in einem eigenen Vorgang zu machen.
self.countselectionsw()
# show the dialog
self.dlg_sw.show()
# Run the dialog event loop
result = self.dlg_sw.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
# pass
# Start der Verarbeitung
# Inhalte aus Formular lesen
suchradius = self.dlg_sw.tf_suchradius.text()
# Abrufen der ausgewählten Elemente in beiden Listen
liste_hal_entw = self.listselecteditems(self.dlg_sw.lw_hal_entw)
liste_teilgebiete = self.listselecteditems(self.dlg_sw.lw_teilgebiete)
# Konfigurationsdaten schreiben
self.config['suchradius'] = suchradius
self.config['liste_hal_entw'] = liste_hal_entw
self.config['liste_teilgebiete'] = liste_teilgebiete
self.config['epsg'] = epsg
with open(self.configfil, 'w') as fileconfig:
fileconfig.write(json.dumps(self.config))
# Start der Verarbeitung
createlinksw(self.dbQK, liste_teilgebiete, suchradius, epsg)
# Einfügen der Verbindungslinien in die Layerliste, wenn nicht schon geladen
layers = iface.legendInterface().layers()
if u'Anbindungen Direkteinleitungen' not in [lay.name() for lay in layers]: # layers wurde oben erstellt
uri = QgsDataSourceURI()
uri.setDatabase(database_QKan)
uri.setDataSource(u'', u'linksw', u'glink')
vlayer = QgsVectorLayer(uri.uri(), u'Anbindungen Direkteinleitungen', u'spatialite')
QgsMapLayerRegistry.instance().addMapLayer(vlayer)
# --------------------------------------------------------------------------
# Datenbankverbindungen schliessen
del self.dbQK
def run_createlinefl(self):
"""Run method that performs all the real work"""
# Check, ob die relevanten Layer nicht editable sind.
if len({u'flaechen', u'haltungen', u'linkfl'} & get_editable_layers()) > 0:
iface.messageBar().pushMessage(u"Bedienerfehler: ",
u'Die zu verarbeitenden Layer dürfen nicht im Status "bearbeitbar" sein. Abbruch!',
level=QgsMessageBar.CRITICAL)
return False
database_QKan = u''
database_QKan, epsg = get_database_QKan()
if not database_QKan:
fehlermeldung(u"Fehler in k_link",
u"database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
logger.error(u"k_link: database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
return False
# Datenbankverbindung für Abfragen
self.dbQK = DBConnection(dbname=database_QKan) # Datenbankobjekt der QKan-Datenbank zum Lesen
if self.dbQK is None:
fehlermeldung(u"Fehler in LinkFl.run_createlinefl",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format(database_QKan))
iface.messageBar().pushMessage(u"Fehler in LinkFl.run_createlinefl",
u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format( \
database_QKan), level=QgsMessageBar.CRITICAL)
return None
# Check, ob alle Teilgebiete in Flächen und Haltungen auch in Tabelle "teilgebiete" enthalten
sql = u"""INSERT INTO teilgebiete (tgnam)
SELECT teilgebiet FROM flaechen
WHERE teilgebiet IS NOT NULL AND teilgebiet <> '' AND
teilgebiet NOT IN (SELECT tgnam FROM teilgebiete)
GROUP BY teilgebiet"""
if not self.dbQK.sql(sql, u"QKan_LinkFlaechen (1)"):
return False
sql = u"""INSERT INTO teilgebiete (tgnam)
SELECT teilgebiet FROM haltungen
WHERE teilgebiet IS NOT NULL AND teilgebiet <> '' AND
teilgebiet NOT IN (SELECT tgnam FROM teilgebiete)
GROUP BY teilgebiet"""
if not self.dbQK.sql(sql, u"QKan_LinkFlaechen (1)"):
return False
self.dbQK.commit()
# Abfragen der Tabelle flaechen nach verwendeten Abflussparametern
sql = u'SELECT abflussparameter FROM flaechen GROUP BY abflussparameter'
if not self.dbQK.sql(sql, u"QKan_LinkFlaechen.run_createlinefl (1)"):
return False
daten = self.dbQK.fetchall()
# logger.debug(u'\ndaten: {}'.format(str(daten))) # debug
self.dlg_cl.lw_flaechen_abflussparam.clear()
for ielem, elem in enumerate(daten):
if elem[0] is not None:
self.dlg_cl.lw_flaechen_abflussparam.addItem(QListWidgetItem(elem[0]))
if 'liste_flaechen_abflussparam' in self.config:
try:
if elem[0] in self.config['liste_flaechen_abflussparam']:
self.dlg_cl.lw_flaechen_abflussparam.setCurrentRow(ielem)
self.dlg_cl.cb_selFlActive.setChecked(True) # Auswahlcheckbox aktivieren
except BaseException as err:
del self.dbQK
# logger.debug(u'\nelem: {}'.format(str(elem))) # debug
# if len(daten) == 1:
# self.dlg_cl.lw_flaechen_abflussparam.setCurrentRow(0)
# Abfragen der Tabelle haltungen nach vorhandenen Entwässerungsarten
sql = u'SELECT "entwart" FROM "haltungen" GROUP BY "entwart"'
if not self.dbQK.sql(sql, u"QKan_LinkFlaechen.run_createlinefl (2)"):
return False
daten = self.dbQK.fetchall()
self.dlg_cl.lw_hal_entw.clear()
for ielem, elem in enumerate(daten):
if elem[0] is not None:
self.dlg_cl.lw_hal_entw.addItem(QListWidgetItem(elem[0]))
if 'liste_hal_entw' in self.config:
if elem[0] in self.config['liste_hal_entw']:
self.dlg_cl.lw_hal_entw.setCurrentRow(ielem)
self.dlg_cl.cb_selHalActive.setChecked(True) # Auswahlcheckbox aktivieren
# if len(daten) == 1:
# self.dlg_cl.lw_hal_entw.setCurrentRow(0)
# Abfragen der Tabelle teilgebiete nach Teilgebieten
sql = u'SELECT "tgnam" FROM "teilgebiete" GROUP BY "tgnam"'
if not self.dbQK.sql(sql, u"QKan_LinkFlaechen.run_createlinefl (3)"):
return False
daten = self.dbQK.fetchall()
self.dlg_cl.lw_teilgebiete.clear()
for ielem, elem in enumerate(daten):
if elem[0] is not None:
self.dlg_cl.lw_teilgebiete.addItem(QListWidgetItem(elem[0]))
if 'liste_teilgebiete' in self.config:
if elem[0] in self.config['liste_teilgebiete']:
self.dlg_cl.lw_teilgebiete.setCurrentRow(ielem)
self.dlg_cl.cb_selTgbActive.setChecked(True) # Auswahlcheckbox aktivieren
# if len(daten) == 1:
# self.dlg_cl.lw_teilgebiete.setCurrentRow(0)
# config in Dialog übernehmen
# Autokorrektur
if 'autokorrektur' in self.config:
autokorrektur = self.config['autokorrektur']
else:
autokorrektur = True
self.dlg_cl.cb_autokorrektur.setChecked(autokorrektur)
# Verbindungslinien nur innerhalb tezg
if 'linksw_in_tezg' in self.config:
linksw_in_tezg = self.config['linksw_in_tezg']
else:
linksw_in_tezg = True
self.dlg_cl.cb_linkswInTezg.setChecked(linksw_in_tezg)
# Suchradius
if 'suchradius' in self.config:
suchradius = self.config['suchradius']
else:
suchradius = u'50'
self.dlg_cl.tf_suchradius.setText(str(suchradius))
# Mindestflächengröße
if 'mindestflaeche' in self.config:
mindestflaeche = self.config['mindestflaeche']
else:
mindestflaeche = u'0.5'
# Fangradius für Anfang der Anbindungslinie
# Kann über Menü "Optionen" eingegeben werden
if 'fangradius' in self.config:
fangradius = self.config['fangradius']
else:
fangradius = u'0.1'
# Festlegung, ob sich der Abstand auf die Flächenkante oder deren Mittelpunkt bezieht
if 'bezug_abstand' in self.config:
bezug_abstand = self.config['bezug_abstand']
else:
bezug_abstand = 'kante'
if bezug_abstand == 'kante':
self.dlg_cl.rb_abstandkante.setChecked(True)
elif bezug_abstand == 'mittelpunkt':
self.dlg_cl.rb_abstandmittelpunkt.setChecked(True)
else:
fehlermeldung(u"Fehler im Programmcode", u"Nicht definierte Option")
return False
self.countselectionfl()
# show the dialog
self.dlg_cl.show()
# Run the dialog event loop
result = self.dlg_cl.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
# pass
# Start der Verarbeitung
# Abrufen der ausgewählten Elemente in beiden Listen
liste_flaechen_abflussparam = self.listselecteditems(self.dlg_cl.lw_flaechen_abflussparam)
liste_hal_entw = self.listselecteditems(self.dlg_cl.lw_hal_entw)
liste_teilgebiete = self.listselecteditems(self.dlg_cl.lw_teilgebiete)
suchradius = self.dlg_cl.tf_suchradius.text()
if self.dlg_cl.rb_abstandkante.isChecked():
bezug_abstand = 'kante'
elif self.dlg_cl.rb_abstandmittelpunkt.isChecked():
bezug_abstand = 'mittelpunkt'
else:
fehlermeldung(u"Fehler im Programmcode", u"Nicht definierte Option")
return False
autokorrektur = self.dlg_cl.cb_autokorrektur.isChecked()
linksw_in_tezg = self.dlg_cl.cb_linkswInTezg.isChecked()
# if len(liste_flaechen_abflussparam) == 0 or len(liste_hal_entw) == 0:
# iface.messageBar().pushMessage(u"Bedienerfehler: ",
# u'Bitte in beiden Tabellen mindestens ein Element auswählen!',
# level=QgsMessageBar.CRITICAL)
# self.run_createlinefl()
# Konfigurationsdaten schreiben
self.config['suchradius'] = suchradius
self.config['fangradius'] = fangradius
self.config['mindestflaeche'] = mindestflaeche
self.config['bezug_abstand'] = bezug_abstand
self.config['liste_hal_entw'] = liste_hal_entw
self.config['liste_flaechen_abflussparam'] = liste_flaechen_abflussparam
self.config['liste_teilgebiete'] = liste_teilgebiete
self.config['epsg'] = epsg
self.config['autokorrektur'] = autokorrektur
self.config['linksw_in_tezg'] = linksw_in_tezg
with open(self.configfil, 'w') as fileconfig:
fileconfig.write(json.dumps(self.config))
# Start der Verarbeitung
createlinkfl(self.dbQK, liste_flaechen_abflussparam, liste_hal_entw,
liste_teilgebiete, linksw_in_tezg, autokorrektur, suchradius,
mindestflaeche, fangradius, bezug_abstand, epsg)
# Einfügen der Verbindungslinien in die Layerliste, wenn nicht schon geladen
layers = iface.legendInterface().layers()
if u'Anbindungen Flächen' not in [lay.name() for lay in layers]: # layers wurde oben erstellt
uri = QgsDataSourceURI()
uri.setDatabase(database_QKan)
uri.setDataSource(u'', u'linkfl', u'glink')
vlayer = QgsVectorLayer(uri.uri(), u'Anbindungen Flächen', u'spatialite')
QgsMapLayerRegistry.instance().addMapLayer(vlayer)
# --------------------------------------------------------------------------
# Datenbankverbindungen schliessen
del self.dbQK
def run_updatelinks(self):
'''Aktualisieren des logischen Verknüpfungscaches in linkfl und linksw'''
# Check, ob die relevanten Layer nicht editable sind.
if len({u'flaechen', u'haltungen', u'linkfl', u'linksw', u'tezg',
u'einleit'} & get_editable_layers()) > 0:
iface.messageBar().pushMessage(u"Bedienerfehler: ",
u'Die zu verarbeitenden Layer dürfen nicht im Status "bearbeitbar" sein. Abbruch!',
level=QgsMessageBar.CRITICAL)
return False
database_QKan = u''
database_QKan, epsg = get_database_QKan()
if not database_QKan:
fehlermeldung(u"Fehler in k_link", u"database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
logger.error(u"k_link: database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
return False
# Datenbankverbindung für Abfragen
self.dbQK = DBConnection(dbname=database_QKan) # Datenbankobjekt der QKan-Datenbank zum Lesen
if self.dbQK is None:
fehlermeldung(u"Fehler in LinkFl.run_assigntgeb", u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format(database_QKan))
iface.messageBar().pushMessage(u"Fehler in LinkFl.run_assigntgeb", u'QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!'.format( \
database_QKan), level=QgsMessageBar.CRITICAL)
return False
self.dlg_ul.tf_qkDB.setText(database_QKan)
# Festlegung des Fangradius
# Kann über Menü "Optionen" eingegeben werden
if 'fangradius' in self.config:
fangradius = self.config['fangradius']
else:
fangradius = u'0.1'
# Löschen von Flächenverknüpfungen ohne Linienobjekt
if 'deletelinkflGeomNone' in self.config:
deletelinkflGeomNone = self.config['deletelinkflGeomNone']
else:
deletelinkflGeomNone = True
self.dlg_ul.cb_deleteGeomNone.setChecked(deletelinkflGeomNone)
# show the dialog
self.dlg_ul.show()
# Run the dialog event loop
result = self.dlg_ul.exec_()
# See if OK was pressed
if result:
# Inhalte aus Formular lesen
deletelinkflGeomNone = self.dlg_ul.cb_deleteGeomNone.isChecked()
# config schreiben
self.config['deletelinkflGeomNone'] = deletelinkflGeomNone
self.config['fangradius'] = fangradius
with open(self.configfil, 'w') as fileconfig:
fileconfig.write(json.dumps(self.config))
# Start der Verarbeitung
if self.dlg_ul.cb_linkfl.isChecked():
updatelinkfl(self.dbQK, fangradius, deletelinkflGeomNone)
if self.dlg_ul.cb_linksw.isChecked():
updatelinksw(self.dbQK, fangradius, deletelinkflGeomNone)
# ----------------------------------------------------------------------------------------------
# Datenbankverbindungen schliessen
del self.dbQK
def run(self):
"""Run method that performs all the real work"""
# show the dialog
# Check, ob die relevanten Layer nicht editable sind.
if len({'flaechen', 'haltungen', 'linkfl', 'tezg', 'schaechte'} & get_editable_layers()) > 0:
iface.messageBar().pushMessage(u"Bedienerfehler: ",
u'Die zu verarbeitenden Layer dürfen nicht im Status "bearbeitbar" sein. Abbruch!',
level=QgsMessageBar.CRITICAL)
return False
# Übernahme der Quelldatenbank:
# Wenn ein Projekt geladen ist, wird die Quelldatenbank daraus übernommen.
# Wenn dies nicht der Fall ist, wird die Quelldatenbank aus der
# json-Datei übernommen.
database_QKan = ''
database_QKan, epsg = get_database_QKan()
if not database_QKan:
fehlermeldung(u"Fehler in k_link", u"database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
logger.error("k_link: database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!")
return False
if database_QKan != '':
self.dlg.tf_QKanDB.setText(database_QKan)
# Datenbankverbindung für Abfragen
self.dbQK = DBConnection(dbname=database_QKan) # Datenbankobjekt der QKan-Datenbank zum Lesen
if not self.dbQK.connected:
logger.error(u"Fehler in exportdyna.application:\n",
u'QKan-Datenbank {:s} wurde nicht gefunden oder war nicht aktuell!\nAbbruch!'.format(database_QKan))
return None
# Check, ob alle Teilgebiete in Flächen, Schächten und Haltungen auch in Tabelle "teilgebiete" enthalten
sql = u"""INSERT INTO teilgebiete (tgnam)
SELECT teilgebiet FROM flaechen
WHERE teilgebiet IS NOT NULL AND
teilgebiet NOT IN (SELECT tgnam FROM teilgebiete)
GROUP BY teilgebiet"""
if not self.dbQK.sql(sql, u"QKan_ExportHE.application.run (1) "):
return False
sql = u"""INSERT INTO teilgebiete (tgnam)
SELECT teilgebiet FROM haltungen
WHERE teilgebiet IS NOT NULL AND
teilgebiet NOT IN (SELECT tgnam FROM teilgebiete)
GROUP BY teilgebiet"""
if not self.dbQK.sql(sql, u"QKan_ExportHE.application.run (2) "):
return False
sql = u"""INSERT INTO teilgebiete (tgnam)
SELECT teilgebiet FROM schaechte
WHERE teilgebiet IS NOT NULL AND
teilgebiet NOT IN (SELECT tgnam FROM teilgebiete)
GROUP BY teilgebiet"""
if not self.dbQK.sql(sql, u"QKan_ExportHE.application.run (3) "):
return False
self.dbQK.commit()
# Anlegen der Tabelle zur Auswahl der Teilgebiete
# Zunächst wird die Liste der beim letzten Mal gewählten Teilgebiete aus config gelesen
liste_teilgebiete = []
if 'liste_teilgebiete' in self.config:
liste_teilgebiete = self.config['liste_teilgebiete']
# Abfragen der Tabelle teilgebiete nach Teilgebieten
sql = 'SELECT "tgnam" FROM "teilgebiete" GROUP BY "tgnam"'
if not self.dbQK.sql(sql, u"QKan_ExportHE.application.run (4) "):
return False
daten = self.dbQK.fetchall()
self.dlg.lw_teilgebiete.clear()
for ielem, elem in enumerate(daten):
self.dlg.lw_teilgebiete.addItem(QListWidgetItem(elem[0]))
try:
if elem[0] in liste_teilgebiete:
self.dlg.lw_teilgebiete.setCurrentRow(ielem)
except BaseException as err:
fehlermeldung(u'QKan_ExportHE (6), Fehler in elem = {}\n'.format(elem), repr(err))
# if len(daten) == 1:
# self.dlg.lw_teilgebiete.setCurrentRow(0)
# Ereignis bei Auswahländerung in Liste Teilgebiete
self.countselection()
# Autokorrektur
if 'autokorrektur' in self.config:
autokorrektur = self.config['autokorrektur']
else:
autokorrektur = True
self.dlg.cb_autokorrektur.setChecked(autokorrektur)
# Festlegung des Fangradius
# Kann über Menü "Optionen" eingegeben werden
if 'fangradius' in self.config:
fangradius = self.config['fangradius']
else:
fangradius = u'0.1'
# Haltungsflächen (tezg) berücksichtigen
if 'mit_verschneidung' in self.config:
mit_verschneidung = self.config['mit_verschneidung']
else:
mit_verschneidung = True
self.dlg.cb_regardTezg.setChecked(mit_verschneidung)
# Mindestflächengröße
# Kann über Menü "Optionen" eingegeben werden
if 'mindestflaeche' in self.config:
mindestflaeche = self.config['mindestflaeche']
else:
mindestflaeche = u'0.5'
self.countselection()
# Formular anzeigen
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Abrufen der ausgewählten Elemente in beiden Listen
liste_teilgebiete = self.listselecteditems(self.dlg.lw_teilgebiete)
# Eingaben aus Formular übernehmen
database_QKan = self.dlg.tf_QKanDB.text()
database_HE = self.dlg.tf_heDB_dest.text()
dbtemplate_HE = self.dlg.tf_heDB_template.text()
datenbanktyp = 'spatialite'
autokorrektur = self.dlg.cb_autokorrektur.isChecked()
mit_verschneidung = self.dlg.cb_regardTezg.isChecked()
check_export = {}
check_export['export_schaechte'] = self.dlg.cb_export_schaechte.isChecked()
check_export['export_auslaesse'] = self.dlg.cb_export_auslaesse.isChecked()
check_export['export_speicher'] = self.dlg.cb_export_speicher.isChecked()
check_export['export_haltungen'] = self.dlg.cb_export_haltungen.isChecked()
check_export['export_pumpen'] = self.dlg.cb_export_pumpen.isChecked()
check_export['export_wehre'] = self.dlg.cb_export_wehre.isChecked()
check_export['export_flaechenrw'] = self.dlg.cb_export_flaechenrw.isChecked()
check_export['export_einleitdirekt'] = self.dlg.cb_export_einleitdirekt.isChecked()
check_export['export_aussengebiete'] = self.dlg.cb_export_aussengebiete.isChecked()
check_export['export_abflussparameter'] = self.dlg.cb_export_abflussparameter.isChecked()
check_export['export_regenschreiber'] = self.dlg.cb_export_regenschreiber.isChecked()
check_export['export_rohrprofile'] = self.dlg.cb_export_rohrprofile.isChecked()
check_export['export_speicherkennlinien'] = self.dlg.cb_export_speicherkennlinien.isChecked()
check_export['export_bodenklassen'] = self.dlg.cb_export_bodenklassen.isChecked()
check_export['modify_schaechte'] = self.dlg.cb_modify_schaechte.isChecked()
check_export['modify_auslaesse'] = self.dlg.cb_modify_auslaesse.isChecked()
check_export['modify_speicher'] = self.dlg.cb_modify_speicher.isChecked()
check_export['modify_haltungen'] = self.dlg.cb_modify_haltungen.isChecked()
check_export['modify_pumpen'] = self.dlg.cb_modify_pumpen.isChecked()
check_export['modify_wehre'] = self.dlg.cb_modify_wehre.isChecked()
check_export['modify_flaechenrw'] = self.dlg.cb_modify_flaechenrw.isChecked()
check_export['modify_einleitdirekt'] = self.dlg.cb_modify_einleitdirekt.isChecked()
check_export['modify_aussengebiete'] = self.dlg.cb_modify_aussengebiete.isChecked()
check_export['modify_abflussparameter'] = self.dlg.cb_modify_abflussparameter.isChecked()
check_export['modify_regenschreiber'] = self.dlg.cb_modify_regenschreiber.isChecked()
check_export['modify_rohrprofile'] = self.dlg.cb_modify_rohrprofile.isChecked()
check_export['modify_speicherkennlinien'] = self.dlg.cb_modify_speicherkennlinien.isChecked()
check_export['modify_bodenklassen'] = self.dlg.cb_modify_bodenklassen.isChecked()
check_export['combine_flaechenrw'] = self.dlg.cb_combine_flaechenrw.isChecked()
check_export['combine_einleitdirekt'] = self.dlg.cb_combine_einleitdirekt.isChecked()
# Konfigurationsdaten schreiben
self.config['database_HE'] = database_HE
self.config['dbtemplate_HE'] = dbtemplate_HE
self.config['database_QKan'] = database_QKan
self.config['datenbanktyp'] = datenbanktyp
self.config['liste_teilgebiete'] = liste_teilgebiete
self.config['autokorrektur'] = autokorrektur
self.config['fangradius'] = fangradius
self.config['mit_verschneidung'] = mit_verschneidung
self.config['mindestflaeche'] = mindestflaeche
for el in check_export:
self.config[el] = check_export[el]
with open(self.configfil, 'w') as fileconfig:
# logger.debug(u"Config-Dictionary: {}".format(self.config))
fileconfig.write(json.dumps(self.config))
exportKanaldaten(iface, database_HE, dbtemplate_HE, self.dbQK, liste_teilgebiete, autokorrektur,
fangradius, mindestflaeche, mit_verschneidung, datenbanktyp, check_export)
