Files
2026-10-30 15:10:26 +01:00

50 KiB
Raw Permalink Blame History

CMBNet Kartenanwendung Architektur

Als Technik verwendest du serverseitig Python3 mit Flask als Framework. Für das Frontend verwendest du reines Javascript (Vanilla Javascript). Als CSS-Framework für das Frontend kommt pico.css zum Einsatz. Weil die Webanwendung primär eine Kartenanwendung sein wird, wird leaflet als Javascript Bibliothek eingesetzt.

Die Zustände der Anwendung soll für die verschiedenen Clients mittels Websocket synchronisiert werden. Dazu muss im Server ein Routing implementiert werden, das Clients mit unterschiedlichen Accounts voneinander trennt und individuelle bedient. Für die Kommunikation mittels Websocket soll ein eigenes Protokoll implementiert werden, dass ID's für Sender und Empfänger, einen Code zur Unterscheidung verschiedener Nachrichtentypen, einen Zeitstempel und ein Textfeld für die Nachricht vorsieht. Zu Beginn der Websocketkommunikationn muss die Webseite sich nach dem Login über den Websocket selbst auch authentifizieren. Dazu ruft die Webseite nach dem Neuladen mittels AJAX die aktuellen Attribute aller Entitäten 1) und 2) ab und erhält mit diesem Request auch ein Zugriffstoken, den sie bei der Websocketkommunikation zur Authentifizierung verwendet.

Die Webanwendung soll mandantenfähig sein. Dazu soll im Datenmodell bei jeder Entität auch eine ID für den Mandanten vorgesehen sein. In der URL der jeweiligen Webzugriffe ist der Mandant codiert, Accounts beziehen sich eindeutig auf einen Mandanten.

Die Kartenansicht dient der Darstellung und Manipulation verschiedener Entitäten mit Attributen, deren Applikationslogik später entwickelt wird:

  1. Strassen a) ID b) Name c) State (mindestens: unbearbeitet, zugewiesen, erledigt) d) Verknüpfung mit einer Gruppe (1:1) oder null beim State "unbearbeitet" e) Hausnummer mininmal f) Hausnummer maximal g) Bounding Box (Geokoordinaten für Nordwest- und Südost-Ecke) im Format eines Javascript Arrays

  2. Gruppen a) ID b) State (offen, unterwegs, online, pausierend, fertig) c) Letzte geographische Position mit Datum und Uhrzeit d) Aliasname e) Verknüpfung mit Account (1:1)

  3. Accounts a) ID b) Name c) Rolle (Gast, Beobachter, Gruppe, Dispatcher, Administrator) d) Passwordhash

Von Beginn an soll ein Zugangsschutz mittels Accounts eingebaut sein.

Für einen Account mit der Rolle eines Administrators sind spezielle Views bzw. Webseiten aufrufbar, die ausschließlich der Verwaltung (Anlegen, Bearbeiten, Löschen) der verschiedenen Entitätstypen dienen:

  • Accountverwaltung: Nutzer anlegen mit Namen, Rolle, Passwordhash
  • Gruppenverwaltung: Anlegen, Attribute verändern, Gruppe löschen, mit einem oder mehreren Accounts verknüpfen
  • Strassenverwaltung: Hier soll mittels Dateiupload eine csv-Datei importiert werden, aus der die Entitäten extrahiert werden. Danach sollen hier auch einzelne Einträge editierbar sein und gelöscht werden können.

Alle Transaktionen auf diesen Entitäten sollen in ein Logfile lesbar mit Zeitstempel geschrieben werden.

Über State-Wechsel von 1) und 2) soll eine Historie mit Datum/Uhrzeit-Stempel geführt werden, die in der jeweiligen Verwaltungsseite aufrufbar ist. Durch Anklicken eines alten States soll dieser State wieder gültig werden, z.B. die geographische Position wird wieder darauf zurückgesetzt.

Alle Daten sollen mandantenfähig in einer SQLite3 Datenbank verwaltet werden.

Zur Administrierung der Entitäten sollen eigene Webseiten vorgesehen werden, die einem Account mit Administratorrechten das Anlegen, Löschen und Editieren erlauben.

Beschreibe zunächst in einer Architekturskizze, wie der grundsätzliche Aufbau des Projekts CMBNet mit diesen Vorgaben zur Darstellung unterschiedlicher Views aussehen wirfd.


Assistant

Architekturskizze: CMBNet

Dieses Dokument beschreibt den grundsätzlichen Aufbau der Webanwendung CMBNet gemäß den Anforderungen. Es werden Architekturentscheidungen, Modulzusammenhänge, Schnittstellen, Datenmodell und Ablaufdiagramme erläutert, bevor mit der Implementierung begonnen wird.

1. Ziele und Rahmenbedingungen

Anforderung Entscheidung
Server Python 3 + Flask
Frontend Reines Vanilla-JavaScript, pico.css, Leaflet
Realtime-Synchronisation WebSocket mit eigenem Protokoll und mandantenabhängigem Routing
Mandantenfähigkeit Tenant-ID in URL, Referenz auf Tenant in jeder Entität und Account
Zugriffsschutz Login mit Rollenmodell (Gast, Beobachter, Gruppe, Dispatcher, Administrator)
Verwaltung Separate Admin-Views für Accounts, Gruppen, Straßen
Historie & Logging State-Historie für Straßen/Gruppen, reversibel; transaktionales Logfile
Performance In-Memory-Caching für Gruppen (mit Invalidierung)
Kartenanwendung Leaflet mit Polylines aus str2pl.js, dynamische Marker für Gruppen

2. Projektstruktur

Der Code soll sauber strukturiert im Projektverzeichnis CMBNet/ abgelegt werden. Folgende Gliederung wird vorgeschlagen:

CMBNet/
├── app.py                    # Entrypoint, Flask-App-Initialisierung
├── config.py                 # Konfiguration (DB, Secret, Tenant-Defaults, Limits)
├── requirements.txt          # Abhängigkeiten (Flask, flask-sock/gevent/eventlet o.ä., ...)
├── wsgi.py                   # WSGI für Deployment
├── instance/                 # SQLite-DB, Laufzeitdateien (nicht versioniert)
├── logs/                     # Lesbare Transaktions-Logs
├── data/                     # Importvorlagen / Hilfsdaten (z. B. CSV)
├── migrations/               # Schema-Migrationen für SQLite
├── cmbnet/                   # Hauptpaket
│   ├── __init__.py           # create_app(), Blueprints, Erweiterungen
│   ├── extensions.py         # DB, WebSocket-Broker-Instanz, etc.
│   ├── auth/                 # Authentifizierung, Sessions, Token
│   ├── core/                 # Konstanten, Protokolldefinition, Fehlerklassen
│   ├── db/                   # DB-Verbindung, Schema, Hilfsfunktionen
│   ├── models/               # DAO/Repository für Entitäten
│   ├── services/             # Geschäftslogik (Streets, Groups, Accounts, History, Logging)
│   ├── api/                  # AJAX/REST-Handler (Initialdaten + Aktionen)
│   ├── ws/                   # WebSocket-Broker, Routing, Protokoll, Heartbeat
│   ├── views/                # View-Routen für Nicht-Admin
│   ├── admin/                # Admin-Routen & Handler
│   ├── utils/                # Helfer (CSV-Parsing, Geo, Zeit)
│   └── static/               # Statische Assets
│       ├── css/              # pico.css + eigene Styles
│       ├── js/               # Vanilla-JS
│       │   ├── lib/          # leaflet.js, ggf. pico.js (falls benötigt)
│       │   ├── core/         # ws_client.js, utils.js, state.js
│       │   ├── map/          # map.js, str2pl.js Integration
│       │   ├── views/        # dispatcher.js, gruppen.js, login.js, admin-*.js
│       │   └── str2pl.js     # Extern bereitgestelltes Polyline-Fragment (wie gefordert)
│       └── img/              # Icons/Symbole
├── templates/                # Jinja2-Templates
│   ├── base.html
│   ├── login.html
│   ├── dispatcher.html
│   ├── dispatcher_mobil.html
│   ├── gruppen.html
│   ├── praesentation.html
│   ├── oeffentlich.html
│   └── admin/
│       ├── accounts.html
│       ├── gruppen.html
│       └── strassen.html
└── README.md

Begründung: Trennung von Routen (views/, admin/, api/), Geschäftslogik (services/), Datenzugriff (models/), Echtzeit (ws/) und Frontend (static/js/views/) sorgt für Übersichtlichkeit und Erweiterbarkeit.


3. Mandantenfähigkeit & Routing

  • Tenant in URL: Alle relevanten Zugriffe laufen über /<tenant>/.... Der Tenant wird aus der URL extrahiert, validiert und im Request-Kontext (g.tenant_id) verfügbar gemacht.
  • Accounts mandantengebunden: accounts.tenant_id ist Pflicht, Login prüft (tenant_id, name) eindeutig.
  • Datenisolation: Alle Queries filtern konsequent nach tenant_id (Streets, Groups, Accounts, History, Messages).
  • Blueprints: auth_bp, views_bp, admin_bp, api_bp, ws_bp mit url_prefix='/<tenant>' bzw. tenant-Middleware.

4. Datenmodell (SQLite3)

Folgende Tabellen werden vorgeschlagen (Schlüsselideen). Genauere Typen/Indizes werden bei Implementierung finalisiert.

Tabelle Zweck Wesentliche Felder
tenants Mandantenstamm id (PK), code (z. B. BV/RV/SV), name, created_at
accounts Nutzer id (PK), tenant_id (FK), name, password_hash, role (ENUM/Gast/Beobachter/Gruppe/Dispatcher/Administrator), created_at, updated_at
groups Gruppen id (PK), tenant_id (FK), aliasname, state (offen/unterwegs/online/pausierend/fertig), last_lat, last_lon, last_pos_at (DATETIME), account_id (FK -> accounts, 1:1 wie gefordert), created_at, updated_at
streets Straßen id (PK), tenant_id (FK), name, state (unbearbeitet/zugewiesen/erledigt), group_id (FK -> groups, NULL wenn unbearbeitet), hn_min, hn_max, bbox (TEXT/JSON: [ [nwLon,nwLat],[seLon,seLat] ] oder Array), created_at, updated_at
street_state_history Historie Straßen id (PK), tenant_id, street_id (FK), from_state, to_state, group_id (vorher/nachher Kontext), actor_account_id (FK), reason, created_at (DATETIME)
group_state_history Historie Gruppen id (PK), tenant_id, group_id (FK), from_state, to_state, last_lat, last_lon, last_pos_at, actor_account_id, created_at
ws_tokens Zugriffstokens für WS-Auth id (PK), tenant_id, account_id, token (zufällig), session_id, expires_at, used (bool), created_at
ws_messages_store Persistenz für >=1000 (Late Entry) id (PK), tenant_id, sender_id, receiver_id (nullable für Broadcast/Gruppe), code (INT), ts (DATETIME/UNIX), msg (TEXT/JSON), delivered_to (JSON/rel), created_at
transaction_log Lesbares Transaktionslog id (PK), tenant_id, ts (DATETIME), actor_account_id, action, entity_type, entity_id, details (TEXT)

Anmerkungen:

  • bbox wird als JSON-String in SQLite abgelegt, beim Ausliefern an Frontend als JS-Array geparst.
  • Historieeinträge werden bei jedem State-Wechsel erzeugt. Revert setzt State zurück und schreibt neuen History-Eintrag (inkl. Kontext) gemäß "durch Anklicken alten States wieder gültig".
  • Transaktionen (CRUD an Accounts/Gruppen/Straßen) werden sowohl in transaction_log als auch lesbar in Logfile geschrieben (logs/cmbnet-YYYY-MM-DD.log).

5. Authentifizierung & Sessions

sequenceDiagram
  participant B as Browser
  participant FL as Flask (Auth)
  participant DB as SQLite
  participant S as Session/Store

  B->>FL: GET /<tenant>/login
  FL-->>B: login.html (Mandantenvorwahl RV/BV/SV)
  B->>FL: POST /<tenant>/login (name, password, tenant)
  FL->>DB: Account + tenant prüfen
  FL->>FL: password_hash gegen Password vergleichen
  alt Erfolg
    FL->>S: Session setzen (account_id, tenant_id, role, group_id?)
    FL-->>B: Redirect je nach Rolle (Dispatcher/Beobachter/Gruppen-View) oder next
  else Misserfolg
    FL-->>B: login.html + Fehlermeldung
  end
  • Passwortprüfung: Nur Hashvergleich (siehe Accounts-Service).
  • Weiterleitung: next-Parameter wird unterstützt. Ansonsten Rollenbasiert.
  • Zugriffsschutz: Decorators login_required, role_required([roles...]), tenant_required für alle geschützten Routen.
  • WS-Token: Nach Login/bei Initialload liefert AJAX-Endpoint /<tenant>/api/auth/ws-token ein zufälliges Token, das serverseitig kurzzeitig gespeichert (ws_tokens) und für WS-Auth benötigt wird.

6. WebSocket-Protokoll & Broker

6.1 Protokollformat

Jede Nachricht ist JSON mit folgendem Schema:

{
  "sender_id": 123,
  "receiver_id": 456,  // optional, je nach Code/Broadcast
  "code": 100,
  "ts": 1729612345678, // UNIX ms oder ISO8601; Broker setzt/validiert
  "msg": "{\"name\":\"Musterstraße\",\"state\":\"zugewiesen\",\"actor\":...}"
}
  • code < 100: nur intern, wird nicht in UI angezeigt
  • Zeitstempel wird serverseitig normalisiert
  • msg ist Freitext oder JSON (abhängig von Code)

6.2 Broker-Architektur

Der Broker verwaltet Verbindungen pro Tenant und Account.

graph TD
  subgraph Server
    B[WebSocket Broker]
    R[Routing-Engine]
    H[Handlers by Code]
    M[InMemory Groups]
    DB[(SQLite)]
    LOG[Logger]
  end

  C1[Dispatcher Client] --> B
  C2[Beobachter Client] --> B
  C3[Gruppen Client] --> B
  C4[Admin irrelevant für WS-Relay] --> B

  B --> R
  R --> H
  H --> M
  H --> DB
  H --> LOG
  H --> B

