API_Karte_QGISDemo/vln_karten/plugin.py

"""Hauptklasse des Plugins.

Ablauf:
- Der API-Key wird nach dem ersten Login in den QGIS-Einstellungen
  gespeichert und bei jedem QGIS-Start wiederverwendet (kein erneuter
  Login nötig, solange der Key gültig ist).
- Die Bedienung sitzt in einer andockbaren Seitenleiste rechts (``panel.py``,
  seit 08.09.2026 anstelle der früheren Werkzeugleiste). Sie zeigt Anmeldung,
  Verfahrensliste aus GET /tgen mit Suchfeld sowie die Knöpfe zum Laden,
  Speichern und Hochladen.
- Das gewählte Verfahren wird in der Projektdatei gemerkt und beim Öffnen
  des Projekts wiederhergestellt.
"""

from qgis.PyQt.QtCore import QSettings, Qt, QTimer
from qgis.PyQt.QtWidgets import QAction, QDialog, QMessageBox
from qgis.core import Qgis, QgsDataSourceUri, QgsProject

from .api_client import ApiError, AuthError, KartenApiClient
from .panel import VlnPanel
from .login_dialog import LoginDialog, SETTINGS_GROUP
from . import linkliste
from . import ogc_layers

MENU_TITLE = "&VLN Karten"

# Schlüssel für die VKZ-Ablage in der Projektdatei (*.qgz).
PROJECT_SCOPE = "vln_karten"
PROJECT_KEY_VKZ = "/vkz"

