340 lines
25 KiB
Plaintext
340 lines
25 KiB
Plaintext
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 (https://picocss.com/), Leaflet (https://leafletjs.com/)
|
|
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
|
|
- 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.
|
|
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).
|
|
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)
|
|
|
|
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)
|
|
9.2 Gruppenposition setzen (Gruppen-View / Fadenkreuz)
|
|
9.3 Admin CSV-Import
|
|
|
|
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.
|
|
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 app init-db
|
|
|
|
# Entwicklungswebserver starten
|
|
flask --app app 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. |