WIP: Preparation Postgres

qkan/__init__.py

@@ -74,9 +74,10 @@ class QKan:
     forms: str
 
     # SQL-Statements werden abhängig vom Datenbanktyp und Modul geladen
-    sqls: str                       # SQL-Statements
-    dbtype: enums.QKanDBChoice            # Datenbanktyp
-    module: str                   # aktuelles Modul
+    sqls: str = None                    # SQL-Statements
+    dbtype: enums.QKanDBChoice = None   # Datenbanktyp
+    sqlmodule: str = None               # Modul, für das aktuell SQL-Statements geladen sind
+    dbsource: str = None                # zur Kontrolle, ob noch das gleiche Projekt geladen ist
 
     def __init__(self, iface: qgis.gui.QgisInterface):
         QKan.instance = self

qkan/config.py

@@ -231,6 +231,7 @@ class CheckImport(ClassObject):
 class DatabaseConfig(ClassObject):
     qkan: str = ""
     type: enums.QKanDBChoice = enums.QKanDBChoice.SPATIALITE
+    authConfigId: str = 'qkan001'
 
 
 class DynaConfig(ClassObject):

qkan/createunbeffl/application_dialog.py

@@ -178,12 +178,12 @@ def count_selection(self) -> None:
     def run(self) -> None:
         """Run method that performs all the real work"""
 
-        database_qkan, epsg = get_database_QKan()
+        get_database_QKan()
+        database_qkan, epsg = QKan.config.database.qkan, QKan.config.epsg
         if not database_qkan:
