Files
Sternsinger/CMBNet/cmbnet/ws/broker.py
T
2026-10-23 00:05:06 +02:00

755 lines
30 KiB
Python

"""
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': <WebSocket-Objekt>,
# 'role': <Rolle des Accounts>,
# 'group_id': <verknüpfte Gruppe oder None>,
# }
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: nur Dispatcher und Beobachter.
if code == 2000:
return role in ('Dispatcher', 'Beobachter')
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 _prepare_message(self, tenant_id, message, sender):
"""Ergänzt Nachrichten um serverseitig abgeleitete Informationen."""
db = get_db()
payload = self._payload(message)
if message.code == 1100:
# Empfänger ist eine spezielle Gruppe. Die Gruppen-ID wird aus dem
# Payload oder dem receiver_id-Feld gelesen.
group_id = self._resolve_group_id(tenant_id, message, sender, payload)
group = self._fetch_group(tenant_id, group_id)
message.receiver_id = group_id
# Spezifikation: Dem Freitext wird der Aliasname der Gruppe
# vorangestellt. Ein bereits vorhandenes Präfix wird nicht doppelt
# gesetzt.
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
elif message.code == 2000:
# Spezifikation: Inhalt ist JSON mit Gruppen-ID und Freitext.
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 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.
add_accounts(('Dispatcher', 'Beobachter'))
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.msg, dict):
return message.msg
if not isinstance(message.msg, str):
return None
try:
data = json.loads(message.msg)
return data if isinstance(data, dict) else None
except (ValueError, TypeError):
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()