Version 2.8.7: drei Standardgruppen, Module abschaltbar

apps/tesm-license/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tesm-license"
-version = "2.8.0"
+version = "2.8.3"
 description = "TESM-Lizenzserver -- Kunden, Tickets, Lizenzen, Aktivierung"
 requires-python = ">=3.11"
 dependencies = [

apps/tesm-license/src/tesm_license/blueprints/settings.py

@@ -68,7 +68,11 @@ def system():
             else ""
         ),
         timezones=_timezone_choices(),
-        nav_items=extension.nav.items,
+        # Nicht ``nav_items``: dieser Name gehoert dem Seitenrahmen. Wer ihn hier
+        # belegt, ueberschreibt die gefilterte Navigation aus dem Kontext --
+        # und die Seitenleiste zeigte dann jeden Punkt, auch den, den dieser
+        # Benutzer nicht darf und den die Lizenz nicht freischaltet.
+        nav_baum=extension.nav.items,
         nav_order=extension.settings.get(conn, "nav_order") or extension.nav.default_order(),
         nav_child_order=extension.settings.get(conn, "nav_child_order") or {},
         sysops_available=bool(sysops and sysops.available),

apps/tesm-license/src/tesm_license/permissions.py

@@ -183,6 +183,14 @@ FUNKTIONEN_VOLLZUGRIFF = RolePreset(
 )
 
 