-            logger.error(
+            logger.error_code(
                 "CreateUnbefFl: database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!"
             )
-            return
 
         self.db_name = database_qkan
 

qkan/database/dbfunc.py

@@ -139,13 +139,14 @@ def _connect(self) -> None:
         """
 
         if not self.dbname:
-            self.dbname, _, self.dbtype = get_database_QKan()
+            get_database_QKan()
+            self.dbname = QKan.config.database.qkan
             if not self.dbname:
                 logger.warning("Fehler: Für die gewählte Funktion muss ein Projekt geladen sein!")
                 raise DBConnectError()
 
         # Queries zu diesem Modul laden, wenn noch nicht geschehen oder Datenbank oder Modul geändert
-        if not QKan.dbtype or QKan.dbtype != self.dbtype or not QKan.module or QKan.module != self.module:
+        if not QKan.dbtype or not QKan.module or QKan.module != self.module:
             QKan.dbtype = self.dbtype
             QKan.module = self.module
             if QKan.dbtype == enums.QKanDBChoice.SPATIALITE:

qkan/database/qkan_utils.py

@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
 from xml.etree.ElementTree import ElementTree
 
-from qgis.core import Qgis, QgsMessageLog, QgsProject
+from qgis.core import Qgis, QgsMessageLog, QgsProject, QgsProviderRegistry
 from qgis.utils import iface
 
 from qkan import QKan, enums
@@ -246,73 +246,36 @@ def set_qkanlayer_dbname(oldsource: str, newdb: str) -> str:
     return newsource
 
 
-def get_database_QKan(silent: bool = False) -> Tuple[Optional[str], Optional[int], Optional[str]]:
-    """Ermittlung der aktuellen SpatiaLite-Datenbank aus den geladenen Layern"""
+def get_database_QKan(silent: bool = False) -> None:
+    """Ermittlung der aktuellen Datenbank aus den geladenen Layern"""
 
     # noinspection PyArgumentList
-    project = QgsProject.instance()
 
-    layerobjects = project.mapLayersByName("Schächte")
-    logger.debug(
-        f"qkan.database.qkan_utils.get_database_QKan: \nlayerobjects: {layerobjects}"
-    )
-    if len(layerobjects) > 0:
-        lay = layerobjects[0]
-        dbname_s: Optional[str] = get_qkanlayer_attributes(lay.source())[0].replace('\\', '/')
-        epsg_s = int(lay.crs().postgisSrid())
-        _dt = lay.providerType()
-        if _dt == 'spatialite':
-            dbtype_s = enums.QKanDBChoice.SPATIALITE
-        elif _dt == 'postgres':
-            dbtype_s = enums.QKanDBChoice.POSTGIS
-        else:
-            dbtype_s = None
+    project = QgsProject.instance()
+    qkanlayers = ["Schächte", "Haltungen", "Flächen"]
+    layerobjects = None
+    for lnam in qkanlayers:
+        layerobjects = project.mapLayersByName(lnam)
+        if len(layerobjects) > 0:
+            break
     else:
-        dbname_s = None
-        epsg_s = 0
-        dbtype_s = None
-
-    layerobjects = project.mapLayersByName("Flächen")
-    if len(layerobjects) > 0:
-        lay = layerobjects[0]
-        dbname_f: Optional[str] = get_qkanlayer_attributes(lay.source())[0].replace('\\', '/')
-        epsg_f = int(lay.crs().postgisSrid())
-        _dt = lay.providerType()
-        if _dt == 'spatialite':
-            dbtype_f = enums.QKanDBChoice.SPATIALITE
-        elif _dt == 'postgres':
-            dbtype_f = enums.QKanDBChoice.POSTGIS
+        logger.error_user("Fehler: Es wurde noch kein QKan-Projekt geladen")
+
+    layer = layerobjects[0]
+    # only once for loaded project
+    if not QKan.dbsource or layer.publicSource() != QKan.dbsource:
+        QKan.dbsource = layer.publicSource()
+
+        provider = layer.dataProvider().name()
+        if provider == 'postgres':
+            QKan.dbtype = enums.QKanDBChoice.POSTGIS
+        elif provider == 'spatialite':
+            QKan.dbtype = enums.QKanDBChoice.SPATIALITE
+            uri_components = QgsProviderRegistry.instance().decodeUri(layer.dataProvider().name(), layer.publicSource())
+            QKan.config.database.qkan = uri_components['dbname']
+            QKan.config.epsg = uri_components['epsg']
         else:
-            dbtype_f = None
-    else:
-        dbname_f = None
-        epsg_f = 0
-        dbtype_f = None
-
-    if dbname_s == dbname_f and dbname_s is not None:
-        return dbname_s, epsg_s, dbtype_s
-    elif dbname_s is None and dbname_f is None:
-        logger.error_user(
-            "Fehler in Layerliste:\n"
-            'Layer "Schächte und Flächen existieren nicht"',
-        )
-        raise BaseException
-    elif dbname_f is not None:
-        if not silent:
-            logger.warning("Fehler in Layerliste:", 'Layer "Schächte existiert nicht"')
-        return dbname_f, epsg_f, dbtype_f
-    elif dbname_s is not None:
-        if not silent:
-            logger.warning("Fehler in Layerliste:", 'Layer "Flächen existiert nicht"')
-        return dbname_s, epsg_s, dbtype_s
-    else:
-        logger.error_user(
-            "Fehler in Layerliste:",
-            f"""Layer "Schächte" und "Flächen" sind mit abweichenden Datenbanken verknüpft:
-        Schächte: {dbname_s}
-        Flächen:  {dbname_f}""",
-        )
-        raise BaseException
+            logger.error_code(f"no or wrong dataProvider {provider}")
 
 
 def get_editable_layers() -> Set[str]:

qkan/database/spatialite.yml

@@ -522,25 +522,3 @@ UPDATE schaechte SET knotentyp = 'Einzelschacht' WHERE schaechte.schnam IN
   ON t_sch.schnam = t_hob.schunten
   WHERE t_hun.pk IS NULL AND t_hob.pk IS NULL)"
 
-qgsadapt_zoom: "
-SELECT
-    min(x) AS xmin,
-    min(y) AS ymin,
-    max(x) AS xmax,
-    max(y) AS ymax
-FROM (
-    SELECT x(coalesce(geop, centroid(geom))) AS x, 
-           y(coalesce(geop, centroid(geom))) AS y
-    FROM schaechte
-    UNION 
-    SELECT x(centroid(geom)) AS x, 
-           y(centroid(geom)) AS y
-    FROM haltungen
-)"
-
-qgsadapt_proj: "
-SELECT srid
-FROM geom_cols_ref_sys
-WHERE Lower(f_table_name) = Lower('schaechte')
-AND Lower(f_geometry_column) = Lower('geom')"
-

qkan/dynaporter/dialogs.py

@@ -213,7 +213,8 @@ def run(self) -> None:
         # Wenn dies nicht der Fall ist, wird die Quelldatenbank aus der
         # json-Datei übernommen.
 
-        database_qkan, epsg = get_database_QKan()
+        get_database_QKan()
+        database_qkan, epsg = QKan.config.database.qkan, QKan.config.epsg
         if not database_qkan:
             logger.error(
                 "exportdyna.application: database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!"

qkan/he8porter/_results.py

@@ -47,18 +47,19 @@ def __init__(self):
 
     def run(self) -> bool:
 
-        database_QKan, epsg = get_database_QKan()
+        get_database_QKan()
+        database_qkan, epsg = QKan.config.database.qkan, QKan.config.epsg
 
         # Attach SQLite-Database with HE8 Data
         sql = f'ATTACH DATABASE "{QKan.config.he8.results_file}" AS he'
 
-        with DBConnection(dbname=database_QKan) as db_qkan:
+        with DBConnection(dbname=database_qkan) as db_qkan:
             if not db_qkan.connected:
                 return False
 
             if db_qkan is None:
                 errormsg = "Fehler in QKan_Import_from_HE\n" + \
-                           "QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!".format(database_QKan)
+                           "QKan-Datenbank {:s} wurde nicht gefunden!\nAbbruch!".format(database_qkan)
                 logger.error(errormsg)
                 raise Exception(f"{__name__}: {errormsg}")
 
@@ -121,8 +122,8 @@ def run(self) -> bool:
             if not project.mapLayersByName("Überstau Schächte"):
 
                 uri = QgsDataSourceUri()
-                uri.setDatabase(database_QKan)
-                logger.debug(f"database_QKan (1): {database_QKan}")
+                uri.setDatabase(database_qkan)
+                logger.debug(f"database_qkan (1): {database_qkan}")
                 uri.setDataSource("", "ResultsSch", "geom")
                 logger.debug(f"(2) uri.database(): {uri.database()}")
                 vlayer = QgsVectorLayer(uri.uri(), "Überstau Schächte", "spatialite")

qkan/info/application_dialog.py

@@ -75,7 +75,8 @@ def __init__(
     def select_date(self):
 
         try:
-            database_qkan, epsg = get_database_QKan()
+            get_database_QKan()
+            database_qkan, epsg = QKan.config.database.qkan, QKan.config.epsg
             if not database_qkan:
                 return
             db_x = database_qkan #Datenbank name

qkan/isyporter/application.py

@@ -49,7 +49,8 @@ def run_export(self) -> None:
         self.export_dlg.show()
 
         # Fill dialog with current info
-        self.database_qkan, _ = get_database_QKan()
+        get_database_QKan()
+        self.database_qkan = QKan.config.database.qkan
         if self.database_qkan:
             self.export_dlg.tf_database.setText(self.database_qkan)
         else:

qkan/laengsschnitt/application.py

@@ -165,7 +165,8 @@ def run_laengs(self) -> None:
 
 
         # Fill dialog with current info
-        self.database_qkan, _ = get_database_QKan()
+        get_database_QKan()
+        self.database_qkan = QKan.config.database.qkan
         self.db_qkan = DBConnection(dbname=self.database_qkan)
         self.log.debug(f"{__file__}: Datenbankverbindung wurde hergestellt...")
 

qkan/linkflaechen/application.py

@@ -121,7 +121,8 @@ def unload(self) -> None:
     def database_name(self) -> str:
         """Contains the database name"""
         if not self.db_name:
-            self.db_name, _, _ = get_database_QKan()
+            get_database_QKan()
+            self.db_name = QKan.config.database.qkan
         return self.db_name
 
     def run_createlinefl(self) -> None:

qkan/m145porter/application.py

@@ -42,7 +42,8 @@ def run_export(self) -> None:
         self.export_dlg.show()
 
         # Fill dialog with current info
-        self.database_name, _ = get_database_QKan()
+        get_database_QKan()
+        self.database_name = QKan.config.database.qkan
         if self.database_name:
             self.export_dlg.tf_database.setText(self.database_name)
 

qkan/m150porter/application.py

@@ -49,7 +49,8 @@ def run_export(self) -> None:
         self.export_dlg.show()
 
         # Fill dialog with current info
-        self.database_name, _ = get_database_QKan()
+        get_database_QKan()
+        self.database_name = QKan.config.database.qkan
         if self.database_name:
             self.export_dlg.tf_database.setText(self.database_name)
 

qkan/muporter/application.py

@@ -54,7 +54,8 @@ def database_name(self) -> str:
         if self.db_name:
             return self.db_name
 
-        self.db_name, _ = get_database_QKan()
+        get_database_QKan()
+        self.db_name = QKan.config.database.qkan
         return self.db_name
 
     def run_export(self) -> None:

qkan/openqkanproject.py

@@ -17,8 +17,9 @@ def initQKanProject():
         logger = get_logger("QKan.openproject")
         logger.debug("openProjekt started\n")
 
-        database_qkan, _, dbtype = get_database_QKan(silent=True)
-        with DBConnection(dbname=database_qkan) as db_qkan:
+        get_database_QKan(silent=True)
+        database_name = QKan.config.database.qkan
+        with DBConnection(dbname=database_name) as db_qkan:
             is_actual = db_qkan.isCurrentDbVersion
         if not is_actual:
             qkt = QKanTools(QKan.instance.iface)

qkan/surfaceTools/application.py

@@ -66,7 +66,8 @@ def run_cut(self) -> None:
         # Fetch the currently loaded layers
         # Fetch the currently loaded layers
 
-        database_qkan, epsg = get_database_QKan()
+        get_database_QKan()
+        database_qkan, epsg = QKan.config.database.qkan, QKan.config.epsg
 
         self.surface_dlg.prepareDialog(database_qkan, epsg)
 
@@ -96,7 +97,8 @@ def run_cut(self) -> None:
     def run_voronoi(self) -> None:
         """Erzeugt Voronoi-Flächen zu ausgewählten Haltungen"""
 
-        database_qkan, epsg = get_database_QKan()
+        get_database_QKan()
+        database_qkan, epsg = QKan.config.database.qkan, QKan.config.epsg
 
         self.log.debug(f'Modul {__name__}: database_qkan: {database_qkan}')
 

qkan/tools/application.py

@@ -165,7 +165,8 @@ def run_qgsadapt(self) -> None:
         # Formularfeld Datenbank
 
         # Falls eine Datenbank angebunden ist, wird diese zunächst in das Formular eingetragen.
-        self.database_name, epsg = get_database_QKan(silent=True)
+        get_database_QKan(silent=True)
+        self.database_name, epsg = QKan.config.database.qkan, QKan.config.epsg
 
         if self.database_name:
             self.default_dir = os.path.dirname(
@@ -377,7 +378,8 @@ def run_runoffparams(self) -> None:
         # Wenn dies nicht der Fall ist, wird die Quelldatenbank aus der
         # json-Datei übernommen.
 
-        database_qkan, epsg = get_database_QKan()
+        get_database_QKan()
+        database_qkan, epsg = QKan.config.database.qkan, QKan.config.epsg
         if not database_qkan:
             self.log.error(
                 "tools.application: database_QKan konnte nicht aus den Layern ermittelt werden. Abbruch!"
@@ -586,7 +588,8 @@ def run_layersadapt(self) -> None:
         # Formularfeld Datenbank
 
         # Falls eine Datenbank angebunden ist, wird diese zunächst in das Formular eingetragen.
-        self.database_name, epsg = get_database_QKan(silent=True)
+        get_database_QKan(silent=True)
+        self.database_name, epsg = QKan.config.database.qkan, QKan.config.epsg
 
         if self.database_name:
             self.default_dir = os.path.dirname(
@@ -759,7 +762,8 @@ def run_dbAdapt(self) -> None:
         """Aktualisiert die QKan-Datenbank"""
 
         # Falls eine Datenbank angebunden ist, wird diese zunächst in das Formular eingetragen.
-        self.database_name, epsg = get_database_QKan(silent=True)
+        get_database_QKan(silent=True)
+        self.database_name, epsg = QKan.config.database.qkan, QKan.config.epsg
 
         if self.database_name:
             self.default_dir = os.path.dirname(
@@ -850,7 +854,8 @@ def run_help(self) -> None:
 
 
     def run_filepath(self) -> None:
-        self.database_name, epsg = get_database_QKan(silent=True)
+        get_database_QKan(silent=True)
+        self.database_name, epsg = QKan.config.database.qkan, QKan.config.epsg
 
         # with DBConnection(dbname=self.database_name) as db_qkan:
         #     if not db_qkan.connected: