""" WebSocket Broker - Kernkomponente für Realtime-Kommunikation Der Broker nimmt Nachrichten aus WebSocket-Verbindungen (und aus HTTP-Handlern) entgegen, wertet den Code aus, bestimmt den erlaubten Empfängerkreis und stellt die Nachricht zu. Wichtige Regeln aus der Spezifikation: - Code < 100: rein interne Nachrichten (z. B. Authentifizierung, Heartbeat). Code 99 ist eine serverinterne Aufforderung an alle Clients, die Seite wegen geänderter Daten neu zu laden. - Code 100/200/300: State- bzw. Positionsänderungen an Dispatcher, Beobachter und die jeweils betroffene Gruppe. - Code 1000/1100/2000: Chat-/Broadcast-Nachrichten. Diese werden persistiert, damit sie bei einer späteren Anmeldung als "Late Entry" nachgeliefert werden können. Nachrichten, die älter als LATE_ENTRY_MAX_AGE_HOURS (Default 8h) sind, werden gelöscht. - Nicht zustellbare Nachrichten ab Code 100 werden pro Client-Sitzung gepuffert. Eine zu alte Queue wird verworfen; beim nächsten Reconnect wird dann Code 99 mit einem Hinweis auf die zu lange Unterbrechung gesendet. - Code 2 dient zugleich als Lebenszeichen einer Gruppe. Gruppen wechseln bei einem Pong von "unterwegs" auf "online" und ohne Pong nach dem konfigurierten Zeitfenster wieder zurück auf "unterwegs". """ import json import re import time from datetime import datetime, timedelta, timezone from threading import Lock from flask import current_app from cmbnet.db import get_db from cmbnet.services.groups_service import GroupsService from cmbnet.ws.protocol import WSMessage class WebSocketBroker: def __init__(self): # connections[tenant_id][account_id] = { # 'ws': , # 'role': , # 'group_id': , # } self.connections = {} # authenticated[tenant_id][account_id] = True # Erst nach erfolgreichem Code-0-Handshake darf ein Client Nachrichten # über die Verbindung senden. self.authenticated = {} # Nicht zustellbare Nachrichten werden pro Client-Sitzung gepuffert. # Schlüssel: (tenant_id, account_id, session_id). self.session_queues = {} # Zuletzt bekannte Sitzungs-ID je Account. Sie erlaubt es, Nachrichten # auch dann der richtigen Queue zuzuordnen, wenn gerade keine # WebSocket-Verbindung besteht. self.account_sessions = {} self.queue_lock = Lock() # Zeitpunkt des letzten Code-2-Pongs je Gruppe (monotonic). self.group_last_pong = {} self.group_online_since = {} # ------------------------------------------------------------------ # Verbindungen und Authentifizierung # ------------------------------------------------------------------ def register_connection(self, tenant_id, account_id, ws, role=None, group_id=None): """Registriert eine neue, noch nicht authentifizierte Verbindung. Rolle und Gruppenzuordnung werden direkt mitgespeichert. Sie werden später für die Empfängerermittlung und für das Cleanup benötigt. """ db = get_db() account = db.execute( 'SELECT role FROM accounts WHERE id = ? AND tenant_id = ?', (account_id, tenant_id) ).fetchone() if not account: return False if role is None: role = account['role'] # Für Gruppen-Accounts die zugehörige Gruppe ermitteln. Ein Account der # Rolle "Gruppe" ist höchstens einer Gruppe zugeordnet. if group_id is None and role == 'Gruppe': group = db.execute( '''SELECT g.id FROM groups g JOIN group_accounts ga ON ga.group_id = g.id AND ga.tenant_id = g.tenant_id WHERE ga.account_id = ? AND g.tenant_id = ?''', (account_id, tenant_id) ).fetchone() group_id = group['id'] if group else None if tenant_id not in self.connections: self.connections[tenant_id] = {} # Eine neue Verbindung muss den Token-Handshake erneut durchlaufen. # Ein eventuell noch gesetzter Auth-Status einer älteren Verbindung # desselben Accounts darf nicht übernommen werden. authenticated = self.authenticated.get(tenant_id) if authenticated: authenticated.pop(account_id, None) self.connections[tenant_id][account_id] = { 'ws': ws, 'role': role, 'group_id': group_id, 'session_id': None, 'last_ping': datetime.now(), 'connected_at': time.monotonic(), 'last_pong_at': None, # simple-websocket schreibt Nachrichten direkt auf den Socket. # Da Heartbeat, WebSocket-Routen und HTTP-ausgelöste Broadcasts # aus unterschiedlichen Threads senden können, müssen die Frames # pro Verbindung serialisiert werden. Sonst können sich zwei # Frames überlagern und der Browser meldet "Invalid frame header". 'send_lock': Lock() } return True def send_to_connection(self, tenant_id, account_id, data): """Sendet einen Frame thread-sicher an eine registrierte Verbindung.""" conn = self._get_connection(tenant_id, account_id) if not conn: return False try: lock = conn.get('send_lock') if lock is None: lock = Lock() conn['send_lock'] = lock with lock: conn['ws'].send(data) return True except Exception: # Eine fehlerhafte Verbindung darf den Versand an andere Clients # nicht verhindern. Das Aufräumen übernimmt die Route beim # Schließen der Verbindung. return False def is_authenticated(self, tenant_id, account_id): """Prüft, ob eine Verbindung den Code-0-Handshake erfolgreich absolviert hat.""" return self.authenticated.get(tenant_id, {}).get(account_id, False) def authenticate(self, tenant_id, account_id, token, session_id=None): """Authentifiziert eine Verbindung anhand des Einmal-Tokens (Code 0). Die Sitzungs-ID stammt vom Client und bleibt auch nach einem Neuladen erhalten. Sie ordnet die Verbindung einer eventuell vorhandenen Nachrichten-Queue zu. """ db = get_db() token_row = db.execute( 'SELECT * FROM ws_tokens WHERE token = ? AND tenant_id = ? ' 'AND account_id = ? AND used = 0', (token, tenant_id, account_id) ).fetchone() if not token_row: return False # Ablaufzeit prüfen (Tokens sind nur kurzzeitig gültig). if token_row['expires_at']: try: expires = datetime.fromisoformat(token_row['expires_at'].replace('Z', '+00:00')) # SQLite liefert naive Zeitstempel; ein Vergleich mit einer # zeitzonenbehafteten Zeit wäre nicht möglich. if expires.tzinfo is not None: expires = expires.astimezone().replace(tzinfo=None) if expires < datetime.now(): return False except ValueError: return False # Token darf nur einmal verwendet werden. db.execute('UPDATE ws_tokens SET used = 1 WHERE id = ?', (token_row['id'],)) db.commit() session_id = self._normalize_session_id(session_id, account_id) conn = self._get_connection(tenant_id, account_id) if conn: conn['session_id'] = session_id if conn.get('role') == 'Gruppe' and conn.get('group_id'): # Ein frisch verbundener Gruppen-Client erhält eine # Zwei-Minuten-Kulanz, bis der erste Code-2-Pong eintrifft. key = (tenant_id, conn['group_id']) self.group_online_since[key] = time.monotonic() self.account_sessions[(tenant_id, account_id)] = session_id if tenant_id not in self.authenticated: self.authenticated[tenant_id] = {} self.authenticated[tenant_id][account_id] = True # Zuerst die für diese Sitzung gepufferten Nachrichten ausliefern. # Wurde die Queue wegen Überschreitung der Maximalzeit verworfen, wird # stattdessen ausschließlich ein Code-99-Hinweis gesendet. queued_messages, suppress_late_entries = self.restore_session_queue( tenant_id, account_id, session_id ) # Nach erfolgreicher Authentifizierung dürfen die gespeicherten # Nachrichten der letzten 8 Stunden nachgeliefert werden. Bereits aus # der Sitzungs-Queue zugestellte Nachrichten werden dabei ausgelassen. if not suppress_late_entries: self.send_late_entries( tenant_id, account_id, skip_messages=queued_messages ) return True def remove_connection(self, tenant_id, account_id, ws=None): """Entfernt eine Verbindung. Wenn ein Account mehrere Tabs/Verbindungen öffnet, wird nur die tatsächlich beendete Verbindung entfernt (ws-Vergleich), nicht die zuletzt registrierte. """ connections = self.connections.get(tenant_id) if connections and account_id in connections: conn = connections[account_id] if ws is None or conn.get('ws') is ws: session_id = conn.get('session_id') del connections[account_id] # Nur wenn die tatsächlich beendete Verbindung die aktuelle # war, darf auch der Authentifizierungsstatus entfernt werden. authenticated = self.authenticated.get(tenant_id) if authenticated and account_id in authenticated: del authenticated[account_id] # Ab dem Trennen beginnt die Lebenszeit der Sitzungs-Queue. if session_id: with self.queue_lock: self._ensure_session_queue( tenant_id, account_id, session_id ) def _get_connection(self, tenant_id, account_id): return self.connections.get(tenant_id, {}).get(account_id) # ------------------------------------------------------------------ # Sitzungs-Queues # ------------------------------------------------------------------ @staticmethod def _normalize_session_id(value, account_id): """Validiert die vom Client gelieferte Sitzungs-ID. Ältere Clients senden noch keine ID. Für sie wird eine stabile Ersatz-ID je Account gebildet, damit auch dort die Queue funktioniert. """ text = str(value or '').strip() if re.fullmatch(r'[A-Za-z0-9._:-]{8,128}', text): return text return f'legacy-{account_id}' def _session_queue_max_age_seconds(self): minutes = current_app.config.get('WS_QUEUE_MAX_AGE_MINUTES', 15) try: minutes = float(minutes) except (TypeError, ValueError): minutes = 15 return max(0.0, minutes * 60) def _ensure_session_queue(self, tenant_id, account_id, session_id, now=None): """Liefert die Queue einer Sitzung und legt sie bei Bedarf an.""" key = (tenant_id, account_id, session_id) queue = self.session_queues.get(key) if queue is None: queue = { 'messages': [], 'created_at': now if now is not None else time.monotonic(), 'expired': False, 'code99_only': False, 'code99_message': None, } self.session_queues[key] = queue return queue def _expire_session_queue(self, queue, now=None): """Verwirft zu alte Nachrichten und hinterlässt einen Code-99-Hinweis.""" if not queue or queue.get('code99_only') or queue.get('expired'): return now = now if now is not None else time.monotonic() if now - queue.get('created_at', now) < self._session_queue_max_age_seconds(): return queue['messages'].clear() queue['expired'] = True def _queue_undeliverable(self, tenant_id, account_id, message): """Puffert eine nicht zustellbare Nachricht für die letzte Sitzung.""" if message.code < 100 and message.code != 99: return session_id = self.account_sessions.get((tenant_id, account_id)) if not session_id: return with self.queue_lock: queue = self._ensure_session_queue(tenant_id, account_id, session_id) now = time.monotonic() if message.code == 99: # Eine nicht zustellbare Reload-Aufforderung verdrängt alle # älteren Nachrichten. Danach wird nichts weiter gepuffert. queue['messages'].clear() queue['code99_only'] = True queue['code99_message'] = message.to_json() queue['expired'] = False return self._expire_session_queue(queue, now) if queue.get('expired') or queue.get('code99_only'): return queue['messages'].append(message.to_json()) def cleanup_session_queues(self): """Markiert abgelaufene Sitzungs-Queues und verwirft deren Nachrichten.""" now = time.monotonic() with self.queue_lock: for queue in self.session_queues.values(): self._expire_session_queue(queue, now) def _session_queue_timeout_message(self): minutes = current_app.config.get('WS_QUEUE_MAX_AGE_MINUTES', 15) return WSMessage( sender_id=0, code=99, msg=( 'Die WebSocket-Verbindung war zu lange unterbrochen ' f'(mehr als {minutes} Minuten). Bitte lade die Seite neu, ' 'um den aktuellen Stand zu erhalten.' ) ).to_json() def restore_session_queue(self, tenant_id, account_id, session_id): """Liefert gepufferte Nachrichten einer wiedererkannten Sitzung aus. Rückgabe: (Menge der Roh-Nachrichten aus der Queue, Late-Entry-Sperre). Die Menge dient dazu, dieselben Nachrichten nicht zusätzlich als Late Entry zu senden. Die Sperre ist gesetzt, wenn die Queue abgelaufen war oder nur noch eine Code-99-Nachricht enthielt. In diesem Fall darf keine zusätzliche Late-Entry-Historie mehr gesendet werden. """ key = (tenant_id, account_id, session_id) now = time.monotonic() with self.queue_lock: queue = self.session_queues.get(key) if not queue: return set(), False self._expire_session_queue(queue, now) if queue.get('code99_only'): raw_message = queue.get('code99_message') or self._session_queue_timeout_message() self.session_queues.pop(key, None) send_only = True messages = [] elif queue.get('expired'): raw_message = self._session_queue_timeout_message() self.session_queues.pop(key, None) send_only = True messages = [] else: raw_message = None send_only = False messages = list(queue.get('messages', [])) queue['messages'] = [] if send_only: if raw_message and not self.send_to_connection(tenant_id, account_id, raw_message): # Verbindung ist bereits wieder weg: Queue für den nächsten # Versuch erhalten. with self.queue_lock: self.session_queues.setdefault(key, queue) return set(), True unsent = [] for index, raw_message in enumerate(messages): if not self.send_to_connection(tenant_id, account_id, raw_message): unsent = messages[index:] break with self.queue_lock: current = self.session_queues.get(key) if current is not None: if unsent: current['messages'] = unsent + current.get('messages', []) if not current.get('messages'): self.session_queues.pop(key, None) # Auch nicht zugestellte Queue-Nachrichten von den Late Entries # ausnehmen. Sie bleiben in der Queue und werden beim nächsten # Reconnect erneut versucht, statt doppelt gepuffert zu werden. return set(messages), False # ------------------------------------------------------------------ # Late Entry # ------------------------------------------------------------------ def send_late_entries(self, tenant_id, account_id, skip_messages=None): """Sendet gespeicherte Nachrichten (Code >= 1000) der letzten 8 Stunden. Es werden ausschließlich Nachrichten zugestellt, für die der Account laut Protokoll berechtigt ist. Die Zustellung erfolgt chronologisch. Anschließend werden abgelaufene Nachrichten gelöscht. """ db = get_db() cutoff = self._late_entry_cutoff() skip_messages = skip_messages or set() messages = db.execute( 'SELECT * FROM ws_messages_store WHERE tenant_id = ? AND ts >= ? ' 'ORDER BY ts ASC, id ASC', (tenant_id, cutoff) ).fetchall() conn = self._get_connection(tenant_id, account_id) if not conn: return for msg_row in messages: if not self._is_allowed_for_client(tenant_id, account_id, msg_row): continue msg = WSMessage( sender_id=msg_row['sender_id'], receiver_id=msg_row['receiver_id'], code=msg_row['code'], msg=msg_row['msg'], ts=msg_row['ts'] ) if msg.to_json() in skip_messages: continue self._send(tenant_id, account_id, msg) # Abgelaufene Nachrichten werden bei jeder Anmeldung aufgeräumt. self.cleanup_old_messages(tenant_id) def _late_entry_cutoff(self): """Zeitstempel (ms), ab dem gespeicherte Nachrichten noch zustellbar sind.""" max_age_hours = current_app.config.get('LATE_ENTRY_MAX_AGE_HOURS', 8) return int((datetime.now() - timedelta(hours=max_age_hours)).timestamp() * 1000) def cleanup_old_messages(self, tenant_id=None): """Löscht persistierte Nachrichten, die älter als die Late-Entry-Frist sind.""" db = get_db() cutoff = self._late_entry_cutoff() if tenant_id is None: db.execute('DELETE FROM ws_messages_store WHERE ts < ?', (cutoff,)) else: db.execute( 'DELETE FROM ws_messages_store WHERE tenant_id = ? AND ts < ?', (tenant_id, cutoff) ) db.commit() def _is_allowed_for_client(self, tenant_id, account_id, msg_row): """Prüft, ob eine persistierte Nachricht für diesen Client bestimmt ist.""" db = get_db() account = db.execute( 'SELECT * FROM accounts WHERE id = ? AND tenant_id = ?', (account_id, tenant_id) ).fetchone() if not account: return False role = account['role'] code = msg_row['code'] # Code 1000: Broadcast an Dispatcher, Beobachter und alle Gruppen. if code == 1000: return role in ('Dispatcher', 'Beobachter', 'Gruppe') # Code 1100: Dispatcher, Beobachter und die angesprochene Gruppe. if code == 1100: if role in ('Dispatcher', 'Beobachter'): return True if role == 'Gruppe': group = db.execute( '''SELECT g.id FROM groups g JOIN group_accounts ga ON ga.group_id = g.id AND ga.tenant_id = g.tenant_id WHERE ga.account_id = ? AND g.tenant_id = ?''', (account_id, tenant_id) ).fetchone() return bool(group and msg_row['receiver_id'] == group['id']) return False # Code 2000: Dispatcher, Beobachter und Gruppen. if code == 2000: if role in ('Dispatcher', 'Beobachter'): return True if role == 'Gruppe': group = db.execute( '''SELECT g.id FROM groups g JOIN group_accounts ga ON ga.group_id = g.id AND ga.tenant_id = g.tenant_id WHERE ga.account_id = ? AND g.tenant_id = ?''', (account_id, tenant_id) ).fetchone() payload = self._payload(msg_row) group_id = None if isinstance(payload, dict): group_id = payload.get('group_id') if group_id is None: group_id = msg_row['receiver_id'] return bool(group and group_id == group['id']) return False return False # ------------------------------------------------------------------ # Nachrichtenverarbeitung # ------------------------------------------------------------------ def route_message(self, tenant_id, message, apply_business=False): """Wertet den Code aus, persistiert ggf. und stellt die Nachricht zu. ``apply_business`` wird nur für Nachrichten verwendet, die direkt über die WebSocket-Route eingehen. Serverintern erzeugte Nachrichten (z. B. aus der Admin-API) haben die Datenbank bereits aktualisiert und dürfen deshalb nicht ein zweites Mal angewendet werden. """ db = get_db() # Absender muss zum Mandanten gehören. Die Absender-ID wird in der # WebSocket-Route aus der Session gesetzt und kann nicht gefälscht # werden. sender = db.execute( 'SELECT * FROM accounts WHERE id = ? AND tenant_id = ?', (message.sender_id, tenant_id) ).fetchone() if not sender: return code = message.code # Code 0 wird ausschließlich in der WebSocket-Route (Handshake) # verarbeitet und niemals weitergeleitet. if code <= 0: return # Code 1 sendet ausschließlich der Server (Heartbeat-Routine). # Nachrichten dieses Typs von Clients werden ignoriert. if code == 1: return # Code 2 ist die Antwort eines Clients auf den Heartbeat. Sie wird nur # an Dispatcher-Views weitergeleitet und nicht gespeichert. Gleichzeitig # dient sie als Lebenszeichen der Gruppe. if code == 2: self._record_client_pong(tenant_id, sender['id'], sender) self._deliver(tenant_id, message, sender) return # Code 99 ist eine serverinterne Aufforderung zum Neuladen. Clients # dürfen diesen Code nicht selbst auslösen. if code == 99: if apply_business: return self._deliver(tenant_id, message, sender) return # Sonstige interne Codes (< 100) werden nicht an die Oberfläche gegeben. if code < 100: return # Ab hier: fachliche Nachrichten (>= 100). # Zustandsänderungen, die ein Client per WebSocket meldet, werden vor # der Zustellung in der Datenbank persistiert. So sind sie auch nach # einem Neuladen der Seite wieder sichtbar. if apply_business and code in (100, 200, 300): if not self._apply_business_change(tenant_id, message, sender): current_app.logger.warning( 'WebSocket-Nachricht abgelehnt: code=%s sender=%s tenant=%s msg=%s', code, sender['id'], tenant_id, str(message.msg)[:300] ) return message = self._prepare_message(tenant_id, message, sender) # Ab Code 1000 werden Nachrichten für die Late-Entry-Funktion # gespeichert. Gespeichert wird die bereits aufbereitete Nachricht # (bei Code 1100 inklusive Aliasname-Präfix). if code >= 1000: self._persist_message(tenant_id, message) self._deliver(tenant_id, message, sender) def _apply_business_change(self, tenant_id, message, sender): """Persistiert Code 100/200/300 aus einer WebSocket-Nachricht. Gibt ``False`` zurück, wenn die Nachricht ungültig oder für den Absender nicht erlaubt ist. In diesem Fall wird sie nicht zugestellt. """ payload = self._payload(message) if not isinstance(payload, dict): return False if message.code == 100: return self._apply_street_change(tenant_id, message, sender, payload) if message.code == 200: return self._apply_group_state_change(tenant_id, message, sender, payload) if message.code == 300: return self._apply_group_position_change(tenant_id, message, sender, payload) return False # ------------------------------------------------------------------ # Anwesenheit von Gruppen-Clients # ------------------------------------------------------------------ def _record_client_pong(self, tenant_id, account_id, sender): """Wertet ein Code-2-Lebenszeichen eines Clients aus.""" conn = self._get_connection(tenant_id, account_id) if conn: conn['last_pong_at'] = time.monotonic() if not sender or sender['role'] != 'Gruppe': return db = get_db() group = db.execute( '''SELECT g.id, g.state FROM groups g JOIN group_accounts ga ON ga.group_id = g.id AND ga.tenant_id = g.tenant_id WHERE ga.account_id = ? AND g.tenant_id = ?''', (account_id, tenant_id) ).fetchone() if not group: return now = time.monotonic() group_id = group['id'] self.group_last_pong[(tenant_id, group_id)] = now if group['state'] == 'unterwegs': self._set_group_state_internal( tenant_id, group_id, 'online', actor_account_id=account_id ) def _set_group_state_internal(self, tenant_id, group_id, new_state, actor_account_id=None): """Setzt einen automatisch abgeleiteten Gruppenstatus und informiert Clients.""" db = get_db() group = db.execute( 'SELECT * FROM groups WHERE id = ? AND tenant_id = ?', (group_id, tenant_id) ).fetchone() if not group or group['state'] == new_state: return False old_state = group['state'] db.execute( 'UPDATE groups SET state = ?, updated_at = CURRENT_TIMESTAMP ' 'WHERE id = ? AND tenant_id = ?', (new_state, group_id, tenant_id) ) db.execute( '''INSERT INTO group_state_history (tenant_id, group_id, from_state, to_state, last_lat, last_lon, last_pos_at, actor_account_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)''', (tenant_id, group_id, old_state, new_state, group['last_lat'], group['last_lon'], group['last_pos_at'], actor_account_id) ) db.commit() GroupsService.update_cache_entry( tenant_id, group_id, {'state': new_state} ) if new_state == 'online': self.group_online_since[(tenant_id, group_id)] = time.monotonic() message = WSMessage( sender_id=actor_account_id or 0, code=200, msg=json.dumps({ 'group_id': group_id, 'state': new_state, 'actor': actor_account_id, 'automatic': True }, ensure_ascii=False) ) self._deliver(tenant_id, message, None) return True def check_group_presence_timeouts(self, tenant_id=None): """Setzt Online-Gruppen ohne Code-2-Pong auf "unterwegs" zurück.""" db = get_db() if tenant_id is None: rows = db.execute( "SELECT id, tenant_id FROM groups WHERE state = 'online'" ).fetchall() else: rows = db.execute( "SELECT id, tenant_id FROM groups " "WHERE state = 'online' AND tenant_id = ?", (tenant_id,) ).fetchall() timeout = current_app.config.get('WS_GROUP_ONLINE_TIMEOUT_SECONDS', 120) try: timeout = float(timeout) except (TypeError, ValueError): timeout = 120.0 now = time.monotonic() for row in rows: key = (row['tenant_id'], row['id']) reference = self.group_last_pong.get(key) online_since = self.group_online_since.get(key) if online_since is not None: reference = max(reference, online_since) if reference else online_since if reference is None: # Zustand war bereits vor dem Start des Trackings "online". # Ab jetzt läuft die Kulanzfrist. self.group_online_since[key] = now continue if now - reference > timeout: self._set_group_state_internal( row['tenant_id'], row['id'], 'unterwegs' ) def _apply_street_change(self, tenant_id, message, sender, payload): """Wendet einen Straßen-State-Wechsel aus einer Code-100-Nachricht an.""" if sender['role'] not in ('Dispatcher', 'Administrator', 'Gruppe'): return False db = get_db() street = None street_id = payload.get('street_id') if street_id is not None: try: street_id = int(street_id) except (TypeError, ValueError): return False street = db.execute( 'SELECT * FROM streets WHERE id = ? AND tenant_id = ?', (street_id, tenant_id) ).fetchone() if not street and payload.get('name'): street = db.execute( 'SELECT * FROM streets WHERE name = ? AND tenant_id = ?', (str(payload['name']), tenant_id) ).fetchone() if not street: return False # Gruppen-Accounts dürfen nur Straßen bearbeiten, die ihrer eigenen # Gruppe zugewiesen sind. Die Zuordnung darf dabei nicht auf eine # andere Gruppe verschoben werden. own_group_id = None if sender['role'] == 'Gruppe': group = db.execute( '''SELECT g.id FROM groups g JOIN group_accounts ga ON ga.group_id = g.id AND ga.tenant_id = g.tenant_id WHERE ga.account_id = ? AND g.tenant_id = ?''', (sender['id'], tenant_id) ).fetchone() if not group: return False own_group_id = group['id'] if street['group_id'] != own_group_id: return False new_state = payload.get('state') if new_state not in ('unbearbeitet', 'zugewiesen', 'erledigt'): return False if 'group_id' in payload: group_id = payload['group_id'] if group_id in ('', None): group_id = None else: try: group_id = int(group_id) except (TypeError, ValueError): return False else: group_id = street['group_id'] # Unbearbeitet bedeutet immer "keine Gruppe". Für "zugewiesen" ist # dagegen eine gültige Gruppe erforderlich. if new_state == 'unbearbeitet': group_id = None elif new_state == 'zugewiesen' and group_id is None: return False if sender['role'] == 'Gruppe': # Eine Gruppe darf ihre eigene Straße freigeben (unbearbeitet), # aber nicht einer anderen Gruppe zuweisen. if new_state != 'unbearbeitet': if new_state == 'erledigt' and group_id is None: group_id = own_group_id if group_id != own_group_id: return False if group_id is not None: group = db.execute( 'SELECT id FROM groups WHERE id = ? AND tenant_id = ?', (group_id, tenant_id) ).fetchone() if not group: return False old_state = street['state'] old_group_id = street['group_id'] changed = old_state != new_state or old_group_id != group_id if changed: db.execute( 'UPDATE streets SET state = ?, group_id = ?, updated_at = CURRENT_TIMESTAMP ' 'WHERE id = ? AND tenant_id = ?', (new_state, group_id, street['id'], tenant_id) ) db.execute( '''INSERT INTO street_state_history (tenant_id, street_id, from_state, to_state, group_id, actor_account_id, reason) VALUES (?, ?, ?, ?, ?, ?, ?)''', (tenant_id, street['id'], old_state, new_state, group_id, sender['id'], 'ws_code_100') ) db.commit() self._log_business(tenant_id, sender['id'], 'street.state_change', 'street', street['id'], {'from': old_state, 'to': new_state, 'group_id': group_id}) # Für die Empfängerermittlung muss die alte Gruppe bekannt bleiben: # Bei einem Gruppenwechsel erhält sowohl die alte als auch die neue # Gruppe die Code-100-Nachricht. message._old_group_id = old_group_id message.msg = json.dumps({ 'name': street['name'], 'state': new_state, 'actor': sender['id'], 'street_id': street['id'], 'group_id': group_id }, ensure_ascii=False) return True def _apply_group_state_change(self, tenant_id, message, sender, payload): """Wendet einen Gruppen-State-Wechsel aus einer Code-200-Nachricht an.""" if sender['role'] not in ('Dispatcher', 'Administrator', 'Gruppe'): return False group_id = self._resolve_group_id(tenant_id, message, sender, payload) if not group_id: return False db = get_db() group = db.execute( 'SELECT * FROM groups WHERE id = ? AND tenant_id = ?', (group_id, tenant_id) ).fetchone() if not group: return False # Ein Gruppen-Account darf nur den Zustand seiner eigenen Gruppe ändern. if sender['role'] == 'Gruppe': linked = db.execute( '''SELECT 1 FROM group_accounts WHERE tenant_id = ? AND group_id = ? AND account_id = ?''', (tenant_id, group_id, sender['id']) ).fetchone() if not linked: return False new_state = payload.get('state') if new_state not in ('offen', 'unterwegs', 'online', 'pausierend', 'fertig'): return False if new_state != group['state']: db.execute( 'UPDATE groups SET state = ?, updated_at = CURRENT_TIMESTAMP ' 'WHERE id = ? AND tenant_id = ?', (new_state, group_id, tenant_id) ) db.execute( '''INSERT INTO group_state_history (tenant_id, group_id, from_state, to_state, last_lat, last_lon, last_pos_at, actor_account_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)''', (tenant_id, group_id, group['state'], new_state, group['last_lat'], group['last_lon'], group['last_pos_at'], sender['id']) ) db.commit() GroupsService.update_cache_entry(tenant_id, group_id, {'state': new_state}) if new_state == 'online': self.group_online_since[(tenant_id, group_id)] = time.monotonic() self._log_business(tenant_id, sender['id'], 'group.state_change', 'group', group_id, {'from': group['state'], 'to': new_state}) message.receiver_id = group_id message.msg = json.dumps({ 'group_id': group_id, 'state': new_state, 'actor': sender['id'] }, ensure_ascii=False) return True def _apply_group_position_change(self, tenant_id, message, sender, payload): """Wendet eine Positionsänderung aus einer Code-300-Nachricht an.""" if sender['role'] not in ('Dispatcher', 'Administrator', 'Gruppe'): return False group_id = self._resolve_group_id(tenant_id, message, sender, payload) if not group_id: return False db = get_db() group = db.execute( 'SELECT * FROM groups WHERE id = ? AND tenant_id = ?', (group_id, tenant_id) ).fetchone() if not group: return False if sender['role'] == 'Gruppe': linked = db.execute( '''SELECT 1 FROM group_accounts WHERE tenant_id = ? AND group_id = ? AND account_id = ?''', (tenant_id, group_id, sender['id']) ).fetchone() if not linked: return False try: lat = float(payload.get('lat')) lon = float(payload.get('lon')) except (TypeError, ValueError): return False if not (-90 <= lat <= 90 and -180 <= lon <= 180): return False # Der Server setzt den Zeitstempel, damit die Progressbar nicht durch # manipulierbare Client-Zeitangaben verfälscht wird. pos_at = datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S') ts_ms = int(time.time() * 1000) automatic = payload.get('automatic') is True db.execute( 'UPDATE groups SET last_lat = ?, last_lon = ?, last_pos_at = ?, ' 'updated_at = CURRENT_TIMESTAMP WHERE id = ? AND tenant_id = ?', (lat, lon, pos_at, group_id, tenant_id) ) # Automatische Positionsmeldungen der Gruppen-View aktualisieren nur # die Live-Position. Die Historie und das Transaktionslog bleiben # manuellen Positionsänderungen vorbehalten, damit sie nicht durch # regelmäßige Telemetrie geflutet werden. if not automatic: db.execute( '''INSERT INTO group_state_history (tenant_id, group_id, from_state, to_state, last_lat, last_lon, last_pos_at, actor_account_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)''', (tenant_id, group_id, group['state'], group['state'], lat, lon, pos_at, sender['id']) ) db.commit() GroupsService.update_cache_entry(tenant_id, group_id, { 'last_lat': lat, 'last_lon': lon, 'last_pos_at': pos_at }) if not automatic: self._log_business(tenant_id, sender['id'], 'group.position_change', 'group', group_id, {'lat': lat, 'lon': lon}) message.receiver_id = group_id # Auch der Nachrichten-Zeitstempel wird serverseitig gesetzt, damit # die Progressbar nicht von einer manipulierten Client-Uhr abhängt. message.ts = ts_ms message.msg = json.dumps({ 'group_id': group_id, 'lat': lat, 'lon': lon, 'ts': ts_ms, 'actor': sender['id'] }, ensure_ascii=False) return True @staticmethod def _log_business(tenant_id, actor_id, action, entity_type, entity_id, details): """Schreibt eine per WebSocket ausgelöste Änderung ins Transaktionslog.""" try: db = get_db() db.execute( 'INSERT INTO transaction_log ' '(tenant_id, actor_account_id, action, entity_type, entity_id, details) ' 'VALUES (?, ?, ?, ?, ?, ?)', (tenant_id, actor_id, action, entity_type, entity_id, json.dumps(details, ensure_ascii=False)) ) db.commit() from cmbnet.core.logging import write_transaction_log actor = db.execute( 'SELECT name FROM accounts WHERE id = ? AND tenant_id = ?', (actor_id, tenant_id) ).fetchone() write_transaction_log(tenant_id, actor_id, actor['name'] if actor else None, action, entity_type, entity_id, details) except Exception as exc: print(f'Transaction log error: {exc}') def _get_sender_info(self, tenant_id, sender): """Liefert Sender-Informationen inkl. Accountname und ggf. Gruppen-Alias.""" db = get_db() info = { 'account_id': sender['id'] if sender else None, 'account_name': sender['name'] if sender else None, 'role': sender['role'] if sender else None, 'group_id': None, 'group_alias': None } if sender and sender['role'] == 'Gruppe': group = db.execute( '''SELECT g.id, g.aliasname FROM groups g JOIN group_accounts ga ON ga.group_id = g.id AND ga.tenant_id = g.tenant_id WHERE ga.account_id = ? AND g.tenant_id = ?''', (sender['id'], tenant_id) ).fetchone() if group: info['group_id'] = group['id'] info['group_alias'] = group['aliasname'] else: # Auch für andere Rollen kann ein verknüpfter Gruppen-Account Kontext # liefern; für Dispatcher reicht der Accountname. pass return info def _normalize_chat_message(self, tenant_id, message, sender, payload): """Normalisiert Chat-Nachrichten (Code >= 1000) auf einheitliches JSON.""" sender_info = self._get_sender_info(tenant_id, sender) text = '' if isinstance(payload, dict): if payload.get('text') is not None: text = str(payload.get('text') or '') elif payload.get('msg') is not None: inner = payload.get('msg') if isinstance(inner, dict) and inner.get('text') is not None: text = str(inner.get('text') or '') elif isinstance(inner, str): text = inner else: text = str(inner or '') else: # Fallback: falls nur andere Felder, versuche text text = str(payload.get('message') or '') elif isinstance(message.msg, str): text = message.msg else: text = str(message.msg or '') text = str(text).strip() normalized = { 'text': text, 'sender': { 'account_id': sender_info['account_id'], 'name': sender_info['account_name'], 'role': sender_info['role'], 'group_id': sender_info['group_id'], 'group_alias': sender_info['group_alias'] } } if message.code == 1100: group_id = self._resolve_group_id(tenant_id, message, sender, payload) if group_id is not None: try: message.receiver_id = int(group_id) except (TypeError, ValueError): message.receiver_id = group_id normalized['group_id'] = message.receiver_id elif message.code == 1000: normalized['broadcast'] = True else: if message.receiver_id is not None: normalized['receiver_id'] = message.receiver_id message.msg = json.dumps(normalized, ensure_ascii=False) return message def _prepare_message(self, tenant_id, message, sender): """Ergänzt Nachrichten um serverseitig abgeleitete Informationen.""" db = get_db() payload = self._payload(message) code = message.code if code >= 1000: return self._normalize_chat_message(tenant_id, message, sender, payload) if message.code == 1100: group_id = self._resolve_group_id(tenant_id, message, sender, payload) group = self._fetch_group(tenant_id, group_id) message.receiver_id = group_id if group: alias = group['aliasname'] or str(group['id']) prefix = f'{alias}: ' text = message.msg if isinstance(message.msg, str) else json.dumps(message.msg) if not text.startswith(prefix): message.msg = prefix + text return self._normalize_chat_message(tenant_id, message, sender, payload) elif message.code == 2000: group_id = self._resolve_group_id(tenant_id, message, sender, payload) message.receiver_id = group_id if isinstance(payload, dict): if group_id and not payload.get('group_id'): payload['group_id'] = group_id message.msg = json.dumps(payload, ensure_ascii=False) elif group_id: message.msg = json.dumps( {'group_id': group_id, 'text': message.msg}, ensure_ascii=False ) return self._normalize_chat_message(tenant_id, message, sender, payload) return message def _deliver(self, tenant_id, message, sender): """Stellt eine Nachricht an alle berechtigten, verbundenen Clients zu.""" for recipient_id in self._get_recipients(tenant_id, message, sender): self._send(tenant_id, recipient_id, message) def _send(self, tenant_id, account_id, message): """Sendet eine Nachricht oder puffert sie für die letzte Sitzung.""" # Erst nach erfolgreicher Token-Authentifizierung dürfen Nachrichten # an einen Client zugestellt werden. if not self.is_authenticated(tenant_id, account_id): self._queue_undeliverable(tenant_id, account_id, message) return False if self.send_to_connection(tenant_id, account_id, message.to_json()): return True self._queue_undeliverable(tenant_id, account_id, message) return False def _get_recipients(self, tenant_id, message, sender): """Bestimmt den Empfängerkreis abhängig vom Nachrichtencode.""" db = get_db() recipients = set() code = message.code payload = self._payload(message) def add_accounts(roles): placeholders = ','.join('?' for _ in roles) rows = db.execute( f'SELECT id FROM accounts WHERE tenant_id = ? AND role IN ({placeholders})', (tenant_id, *roles) ).fetchall() recipients.update(row['id'] for row in rows) def add_group_account(group_id): if not group_id: return rows = db.execute( '''SELECT account_id FROM group_accounts WHERE group_id = ? AND tenant_id = ?''', (group_id, tenant_id) ).fetchall() recipients.update(row['account_id'] for row in rows) if code == 99: # Alle verbundenen Clients des Mandanten müssen die Seite neu laden. add_accounts(('Gast', 'Beobachter', 'Gruppe', 'Dispatcher', 'Administrator')) elif code == 100: # Dispatcher, Gast, Beobachter + die mit der Straße verknüpfte # Gruppe. Bei einem Gruppenwechsel werden sowohl die alte als auch # die neue Gruppe benachrichtigt. add_accounts(('Dispatcher', 'Beobachter', 'Gast')) group_ids = set() group_id = payload.get('group_id') if isinstance(payload, dict) else None if group_id not in (None, ''): group_ids.add(group_id) old_group_id = getattr(message, '_old_group_id', None) if old_group_id is not None: group_ids.add(old_group_id) street_id = payload.get('street_id') if isinstance(payload, dict) else None # Das Payload stammt aus dem vertrauenswürdigen Server-Code. Nur # wenn keine Gruppen-ID enthalten ist, wird die Straße aus der # Datenbank gelesen. if street_id and not (isinstance(payload, dict) and 'group_id' in payload): street = db.execute( 'SELECT group_id FROM streets WHERE id = ? AND tenant_id = ?', (street_id, tenant_id) ).fetchone() if street and street['group_id'] is not None: group_ids.add(street['group_id']) for group_id in group_ids: add_group_account(group_id) elif code in (200, 300): # Dispatcher, Beobachter + die betroffene Gruppe. add_accounts(('Dispatcher', 'Beobachter')) group_id = self._resolve_group_id(tenant_id, message, sender, payload) add_group_account(group_id) elif code == 1000: # Broadcast an Dispatcher, Beobachter und alle Gruppen. add_accounts(('Dispatcher', 'Beobachter', 'Gruppe')) elif code == 1100: # Dispatcher, Beobachter + die spezielle Gruppe. add_accounts(('Dispatcher', 'Beobachter')) add_group_account(message.receiver_id) elif code == 2000: # Eine Gruppe sendet an Dispatcher und Beobachter. # Im Gruppen/Mobil-View sollen nur Nachrichten an alle oder an diese Gruppe ankommen. add_accounts(('Dispatcher', 'Beobachter')) group_id = self._resolve_group_id(tenant_id, message, sender, payload) if group_id: add_group_account(group_id) elif code == 2: # Heartbeat-Antworten werden nur an Dispatcher-Views weitergegeben. add_accounts(('Dispatcher',)) return recipients def _persist_message(self, tenant_id, message): """Speichert Nachrichten mit Code >= 1000 für die Late-Entry-Funktion.""" db = get_db() db.execute( 'INSERT INTO ws_messages_store ' '(tenant_id, sender_id, receiver_id, code, ts, msg) ' 'VALUES (?, ?, ?, ?, ?, ?)', (tenant_id, message.sender_id, message.receiver_id, message.code, message.ts, message.msg) ) db.commit() # ------------------------------------------------------------------ # Hilfsfunktionen # ------------------------------------------------------------------ @staticmethod def _payload(message): """Liefert den JSON-Payload einer Nachricht oder None.""" if isinstance(message, dict): msg = message.get('msg') if isinstance(msg, dict): return msg if isinstance(msg, str): try: data = json.loads(msg) return data if isinstance(data, dict) else None except (ValueError, TypeError): return None return None if hasattr(message, 'msg'): if isinstance(message.msg, dict): return message.msg if isinstance(message.msg, str): try: data = json.loads(message.msg) return data if isinstance(data, dict) else None except (ValueError, TypeError): return None return None def _resolve_group_id(self, tenant_id, message, sender, payload): """Ermittelt die betroffene Gruppen-ID aus Payload, receiver_id oder Absender.""" group_id = payload.get('group_id') if isinstance(payload, dict) else None if group_id is None: group_id = message.receiver_id if group_id is None and sender is not None and message.code in (200, 300, 2000): # Bei Gruppen-Nachrichten ist der Absender die Gruppe selbst. group = get_db().execute( '''SELECT g.id FROM groups g JOIN group_accounts ga ON ga.group_id = g.id AND ga.tenant_id = g.tenant_id WHERE ga.account_id = ? AND g.tenant_id = ?''', (sender['id'], tenant_id) ).fetchone() group_id = group['id'] if group else None if group_id is not None: try: group_id = int(group_id) except (TypeError, ValueError): group_id = None return group_id @staticmethod def _fetch_group(tenant_id, group_id): """Lädt eine Gruppe mandantenspezifisch.""" if not group_id: return None return get_db().execute( 'SELECT id, aliasname FROM groups WHERE id = ? AND tenant_id = ?', (group_id, tenant_id) ).fetchone()