""" 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 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. """ import json import time from datetime import datetime, timedelta, timezone 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 = {} # ------------------------------------------------------------------ # 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 genau einer Gruppe zugeordnet. if group_id is None and role == 'Gruppe': group = db.execute( 'SELECT id FROM groups WHERE account_id = ? AND 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, 'last_ping': datetime.now() } return True 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): """Authentifiziert eine Verbindung anhand des Einmal-Tokens (Code 0).""" 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 tenant_id not in self.authenticated: self.authenticated[tenant_id] = {} self.authenticated[tenant_id][account_id] = True # Nach erfolgreicher Authentifizierung dürfen die gespeicherten # Nachrichten der letzten 8 Stunden nachgeliefert werden. self.send_late_entries(tenant_id, account_id) 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: if ws is None or connections[account_id].get('ws') is ws: 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] def _get_connection(self, tenant_id, account_id): return self.connections.get(tenant_id, {}).get(account_id) # ------------------------------------------------------------------ # Late Entry # ------------------------------------------------------------------ def send_late_entries(self, tenant_id, account_id): """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() 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'] ) 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 id FROM groups WHERE account_id = ? AND 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 id FROM groups WHERE account_id = ? AND 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. if code == 2: 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): 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 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'): 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 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 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' and group['account_id'] != sender['id']: 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}) 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' and group['account_id'] != sender['id']: 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) 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) ) 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 }) 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 id, aliasname FROM groups WHERE account_id = ? AND 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, falls für den Account eine Verbindung besteht.""" # Erst nach erfolgreicher Token-Authentifizierung dürfen Nachrichten # an einen Client zugestellt werden. if not self.is_authenticated(tenant_id, account_id): return conn = self._get_connection(tenant_id, account_id) if not conn: return try: conn['ws'].send(message.to_json()) except Exception: # Eine fehlerhafte Verbindung darf den Versand an andere Clients # nicht verhindern. Das Aufräumen übernimmt die Route beim # Schließen der Verbindung. pass 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 group = db.execute( 'SELECT account_id FROM groups WHERE id = ? AND tenant_id = ?', (group_id, tenant_id) ).fetchone() if group and group['account_id']: recipients.add(group['account_id']) if 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 id FROM groups WHERE account_id = ? AND 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()