Komponenten:

  • ws/broker.py: Connection-Pool (connections[tenant_id][account_id] = ws), Auth-Flow (Code 0 + Token), Heartbeat (Code 1/2), Broadcast/Unicast
  • ws/router.py: Entscheidung Empfängerkreis je Nachrichtentyp
  • ws/handlers.py: Verarbeitung eingehender Codes
  • ws/protocol.py: Validierung, Serialisierung

6.3 Routing nach Nachrichtentypen

Code Auslöser Empfängerkreis Inhalt msg Persistenz
0 Client nach Connect Broker-intern (Auth) Token Nein
1 Server (zyklisch 1/min) Alle verbundenen Clients Ping/Markierung Nein
2 Client (Antwort auf 1) Nur Dispatcher-Views Pong/Antwort Nein
100 State-Wechsel Straße Alle Dispatcher, Gast, Beobachter + Gruppe, die mit Straße verknüpft ist (bei Zuweisung/Änderung) JSON {name, state, actor, street_id, group_id?} Nein (Echtzeit)
200 State-Wechsel Gruppe Alle Dispatcher, Beobachter + betroffene Gruppe JSON {group_id, state, actor} Nein
300 Positionswechsel Gruppe Verbundene Dispatcher, Beobachter + betroffene Gruppe JSON {group_id, lat, lon, ts, actor} Nein
1000 Dispatcher Alle Dispatcher, Beobachter, alle Gruppen (Broadcast) Freitext Ja (>=1000)
1100 Dispatcher Alle Dispatcher, Beobachter + spezielle Gruppe (Aliasname vorangestellt) Freitext mit Präfix Ja
2000 Gruppe Alle Dispatcher, Beobachter JSON {group_id, text} Ja

Heartbeatroutine: Server sendet code=1 jede Minute. Clients antworten code=2. code=2 wird ausschließlich an angeschlossene Dispatcher-Views weitergeleitet. Verbindungen ohne rechtzeitige Antwort können nach Timeout getrennt werden.

Late Entry: Bei Anmeldung am Broker werden nur für diesen Client berechtigte Nachrichten aus ws_messages_store mit ts >= now - 8h in chronologischer Reihenfolge zugestellt. Ältere Einträge werden gelöscht. Zuständigkeit für Löschung: Broker-Routine (z. B. bei Zustellung oder periodisch).

sequenceDiagram
  participant B as Browser
  participant BR as Broker
  participant DB as SQLite
  participant R as Router

  B->>BR: WS Connect
  B->>BR: {code:0, msg:"<token>", sender_id:...}
  BR->>BR: Token validieren (ws_tokens)
  alt gültig
    BR->>DB: Lade berechtigte gespeicherte Nachrichten (code>=1000, letzte 8h)
    BR->>B: Sende gespeicherte Nachrichten in Reihenfolge
    BR->>R: Registriere Connection (tenant,account,role,group_id)
  else ungültig
    BR->>B: Close Connection
  end

7. Backend-Module im Detail

7.1 models/ (DAO)

Abstraktionsschicht für CRUD. Jede Methode filtert nach tenant_id.

  • streets.py: get_all(), get_by_id(), create(), update(), delete(), import_from_csv_rows()
  • groups.py: primär über Service (In-Memory), aber DB-Zugriff hier
  • accounts.py: get_by_name_and_tenant(), get_by_id(), create(), update_role(), delete(), set_password_hash()
  • history.py: Historieneinträge lesen/schreiben
  • messages.py: Persistenz für Code>=1000 + Cleanup
  • log.py: Transaktionslog (DB + File)

7.2 services/ (Geschäftslogik)

  • streets_service.py
    • handle_initial_ajax(tenant_id, ...) -> JSON aller Straßenattribute inkl. State
    • update_street(street_id, changes, actor) -> DB-Update, History-Eintrag, Logging, Broker-Notify (Code 100 je nach Statewechsel)
  • groups_service.py (Kernstück)
    • In-Memory-Cache: groups_cache[tenant_id][group_id] = {...}
    • load_from_db(tenant_id): beim Start + bei Invalidierung
    • invalidate(tenant_id): erzwingen Neuladen (z. B. Admin-Änderung)
    • is_account_linked(account_id, group_id)
    • get_accounts_for_group(group_id)
    • get_streets_for_group(group_id)
    • handle_initial_ajax(...)
    • update_group(...), set_position(...), change_state(...) -> DB + Cache + History + Broker (200/300)
  • accounts_service.py
    • verify_password(account, password) (Hashvergleich)
    • has_role(account, roles)
    • issue_ws_token(account, session)
  • history_service.py: Revert-Funktion (lädt alten Snapshot, setzt Entität zurück, schreibt neuen History-Eintrag)

7.3 api/ (AJAX)

Endpoints für Initialload und Aktionen:

Endpoint Methode Zweck
/<tenant>/api/init/streets GET Liste Straßen (inkl. State, group_id)
/<tenant>/api/init/groups GET Liste Gruppen (inkl. State, Position, last_pos_at)
/<tenant>/api/auth/ws-token GET/POST Token für WS-Auth erzeugen
/<tenant>/api/streets/<id>/state POST State-Wechsel Straße (Dispatcher/Gruppen-Kontext)
/<tenant>/api/groups/<id>/state POST State-Wechsel Gruppe
/<tenant>/api/groups/<id>/position POST Position setzen (Gruppen-View)

Antworten sind JSON. CSRF-Schutz gemäß Flask-Konzept (oder passende Maßnahme).

7.4 admin/

Nur für Rolle Administrator. Validierung serverseitig.

  • accounts: Liste, Rolle ändern (AJAX), Passwort-Reset (Modal), Anlegen (Modal), Löschen (mit Rückfrage)
  • gruppen: Liste, State ändern, Account verknüpfen/ändern, Position manuell/aus Historie zurücksetzen/löschen, Anlegen, Löschen, Historie-Anzeige + Revert
  • strassen: Tabelle editierbar, Modal Edit, Modal Neu, Löschdialog, CSV-Import (Upload multipart/form-data, Delimiter ;, Spalten Name, Hausnummer minimal, Hausnummer maximal, Bounding Box). Import erzeugt Einträge mit State unbearbeitet, group_id = NULL. Jede Änderung triggert Transaktionslog + bei State-Wechsel Broker-Code 100.

CSV-Import: Parsing robust (Quotes/Encoding). bbox wird validiert und als JSON für Frontend normalisiert.

7.5 ws/ Ablauf Code 0 Auth

  1. Client sendet {code:0, msg: token, sender_id: account_id}
  2. Broker sucht Token in ws_tokens (tenant, account, nicht genutzt, nicht abgelaufen)
  3. Bei Erfolg: markiert genutzt/erstellt Session-Mapping, führt Late-Entry durch, registriert Connection in Routing-Tabellen
  4. Bei Misserfolg: schließt Verbindung

8. Frontend-Architektur

8.1 Templates

  • base.html: Grundgerüst, pico.css, Leaflet CSS/JS, gemeinsame Skripte
  • login.html: Formular Name/Passwort + Select Mandant (BV/RV/SV, Default RV)
  • View-Templates binden view-spezifisches JS ein

