228 lines
8.0 KiB
Python
228 lines
8.0 KiB
Python
"""HTTP-Endpunkte für FCM-Registrierung und manuelle Aufwachsignale."""
|
||
from __future__ import annotations
|
||
|
||
import re
|
||
|
||
from flask import Blueprint, current_app, g, jsonify, request, session
|
||
|
||
from cmbnet.auth import login_required, role_required
|
||
from cmbnet.core.logging import write_fcm_debug_log
|
||
from cmbnet.services.fcm_service import fcm_service, public_fcm_config
|
||
from cmbnet.ws import broker, store
|
||
from cmbnet.ws.client_types import normalize_client_type
|
||
|
||
api_push_bp = Blueprint('api_push', __name__)
|
||
|
||
TOKEN_RE = re.compile(r'^[A-Za-z0-9_\-:.=]{20,4096}$')
|
||
|
||
|
||
def _json_body():
|
||
data = request.get_json(silent=True)
|
||
return data if isinstance(data, dict) else {}
|
||
|
||
|
||
def _platform_name(value):
|
||
text = str(value or '').strip().lower()
|
||
if text in ('ios', 'android', 'desktop'):
|
||
return text
|
||
return 'other'
|
||
|
||
|
||
@api_push_bp.route('/push/config', methods=['GET'])
|
||
@login_required
|
||
def push_config(**kwargs):
|
||
"""Liefert die öffentliche Firebase-Webkonfiguration."""
|
||
return jsonify(public_fcm_config())
|
||
|
||
|
||
@api_push_bp.route('/push/register', methods=['POST'])
|
||
@login_required
|
||
def register_push_token(**kwargs):
|
||
"""Registriert bzw. aktualisiert das FCM-Token einer mobilen Webview."""
|
||
account_id = session.get('account_id')
|
||
role = session.get('role')
|
||
data = _json_body()
|
||
|
||
token = str(data.get('token') or '').strip()
|
||
if not TOKEN_RE.fullmatch(token):
|
||
return jsonify({'ok': False, 'error': 'Ungültiges FCM-Token.'}), 400
|
||
|
||
client_type = normalize_client_type(data.get('client_type'), role)
|
||
if client_type is None:
|
||
return jsonify({
|
||
'ok': False,
|
||
'error': 'FCM ist für diese View oder Rolle nicht zugelassen.'
|
||
}), 403
|
||
|
||
requested_client_id = str(data.get('client_id') or '').strip()
|
||
if not requested_client_id:
|
||
return jsonify({'ok': False, 'error': 'Client-ID fehlt.'}), 400
|
||
client_id = broker.normalize_client_id(requested_client_id, account_id)
|
||
|
||
stored = store.upsert_push_token(
|
||
g.tenant_id,
|
||
client_id,
|
||
account_id,
|
||
token,
|
||
client_type,
|
||
platform=_platform_name(data.get('platform')),
|
||
auto_position=data.get('auto_position') is True,
|
||
)
|
||
if not stored:
|
||
return jsonify({
|
||
'ok': False,
|
||
'error': 'Client-ID gehört bereits zu einem anderen Account.'
|
||
}), 409
|
||
current_app.logger.info(
|
||
'FCM-Token registriert: tenant=%s client=%s type=%s',
|
||
g.tenant_id, client_id, client_type
|
||
)
|
||
write_fcm_debug_log({
|
||
'event': 'token-registered',
|
||
'client_id': client_id,
|
||
'account_id': account_id,
|
||
'client_type': client_type,
|
||
'platform': _platform_name(data.get('platform')),
|
||
}, tenant_id=g.tenant_id)
|
||
return jsonify({'ok': True})
|
||
|
||
|
||
@api_push_bp.route('/push/register', methods=['DELETE'])
|
||
@login_required
|
||
def unregister_push_token(**kwargs):
|
||
"""Entfernt ein FCM-Token, z. B. beim Abmelden."""
|
||
data = _json_body()
|
||
token = str(data.get('token') or '').strip()
|
||
if not token:
|
||
return jsonify({'ok': False, 'error': 'Token fehlt.'}), 400
|
||
store.delete_push_token(
|
||
g.tenant_id,
|
||
token=token,
|
||
account_id=session.get('account_id')
|
||
)
|
||
return jsonify({'ok': True})
|
||
|
||
|
||
@api_push_bp.route('/push/wake', methods=['POST'])
|
||
@role_required(['Dispatcher', 'Administrator'])
|
||
def wake_mobile_clients(**kwargs):
|
||
"""Löst manuell ein FCM-Aufwachsignal für mobile Clients aus.
|
||
|
||
Optional kann mit ``group_id`` auf die Clients einer Gruppe eingeschränkt
|
||
werden. Angesprochen werden alle mobilen Clients mit gültigem FCM-Token,
|
||
unabhängig davon, ob der Broker sie noch als verbunden führt. Gerade auf
|
||
iOS bleibt der Verbindungsstatus häufig veraltet, obwohl der Push-Kanal
|
||
weiterhin funktioniert.
|
||
"""
|
||
config = public_fcm_config()
|
||
if not config.get('enabled'):
|
||
return jsonify({
|
||
'ok': False,
|
||
'configured': False,
|
||
'error': 'FCM ist nicht vollständig konfiguriert.'
|
||
}), 503
|
||
|
||
data = _json_body()
|
||
group_id = data.get('group_id')
|
||
try:
|
||
group_id = int(group_id) if group_id not in (None, '') else None
|
||
except (TypeError, ValueError):
|
||
return jsonify({'ok': False, 'error': 'Ungültige Gruppen-ID.'}), 400
|
||
|
||
current = store.now()
|
||
stats = store.mobile_push_stats(g.tenant_id)
|
||
|
||
# Die öffentliche Web-Konfiguration kann vollständig sein, während der
|
||
# Server selbst nicht senden kann (fehlendes firebase-admin, fehlender
|
||
# oder ungültiger Service-Account). Ohne diese Prüfung würde der Button
|
||
# fälschlich „keine Clients gefunden“ melden, obwohl Tokens vorhanden
|
||
# sind.
|
||
server = fcm_service.server_status()
|
||
if not server['ready']:
|
||
message = server['error'] or 'FCM-Server ist nicht sendebereit.'
|
||
current_app.logger.warning(
|
||
'FCM-Wake nicht möglich: tenant=%s tokens=%s grund=%s',
|
||
g.tenant_id, stats['valid_tokens'], message
|
||
)
|
||
write_fcm_debug_log({
|
||
'event': 'wake-unavailable',
|
||
'group_id': group_id,
|
||
'valid_tokens': stats['valid_tokens'],
|
||
'connected': stats['connected'],
|
||
'error': message,
|
||
}, tenant_id=g.tenant_id)
|
||
return jsonify({
|
||
'ok': False,
|
||
'configured': False,
|
||
'error': message,
|
||
'valid_tokens': stats['valid_tokens'],
|
||
'connected': stats['connected'],
|
||
}), 503
|
||
|
||
candidates = store.offline_mobile_wake_candidates(
|
||
g.tenant_id,
|
||
disconnected_before=current,
|
||
# Ein ausdrücklicher Klick soll immer senden. Die automatische
|
||
# Drosselung über ``last_wake_at`` gilt nur für Nachrichten-Wakes.
|
||
# Andernfalls könnte ein kurz zuvor automatisch versuchtes Signal den
|
||
# Button für 15 Sekunden blockieren – der Nutzer sähe dann trotz
|
||
# registrierter Tokens „kein passender Client“.
|
||
re_wake_before=None,
|
||
group_id=group_id,
|
||
auto_position_only=False,
|
||
# Der Button soll alle registrierten mobilen Clients erreichen – auch
|
||
# solche, die der Broker noch als verbunden führt (typisch bei iOS).
|
||
include_connected=True,
|
||
limit=1000,
|
||
)
|
||
|
||
tokens = [row['token'] for row in candidates]
|
||
result = fcm_service.send_wake(tokens, reason='manual')
|
||
sent_tokens = set(result.get('sent_tokens') or [])
|
||
invalid_tokens = set(result.get('invalid_tokens') or [])
|
||
|
||
for row in candidates:
|
||
if row['token'] in sent_tokens:
|
||
store.set_client_wake_sent(
|
||
g.tenant_id, row['client_id'], 'manual', current
|
||
)
|
||
for token in invalid_tokens:
|
||
store.mark_push_token_invalid(token)
|
||
|
||
current_app.logger.info(
|
||
'FCM-Wake manuell: tenant=%s group=%s tokens=%s verbunden=%s '
|
||
'candidates=%s sent=%s failed=%s',
|
||
g.tenant_id, group_id, stats['valid_tokens'], stats['connected'],
|
||
len(candidates), int(result.get('sent') or 0),
|
||
int(result.get('failed') or 0)
|
||
)
|
||
error_details = list(result.get('errors') or [])[:5]
|
||
for item in error_details:
|
||
current_app.logger.warning(
|
||
'FCM-Wake-Fehler: tenant=%s token=%s error=%s',
|
||
g.tenant_id, item.get('fingerprint'), item.get('error')
|
||
)
|
||
write_fcm_debug_log({
|
||
'event': 'wake-manual',
|
||
'group_id': group_id,
|
||
'valid_tokens': stats['valid_tokens'],
|
||
'connected': stats['connected'],
|
||
'candidates': len(candidates),
|
||
'sent': int(result.get('sent') or 0),
|
||
'failed': int(result.get('failed') or 0),
|
||
'errors': error_details,
|
||
'error': result.get('error'),
|
||
}, tenant_id=g.tenant_id)
|
||
|
||
return jsonify({
|
||
'ok': True,
|
||
'configured': bool(result.get('configured')),
|
||
'candidates': len(candidates),
|
||
'sent': int(result.get('sent') or 0),
|
||
'failed': int(result.get('failed') or 0),
|
||
'valid_tokens': stats['valid_tokens'],
|
||
'connected': stats['connected'],
|
||
'errors': error_details,
|
||
'error': result.get('error'),
|
||
})
|