# 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](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: ```text 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 `//...`. 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='/'` 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 ```mermaid sequenceDiagram participant B as Browser participant FL as Flask (Auth) participant DB as SQLite participant S as Session/Store B->>FL: GET //login FL-->>B: login.html (Mandantenvorwahl RV/BV/SV) B->>FL: POST //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 `//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: ```json { "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. ```mermaid 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). ```mermaid 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:"", 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 | |----------|---------|-------| | `//api/init/streets` | GET | Liste Straßen (inkl. State, group_id) | | `//api/init/groups` | GET | Liste Gruppen (inkl. State, Position, last_pos_at) | | `//api/auth/ws-token` | GET/POST | Token für WS-Auth erzeugen | | `//api/streets//state` | POST | State-Wechsel Straße (Dispatcher/Gruppen-Kontext) | | `//api/groups//state` | POST | State-Wechsel Gruppe | | `//api/groups//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): ```js // 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) ```mermaid sequenceDiagram participant B as Browser participant API as Flask API participant WS as WebSocket Broker B->>B: DOM ready B->>API: GET //api/init/streets API-->>B: streets[] B->>API: GET //api/init/groups API-->>B: groups[] B->>API: GET //api/auth/ws-token API-->>B: {token: "..."} B->>B: build Polylines + Marker B->>B: fitBounds auf alle bbox B->>WS: connect ws://...//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::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) ```mermaid 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) ```mermaid 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//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 ```mermaid 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: ```text 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. ```mermaid 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 //admin///history//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: ```txt 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. ```bash # 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//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:** ```bash 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 - [x] **Phase 0:** Projektstruktur, `config.py`, Flask-App-Factory, DB-Verbindung, Schema, Blueprints - [x] **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 //api/init/streets` liefert alle Straßen des Mandanten inkl. State/Gruppe - `GET //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 //api/init/streets`, `GET //api/init/groups`, `GET //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:** ```bash 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//ws`. API-Endpoints unter `//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: ```bash 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`: ```bash 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: ```bash sqlite3 instance/cmbnet.sqlite3 ``` Füge dann folgende SQL-Befehle ein. Ersetze `` mit dem eben kopierten Hash: ```sql -- 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', '', '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): ```bash 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 ```bash 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//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='/'` 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='/'` 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='/'` 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: ```bash cd /Users/thomas/Src/Sternsinger/CMBNet python3 create_admin.py ``` Dann Server starten und einloggen: ```bash 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 `//admin/api/*` - Transaktionslog wird geschrieben **Test:** Server starten: ```bash 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='/'` 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 ```python # cmbnet/admin/api.py admin_api_bp = Blueprint('admin_api', __name__) ``` ### 2) Beim Registrieren den vollen Pfad nutzen ```python # cmbnet/__init__.py app.register_blueprint(admin_api_bp, url_prefix='//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 `//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.