8.2 JS-Module

Datei Aufgabe
core/ws_client.js WebSocket-Verbindung, Reconnect, Senden/Empfangen, Heartbeat-Handling (Code 1 -> Code 2)
core/utils.js Helper, Formatierung Zeit/Datum, LocalStorage
core/state.js Gemeinsamer State (streetsDict, groupsDict, token, tenant)
map/map.js Leaflet-Initialisierung, Bounds, Tiles (OSM/Luftbild), Marker/Polylines, Events
map/str2pl_integration.js Lädt str2pl.js, baut Strasse2Polylines, rendert Polylines nach State
views/dispatcher.js Dispatcher-View Logik (Accordion, Position, Code 1000/1100, Opacity/Weight, Timer)
views/gruppen.js Gruppen-View (State-Wechsel, Position setzen, Nachrichten)
views/praesentation.js / oeffentlich.js Nur Darstellung + Suche, keine Modifikation
views/dispatcher_mobil.js Mobiloptimiert, selektive Darstellung
views/admin_*.js Admin-Interaktionen (Modals, AJAX, CSV-Upload)
views/login.js Client-seitige Validierung falls gewünscht

8.3 str2pl.js

Wird als separates JS-Fragment unter static/js/str2pl.js bereitgestellt. Erwartetes Format (konzeptionell):

// Beispielhaft
window.STRASSE2POLYLINES = {
  "Musterstraße": [
    [[7.1234, 50.1234],[7.1235,50.1235]],
    [[7.1235,50.1235],[7.1236,50.1236]]
  ],
  // ...
};

map/str2pl_integration.js iteriert über Einträge, erzeugt L.polyline pro Segment, speichert Referenz in Strasse2PolylinesMap[streetName] = [polyline1,...] für spätere Farbupdates bei Code 100.

8.4 Initialisierungsreihenfolge (Dispatcher-Prototyp)

sequenceDiagram
  participant B as Browser
  participant API as Flask API
  participant WS as WebSocket Broker

  B->>B: DOM ready
  B->>API: GET /<tenant>/api/init/streets
  API-->>B: streets[]
  B->>API: GET /<tenant>/api/init/groups
  API-->>B: groups[]
  B->>API: GET /<tenant>/api/auth/ws-token
  API-->>B: {token: "..."}
  B->>B: build Polylines + Marker
  B->>B: fitBounds auf alle bbox
  B->>WS: connect ws://.../<tenant>/ws
  B->>WS: {code:0, sender_id, msg: token}
  WS-->>B: late entries (falls vorhanden)
  B->>B: start Timer (Uhrzeit, Progressbars)

8.5 Kartenlogik

  • Bounds: Union aller bbox von Straßen -> L.latLngBounds
  • LocalStorage: cmbnet:<tenant>:map speichert {center:[lat,lng], zoom, opacity, weight}
  • Tiles: OSM + optional Luftbild (Layer-Control)
  • Polylines: Farbe nach State (unbearbeitet blau, zugewiesen rot, erledigt grün), opacity, weight konfigurierbar
  • Klick Polyline: Modal State-Wechsel je Übergang (wie 156-161), sendet Code 100 via API/WS-Pfad
  • Gruppen-Marker: individuelle Farben, Position aus last_lat/lon oder Browser-Geolocation bei unbekannt
  • Code 100: Aktualisiert Farbe aller Segmente betroffener Straße
  • Code 200/300: Aktualisiert Accordion + Marker

8.6 Kontrollansicht (Dispatcher)

  • Header: Wochentag/Datum (klein), Uhrzeit (groß), sekundengenau aktualisiert
  • Dropdown: Kartenhintergrund
  • Lautsprecher: Modal Freitext -> Code 1000
  • Zentral: Accordion pro Gruppe, Kreis Farbe, State, Position-Button, Progressbar (Zeitdiff), Fadenkreuz-Modus (Klick setzt Position -> Code 300), Nachrichtenfeld (Code 2000), Chat-Dialog für >=1000
  • Footer: Opacity-Slider (0-1 step 0.05), Weight-Slider (1-100), Fit-Bounds-Button, Exit -> Logout

Progressbar-Berechnung: diff = now - last_pos_at. 100% < 60s, 0% >= 3600s, linear dazwischen. >3600s -> Button inaktiv.

Fadenkreuz-Modus: Cursor-Wechsel, ESC oder erneuter Button-Abbruch, Klick -> API set_position + WS Code 300.

8.7 Views nach Anforderung

View Zielgerät Darstellung Interaktion
Login-View Alle Login-Formular Authentifizierung, Redirect
Dispatcher-View Desktop Karte 2/3 + Kontrollansicht 1/3 Voll (State-Wechsel, Nachrichten, Position)
Dispatcher-Mobil-View Smartphone Optimiert, selektiv Ähnlich reduziert
Gruppen-View Smartphone Für Gruppenaccount Nur eigene Gruppe, State-Wechsel, Position, Nachrichten
Präsentations-View Alle Alle Infos Nur Suche, keine Modifikation
Öffentlicher-View Alle Wie Präsentation, ohne Gruppen Nur Suche

9. Wichtige Abläufe (Diagramme)

9.1 State-Wechsel Straße (Dispatcher klickt Polyline)

sequenceDiagram
  participant B as Browser (Map)
  participant API as API Handler
  participant S as StreetsService
  participant DB as SQLite
  participant BR as Broker
  participant CL as Clients

  B->>API: POST state change (street_id, to_state, group_id)
  API->>S: update_street(...)
  S->>DB: UPDATE streets + INSERT history + INSERT log
  S->>BR: publish Code 100 (an berechtigte)
  BR->>CL: Code 100 an Dispatcher/Gast/Beobachter + verknüpfte Gruppe
  CL->>CL: Farbe Polyline aktualisieren

9.2 Gruppenposition setzen (Gruppen-View / Fadenkreuz)

sequenceDiagram
  participant B as Browser
  participant API as API
  participant GS as GroupsService
  participant DB as SQLite
  participant BR as Broker

  B->>API: POST /groups/<id>/position {lat,lng}
  API->>GS: set_position(...)
  GS->>DB: UPDATE groups + INSERT history
  GS->>GS: Cache aktualisieren
  GS->>BR: publish Code 300
  BR-->>B: Code 300 -> Marker + UI aktualisieren

9.3 Admin CSV-Import

sequenceDiagram
  participant B as Browser (Admin)
  participant API as Admin API
  participant U as CSV Parser
  participant SS as StreetsService
  participant DB as SQLite

  B->>API: POST multipart (file)
  API->>U: parse ';' -> rows
  loop jede Zeile
    U->>SS: create street (unbearbeitet, group_id NULL)
    SS->>DB: INSERT street + log
  end
  API-->>B: Ergebnis + aktualisierte Tabelle