class VlnKartenPlugin:
    def __init__(self, iface):
        self.iface = iface
        self.client = KartenApiClient()
        self.actions = []
        self.panel = None

    # ------------------------------------------------------------------
    # Plugin-Lebenszyklus
    # ------------------------------------------------------------------

    def initGui(self):
        # Seitenleiste statt Werkzeugleiste (Erik, 08.09.2026). Geladen und gespeichert wird
        # ausschließlich über die OGC API: die Layer sind nativ editierbar, QGIS schreibt jede
        # Änderung einzeln zurück (Part 4). Der frühere GeoJSON-Weg ist entfallen.
        self.panel = VlnPanel(
            self.iface.mainWindow(),
            callbacks={
                "login": self.run_login,
                "logout": self.run_logout,
                "verfahren_gewaehlt": self.on_verfahren_changed,
                "load_ogc": self.run_load_ogc,
                "save_edits": self.run_save_edits,
                "dienste_holen": self.run_dienste_holen,
                "dienste_laden": self.run_dienste_laden,
                "save_style": self.run_save_style,
            },
        )
        self.iface.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.panel)

        # Menüeintrag zum Wiedereinblenden, falls die Leiste geschlossen wurde.
        self.panel_action = QAction("Seitenleiste anzeigen", self.iface.mainWindow())
        self.panel_action.setCheckable(True)
        self.panel_action.setChecked(True)
        self.panel_action.toggled.connect(self.panel.setVisible)
        self.panel.visibilityChanged.connect(self.panel_action.setChecked)
        self.iface.addPluginToWebMenu(MENU_TITLE, self.panel_action)
        self.actions.append(self.panel_action)

        self.iface.projectRead.connect(self.restore_project_selection)
        self.iface.newProjectCreated.connect(self.restore_project_selection)

        self._set_logged_out_ui()

        # Gespeicherten API-Key aus früherer Sitzung wiederverwenden; sonst gleich beim Start
        # anmelden (Erik, 07.09.2026: „zuerst ein Loginfenster, danach den API-Key speichern").
        # Beides erst NACH dem QGIS-Start (singleShot), sonst blockiert der Dialog das Laden.
        settings = QSettings()
        settings.beginGroup(SETTINGS_GROUP)
        api_key = settings.value("api_key", "")
        mail = settings.value("mail", "")
        settings.endGroup()
        if api_key:
            self.client = KartenApiClient(api_key=api_key, mail=mail)
            QTimer.singleShot(0, self.populate_verfahren)
        else:
            QTimer.singleShot(1500, self.run_login)

    def unload(self):
        for signal in (self.iface.projectRead, self.iface.newProjectCreated):
            try:
                signal.disconnect(self.restore_project_selection)
            except (TypeError, RuntimeError):
                pass
        for action in self.actions:
            self.iface.removePluginWebMenu(MENU_TITLE, action)
        self.actions = []
        if self.panel is not None:
            self.iface.removeDockWidget(self.panel)
            self.panel.deleteLater()
            self.panel = None

    # ------------------------------------------------------------------
    # Anmeldung & Verfahrensliste
    # ------------------------------------------------------------------

    def run_login(self):
        dialog = LoginDialog(self.iface.mainWindow())
        if dialog.exec() != QDialog.DialogCode.Accepted:
            return

        client = KartenApiClient()
        try:
            client.login(dialog.mail(), dialog.password())
        except ApiError as exc:
            self._show_error("Anmeldung fehlgeschlagen", str(exc))
            return

        self.client = client
        # Nach dem Login wird der API-Key (userauth) gespeichert und in jeder weiteren Sitzung
        # wiederverwendet — das Passwort selbst speichert das Plugin nie. Ablage: QSettings
        # („vln_karten/api_key"), zurücksetzen über „Abmelden".
        settings = QSettings()
        settings.beginGroup(SETTINGS_GROUP)
        settings.setValue("api_key", client.api_key)
        settings.setValue("mail", client.mail or dialog.mail())
        settings.endGroup()

        self.iface.messageBar().pushMessage(
            "VLN Karten",
            "Angemeldet als %s — der API-Key ist gespeichert und gilt auch nach einem "
            "QGIS-Neustart." % (client.mail or dialog.mail()),
            level=Qgis.Success,
            duration=6,
        )
        self.populate_verfahren()

    def populate_verfahren(self):
        """Füllt die Auswahlliste mit allen Verfahren aus GET /tgen."""
        try:
            verfahren = self.client.get_verfahren()
        except AuthError:
            self._handle_session_expired()
            return
        except ApiError as exc:
            self.iface.messageBar().pushMessage(
                "VLN Karten",
                "Verfahrensliste konnte nicht geladen werden: %s" % exc,
                level=Qgis.Warning,
                duration=10,
            )
            return

        self.panel.set_angemeldet(True, self.client.mail or "API-Key")
        self.panel.set_verfahren(verfahren)
        self.panel.set_status("%d Verfahren geladen." % len(verfahren))
        self.restore_project_selection()

    def _handle_session_expired(self):
        settings = QSettings()
        settings.beginGroup(SETTINGS_GROUP)
        settings.remove("api_key")
        settings.endGroup()
        self.client.logout()
        self._set_logged_out_ui()
        self._show_error(
            "Sitzung abgelaufen",
            "Der gespeicherte API-Key ist nicht mehr gültig — "
            "bitte neu anmelden.",
        )
        self.run_login()

    def _set_logged_out_ui(self):
        if self.panel is not None:
            self.panel.set_angemeldet(False)
            self.panel.set_status("")

    def run_logout(self):
        """Abmelden: gespeicherten API-Key verwerfen, Oberfläche zurücksetzen."""
        settings = QSettings()
        settings.beginGroup(SETTINGS_GROUP)
        settings.remove("api_key")
        settings.endGroup()
        self.client.logout()
        self.client = KartenApiClient()
        self._set_logged_out_ui()
        self.iface.messageBar().pushMessage(
            "VLN Karten", "Abgemeldet — der gespeicherte API-Key wurde entfernt.",
            level=Qgis.Info, duration=5)

    # ------------------------------------------------------------------
    # Verfahrens-Auswahl <-> Projektdatei
    # ------------------------------------------------------------------

    def on_verfahren_changed(self, vkz):
        if vkz:
            QgsProject.instance().writeEntry(
                PROJECT_SCOPE, PROJECT_KEY_VKZ, vkz
            )

    def restore_project_selection(self):
        if self.panel is None or self.panel.anzahl_eintraege() == 0:
            return
        vkz, _ok = QgsProject.instance().readEntry(
            PROJECT_SCOPE, PROJECT_KEY_VKZ, ""
        )
        self.panel.waehle_vkz(vkz)

    def _current_vkz(self):
        return self.panel.aktuelles_vkz() if self.panel is not None else None

    # ------------------------------------------------------------------
    # Laden & Hochladen
    # ------------------------------------------------------------------

    def run_load_ogc(self):
        """Alle Sammlungen des gewählten Verfahrens (Verfahrens-Layer, Vorerhebung,
        Maßnahmenblätter) als OAPIF-Layer laden — editierbar in QGIS, Rückschreiben je Feature."""
        if not self._ensure_logged_in():
            return
        vkz = self._current_vkz()
        if not vkz:
            self._show_error("Kein Verfahren", "Bitte zuerst ein Verfahren auswählen.")
            return
        authcfg = ogc_layers.authcfg_sicherstellen(self.client.api_key, SETTINGS_GROUP)
        if not authcfg:
            self.iface.messageBar().pushMessage(
                "VLN Karten",
                "Keine QGIS-Authentifizierungskonfiguration — der API-Key steht jetzt in den "
                "Datenquellen der Layer (und damit in einer gespeicherten Projektdatei).",
                level=Qgis.Warning, duration=8)
        try:
            collections = ogc_layers.collections_laden(self.client, vkz)
        except AuthError:
            self._handle_session_expired()
            return
        except ApiError as exc:
            self._show_error("OGC API", str(exc))
            return
        if not collections:
            self._show_error("OGC API", "Für dieses Verfahren gibt es keine Sammlungen "
                             "(oder keine Berechtigung).")
            return
        # Nur die in der Seitenleiste angehakten Gruppen laden — jede Sammlung kostet beim
        # Anlegen rund eine halbe Sekunde, und selten braucht man alle 27 gleichzeitig.
        gewaehlt = self.panel.gewaehlte_gruppen()
        gruppe_von = dict(ogc_layers.GRUPPEN)
        collections = [c for c in collections
                       if gruppe_von.get(str(c.get("id") or "").split("-", 1)[0], "Weitere")
                       in gewaehlt]
        if not collections:
            self._show_error("Nichts ausgewählt",
                             "Bitte oben mindestens eine Gruppe anhaken (Verfahren, "
                             "Vorerhebung oder Maßnahmenblätter).")
            return
        # Schrittweise: je Ereignisschleifen-Durchlauf ein Layer, Fortschritt in der
        # Meldungsleiste. Fehler kommen dort am Ende gesammelt, nicht als Modal-Dialog.
        self.panel.set_status("Lade %d Sammlungen …" % len(collections))
        ogc_layers.layer_hinzufuegen(
            self.iface, self.client.base_url, vkz, self.panel.aktueller_text(), collections,
            authcfg, api_key=None if authcfg else self.client.api_key)

    def run_save_edits(self):
        """Offene Bearbeitungssitzungen aller geladenen VLN-Layer schließen.

        Über die OGC API schreibt QGIS jede Änderung einzeln zurück (Part 4) — dieser Knopf
        beendet nur die Bearbeitung, so wie „Layeränderungen speichern" in QGIS, aber für
        alle Layer des Verfahrens auf einmal.
        """
        layer = [l for l in QgsProject.instance().mapLayers().values()
                 if getattr(l, "providerType", None) and l.providerType() == "OAPIF"]
        offen = [l for l in layer if l.isEditable()]
        if not offen:
            self.iface.messageBar().pushMessage(
                "VLN Karten", "Keine offene Bearbeitung — es gibt nichts zu speichern.",
                level=Qgis.Info, duration=5)
            return
        gespeichert, fehler = [], []
        for l in offen:
            if l.commitChanges():
                gespeichert.append(l.name())
            else:
                fehler.append("%s: %s" % (l.name(), "; ".join(l.commitErrors())[:120]))
        if fehler:
            self._show_error("Nicht alles gespeichert", "\n".join(fehler))
        if gespeichert:
            self.iface.messageBar().pushMessage(
                "VLN Karten", "%d Layer gespeichert (%s)." % (len(gespeichert),
                                                              ", ".join(gespeichert[:4])),
                level=Qgis.Success, duration=6)
        if self.panel is not None:
            self.panel.set_status("%d von %d Layern gespeichert." % (len(gespeichert), len(offen)))

    def run_dienste_holen(self):
        """Die Linkliste des gewählten Verfahrens holen und in der Seitenleiste anzeigen.

        Der Server liefert sie bereits aufgelöst: landesweit, Landkreis, Team und Verfahren
        sind zusammengeführt, geerbte Einträge tragen ihre Herkunft. Das Plugin rechnet nichts
        nach, es zeigt und lädt.
        """
        if not self._ensure_logged_in():
            return
        vkz = self._current_vkz()
        if not vkz:
            self._show_error("Kein Verfahren", "Bitte zuerst ein Verfahren auswählen.")
            return
        try:
            dienste = linkliste.dienste_laden(self.client, vkz)
        except AuthError:
            self._handle_session_expired()
            return
        except ApiError as exc:
            self._show_error("Linkliste", str(exc))
            return
        self.panel.set_dienste(dienste)
        herkunft = {}
        for d in dienste:
            herkunft[d.get("herkunft_text") or "?"] = herkunft.get(d.get("herkunft_text") or "?", 0) + 1
        text = ", ".join("%d %s" % (n, k) for k, n in herkunft.items()) or "nichts hinterlegt"
        self.panel.set_status("%d Geodienste: %s" % (len(dienste), text))
        self.iface.messageBar().pushMessage(
            "VLN Karten", "%d Geodienste für dieses Verfahren (%s)." % (len(dienste), text),
            level=Qgis.Info, duration=6)

    def run_dienste_laden(self):
        """Die angehakten Dienste als Layer in die Gruppe „Geodienste" hängen."""
        if not self._ensure_logged_in():
            return
        vkz = self._current_vkz()
        if not vkz:
            self._show_error("Kein Verfahren", "Bitte zuerst ein Verfahren auswählen.")
            return
        gewaehlt = self.panel.gewaehlte_dienste()
        if not gewaehlt:
            self._show_error("Nichts ausgewählt",
                             "Bitte zuerst die Liste holen und dann die gewünschten Dienste "
                             "anhaken.")
            return
        linkliste.dienste_hinzufuegen(
            self.iface, self.client.base_url, vkz, self.panel.aktueller_text(), gewaehlt,
            api_key=self.client.api_key)
        self.panel.set_status("%d Geodienste werden geladen …" % len(gewaehlt))

    def run_save_style(self):
        """Den Stil des aktiven OGC-Layers auf den Server zurückschreiben.

        Erlaubt für Verbandsmitarbeiter und die Gruppe MODUL_KARTENSTIL; der Server antwortet
        sonst mit 403. Ist in der Seitenleiste „als Vorlage für alle Verfahren“ angehakt (oder
        die Umschalttaste gedrückt), gilt der Stil für die **Art** statt nur für dieses
        Verfahren — z. B. ein Stil für jede „Karte alter Stand“.
        """
        from qgis.PyQt.QtWidgets import QApplication
        from qgis.PyQt.QtCore import Qt as _Qt

        layer = self.iface.activeLayer()
        if layer is None or layer.providerType() != "OAPIF":
            self._show_error("Kein OGC-Layer",
                             "Bitte zuerst einen über „Alle Layer (OGC API) laden“ geladenen "
                             "Layer auswählen.")
            return
        cid = QgsDataSourceUri(layer.source()).param("typename")
        if not cid:
            self._show_error("Kein OGC-Layer", "Die Datenquelle nennt keine Sammlung (typename).")
            return
        vorlage = (self.panel is not None and self.panel.als_vorlage()) or bool(
            QApplication.keyboardModifiers() & _Qt.KeyboardModifier.ShiftModifier)
        settings = QSettings()
        settings.beginGroup(SETTINGS_GROUP)
        authcfg = settings.value(ogc_layers.SETTINGS_AUTHCFG, "")
        settings.endGroup()
        try:
            ok, text = ogc_layers.stil_speichern(layer, self.client.base_url, cid,
                                                 api_key=self.client.api_key, authcfg=authcfg or None,
                                                 vorlage=vorlage)
        except AuthError:
            self._handle_session_expired()
            return
        if ok:
            self.iface.messageBar().pushMessage(
                "VLN Karten", "Stil für %s gespeichert — %s" % (cid, text),
                level=Qgis.Success, duration=8)
            if self.panel is not None:
                self.panel.set_status("Stil gespeichert: %s%s"
                                      % (cid, " (Vorlage)" if vorlage else ""))
        else:
            self._show_error("Stil nicht gespeichert", text)

    # ------------------------------------------------------------------
    # Hilfsfunktionen
    # ------------------------------------------------------------------

    def _ensure_logged_in(self):
        if self.client.is_authenticated:
            return True
        self.run_login()
        return self.client.is_authenticated

    def _show_error(self, title, message):
        QMessageBox.warning(self.iface.mainWindow(), title, message)