+#: Wie in TESM: drei Gruppen ab Werk, nicht sechs.
+#:
+#: Auch "Vertrieb" ist hier entfallen, obwohl es die Rolle ist, die den
+#: Lizenzserver taeglich benutzt -- gerade deshalb: wer Lizenzen ausstellt,
+#: schneidet die Gruppe ohnehin auf sein Haus zu (darf Vertrieb widerrufen?
+#: Tickets loeschen? in die Protokolle sehen?). Eine mitgelieferte Antwort auf
+#: diese Frage wird entweder uebernommen, ohne sie zu pruefen, oder sie wird
+#: umgebaut. "Funktionen (Vollzugriff)" ist der ehrlichere Startpunkt.
 ROLE_PRESETS: tuple[RolePreset, ...] = (
     RolePreset(
         key="viewer",
@@ -191,52 +199,6 @@ ROLE_PRESETS: tuple[RolePreset, ...] = (
         grants=(("logs_live", (A.READ,)),),
         is_default=True,
     ),
-    RolePreset(
-        key="sales",
-        name="Vertrieb",
-        description="Kunden und Tickets pflegen, Lizenzen ausstellen und versenden.",
-        grants=(
-            ("customers", "*"),
-            ("tickets", "*"),
-            ("licenses", (A.READ, A.EXPORT)),
-            ("license_issue", "*"),
-            ("license_renew", "*"),
-            ("license_revoke", "*"),
-            ("portal", "*"),
-            ("logs_live", (A.READ,)),
-            ("logs_audit", (A.READ,)),
-        ),
-    ),
-    RolePreset(
-        key="support",
-        name="Support",
-        description="Lesen und Offline-Aktivierungen verarbeiten.",
-        grants=(
-            ("customers", (A.READ,)),
-            ("tickets", (A.READ,)),
-            ("licenses", (A.READ,)),
-            ("license_activation", "*"),
-            ("reports", (A.READ,)),
-            ("logs_live", (A.READ,)),
-        ),
-    ),
-    RolePreset(
-        key="auditor",
-        name="Revision",
-        description="Nur lesen – inklusive Änderungsprotokoll und Diagnose.",
-        grants=(
-            ("customers", (A.READ,)),
-            ("tickets", (A.READ,)),
-            ("licenses", (A.READ,)),
-            ("reports", (A.READ,)),
-            ("users", (A.READ,)),
-            ("groups", (A.READ,)),
-            ("logs_live", (A.READ,)),
-            ("logs_history", (A.READ, A.EXPORT)),
-            ("logs_audit", (A.READ, A.EXPORT)),
-            ("diagnostics", (A.READ,)),
-        ),
-    ),
     RolePreset(
         key="administration",
         name="Administration",

apps/tesm-license/src/tesm_license/schema.py

@@ -27,6 +27,8 @@ Aenderungen gegenueber dem Vorgaenger:
 
 from __future__ import annotations
 
+from typing import Any
+
 from tesm_core.migrations import Migration
 
 V1 = """
@@ -223,8 +225,79 @@ def uebergang_funktionsgruppe(conn) -> None:  # type: ignore[no-untyped-def]
     rbac.funktionsgruppe_fuer_administratoren(conn, PERMISSIONS, FUNKTIONEN_VOLLZUGRIFF)
 
 
+#: Die drei Vorlagen, die es bis 2.8.2 gab -- eingefrorene Kopie, siehe TESM.
+ABGELEGTE_VORLAGEN: tuple[tuple[str, str, tuple[tuple[str, Any], ...]], ...] = (
+    (
+        "sales",
+        "Vertrieb",
+        (
+            ("customers", "*"),
+            ("tickets", "*"),
+            ("licenses", ("read", "export")),
+            ("license_issue", "*"),
+            ("license_renew", "*"),
+            ("license_revoke", "*"),
+            ("portal", "*"),
+            ("logs_live", ("read",)),
+            ("logs_audit", ("read",)),
+        ),
+    ),
+    (
+        "support",
+        "Support",
+        (
+            ("customers", ("read",)),
+            ("tickets", ("read",)),
+            ("licenses", ("read",)),
+            ("license_activation", "*"),
+            ("reports", ("read",)),
+            ("logs_live", ("read",)),
+        ),
+    ),
+    (
+        "auditor",
+        "Revision",
+        (
+            ("customers", ("read",)),
+            ("tickets", ("read",)),
+            ("licenses", ("read",)),
+            ("reports", ("read",)),
+            ("users", ("read",)),
+            ("groups", ("read",)),
+            ("logs_live", ("read",)),
+            ("logs_history", ("read", "export")),
+            ("logs_audit", ("read", "export")),
+            ("diagnostics", ("read",)),
+        ),
+    ),
+)
+
+
+def uebergang_standardgruppen(conn) -> None:  # type: ignore[no-untyped-def]
+    """Wie in TESM: unberuehrte Vorlagen in den Papierkorb, benutzte bleiben."""
+    from tesm_core.rbac import service as rbac
+    from tesm_core.rbac.model import Action, RolePreset
+
+    from .permissions import PERMISSIONS
+
+    vorlagen = [
+        RolePreset(
+            key=key,
+            name=name,
+            description="",
+            grants=tuple(
+                (ressource, a if a == "*" else tuple(Action(x) for x in a))
+                for ressource, a in grants
+            ),
+        )
+        for key, name, grants in ABGELEGTE_VORLAGEN
+    ]
+    rbac.unberuehrte_vorlagen_entfernen(conn, PERMISSIONS, vorlagen)
+
+
 LICENSE_MIGRATIONS: tuple[Migration, ...] = (
     Migration(version=1, name="baseline", sql=V1, allow_integrity_error=True),
     Migration(version=2, name="revision-timestamp", sql=V2),
     Migration(version=3, name="funktionsgruppe-fuer-admins", fn=uebergang_funktionsgruppe),
+    Migration(version=4, name="standardgruppen-aufraeumen", fn=uebergang_standardgruppen),
 )

apps/tesm-license/src/tesm_license/templates/license/settings_system.html

@@ -129,7 +129,7 @@
     </section>
 
     {% if current_user.is_admin %}
-      {{ nav_order_card(nav_items, nav_order, nav_child_order,
+      {{ nav_order_card(nav_baum, nav_order, nav_child_order,
                         url_for('admin.nav_order'), csrf_field_name, csrf_token(),
                         sub='Gilt für alle Benutzer') }}
     {% endif %}

packages/tesm-core/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tesm-core"
-version = "2.8.0"
+version = "2.8.3"
 description = "Gemeinsames Anwendungsgeruest (Auth, RBAC, Navigation, Design-System, Migrationen) fuer TESM und TESM-Lizenzserver"
 requires-python = ">=3.11"
 dependencies = [

packages/tesm-core/src/tesm_core/app_factory.py

@@ -102,6 +102,14 @@ CORE_SETTINGS: tuple[SettingSpec, ...] = (
     ),
     # -- Webserver/TLS (Host-Ebene, in beiden Anwendungen gleich) ----------- #
     # Lizenzserver: eigenes Zertifikat statt abgeschalteter Pruefung.
+    SettingSpec(
+        "modules_disabled",
+        [],
+        "json",
+        "Vor Ort abgeschaltete Module",
+        hint="Die Lizenz sagt, was erlaubt ist; das hier sagt, was benutzt wird.",
+        section="system",
+    ),
     SettingSpec(
         "license_server_ca",
         "",

packages/tesm-core/src/tesm_core/auth/directory.py

@@ -26,6 +26,7 @@ import re
 import socket
 import sqlite3
 import ssl
+import time
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Any, Literal
@@ -162,19 +163,82 @@ def _tls_object(config: dict[str, Any]):
 
 
 def _server(config: dict[str, Any]):
+    """Das Server-Objekt -- so sparsam wie moeglich.
+
+    ``get_info`` entscheidet, was ldap3 beim Verbinden **zusaetzlich** holt.
+    Mit ``ALL`` ist das die Beschreibung des Verzeichnisses *und sein ganzes
+    Schema*: bei einem Active Directory sind das Tausende Attribut- und
+    Klassendefinitionen, mehrere Megabyte, bei jeder Verbindung neu. Fuer eine
+    Anmeldung braucht davon nichts -- gelesen wird hoechstens der
+    ``defaultNamingContext``, wenn kein Basis-DN eingetragen ist, und dafuer
+    genuegt ``DSA`` (nur die Serverinformation, ein Datensatz).
+
+    Liegt der Domain-Controller in einem anderen Netz, ist genau das der
+    Unterschied zwischen "geht sofort" und "dauert manchmal".
+    """
     from ldap3 import Server
 
     security = str(config["ldap_security"])
+    braucht_basis = not str(config.get("ldap_base_dn") or "").strip()
     return Server(
         str(config["ldap_host"]),
         port=int(config["ldap_port"]),
         use_ssl=security == "ldaps",
         tls=_tls_object(config) if security in {"ldaps", "starttls"} else None,
-        get_info="ALL",
+        get_info="DSA" if braucht_basis else "NO_INFO",
         connect_timeout=int(config["ldap_timeout"]),
     )
 
 
+#: Fehler, die nur "gerade jetzt nicht" bedeuten -- nicht "falsches Passwort".
+#:
+#: Die Liste stammt aus der Fassung 1.2.8, wo dieses Problem schon einmal
+#: geloest war. Der Kommentar dort beschreibt es genauer, als ich es koennte:
+#: ein Domain-Controller in einem anderen, langsameren Netzsegment -- die
+#: allererste Verbindung dorthin ist oft spuerbar langsamer als jede folgende,
+#: und der erste Login schlug mit "Benutzer/Passwort ungueltig" fehl, waehrend
+#: ein sofortiger zweiter Versuch klappte.
+TRANSIENTE_FEHLER: tuple[type[Exception], ...] = ()
+
+
+def _transiente_fehler() -> tuple[type[Exception], ...]:
+    """Die Ausnahmeklassen von ldap3, die einen Wiederholversuch verdienen."""
+    global TRANSIENTE_FEHLER
+    if TRANSIENTE_FEHLER:
+        return TRANSIENTE_FEHLER
+    from ldap3.core.exceptions import (
+        LDAPResponseTimeoutError,
+        LDAPSocketOpenError,
+        LDAPSocketReceiveError,
+        LDAPSocketSendError,
+    )
+
+    TRANSIENTE_FEHLER = (
+        LDAPSocketOpenError,
+        LDAPSocketReceiveError,
+        LDAPSocketSendError,
+        LDAPResponseTimeoutError,
+    )
+    return TRANSIENTE_FEHLER
+
+
+def mit_wiederholung(aufbau: Any) -> Any:
+    """Genau ein zweiter Versuch -- und nur bei einem Netzfehler.
+
+    Nicht bei einer abgelehnten Anmeldung: ein Tippfehler im Passwort wuerde
+    sonst den Sperrzaehler des Kontos zweimal statt einmal hochzaehlen. Das
+    ist die Regel aus 1.2.8, und sie ist richtig.
+    """
+    try:
+        return aufbau()
+    except _transiente_fehler() as fehler:
+        logger.info(
+            "Verzeichnisdienst antwortete nicht (%s) -- ein zweiter Versuch",
+            type(fehler).__name__,
+        )
+        return aufbau()
+
+
 def _connect(config: dict[str, Any], user: str, password: str):
     """Baut eine Verbindung auf und bindet. Wirft bei Netz-/TLS-Problemen."""
     from ldap3 import Connection
@@ -192,6 +256,12 @@ def _connect(config: dict[str, Any], user: str, password: str):
         auto_bind=False,
         raise_exceptions=False,
         receive_timeout=int(config["ldap_timeout"]),
+        # Ein Active Directory antwortet auf eine Suche ab der Domaenenwurzel
+        # mit Verweisen auf andere Controller. ldap3 folgt ihnen von sich aus
+        # -- und baut dafuer neue Verbindungen auf, womoeglich in ein anderes
+        # Netz. Fuer eine Anmeldung ist das nicht nur unnoetig, sondern die
+        # Quelle genau der Wartezeiten, die niemand erklaeren kann.
+        auto_referrals=False,
     )
     if security == "starttls":
         if not connection.open():
@@ -253,8 +323,19 @@ def authenticate(conn: sqlite3.Connection, username: str, password: str) -> Dire
     if not config["ldap_verify_cert"]:
         warnings.append("Serverzertifikat des Verzeichnisdienstes wird nicht geprüft")
 
+    begonnen = time.monotonic()
+    zeiten: list[str] = []
+
+    def gemessen(name: str, seit: float) -> float:
+        """Haelt eine Stufe mit ihrer Dauer fest und gibt die neue Marke."""
+        jetzt = time.monotonic()
+        zeiten.append(f"{name} {int((jetzt - seit) * 1000)}ms")
+        return jetzt
+
     try:
-        service_conn, bound = _connect(config, bind_user, bind_password)
+        service_conn, bound = mit_wiederholung(
+            lambda: _connect(config, bind_user, bind_password)
+        )
     except (PermissionError, ConnectionError) as exc:
         logger.error("Verzeichnisdienst: %s", exc)
         return DirectoryResult("unavailable", message=str(exc), warnings=tuple(warnings))
@@ -271,8 +352,10 @@ def authenticate(conn: sqlite3.Connection, username: str, password: str) -> Dire
             warnings=tuple(warnings),
         )
 
+    marke = gemessen("Dienstbindung", begonnen)
     try:
         base = _base_dn(service_conn, config)
+        marke = gemessen("Basis-DN", marke)
         if not base:
             return DirectoryResult(
                 "unavailable", message="Basis-DN konnte nicht ermittelt werden.", warnings=tuple(warnings)
@@ -288,8 +371,10 @@ def authenticate(conn: sqlite3.Connection, username: str, password: str) -> Dire
             attributes=list(dict.fromkeys(wanted)),
             size_limit=2,
         )
+        marke = gemessen("Benutzersuche", marke)
         entries = list(service_conn.entries)
         if len(entries) != 1:
+            logger.info("Verzeichnisanmeldung %s: %s", username, ", ".join(zeiten))
             return DirectoryResult("invalid", warnings=tuple(warnings))
 
         entry = entries[0]
@@ -300,9 +385,18 @@ def authenticate(conn: sqlite3.Connection, username: str, password: str) -> Dire
 
         # Zweite, unabhaengige Verbindung mit den Benutzerdaten -- die eigentliche
         # Passwortpruefung. Niemals ueber die Dienstkonto-Verbindung rebinden.
-        user_conn, user_bound = _connect(config, dn, password)
+        #
+        # Mit Wiederholversuch, und genau hier zeigte sich das Symptom: bei
+        # einem Domain-Controller in einem anderen Netz schlug der erste
+        # Versuch mit "Benutzer/Passwort ungueltig" fehl, der zweite gleich
+        # darauf klappte. Wiederholt wird nur bei einem Netzfehler -- eine
+        # abgelehnte Anmeldung bleibt abgelehnt, sonst zaehlt ein Tippfehler
+        # den Sperrzaehler des Kontos zweimal hoch.
+        user_conn, user_bound = mit_wiederholung(lambda: _connect(config, dn, password))
+        marke = gemessen("Passwortpruefung", marke)
         try:
             if not user_bound:
+                logger.info("Verzeichnisanmeldung %s: %s", username, ", ".join(zeiten))
                 return DirectoryResult("invalid", warnings=tuple(warnings))
         finally:
             try:
@@ -313,6 +407,7 @@ def authenticate(conn: sqlite3.Connection, username: str, password: str) -> Dire
         group_dns: tuple[str, ...] = ()
         if config["ldap_group_sync"]:
             group_dns = _resolve_groups(service_conn, base, dn)
+            marke = gemessen("Gruppen", marke)
 
         profile = DirectoryProfile(
             username=_attr(entry, attribute) or username,
@@ -322,6 +417,15 @@ def authenticate(conn: sqlite3.Connection, username: str, password: str) -> Dire
             email=_attr(entry, email_attribute),
             group_dns=group_dns,
         )
+        # Eine Zeile je Anmeldung mit den Dauern der Stufen. Aus "dauert
+        # manchmal laenger" wird damit eine Zahl -- und man sieht, ob es die
+        # Verbindung ist, die Suche oder die Gruppen.
+        logger.info(
+            "Verzeichnisanmeldung %s: %s, gesamt %dms",
+            username,
+            ", ".join(zeiten),
+            int((time.monotonic() - begonnen) * 1000),
+        )
         return DirectoryResult("ok", profile=profile, warnings=tuple(warnings))
     finally:
         try:

packages/tesm-core/src/tesm_core/licensing_client.py

@@ -34,7 +34,7 @@ import urllib.request
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any, Callable, Iterable
 
 import tesm_licensing as lic
 
@@ -54,6 +54,21 @@ SETTING_HEARTBEAT_ERROR = "license_heartbeat_error"
 EXPIRY_HINT_DAYS = 90
 SETTING_EXPORT_GRACE = "license_export_grace"
 
+#: Module, die der Betreiber vor Ort abgeschaltet hat (Liste von Namen).
+#:
+#: Die Lizenz sagt, *was erlaubt ist*; sie sagt nicht, was ein Haus auch
+#: benutzen will. Wer kein DHCP ueber TESM fahren will, weil ein anderer Server
+#: das tut, soll den Punkt nicht wegdruecken muessen -- und vor allem soll
+#: niemand versehentlich eine fremde Kea-Konfiguration ueberschreiben koennen.
+#: Abschalten ist deshalb mehr als Aufraeumen der Navigation: die Sperre sitzt
+#: an derselben Stelle wie die Lizenzpruefung, also vor jeder Route.
+#: Bewusst **ohne** das Praefix ``license_``: Sicherungen lassen alles mit
+#: diesem Praefix draussen, weil Lizenz- und Aktivierungszustand zur Maschine
+#: gehoeren und nicht in ein Backup. Der Schalter ist aber keine Lizenzangabe,
+#: sondern eine Entscheidung des Hauses -- die soll eine Wiederherstellung
+#: mitbringen.
+SETTING_MODULES_OFF = "modules_disabled"
+
 STATUS_INACTIVE = "inactive"
 STATUS_PENDING = "pending"
 STATUS_ACTIVE = "active"
@@ -121,6 +136,8 @@ class LicenseState:
     last_heartbeat_at: str = ""
     heartbeat_error: str = ""
     pending_action: str = ""
+    #: Vor Ort abgeschaltet -- unabhaengig davon, was die Lizenz erlaubt.
+    modules_off: frozenset[str] = frozenset()
 
     @property
     def role(self) -> str:
@@ -128,8 +145,14 @@ class LicenseState:
 
     @property
     def modules(self) -> frozenset[str]:
+        """Was die Lizenz freischaltet -- ohne Ruecksicht auf den Schalter."""
         return self.status.modules if self.status else frozenset()
 
+    @property
+    def modules_in_use(self) -> frozenset[str]:
+        """Was tatsaechlich laeuft: lizenziert **und** nicht abgeschaltet."""
+        return self.modules - self.modules_off
+
     @property
     def customer_name(self) -> str:
         return str((self.status.customer if self.status else {}).get("name") or "")
@@ -179,6 +202,7 @@ class LicenseManager:
         """Liest Lizenzdatei und Status neu ein."""
         with self._lock:
             state = LicenseState()
+            state.modules_off = self.abgeschaltete_module(conn)
             state.last_heartbeat_at = str(self.settings.get(conn, SETTING_LAST_HEARTBEAT) or "")
             state.heartbeat_error = str(self.settings.get(conn, SETTING_HEARTBEAT_ERROR) or "")
             pending = self._pending(conn)
@@ -239,9 +263,51 @@ class LicenseManager:
         )
 
     def module_active(self, name: str) -> bool:
-        """Ist ein Vollmodul (dhcp/fileshare/maintenance) freigeschaltet?"""
+        """Ist ein Vollmodul (dhcp/fileshare/maintenance) in Betrieb?
+
+        Zwei Bedingungen, und beide muessen gelten: die Lizenz muss es
+        freischalten, und der Betreiber darf es nicht abgeschaltet haben. Diese
+        eine Funktion fragen die Navigation, jede Route und die Hintergrund-
+        aufgaben -- darum sitzt der Schalter hier und nicht in einer Vorlage.
+        """
+        return (
+            self.active()
+            and name in self._state.modules
+            and name not in self._state.modules_off
+        )
+
+    def module_licensed(self, name: str) -> bool:
+        """Schaltet die Lizenz das Modul frei? (Ohne den Schalter vor Ort.)"""
         return self.active() and name in self._state.modules
 
+    def abgeschaltete_module(self, conn: sqlite3.Connection) -> frozenset[str]:
+        """Liest die Liste aus den Einstellungen."""
+        gespeichert = self.settings.get(conn, SETTING_MODULES_OFF) or []
+        if isinstance(gespeichert, str):  # Altbestand: ein einzelner Name
+            gespeichert = [gespeichert]
+        return frozenset(str(name) for name in gespeichert)
+
+    def module_abschalten(
+        self, conn: sqlite3.Connection, namen: Iterable[str], *, actor: str = ""
+    ) -> tuple[frozenset[str], frozenset[str]]:
+        """Setzt die Liste der abgeschalteten Module neu.
+
+        Gibt ``(eingeschaltet, abgeschaltet)`` zurueck -- also nur das, was sich
+        wirklich geaendert hat; der Aufrufer schreibt daraus seinen
+        Protokolleintrag.
+
+        Der Zustand wird hier nicht neu eingelesen, sondern nur an dieser einen
+        Stelle nachgezogen: ein voller Neuaufbau wuerde die Lizenzdatei erneut
+        pruefen, obwohl sich an ihr nichts geaendert hat -- und der Schalter ist
+        das Einzige, was jetzt anders ist.
+        """
+        vorher = self.abgeschaltete_module(conn)
+        nachher = frozenset(str(name) for name in namen)
+        self.settings.set(conn, SETTING_MODULES_OFF, sorted(nachher), actor=actor)
+        with self._lock:
+            self._state.modules_off = nachher
+        return vorher - nachher, nachher - vorher
+
     def feature_allowed(self, feature: str) -> bool:
         """Lizenzpflichtige Einzelfunktion.
 

packages/tesm-core/src/tesm_core/rbac/service.py

@@ -328,6 +328,83 @@ def ensure_presets(
     return created
 
 
+def unberuehrte_vorlagen_entfernen(
+    conn: sqlite3.Connection, tree: PermissionTree, presets: Sequence[RolePreset]
+) -> list[str]:
+    """Legt Vorlagengruppen in den Papierkorb -- aber nur unberuehrte.
+
+    Wird gebraucht, wenn eine Vorlage aus der Auslieferung verschwindet. Auf
+    einer frischen Installation entsteht sie dann gar nicht erst; auf einer
+    bestehenden steht sie in der Datenbank, und eine Migration, die sie einfach
+    loescht, nimmt einem Kunden womoeglich eine Gruppe weg, mit der er
+    arbeitet.
+
+    Darum diese fuenf Bedingungen, und alle fuenf muessen zutreffen:
+
+    * Die Gruppe stammt **aus der Auslieferung**: ihr ``preset_key`` ist der der
+      Vorlage. Diese Kennung setzt nur :func:`ensure_presets`; eine selbst
+      angelegte Gruppe hat sie nicht, auch wenn sie zufaellig denselben Namen
+      traegt. Ueber den Namen wird bewusst *nicht* gesucht -- sonst raeumte
+      dieser Schritt jemandem seine eigene Gruppe "Betrieb" weg.
+    * Sie heisst noch so, wie sie ausgeliefert wurde. Ein anderer Name heisst:
+      jemand hat sie uebernommen.
+    * Die Gruppe hat **keine Mitglieder**. Wer Mitglieder hat, wird benutzt.
+    * Ihre Rechte sind **unveraendert** die der Vorlage. Jede Abweichung heisst:
+      jemand hat sie angepasst, also ist sie seine, nicht unsere.
+    * Sie ist keine Systemgruppe.
+
+    Geloescht wird weich: die Gruppe liegt im Papierkorb und kommt mit einem
+    Klick zurueck. Gibt die Namen der einsortierten Gruppen zurueck.
+    """
+    entfernt: list[str] = []
+    gruppen = list_groups(conn)
+    for preset in presets:
+        gruppe = next(
+            (
+                g
+                for g in gruppen
+                if g.preset_key
+                and g.preset_key == preset.key
+                and g.name.lower() == preset.name.lower()
+            ),
+            None,
+        )
+        if gruppe is None or gruppe.is_system or gruppe.member_count:
+            continue
+        if set(gruppe.permissions) != set(tree.expand_preset(preset)):
+            continue
+        conn.execute("UPDATE groups SET deleted_at=? WHERE id=?", (_now(), gruppe.id))
+        entfernt.append(gruppe.name)
+    return entfernt
+
+
+def funktionsgruppe_anlegen(
+    conn: sqlite3.Connection, tree: PermissionTree, preset: RolePreset
+) -> int:
+    """Legt die Vollzugriffsgruppe an, falls sie fehlt, und gibt ihre Nummer.
+
+    Getrennt von :func:`funktionsgruppe_fuer_administratoren`, weil das zwei
+    verschiedene Dinge sind: hier entsteht nur die Gruppe, dort bekommt sie
+    **jeder** Administrator. Wer ein einzelnes Konto aufnehmen will -- etwa
+    das, das an der Kommandozeile entsteht --, braucht das erste ohne das
+    zweite; sonst faengt sich ein Administrator, der die Gruppe bewusst
+    abgelegt hat, sie beim naechsten Aufruf wieder ein.
+    """
+    zeile = Database.one(
+        conn, "SELECT id FROM groups WHERE name=? COLLATE NOCASE", (preset.name,)
+    )
+    if zeile is not None:
+        return int(zeile["id"])
+    cursor = conn.execute(
+        "INSERT INTO groups (name, description, is_system, is_default, preset_key, "
+        "created_at, updated_at) VALUES (?,?,0,0,?,?,?)",
+        (preset.name, preset.description, preset.key, _now(), _now()),
+    )
+    gruppe = int(cursor.lastrowid or 0)
+    _write_permissions(conn, gruppe, tree.expand_preset(preset))
+    return gruppe
+
+
 def funktionsgruppe_fuer_administratoren(
     conn: sqlite3.Connection, tree: PermissionTree, preset: RolePreset
 ) -> int:
@@ -345,20 +422,7 @@ def funktionsgruppe_fuer_administratoren(
 
     Gibt die Nummer der Gruppe zurueck.
     """
-    zeile = Database.one(
+    gruppe = funktionsgruppe_anlegen(conn, tree, preset)
-        conn, "SELECT id FROM groups WHERE name=? COLLATE NOCASE", (preset.name,)
-    )
-    if zeile is None:
-        cursor = conn.execute(
-            "INSERT INTO groups (name, description, is_system, is_default, preset_key, "
-            "created_at, updated_at) VALUES (?,?,0,0,?,?,?)",
-            (preset.name, preset.description, preset.key, _now(), _now()),
-        )
-        gruppe = int(cursor.lastrowid or 0)
-        _write_permissions(conn, gruppe, tree.expand_preset(preset))
-    else:
-        gruppe = int(zeile["id"])
-
     conn.executemany(
         "INSERT OR IGNORE INTO user_groups (user_id, group_id) VALUES (?,?)",
         [

packages/tesm-core/src/tesm_core/settings_store.py

@@ -58,6 +58,30 @@ class SettingSpec:
         return str(raw)
 
     def serialize(self, value: Any) -> str:
+        """Ein Wert als Text fuer die Datenbank.
+
+        Der Wert kann als Python-Wert kommen (aus einem Formular, aus dem
+        Code) -- oder als die Zeichenkette, die schon in der Datenbank stand.
+        Genau so liest eine **Sicherung** ihn wieder ein, und genau dort lag
+        ein stiller Fehler: ``serialize("0")`` ergab ``"1"``, weil jede nicht
+        leere Zeichenkette wahr ist. Aus jedem abgeschalteten Schalter wurde
+        beim Einspielen ein eingeschalteter -- auch aus
+        ``ldap_allow_insecure``. Ein JSON-Feld wurde ein zweites Mal kodiert,
+        und aus der Navigationsreihenfolge damit eine Zeichenkette.
+
+        Deshalb: eine Zeichenkette erst lesen. Was hier herauskommt, muss
+        durch ``serialize`` unveraendert hindurchgehen -- sonst ueberlebt kein
+        Wert eine Sicherung.
+        """
+        if isinstance(value, str):
+            if self.kind == "bool":
+                value = self.parse(value)
+            elif self.kind == "json":
+                try:
+                    value = json.loads(value)
+                except ValueError:
+                    # Kein JSON-Text, also ein Wert: dann wird er kodiert.
+                    pass
         if self.kind == "bool":
             return "1" if value else "0"
         if self.kind == "json":