10. Logging, Historie & Revert

  • Transaktionslog: Alle schreibenden Aktionen (Anlegen/Bearbeiten/Löschen Accounts/Gruppen/Straßen, CSV-Import, State-Wechsel, Position, Rolle ändern) werden protokolliert: timestamp, tenant, actor_id, action, entity_type, entity_id, details. Zusätzlich lesbares Logfile in `logs

Assistant

Fortsetzung der Architekturskizze: CMBNet

10. Logging, Historie & Revert

10.1 Transaktionslog

Jede schreibende Transaktion muss sowohl in einer maschinenlesbaren Datenbanktabelle, als auch in einem menschenlesbaren Logfile protokolliert werden.

Ziel Umsetzung
Datenbank Tabelle transaction_log mit ts, tenant_id, actor_account_id, action, entity_type, entity_id und details (als JSON-String für eine strukturierte Auswertung).
Logfile Tagesbasiert unter logs/cmbnet-YYYY-MM-DD.log. Jedes Logformat soll folgende Felder beinhalten: Timestamp, Tenant, Actor (Account-ID + Name), Aktion, Entitätstyp, Entitäts-ID, Details.
Auslöser CRUD für Accounts, Gruppen und Straßen, CSV-Import, State-Wechsel, Positionsänderungen, Rollenänderungen, Passwort-Resets sowie das Setzen/Löschen einer Gruppenposition.

Beispielhafter Logeintrag:

2026-10-22 14:32:18.542 [TENANT:RV] [ACTOR:42(DispatcherMax)] ACTION:street.state_change ENTITY:street:123 DETAILS:{"from":"unbearbeitet","to":"zugewiesen","group_id":5}

10.2 State-Historie

Für Straßen und Gruppen wird eine lückenlose Historie aller relevanten Zustandsänderungen geführt.

Tabelle Zweck Gespeicherter Snapshot
street_state_history Historie für Straßen from_state, to_state, group_id (Kontext zum Zeitpunkt des Wechsels), actor_account_id, reason, created_at
group_state_history Historie für Gruppen from_state, to_state, last_lat, last_lon, last_pos_at (vollständiger Positionssnapshot), actor_account_id, created_at
  • Erzeugung: Bei jedem validierten State-Wechsel wird automatisch ein neuer Historieneintrag erzeugt, bevor oder im selben Datenbank-Commit wie das Update der Entität.
  • Anzeige: In den jeweiligen Verwaltungsseiten (Gruppenverwaltung, Straßenverwaltung) ist eine Historieansicht pro Eintrag aufrufbar. Diese wird chronologisch absteigend dargestellt.
  • Transparenz: Jeder Eintrag zeigt Zeitpunkt, auslösenden Account, vorherigen und neuen Zustand sowie den zum Wechsel gehörenden Kontext (z. B. verknüpfte Gruppe oder Positionssnapshot).

10.3 Revert von historischen Zuständen

Über das Anklicken eines historischen Eintrages soll der Zustand der Entität wiederhergestellt werden können. Dies ist bewusst als neuer Übergang, nicht als bloßes Überschreiben ohne Nachverfolgung, umgesetzt.

sequenceDiagram
    participant B as Browser (Admin-View)
    participant A as Admin-API
    participant H as HistoryService
    participant S as StreetsService/GruppenService
    participant DB as SQLite
    participant BR as Broker

    B->>A: POST /<tenant>/admin/<entity>/<id>/history/<hist_id>/revert
    A->>H: revert(entity_type, hist_id, actor)
    H->>DB: Lade historischen Snapshot
    H->>S: Erstelle Transition (aktueller -> historischer State)
    S->>DB: UPDATE Entität + INSERT neue History-Zeile + INSERT transaction_log
    alt Straße
        S->>BR: Publish Code 100 (an berechtigte Clients)
    else Gruppe
        S->>DB: Aktualisiere Gruppen-Cache
        S->>BR: Publish Code 200 und/oder Code 300 (abh. von Snapshot)
    end
    S-->>A: Erfolg
    A-->>B: Aktualisierte UI (Tabelle + Historie)

Regeln für den Revert:

  • Nur Administratoren: Der Revert ist ausschließlich für Accounts mit der Rolle Administrator freigegeben und wird serverseitig validiert.
  • Neuer History-Eintrag: Durch den Revert wird kein Eintrag entfernt. Es wird stattdessen ein neuer Eintrag in der Historie geschrieben, der den Übergang vom aktuellen Zustand zum wiederhergestellten Zustand abbildet.
  • Positionswiederherstellung: Für Gruppen wird bei einem Revert eines Positions-Snapshots sowohl last_lat, last_lon, last_pos_at wiederhergestellt, als auch eine Code-300-Nachricht über den Broker ausgelöst, um Marker und UI aller berechtigter Clients zu synchronisieren.
  • Gruppenverknüpfung: Bei Straßen wird group_id anhand des historischen Kontextes wiederhergestellt. Ist der wiederherzustellende Zustand unbearbeitet, wird group_id auf NULL gesetzt.
  • Konsistenz: Nach einem Revert wird der In-Memory-Cache der Gruppen invalidiert (sofern betroffen) und das Transaktionslog entsprechend aktualisiert.

11. Sicherheit

Da die Anwendung Zugangsschutz, Mandantenfähigkeit und Echtzeitkommunikation kombiniert, werden folgende Maßnahmen konsequent umgesetzt.

Bereich Maßnahme Begründung
Authentifizierung Nur Passwort-Hash-Vergleich über einen etablierten Hash-Algorithmus (z. B. werkzeug.security mit generate_password_hash/check_password_hash) Niemals Klartextpasswörter speichern
Sessions Flask-Sessions mit HttpOnly, Secure (in Produktion), SameSite=Lax/Strict Schutz vor Session-Hijacking und CSRF-ähnlichen Angriffen
Autorisierung Serverseitige Decorators (login_required, role_required, tenant_required) für alle geschützten Routen und Aktionen Client-seitige Prüfungen sind niemals ausreichend
Mandantenisolation Filterung sämtlicher DB-Queries nach tenant_id, Prüfung beim Routing und bei jedem Broker-Zugriff Verhindert Cross-Tenant-Zugriff
WebSocket-Auth Einmalig nutzbarer, kurzlebiger Token (Code 0), Speicherung in ws_tokens mit used-Flag und optionalem expires_at Verhindert Missbrauch von Tokens
CSRF CSRF-Schutz für alle POST/PUT/PATCH/DELETE Requests (AJAX und Formulare) Schutz vor Cross-Site-Request-Forgery
Input-Validierung Serverseitige Validierung für alle Formulare, AJAX-Payloads und CSV-Import Robustheit und Integrität der Daten
Datei-Upload Nur .csv zulassen, Dateigröße begrenzen, Delimiter explizit ; erzwingen, Inhalte parsen und validieren Verhindert unerwartete Dateien und fehlerhafte Importe
SQL-Injection Ausschließlich parametrisierte Queries über den DB-Layer Vermeidung von SQL-Injection
XSS Jinja2-Autoescaping aktiv, keine Einbettung ungeprüften HTMLs im Frontend Schutz vor Cross-Site-Scripting
Logging sensibler Daten Keine Passwörter, Tokens oder sensiblen Rohdaten in Logs Vermeidung von Credential-Leaks

12. Konfiguration, Abhängigkeiten & Start

12.1 Abhängigkeiten (requirements.txt)

Folgende Pakete werden für den ersten Entwicklungsstand vorgeschlagen:

Flask>=3.0.0
Werkzeug>=3.0.0
flask-sock>=0.7.0
simple-websocket>=1.0.0
python-dateutil>=2.9.0

Hinweis: Je nach Deployment kann gevent oder eventlet für produktivere WebSocket-Verbindungen ergänzt werden. Für den Entwicklungsserver ist flask-sock in Kombination mit dem Flask-Dev-Server ausreichend.

12.2 Konfiguration (config.py)

Zentrale Konfigurationspunkte:

Variable Zweck Default (Dev)
SECRET_KEY Session-Verschlüsselung Aus Umgebungsvariable laden
DATABASE_PATH Pfad zur SQLite-DB instance/cmbnet.sqlite3
TENANTS Erlaubte Mandanten ["BV", "RV", "SV"]
DEFAULT_TENANT Vorbelegung Login "RV"
WS_HEARTBEAT_INTERVAL Intervall für Code 1 60 Sekunden
WS_HEARTBEAT_TIMEOUT Timeout für Code 2 Antwort 15 Sekunden
LATE_ENTRY_MAX_AGE_HOURS Max. Alter für gespeicherte Nachrichten 8 Stunden
LOG_DIR Verzeichnis für Transaktionslogs logs/
MAX_CSV_SIZE_BYTES Upload-Limit z. B. 5_000_000

12.3 Initialisierung & Start des Entwicklungsservers

Vor dem ersten Start müssen Verzeichnisse angelegt und das Datenbankschema initialisiert werden.

# Ins Projektverzeichnis wechseln
cd CMBNet

# Virtuelles Environment erstellen und aktivieren
python3 -m venv .venv
source .venv/bin/activate  # macOS/Linux
# .\.venv\Scripts\activate   # Windows

# Abhängigkeiten installieren
pip install -r requirements.txt

# Benötigte Verzeichnisse anlegen
mkdir -p instance logs data migrations

# Datenbank initialisieren (über CLI-Command der App)
flask --app cmbnet init-db

# Entwicklungswebserver starten
flask --app cmbnet run --debug --host 127.0.0.1 --port 5000

Anschließend ist die Anwendung unter http://127.0.0.1:5000 erreichbar. Der Zugriff erfolgt mandantenspezifisch über http://127.0.0.1:5000/<tenant>/login (z. B. /RV/login).

Hinweis: app.py bzw. das create_app() in cmbnet/__init__.py muss den CLI-Befehl init-db registrieren, um das Schema aus migrations/ bzw. cmbnet/db/schema.sql anzuwenden.

13. Implementierungsreihenfolge

Um Komplexität beherrschbar zu halten, wird eine schrittweise Umsetzung empfohlen:

Phase Fokus Ziel
Phase 0: Grundgerüst Projektstruktur, Config, DB-Verbindung, Blueprints Laufende Flask-App ohne Businesslogik
Phase 1: Datenmodell & Auth Schema für alle Tabellen, Accounts-Service, Login-View, Rollen-/Tenant-Decorators Funktionsfähiger Login mit Mandantenwahl
Phase 2: Entitätenbasis Models/Services für Streets, Groups, Accounts. In-Memory-Cache für Gruppen inkl. Invalidierung Datenzugriffsschicht steht
Phase 3: WebSocket-Broker Protokoll, Routing, Auth (Code 0), Heartbeat (1/2), Late-Entry, Persistenz für >=1000 Realtime-Grundgerüst funktionsfähig
Phase 4: Admin-Views Account-, Gruppen- und Straßenverwaltung, CSV-Import, Historie + Revert, Transactionlog Vollständige Administration
Phase 5: Karten-Views Login-Flow finalisieren, Dispatcher-Prototyp (Karte + Accordion), str2pl.js Integration, Polylines/Marker, Code 100/200/300 Erster funktionsfähiger Kartenprototyp
Phase 6: Weitere Views Dispatcher-Mobil, Gruppen-View, Präsentations-View, Öffentlicher-View Abdeckung aller geforderter Views
Phase 7: Feintuning Logging, Cleanup alter Nachrichten, LocalStorage, Responsiveness, Fehlerbehandlung Stabilisierung für den Entwicklungsstand

14. Fazit

Der hier beschriebene Aufbau trennt klar zwischen Datenzugriff, Geschäftslogik, Echtzeitkommunikation und Frontend. Durch das mandantenfähige Datenmodell, das eigene WebSocket-Protokoll mit Routing nach Account/Rolle/Gruppenverknüpfung, den In-Memory-Cache für Gruppen, die reversible State-Historie und das ausführliche Transaktionslogging wird bereits im Grundgerüst die geforderte Erweiterbarkeit für die später noch hinzuzufügende Applikationslogik geschaffen.

Der nächste logische Schritt ist die Umsetzung nach obiger Phasenreihenfolge, beginnend mit Phase 0 und Phase 1, direkt auf Basis dieses Konzepts.


User

Beginne mit Phase 0 und 1


Assistant

Ich beginne mit Phase 0 und 1. Ich erstelle zunächst die Projektstruktur gemäß der Architekturskizze und lege das Grundgerüst für Flask, Datenbank, Authentifizierung und Mandantenfähigkeit an.


Assistant

Die Grundstruktur für Phase 0 und 1 ist erstellt. Ich habe folgende Komponenten angelegt:

Phase 0 - Grundgerüst:

  • Projektstruktur nach Architekturskizze
  • config.py mit Mandanten (BV/RV/SV), WS-Konfiguration
  • Flask-App-Factory in cmbnet/__init__.py
  • Datenbankverbindung und Schema in migrations/schema.sql für alle Entitäten
  • CLI-Befehl flask --app app init-db

Phase 1 - Datenmodell & Auth:

  • Alle Tabellen nach Anforderungen (tenants, accounts, groups, streets, Historien, ws_tokens, ws_messages_store, transaction_log)
  • Authentifizierung mit Passwort-Hash (werkzeug.security)
  • Rollenbasierte Decorators
  • Login-View mit Mandantenauswahl
  • Basis-Views für alle geforderten View-Typen
  • Admin-Views Grundgerüst

Startbefehl:

cd CMBNet
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
mkdir -p instance logs
flask --app cmbnet init-db
flask --app cmbnet run --debug --host 127.0.0.1 --port 5000

Nach Initialisierung müssen noch Mandanten und Admin-Account in der DB angelegt werden. Die Anwendung ist unter http://127.0.0.1:5000 erreichbar.


User

Wie geht es weiter?


Assistant

Kurz: Weiter mit Phase 2 – Entitätenbasis.

Aktuell steht das Grundgerüst (Phase 0) und Auth + Datenmodell (Phase 1). Als Nächstes brauchen wir die Datenzugriffsschicht, die Geschäftslogik und vor allem den In-Memory-Cache für Gruppen, wie er in der Skizze gefordert ist.

Aktueller Stand

  • Phase 0: Projektstruktur, config.py, Flask-App-Factory, DB-Verbindung, Schema, Blueprints
  • Phase 1: Login mit Mandantenauswahl, Rollen, Admin-Grundgerüst, Basis-Views

Nächster Schritt: Phase 2 - Entitätenbasis

Ziel dieser Phase ist, dass Streets, Groups und Accounts sauber über Models/Services angesprochen werden können. Außerdem wird der geforderte Gruppen-Cache implementiert.

Geplante Module

Modul Aufgabe
cmbnet/models/ DAO-Schicht. Nur lesende/schreibende DB-Zugriffe, konsequent gefiltert nach tenant_id. (accounts.py, groups.py, streets.py)
cmbnet/services/groups_service.py Kernstück. Hält Gruppen im Speicher (groups_cache[tenant_id][group_id] = {...}), lädt beim Start/Invalidierung aus DB, bietet Hilfsfunktionen (is_account_linked, get_accounts_for_group, get_streets_for_group)
cmbnet/services/streets_service.py Handler für AJAX-Initialdaten, update_street, State-Wechsel inkl. History/Logging (Basis)
cmbnet/services/accounts_service.py Passwortvergleich, Rollenprüfung, Token-Vorbereitung
cmbnet/api/ AJAX-Endpoints für den Frontend-Initialload (/api/init/streets, /api/init/groups) + später ws-token

Reihenfolge der Umsetzung

Ich würde genau so vorgehen:

  1. Models anlegen – accounts.py, groups.py, streets.py mit tenant-gebundenen CRUD-Methoden
  2. Services anlegen – vor allem groups_service mit In-Memory-Cache + load_from_db() + invalidate()
  3. API-Blueprint erstellen – Endpunkte für den Initialload (entspricht Punkt 1)b) und 2)f) aus der Aufgabenstellung)
  4. Cache initialisieren – Gruppen beim App-Start bzw. beim ersten Zugriff laden
  5. Blueprint registrieren – api_bp in cmbnet/__init__.py einbinden

Testbare Zwischenziele

Nach Phase 2 soll Folgendes funktionieren:

  • GET /<tenant>/api/init/streets liefert alle Straßen des Mandanten inkl. State/Gruppe
  • GET /<tenant>/api/init/groups liefert Gruppen aus dem In-Memory-Cache (inkl. letzter Position/State)
  • Gruppen-Cache lässt sich gezielt invalidieren (wird später für Admin-Änderungen benötigt)
  • Datenzugriff läuft ausschließlich über Models/Services, nicht direkt in Views

Loslegen

Ich starte jetzt direkt mit Phase 2. Zuerst erstelle ich models/, services/ und api/, implementiere den Gruppen-Cache und die beiden Initial-Endpoints. Anschließend registriere ich den API-Blueprint und teste kurz die Struktur.

Sobald das Grundgerüst für Phase 2 steht, gehen wir direkt zu Phase 3: WebSocket-Broker über, da dort das eigene Protokoll, Routing und Auth (Code 0) dran sind.


User

Mach weiter mit Phase 2 und 3 in einem.


Assistant

Phase 2 und 3 sind in einem umgesetzt.

Phase 2 - Entitätenbasis:

  • Models: accounts.py, groups.py, streets.py mit tenant-gebundenen CRUD-Operationen
  • Services: GroupsService mit In-Memory-Cache (groups_cache[tenant_id][group_id]), load_from_db(), invalidate(), Hilfsfunktionen is_account_linked, get_accounts_for_group, get_streets_for_group
  • StreetsService für Initial-Load und Updates mit History/Logging
  • API-Endpoints: GET /<tenant>/api/init/streets, GET /<tenant>/api/init/groups, GET /<tenant>/api/auth/ws-token

Phase 3 - WebSocket-Broker:

  • Eigenes Protokoll mit sender_id, receiver_id, code, ts, msg
  • Broker mit mandantenabhängigem Routing nach Rolle/Gruppenverknüpfung
  • Code 0 Authentifizierung über Token
  • Heartbeat-Routine (Code 1/2) - Code 2 nur an Dispatcher
  • Persistierung für Code >= 1000 mit Late-Entry (max 8h)
  • Routing für Codes 100, 200, 300, 1000, 1100, 2000

Start:

cd CMBNet
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
flask --app cmbnet init-db
flask --app cmbnet run --debug --host 127.0.0.1 --port 5000

Danach Mandanten und Admin-Account in instance/cmbnet.sqlite3 anlegen. WebSocket erreichbar unter ws://127.0.0.1:5000/<tenant>/ws. API-Endpoints unter /<tenant>/api/init/*.


User

Wie legen ich einen Admin-Account an?


Assistant

Kurz: Du legst Mandanten und den Admin direkt in der SQLite-DB an. Am einfachsten geht das über sqlite3 + einen generierten Passwort-Hash.

1) Datenbank initialisieren

Falls noch nicht geschehen:

cd /Users/thomas/Src/Sternsinger/CMBNet
flask --app app init-db

2) Passwort-Hash erzeugen

Erzeuge dir einen Hash für dein gewünschtes Passwort. Hier beispielhaft für admin123:

cd /Users/thomas/Src/Sternsinger/CMBNet
python3 -c "from werkzeug.security import generate_password_hash; print(generate_password_hash('admin123'))"

Kopiere die komplette Ausgabe (beginnt z. B. mit pbkdf2:sha256:...).

3) Mandanten und Admin-Account anlegen

Öffne jetzt die Datenbank:

sqlite3 instance/cmbnet.sqlite3

Füge dann folgende SQL-Befehle ein. Ersetze <DEIN_HASH> mit dem eben kopierten Hash:

-- Mandanten anlegen (falls noch nicht vorhanden)
INSERT OR IGNORE INTO tenants (code, name) VALUES ('BV', 'Bezirk BV');
INSERT OR IGNORE INTO tenants (code, name) VALUES ('RV', 'Bezirk RV');
INSERT OR IGNORE INTO tenants (code, name) VALUES ('SV', 'Bezirk SV');

-- Admin für Mandant RV anlegen
INSERT INTO accounts (tenant_id, name, password_hash, role)
VALUES ((SELECT id FROM tenants WHERE code = 'RV'), 'admin', '<DEIN_HASH>', 'Administrator');

-- Prüfen
SELECT a.id, a.name, a.role, t.code AS tenant
FROM accounts a
JOIN tenants t ON a.tenant_id = t.id;

.quit

4) Einloggen

Starte den Server (falls noch nicht laufend):

flask --app app run --debug --host 127.0.0.1 --port 5000

Dann öffne im Browser:

http://127.0.0.1:5000/RV/login

Benutzername: admin, Passwort: admin123 (oder das, das du in Schritt 2 genutzt hast).

Nach dem Login wirst du direkt zur Accountverwaltung weitergeleitet, da der Account die Rolle Administrator hat.


User

Kannst du die Schritte auf der Kommandozeile in ein python Script verwandeln, dass das Passwort vom Nutzer abfragt?


Assistant

Fertig. Das Script create_admin.py fragt jetzt interaktiv nach Mandant, Benutzername, Passwort und Rolle und legt den Account direkt in der SQLite-DB an.

Nutzung

cd /Users/thomas/Src/Sternsinger/CMBNet
python3 create_admin.py

Das Script:

  1. Prüft, ob die Datenbank existiert (sonst Hinweis auf flask --app cmbnet init-db)
  2. Zeigt verfügbare Mandanten an und erstellt sie bei Bedarf
  3. Fragt nach Mandant, Benutzername, Passwort (mit Bestätigung) und Rolle (Standard: Administrator)
  4. Prüft, ob der Account bereits existiert
  5. Erstellt den Passwort-Hash mit werkzeug.security.generate_password_hash
  6. Legt den Account in der Datenbank an

Danach kannst du dich wie gewohnt unter http://127.0.0.1:5000/<tenant>/login einloggen.


User

Bei der Ausführung erhalte ich aber den Fehler: TypeError: login() got an unexpected keyword argument 'tenant'


Assistant

Der Fehler tritt auf, weil das Blueprint mit url_prefix='/<tenant>' registriert ist. Flask übergibt dann tenant als URL-Parameter, aber die View-Funktion login() akzeptiert keine Parameter. Wir müssen die Funktion entsprechend anpassen.


Assistant

Der Fehler kommt daher, dass das Blueprint mit url_prefix='/<tenant>' registriert ist und Flask tenant als URL-Parameter an alle View-Funktionen übergibt. Die meisten unserer View-Funktionen akzeptieren aktuell keine Parameter.

Ich korrigiere das, indem ich allen relevanten Routen **kwargs hinzufüge.


Assistant

Der Fehler liegt daran, dass auth.login_select unter dem Blueprint mit url_prefix='/<tenant>' läuft. Flask erwartet daher den tenant Parameter auch für url_for('auth.login_select', ...).

Ich korrigiere das in den Templates.


Assistant

Der Login funktioniert jetzt. Der Fehler ist behoben.

Für das Anlegen eines Admin-Accounts nutzt du einfach das erstellte Script:

cd /Users/thomas/Src/Sternsinger/CMBNet
python3 create_admin.py

Dann Server starten und einloggen:

flask --app app run --debug --host 127.0.0.1 --port 5000
# http://127.0.0.1:5000/RV/login

User

Es scheint soweit zu funktionieren. Jetzt werden die nächsten Phasen implementiert.


Assistant

Okay. Wir gehen weiter mit Phase 4: Admin-Views komplett umsetzen, und parallel schon erste Bausteine für Phase 5 (Kartenprototyp) mit vorbereiten.

Ziel Phase 4

Gemäß Anforderung sollen die drei Verwaltungsviews voll funktionsfähig werden:

View Funktionen
Accountverwaltung Liste, Rolle ändern (AJAX), Passwort zurücksetzen (Modal), Neuanlage (Modal), Löschen mit Sicherheitsabfrage
Gruppenverwaltung Liste, State ändern, Account verknüpfen, Position aus Historie setzen/löschen, Anlegen, Löschen, Historie einsehen + Revert
Straßenverwaltung Inline/Edit-Modal, Neuanlage, Löschen mit Sicherheitsabfrage, CSV-Import (; getrennt), bei State-Wechsel Code 100 über Broker

Zudem: Transaktionslog (DB + lesbares Logfile), State-Historie für Straßen/Gruppen, Revert als neuer Historieneintrag.

Umsetzung

Ich lege jetzt die fehlenden Services, Utilities, API-Routen für Admin sowie angepasste Templates mit Modals und JS an.

1) History-Service für Revert

Erstellt Logik um historischen Zustand wiederherzustellen und dabei einen neuen History-Eintrag zu schreiben.

2) CSV-Parser für Straßenimport

Parser für CSV mit Delimiter ; und den Spalten Name, Hausnummer minimal, Hausnummer maximal, Bounding Box.

3) Admin-AJAX-Routen

Vollständige Endpunkte für Accounts/Gruppen/Straßen inkl. Historie & Revert.

4) Templates + Frontend-JS

Modals via Pico.css, AJAX-Calls, CSV-Upload, Sicherheitsabfragen.

5) Broker-Helper

Kleine Helper-Funktion um Nachrichten über den bestehenden Broker zu routen.

Los geht's.


Assistant

Phase 4 (Admin-Views) ist jetzt implementiert. Zusätzlich wurden schon Bausteine für Phase 5 vorbereitet.

Implementiert

Accountverwaltung:

  • Liste aller Accounts
  • Rolle direkt in Tabelle ändern (AJAX)
  • Passwort zurücksetzen über Modal
  • Neuen Account anlegen über Modal
  • Account löschen mit Sicherheitsabfrage

Gruppenverwaltung:

  • Liste mit State-Auswahl, Account-Verknüpfung
  • Aliasname editierbar
  • Historie-Modal mit Revert-Funktion
  • Neue Gruppe anlegen, Gruppe löschen
  • State-Wechsel schreibt Historie und sendet Code 200 über Broker

Straßenverwaltung:

  • Tabelle editierbar, Modal für Edit/Neu
  • State und Gruppenverknüpfung änderbar
  • Bei State-Wechsel wird Code 100 über Broker verschickt
  • Löschfunktion mit Sicherheitsabfrage
  • CSV-Import (; getrennt) über Upload
  • Historie mit Revert
  • Neuanlage setzt State auf unbearbeitet, group_id NULL

Services/Utils:

  • HistoryService für Revert (neuer History-Eintrag)
  • csv_utils für CSV-Parsing
  • Admin-API unter /<tenant>/admin/api/*
  • Transaktionslog wird geschrieben

Test: Server starten:

cd /Users/thomas/Src/Sternsinger/CMBNet
flask --app app run --debug --host 127.0.0.1 --port 5000

Als Admin einloggen unter http://127.0.0.1:5000/RV/login → Accountverwaltung → Navigation zu Gruppen-/Straßenverwaltung.


User

Woran liegt das: "POST /RV/admin/api/accounts HTTP/1.1" 404?


Assistant

Der Grund ist die doppelte url_prefix-Kombination.

In cmbnet/admin/api.py hat das Blueprint bereits url_prefix='/admin/api'. In cmbnet/__init__.py wird es zusätzlich mit url_prefix='/<tenant>' registriert. Flask verkettet das zwar, aber in der Praxis führt das hier zu einem 404.

Am saubersten ist, entweder nur im Blueprint oder nur beim Registrieren den Präfix zu setzen. Ich nehme jetzt nur den vollen Präfix beim Registrieren.

Fix

1) Blueprint ohne Prefix anlegen

# cmbnet/admin/api.py
admin_api_bp = Blueprint('admin_api', __name__)

2) Beim Registrieren den vollen Pfad nutzen

# cmbnet/__init__.py
app.register_blueprint(admin_api_bp, url_prefix='/<tenant>/admin/api')

Dann passt auch der JS-Aufruf /${tenant}/admin/api/... genau.

Ich führe das jetzt durch und lösche die alten .pyc-Dateien, damit der Server die Änderungen sicher lädt.

Assistant

Jetzt ist das Routing korrekt. Die Routes sind unter /<tenant>/admin/api/... registriert.

Der Grund für den 404 war die doppelte url_prefix-Kombination. Das ist jetzt behoben.

Starte den Server neu und teste die Accountverwaltung - der POST auf /RV/admin/api/accounts sollte jetzt funktionieren.