""" 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 os import re import socket import time import uuid from datetime import datetime, timedelta, timezone from threading import Event, Lock from flask import current_app from cmbnet.db import get_db from cmbnet.core.logging import write_fcm_debug_log from cmbnet.services.fcm_service import fcm_service from cmbnet.services.groups_service import GroupsService from cmbnet.ws import store from cmbnet.ws.client_types import normalize_client_type from cmbnet.ws.protocol import WSMessage class WebSocketBroker: def __init__(self): # connections[tenant_id][client_id] = { # 'ws': , # 'account_id': , # 'role': , # 'group_id': , # } # Eine Client-ID gehört genau zu einer Webview. Mehrere Clients # desselben Accounts besitzen daher getrennte Einträge. Dieses Dict # enthält bewusst nur die Verbindungen des aktuellen Worker-Prozesses. self.connections = {} # authenticated[tenant_id][client_id] = True # Erst nach erfolgreichem Code-0-Handshake darf ein Client Nachrichten # über die Verbindung senden. Auch dieser Status ist prozesslokal. self.authenticated = {} # Gemeinsamer Zustand liegt in SQLite (siehe cmbnet/ws/store.py): # ws_clients, ws_client_queue und ws_group_presence. Dadurch finden # Reconnects auf einem anderen Worker ihre Queue und Sequenznummer. self.worker_id = os.environ.get('CMBNET_WS_WORKER_ID') or '' if not self.worker_id: self.worker_id = f'{socket.gethostname()}:{os.getpid()}' # Sequenznummern werden pro Client-ID vergeben. Der lokale Cache wird # beim Registrieren aus der Datenbank geladen; nach jedem erfolgreichen # Versand wird die gemeinsame Zählung fortgeschrieben. self.client_sequences = {} # Ein Lock pro Client-ID serialisiert Sequenzvergabe und Sendevorgang # auch dann, wenn die Verbindung während eines Reconnects ersetzt wird. self.client_sequence_locks = {} # Serialisiert das Ausliefern der gemeinsamen Queue pro Client, damit # Authentifizierung und Polling-Schleife nicht parallel dieselben # Aufträge versenden. self.client_delivery_locks = {} # Weckt die lokale Polling-Schleife nach einer neu eingestellten # Nachricht. Workerübergreifend übernimmt das reguläre Polling. self.delivery_wakeup = Event() # ------------------------------------------------------------------ # Verbindungen und Authentifizierung # ------------------------------------------------------------------ def register_connection(self, tenant_id, account_id, client_id, ws, role=None, group_id=None, client_type=None): """Registriert eine neue, noch nicht authentifizierte Client-Verbindung. Die Verbindung wird anhand der Client-ID verwaltet. Die Account-ID wird mitgeführt, damit Empfänger weiterhin über Rollen und Gruppen ermittelt werden können und ein Account mehrere Clients parallel betreiben kann. ``client_type`` ist ausschließlich ein FCM-Routing-Merkmal. Der Wert wird gegen die Rolle des Accounts geprüft; ein Dispatcher kann sich beispielsweise nicht als Gruppen-View ausgeben. """ if not client_id: return False 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 # Eine Client-ID ist an den Account gebunden, der sie im Handshake # verwendet hat. Ein Wechsel des Accounts unter derselben ID wäre ein # Hinweis auf eine falsche bzw. manipulierte Zuordnung. Die Zuordnung # liegt prozessübergreifend in ws_clients. existing_account = store.get_client_account(tenant_id, client_id) if existing_account is not None and existing_account != account_id: return False if role is None: role = account['role'] client_type = normalize_client_type(client_type, role) if not store.ensure_client( tenant_id, client_id, account_id, worker_id=self.worker_id, client_type=client_type ): return False # Der Worker ist offensichtlich aktiv; sein Lebenszeichen verhindert, # dass andere Worker seine Clients fälschlich als verwaist markieren. store.touch_worker(self.worker_id) # 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 connections = self.connections.setdefault(tenant_id, {}) key = (tenant_id, client_id) # Eine neue Verbindung mit derselben Client-ID ersetzt eine eventuell # noch registrierte alte Verbindung (z. B. nach einem schnellen # Reconnect). existing = connections.get(client_id) if existing and existing.get('ws') is not ws: try: existing['ws'].close() except Exception: pass # Eine neue Verbindung muss den Token-Handshake erneut durchlaufen. authenticated = self.authenticated.setdefault(tenant_id, {}) authenticated.pop(client_id, None) connections[client_id] = { 'ws': ws, 'account_id': account_id, 'client_id': client_id, 'role': role, 'group_id': group_id, 'client_type': client_type, 'last_ping': datetime.now(), 'connected_at': time.monotonic(), 'last_pong_at': None, # Zeitpunkt des letzten beliebigen Lebenszeichens. Wird beim # Handshake gesetzt und bei jeder eingehenden Nachricht # aktualisiert, damit auch Clients ohne Pong nicht fälschlich # als tot gelten. 'last_seen_at': time.time(), # Zuletzt an diese Client-ID zugestellte Sequenznummer. Die # maßgebliche Zählung liegt in ws_clients und überlebt damit einen # Worker-Wechsel. 'seq': store.get_last_seq(tenant_id, client_id), # Ob diese Client-ID bereits vor diesem Handshake bekannt war. # Nur dann bleibt ihre Queue auch bei einem fehlgeschlagenen # erneuten Handshake erhalten. 'known_client': existing_account is not 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() } self.client_sequences[key] = store.get_last_seq(tenant_id, client_id) self.client_delivery_locks.setdefault(key, Lock()) return True def send_to_connection(self, tenant_id, client_id, data): """Sendet einen Frame mit Sequenznummer thread-sicher an einen Client. Die Sequenz wird pro Client-ID vergeben. Sie wird erst nach einem erfolgreichen Socket-Send fortgeschrieben, damit ein fehlgeschlagener Versand beim erneuten Zustellen keine Lücke erzeugt. Die Zählung bleibt über Reconnects derselben Webview erhalten. """ key = (tenant_id, client_id) seq_lock = self.client_sequence_locks.setdefault(key, Lock()) with seq_lock: conn = self._get_connection(tenant_id, client_id) if not conn: return False try: payload = json.loads(data) if not isinstance(payload, dict): return False last_seq = self.client_sequences.get(key) if last_seq is None: last_seq = store.get_last_seq(tenant_id, client_id) next_seq = last_seq + 1 payload['seq'] = next_seq framed = json.dumps(payload, ensure_ascii=False) send_lock = conn.get('send_lock') if send_lock is None: send_lock = Lock() conn['send_lock'] = send_lock with send_lock: conn['ws'].send(framed) self.client_sequences[key] = next_seq conn['seq'] = next_seq # Die Sequenz wird erst nach erfolgreichem Senden persistiert, # damit ein fehlgeschlagener Versand keine Lücke erzeugt. store.set_last_seq( tenant_id, client_id, next_seq, account_id=conn.get('account_id') ) 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, client_id): """Prüft, ob ein Client den Code-0-Handshake erfolgreich absolviert hat.""" return self.authenticated.get(tenant_id, {}).get(client_id, False) def describe_connections(self, tenant_id): """Liefert alle verbundenen Clients des Mandanten aus der gemeinsamen DB.""" return store.describe_connections(tenant_id) def authenticate(self, tenant_id, account_id, client_id, token): """Authentifiziert eine Client-Verbindung anhand des Einmal-Tokens (Code 0). Die Client-ID wird pro Webview erzeugt und ordnet die Verbindung einer eventuell vorhandenen Nachrichten-Queue zu. Nach einem Neuladen der Seite entsteht eine neue Client-ID und damit bewusst eine neue Sitzung. """ conn = self._get_connection(tenant_id, client_id) if not conn or conn.get('account_id') != account_id: return False 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() 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. store.set_group_online_since(tenant_id, conn['group_id']) self.authenticated.setdefault(tenant_id, {})[client_id] = True conn['last_seen_at'] = time.time() conn['last_pong_at'] = conn['last_seen_at'] store.mark_authenticated( tenant_id, client_id, True, worker_id=self.worker_id ) self.client_sequences[(tenant_id, client_id)] = store.get_last_seq( tenant_id, client_id ) # Zuerst die für diesen Client 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_client_queue( tenant_id, client_id ) # Nach erfolgreicher Authentifizierung dürfen die gespeicherten # Nachrichten der letzten 8 Stunden nachgeliefert werden. Bereits aus # der Client-Queue zugestellte Nachrichten werden dabei ausgelassen. if not suppress_late_entries: self.send_late_entries( tenant_id, account_id, client_id, skip_messages=queued_messages ) return True def remove_connection(self, tenant_id, client_id, ws=None): """Entfernt eine Client-Verbindung. Die Client-ID bleibt mit ihrem Account und ihrer Queue registriert, bis sie entweder zurückkehrt oder vom Aufräumjob verworfen wird. Dadurch können kurze Unterbrechungen überbrückt werden, ohne andere Clients desselben Accounts zu beeinflussen. """ connections = self.connections.get(tenant_id) if not connections or client_id not in connections: return conn = connections[client_id] if ws is not None and conn.get('ws') is not ws: return was_authenticated = self.is_authenticated(tenant_id, client_id) was_known_client = conn.get('known_client', True) del connections[client_id] if not connections: self.connections.pop(tenant_id, None) authenticated = self.authenticated.get(tenant_id) if authenticated: authenticated.pop(client_id, None) if not authenticated: self.authenticated.pop(tenant_id, None) key = (tenant_id, client_id) self.client_sequences.pop(key, None) self.client_sequence_locks.pop(key, None) if not was_authenticated and not was_known_client: # Ein nie erfolgreich authentifizierter neuer Client hinterlässt # keine Zuordnung, Queue oder Empfängerregistrierung. store.delete_client( tenant_id, client_id, worker_id=self.worker_id ) self.client_delivery_locks.pop(key, None) return # Die Client-ID bleibt samt Queue bekannt. Ein Reconnect kann auf # einem beliebigen Worker landen und findet den Zustand dort wieder. # Das Delivery-Lock bleibt bestehen, damit eine laufende Zustellung # nicht mit einer neuen Verbindung derselben Client-ID kollidiert. store.mark_disconnected( tenant_id, client_id, worker_id=self.worker_id ) def check_client_liveness(self, timeout_seconds): """Trennt authentifizierte Verbindungen ohne Lebenszeichen. Ein sauber geschlossener WebSocket wird bereits in der WS-Route erkannt. Mobile Geräte verlieren die Verbindung beim Schlafenlegen jedoch oft ohne FIN/RST; der Server sieht dann scheinbar eine offene Verbindung und markiert den Client nie als getrennt. Diese Prüfung schließt solche halb offenen Verbindungen nach ``timeout_seconds`` und macht sie damit für FCM-Aufwachsignale sichtbar. Rückgabe: Anzahl der getrennten Verbindungen. """ try: timeout_seconds = float(timeout_seconds) except (TypeError, ValueError): timeout_seconds = 0 if timeout_seconds <= 0: return 0 now = time.time() disconnected = 0 for tenant_id, connections in list(self.connections.items()): for client_id, conn in list(connections.items()): if not self.is_authenticated(tenant_id, client_id): continue last_seen = conn.get('last_seen_at') or conn.get('last_pong_at') if last_seen is None: # Sehr alte Verbindungsobjekte haben noch keinen # Zeitstempel; sie erhalten eine Gnadenfrist. conn['last_seen_at'] = now continue if now - last_seen <= timeout_seconds: continue ws = conn.get('ws') try: if ws is not None: ws.close() except Exception: pass self.remove_connection(tenant_id, client_id, ws) disconnected += 1 try: current_app.logger.info( 'WebSocket-Verbindung ohne Lebenszeichen getrennt: ' 'tenant=%s client=%s last_seen=%.0fs', tenant_id, client_id, now - last_seen ) except Exception: pass return disconnected def _get_connection(self, tenant_id, client_id): return self.connections.get(tenant_id, {}).get(client_id) def log_incoming(self, tenant_id, message, sender=None, recipients=None, note=None): """Schreibt eine Debugzeile für eine beim Broker eingehende Nachricht. Erfasst werden Absender, Code, Empfänger-ID, Payload (bei Code 0 ohne Token) und der ermittelte Empfängerkreis inklusive Verbindungsstatus. Die Ausgabe ist unabhängig von der Flask-Logger-Konfiguration und kann über ``WS_DEBUG_MESSAGES`` abgeschaltet werden. """ try: if not current_app.config.get('WS_DEBUG_MESSAGES', True): return except RuntimeError: return try: db = get_db() if sender is None and message.sender_id: sender = db.execute( 'SELECT * FROM accounts WHERE id = ? AND tenant_id = ?', (message.sender_id, tenant_id) ).fetchone() sender_info = ( self._get_sender_info(tenant_id, sender) if sender is not None else None ) sender_client_id = ( getattr(message, '_sender_client_id', None) or getattr(message, 'client_id', None) ) if sender_info is not None and sender_client_id: sender_info['client_id'] = sender_client_id recipient_rows = [] for recipient_id in sorted(set(recipients or [])): client_row = store.get_client(tenant_id, recipient_id) account_id = client_row['account_id'] if client_row else None account = None if account_id is not None: account = db.execute( 'SELECT * FROM accounts WHERE id = ? AND tenant_id = ?', (account_id, tenant_id) ).fetchone() if account is None: recipient_rows.append({ 'client_id': recipient_id, 'account_id': account_id, 'known': False, 'connected': False, 'authenticated': False }) continue info = self._get_sender_info(tenant_id, account) info['client_id'] = recipient_id info['connected'] = bool( client_row and client_row['disconnected_at'] is None ) info['authenticated'] = bool( client_row and client_row['authenticated'] ) recipient_rows.append(info) payload = message.msg if message.code == 0: payload = '' elif not isinstance(payload, str): payload = json.dumps(payload, ensure_ascii=False, default=str) payload = str(payload) if len(payload) > 1000: payload = payload[:1000] + '…' entry = { 'code': message.code, 'sender': sender_info, 'receiver_id': message.receiver_id, 'client_id': sender_client_id, 'ts': message.ts, 'msg': payload, 'recipients': recipient_rows, 'note': note } from cmbnet.core.logging import write_ws_debug_log write_ws_debug_log(tenant_id, entry) except Exception as exc: # Eine Debugausgabe darf den Nachrichtenfluss niemals stören. try: current_app.logger.warning('WS-Debugausgabe fehlgeschlagen: %s', exc) except Exception: pass # ------------------------------------------------------------------ # Client-Queues # ------------------------------------------------------------------ @staticmethod def normalize_client_id(value, account_id=None): """Validiert die vom Webview gelieferte Client-ID. Die Client-ID wird pro Seitenaufruf neu erzeugt. Ältere Clients, die noch keine ID senden, erhalten eine eindeutige Ersatz-ID. Diese ist bewusst nicht accountweit stabil, weil eine neue Verbindung ohne ID nicht sicher derselben alten Webview zugeordnet werden kann. """ text = str(value or '').strip() if re.fullmatch(r'[A-Za-z0-9._:-]{8,128}', text): return text return f'legacy-{account_id or 0}-{uuid.uuid4().hex}' def _client_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 _client_retention_seconds(self): minutes = current_app.config.get('WS_CLIENT_RETENTION_MINUTES', 60) try: minutes = float(minutes) except (TypeError, ValueError): minutes = 60 return max(self._client_queue_max_age_seconds(), minutes * 60) def _ephemeral_ttl_seconds(self): try: return max(1.0, float(current_app.config.get( 'WS_EPHEMERAL_TTL_SECONDS', 30 ))) except (TypeError, ValueError): return 30.0 def _queue_undeliverable(self, tenant_id, client_id, message): """Puffert eine nicht zustellbare Nachricht für einen Client. Bei Code 2 handelt es sich um ein kurzlebiges Lebenszeichen. Es wird nur für aktuell verbundene Clients gepuffert, damit ein späterer Reconnect kein veraltetes Pong erhält. """ if message.code == 2: if not store.client_is_connected(tenant_id, client_id): return False elif message.code < 100 and message.code != 99: return False if not store.client_exists(tenant_id, client_id): return False queued = store.enqueue_message( tenant_id, client_id, message.code, message.to_json(), self._client_queue_max_age_seconds(), timeout_payload=self._client_queue_timeout_message(), ephemeral_seconds=( self._ephemeral_ttl_seconds() if message.code == 2 else None ) ) if queued: self.delivery_wakeup.set() # Mobile Clients, die als getrennt gelten, werden zusätzlich über # FCM geweckt. Der eigentliche Inhalt bleibt in der Queue. if message.code >= 99: self.wake_client(tenant_id, client_id, 'queue') return queued def wake_client(self, tenant_id, client_id, reason='queue', cooldown_seconds=None): """Sendet bei Bedarf ein FCM-Aufwachsignal an einen mobilen Client. Die Methode ist bewusst idempotent und durch ``last_wake_at`` gedrosselt. Sie wird sowohl beim Einreihen einer Nachricht als auch vom periodischen Offline-Worker aufgerufen. """ try: if not fcm_service.server_ready(): return False if cooldown_seconds is None: try: cooldown_seconds = int(current_app.config.get( 'FCM_QUEUE_WAKE_COOLDOWN_SECONDS', 60 )) except (TypeError, ValueError): cooldown_seconds = 60 current = store.now() rows = store.claim_offline_mobile_wakes( tenant_id, disconnected_before=current, re_wake_before=current - max(0, cooldown_seconds), client_id=client_id, # Auch verbundene mobile Clients wecken: Besonders auf iOS # bleibt der Broker-Status „verbunden“, obwohl der Socket # nicht mehr erreichbar ist. Der Cooldown verhindert eine # Flut von Signalen. include_connected=current_app.config.get( 'FCM_WAKE_CONNECTED_CLIENTS', True ), reason=reason, limit=1, ) if not rows: return False tokens = [row['token'] for row in rows] result = fcm_service.send_wake(tokens, reason=reason) write_fcm_debug_log({ 'event': 'wake-auto', 'client_id': client_id, 'reason': reason, 'tokens': len(tokens), 'sent': int(result.get('sent') or 0), 'failed': int(result.get('failed') or 0), 'errors': list(result.get('errors') or [])[:5], 'error': result.get('error'), }, tenant_id=tenant_id) for token in result.get('invalid_tokens') or []: store.mark_push_token_invalid(token) if result.get('sent'): return True # Ein fehlgeschlagenes Signal wird nicht als erfolgreich verbucht. # Der nächste Versuch darf aber erst nach dem Cooldown erfolgen, um # bei einem FCM-Ausfall keine Schleife zu erzeugen. for row in rows: store.set_client_wake_sent( tenant_id, row['client_id'], f'{reason}:failed', current ) return False except Exception as exc: # Ein FCM-Problem darf das Einreihen und Ausliefern fachlicher # Nachrichten niemals verhindern. try: current_app.logger.warning( 'FCM-Aufwachsignal fehlgeschlagen (tenant=%s, client=%s): %s', tenant_id, client_id, exc ) except Exception: pass return False def cleanup_client_queues(self): """Räumt abgelaufene Queues und verwaiste Clients in der DB auf.""" store.purge_expired_queue_rows() store.expire_queues( self._client_queue_max_age_seconds(), self._client_queue_timeout_message() ) store.cleanup_clients(self._client_retention_seconds()) try: token_retention = float(current_app.config.get( 'FCM_PUSH_TOKEN_RETENTION_MINUTES', 1440 )) * 60 except (TypeError, ValueError): token_retention = 1440 * 60 store.cleanup_orphan_push_tokens(max(3600.0, token_retention)) # Lokale Caches für inzwischen entfernte Clients bereinigen. for key in list(self.client_sequences): if not store.client_exists(*key): self.client_sequences.pop(key, None) self.client_sequence_locks.pop(key, None) for key in list(self.client_delivery_locks): if not store.client_exists(*key): self.client_delivery_locks.pop(key, None) def _client_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 _client_delivery_lock(self, tenant_id, client_id): return self.client_delivery_locks.setdefault( (tenant_id, client_id), Lock() ) def restore_client_queue(self, tenant_id, client_id): """Liefert persistierte Nachrichten eines wiedererkannten Clients 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. """ with self._client_delivery_lock(tenant_id, client_id): rows = store.fetch_queue(tenant_id, client_id) if not rows: return set(), False started_at = store.get_queue_started_at(tenant_id, client_id) max_age = self._client_queue_max_age_seconds() if started_at is not None and store.now() - started_at >= max_age: store.replace_queue_with_timeout( tenant_id, client_id, self._client_queue_timeout_message() ) rows = store.fetch_queue(tenant_id, client_id) suppress_late_entries = True else: suppress_late_entries = any( row['code99_only'] for row in rows ) raw_messages = set() for row in rows: raw_message = row['payload'] if not self.send_to_connection(tenant_id, client_id, raw_message): # Verbindung ist bereits wieder weg. Noch nicht # zugestellte Aufträge bleiben in der Queue. break if not row['code99_only']: raw_messages.add(raw_message) store.delete_queue_row(row['id']) return raw_messages, suppress_late_entries def drain_client_queue(self, tenant_id, client_id): """Stellt die gemeinsame Queue eines lokal verbundenen Clients zu.""" self.restore_client_queue(tenant_id, client_id) def drain_local_clients(self): """Zustellrunde für alle lokal verbundenen, authentifizierten Clients.""" local_clients = set() for tenant_id, connections in list(self.connections.items()): for client_id in list(connections): if self.is_authenticated(tenant_id, client_id): local_clients.add((tenant_id, client_id)) if not local_clients: return # Nur Clients mit tatsächlich wartenden Aufträgen öffnen eine # Transaktion. Das hält die Polling-Schleife bei vielen verbundenen # Clients günstig. for tenant_id, client_id in store.clients_with_queue(local_clients): try: self.drain_client_queue(tenant_id, client_id) except Exception as exc: try: current_app.logger.warning( 'WS-Queue-Zustellung fehlgeschlagen: tenant=%s client=%s error=%s', tenant_id, client_id, exc ) except Exception: pass # ------------------------------------------------------------------ # Late Entry # ------------------------------------------------------------------ def send_late_entries(self, tenant_id, account_id, client_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 an genau den Client, der sich gerade authentifiziert hat. 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, client_id) if not conn or conn.get('account_id') != account_id: 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, client_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, client_id=None): """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. ``client_id`` ist die Verbindung, über die die Nachricht eingegangen ist. Sie wird z. B. für den exakten Pong-Status der Webview benötigt. """ if client_id: message._sender_client_id = client_id conn = self._get_connection(tenant_id, client_id) if conn is not None: conn['last_seen_at'] = time.time() 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: self.log_incoming( tenant_id, message, sender=None, recipients=[], note='Absender nicht im Mandanten gefunden' ) return code = message.code # Code 0 wird ausschließlich in der WebSocket-Route (Handshake) # verarbeitet und niemals weitergeleitet. if code <= 0: self.log_incoming( tenant_id, message, sender, recipients=[], note='interner Code, wird nicht über route_message verteilt' ) return # Code 1 sendet ausschließlich der Server (Heartbeat-Routine). # Nachrichten dieses Typs von Clients werden ignoriert. if code == 1: self.log_incoming( tenant_id, message, sender, recipients=[], note='Code 1 von Client ignoriert' ) 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, client_id) 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: self.log_incoming( tenant_id, message, sender, recipients=[], note='Code 99 von Client ignoriert' ) return self._deliver(tenant_id, message, sender) return # Sonstige interne Codes (< 100) werden nicht an die Oberfläche gegeben. if code < 100: self.log_incoming( tenant_id, message, sender, recipients=[], note='interner Code < 100 ignoriert' ) return # Chat-Nachrichten dürfen nur von der jeweils vorgesehenen Rolle # gesendet werden. Bei Code 2000 muss die Zielgruppe außerdem die # eigene Gruppe des sendenden Accounts sein. if code >= 1000: allowed, reason = self._validate_chat_sender(tenant_id, message, sender) if not allowed: current_app.logger.warning( 'WebSocket-Chatnachricht abgelehnt: code=%s sender=%s role=%s tenant=%s reason=%s', code, sender['id'], sender['role'], tenant_id, reason ) self.log_incoming( tenant_id, message, sender, recipients=[], note=reason ) 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] ) self.log_incoming( tenant_id, message, sender, recipients=[], note='fachliche Änderung abgelehnt' ) 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 normalisierte Nachricht. if code >= 1000: self._persist_message(tenant_id, message) self._deliver(tenant_id, message, sender) def deliver_server_message(self, tenant_id, message, sender=None): """Stellt eine serverseitig erzeugte Nachricht zu. Der Aufrufer hat den fachlichen Zustand bereits in der Datenbank gespeichert. Deshalb wird hier bewusst nicht erneut ``apply_business`` ausgeführt. ``sender`` darf ``None`` sein, wenn die Nachricht nicht von einem Account stammt (z. B. bei der externen Positions-API). """ 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, client_id=None): """Wertet ein Code-2-Lebenszeichen eines Clients aus.""" conn = self._get_connection(tenant_id, client_id) if client_id else None if conn and conn.get('account_id') == account_id: conn['last_pong_at'] = time.time() 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 group_id = group['id'] store.record_group_pong(tenant_id, group_id) 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'] # Der Vergleich im UPDATE verhindert, dass zwei Worker denselben # automatischen Statuswechsel gleichzeitig in die Historie schreiben. cursor = db.execute( 'UPDATE groups SET state = ?, updated_at = CURRENT_TIMESTAMP ' 'WHERE id = ? AND tenant_id = ? AND state = ?', (new_state, group_id, tenant_id, old_state) ) if cursor.rowcount == 0: db.rollback() return False 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': store.set_group_online_since(tenant_id, group_id) 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 current = store.now() for row in rows: presence = store.get_group_presence(row['tenant_id'], row['id']) last_pong = presence['last_pong_at'] if presence else None online_since = presence['online_since'] if presence else None reference = last_pong if online_since is not None: reference = ( max(reference, online_since) if reference is not None else online_since ) if reference is None: # Zustand war bereits vor dem Start des Trackings "online". # Ab jetzt läuft die Kulanzfrist. store.set_group_online_since(row['tenant_id'], row['id'], current) continue if current - 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': store.set_group_online_since(tenant_id, group_id) 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 == 2000: # Auch Code 2000 muss die Zielgruppe explizit im Envelope und im # Payload tragen. Sonst können weder Dispatcher-Ansichten noch # Late Entries die Nachricht einer Gruppe zuordnen. 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 _validate_chat_sender(self, tenant_id, message, sender): """Prüft Senderrolle und Gruppenzuordnung für Chat-Nachrichten.""" code = message.code role = sender['role'] if code in (1000, 1100): if role != 'Dispatcher': return False, f'Code {code} ist nur für Dispatcher erlaubt' return True, None if code == 2000: if role != 'Gruppe': return False, 'Code 2000 ist nur für Gruppen-Accounts erlaubt' payload = self._payload(message) group_id = self._resolve_group_id(tenant_id, message, sender, payload) sender_group_id = self._get_sender_info(tenant_id, sender).get('group_id') if group_id is None or sender_group_id is None: return False, 'Gruppen-Account ist keiner Gruppe zugeordnet' try: if int(group_id) != int(sender_group_id): return False, 'Code 2000 darf nur an die eigene Gruppe gesendet werden' except (TypeError, ValueError): return False, 'Ungültige Gruppen-ID für Code 2000' return True, None return True, None def _prepare_message(self, tenant_id, message, sender): """Ergänzt Chat-Nachrichten um serverseitig abgeleitete Informationen.""" if message.code >= 1000: payload = self._payload(message) 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 Clients zu. Lokal verbundene Clients erhalten den Frame direkt. Für alle anderen Clients wird ein persistenter Auftrag in der gemeinsamen Queue angelegt. Jeder Worker pollt diese Queue für seine eigenen Clients. """ recipients = sorted(self._get_recipients(tenant_id, message, sender)) self.log_incoming(tenant_id, message, sender, recipients=recipients) for client_id in recipients: self._send(tenant_id, client_id, message) self.delivery_wakeup.set() def _send(self, tenant_id, client_id, message): """Sendet eine Nachricht an einen Client oder puffert sie für ihn.""" conn = self._get_connection(tenant_id, client_id) authenticated = self.is_authenticated(tenant_id, client_id) # Ein lokal verbundener Client ohne wartende Queue wird direkt # bedient. Existiert bereits eine Queue, wird auch diese Nachricht # eingereiht, damit die Reihenfolge erhalten bleibt. if conn and authenticated and not store.client_has_queue(tenant_id, client_id): if self.send_to_connection(tenant_id, client_id, message.to_json()): # Ein erfolgreicher Socket-Schreibvorgang bedeutet nicht, # dass der Client die Nachricht wirklich empfängt. Gerade # iOS-Geräte im Hintergrund behalten scheinbar eine offene # Verbindung. Deshalb wird für mobile Clients zusätzlich ein # FCM-Signal abgesetzt; der Cooldown verhindert Duplikate. if message.code >= 99 and current_app.config.get( 'FCM_WAKE_CONNECTED_CLIENTS', True ): self.wake_client(tenant_id, client_id, 'queue') return True self._queue_undeliverable(tenant_id, client_id, message) return False def _client_ids_for_accounts(self, tenant_id, account_ids): """Expandiert Empfänger-Accounts auf alle bekannten Client-IDs. Die Zuordnung liegt in ws_clients und umfasst damit auch Clients, die an anderen Workern verbunden oder momentan getrennt sind. """ return store.client_ids_for_accounts(tenant_id, account_ids) def _get_recipients(self, tenant_id, message, sender): """Bestimmt den Empfängerkreis abhängig vom Nachrichtencode. Die fachliche Empfängerermittlung erfolgt weiterhin über Rollen und Gruppen. Am Ende werden die gefundenen Accounts auf alle ihre bekannten Clients expandiert, damit ein Account mehrere Webviews parallel betreiben kann. """ db = get_db() recipient_accounts = 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() recipient_accounts.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() recipient_accounts.update(row['account_id'] for row in rows) if code == 99: # Alle 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 self._client_ids_for_accounts(tenant_id, recipient_accounts) 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()