1776 lines
73 KiB
Python
1776 lines
73 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 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.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': <WebSocket-Objekt>,
|
|
# 'account_id': <zugehöriger Account>,
|
|
# 'role': <Rolle des Accounts>,
|
|
# 'group_id': <verknüpfte Gruppe oder None>,
|
|
# }
|
|
# 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 = '<redacted>'
|
|
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,
|
|
reason=reason,
|
|
limit=1,
|
|
)
|
|
if not rows:
|
|
return False
|
|
|
|
tokens = [row['token'] for row in rows]
|
|
result = fcm_service.send_wake(tokens, reason=reason)
|
|
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()):
|
|
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()
|