50 KiB
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:
-
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
-
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)
-
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_idist 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_bpmiturl_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:
bboxwird 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_logals 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_requiredfür alle geschützten Routen. - WS-Token: Nach Login/bei Initialload liefert AJAX-Endpoint
/<tenant>/api/auth/ws-tokenein 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
msgist 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/Unicastws/router.py: Entscheidung Empfängerkreis je Nachrichtentypws/handlers.py: Verarbeitung eingehender Codesws/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 hieraccounts.py:get_by_name_and_tenant(),get_by_id(),create(),update_role(),delete(),set_password_hash()history.py: Historieneinträge lesen/schreibenmessages.py: Persistenz für Code>=1000 + Cleanuplog.py: Transaktionslog (DB + File)
7.2 services/ (Geschäftslogik)
streets_service.pyhandle_initial_ajax(tenant_id, ...)-> JSON aller Straßenattribute inkl. Stateupdate_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 Invalidierunginvalidate(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)
- In-Memory-Cache:
accounts_service.pyverify_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 + Revertstrassen: Tabelle editierbar, Modal Edit, Modal Neu, Löschdialog, CSV-Import (Uploadmultipart/form-data, Delimiter;, SpaltenName,Hausnummer minimal,Hausnummer maximal,Bounding Box). Import erzeugt Einträge mit Stateunbearbeitet,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
- Client sendet
{code:0, msg: token, sender_id: account_id} - Broker sucht Token in
ws_tokens(tenant, account, nicht genutzt, nicht abgelaufen) - Bei Erfolg: markiert genutzt/erstellt Session-Mapping, führt Late-Entry durch, registriert Connection in Routing-Tabellen
- Bei Misserfolg: schließt Verbindung
8. Frontend-Architektur
8.1 Templates
base.html: Grundgerüst, pico.css, Leaflet CSS/JS, gemeinsame Skriptelogin.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
bboxvon Straßen ->L.latLngBounds - LocalStorage:
cmbnet:<tenant>:mapspeichert{center:[lat,lng], zoom, opacity, weight} - Tiles: OSM + optional Luftbild (Layer-Control)
- Polylines: Farbe nach State (
unbearbeitetblau,zugewiesenrot,erledigtgrün),opacity,weightkonfigurierbar - 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/lonoder 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
Administratorfreigegeben 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_atwiederhergestellt, 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_idanhand des historischen Kontextes wiederhergestellt. Ist der wiederherzustellende Zustandunbearbeitet, wirdgroup_idaufNULLgesetzt. - 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.pymit Mandanten (BV/RV/SV), WS-Konfiguration- Flask-App-Factory in
cmbnet/__init__.py - Datenbankverbindung und Schema in
migrations/schema.sqlfü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:
- Models anlegen –
accounts.py,groups.py,streets.pymit tenant-gebundenen CRUD-Methoden - Services anlegen – vor allem
groups_servicemit In-Memory-Cache +load_from_db()+invalidate() - API-Blueprint erstellen – Endpunkte für den Initialload (entspricht Punkt 1)b) und 2)f) aus der Aufgabenstellung)
- Cache initialisieren – Gruppen beim App-Start bzw. beim ersten Zugriff laden
- Blueprint registrieren –
api_bpincmbnet/__init__.pyeinbinden
Testbare Zwischenziele
Nach Phase 2 soll Folgendes funktionieren:
GET /<tenant>/api/init/streetsliefert alle Straßen des Mandanten inkl. State/GruppeGET /<tenant>/api/init/groupsliefert 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.pymit tenant-gebundenen CRUD-Operationen - Services:
GroupsServicemit In-Memory-Cache (groups_cache[tenant_id][group_id]),load_from_db(),invalidate(), Hilfsfunktionenis_account_linked,get_accounts_for_group,get_streets_for_group StreetsServicefü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:
- Prüft, ob die Datenbank existiert (sonst Hinweis auf
flask --app cmbnet init-db) - Zeigt verfügbare Mandanten an und erstellt sie bei Bedarf
- Fragt nach Mandant, Benutzername, Passwort (mit Bestätigung) und Rolle (Standard:
Administrator) - Prüft, ob der Account bereits existiert
- Erstellt den Passwort-Hash mit
werkzeug.security.generate_password_hash - 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_idNULL
Services/Utils:
HistoryServicefür Revert (neuer History-Eintrag)csv_utilsfü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.