Files

228 lines
7.3 KiB
Python

"""
Geschäftslogik für Positionsmeldungen über die externe API.
"""
import json
from datetime import datetime, timezone
from flask import current_app
from cmbnet.db import get_db
from cmbnet.services.groups_service import GroupsService
from cmbnet.utils.helpers import log_transaction
from cmbnet.ws import broker
from cmbnet.ws.protocol import WSMessage
class GroupPositionService:
"""Aktualisiert Gruppenpositionen und verteilt sie über den Broker."""
@staticmethod
def parse_timestamp(value):
"""Wandelt gängige Zeitstempelformate in ein UTC-datetime um.
Unterstützt werden ISO-8601-Strings (auch mit ``Z``), SQLite-
Zeitstempel sowie Unix-Zeitangaben in Sekunden oder Millisekunden.
Naive Zeitangaben werden als UTC interpretiert.
"""
if value is None or value == '':
return None
parsed = None
if isinstance(value, datetime):
parsed = value
elif isinstance(value, (int, float)):
parsed = GroupPositionService._from_epoch(value)
elif isinstance(value, str):
text = value.strip()
if not text:
return None
try:
number = float(text)
except ValueError:
number = None
if number is not None:
parsed = GroupPositionService._from_epoch(number)
else:
parsed = GroupPositionService._from_iso(text)
if parsed is None:
return None
if parsed.tzinfo is None:
parsed = parsed.replace(tzinfo=timezone.utc)
return parsed.astimezone(timezone.utc)
@staticmethod
def _from_epoch(value):
try:
number = float(value)
except (TypeError, ValueError):
return None
if number <= 0:
return None
# Sekunden und Millisekunden unterscheiden. Werte ab 1e12 sind
# Millisekunden (entspricht dem Jahr 2001 und später).
if number < 1e12:
number *= 1000
try:
return datetime.fromtimestamp(number / 1000, tz=timezone.utc)
except (OverflowError, OSError, ValueError):
return None
@staticmethod
def _from_iso(text):
iso = text.strip()
if iso.endswith(('Z', 'z')):
iso = iso[:-1] + '+00:00'
try:
return datetime.fromisoformat(iso)
except ValueError:
pass
for fmt in (
'%Y-%m-%d %H:%M:%S',
'%Y-%m-%d %H:%M',
'%Y-%m-%d'
):
try:
return datetime.strptime(iso, fmt)
except ValueError:
continue
return None
@staticmethod
def format_db_timestamp(value):
"""Formatiert einen UTC-Zeitstempel wie die übrigen DB-Zeitstempel."""
return value.astimezone(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')
@staticmethod
def update_by_alias(tenant_id, aliasname, lat, lon, timestamp):
"""Übernimmt eine neue Position für die Gruppe mit dem Aliasnamen.
Die Prüfung auf einen älteren Zeitstempel und das Update erfolgen in
einer Transaktion mit Schreib-Lock. Dadurch können zwei parallele
Requests nicht beide denselben alten Stand überschreiben.
Rückgabe: ``(payload, http_status)``.
"""
db = get_db()
db.execute('BEGIN IMMEDIATE')
try:
groups = db.execute(
'''SELECT id, aliasname, last_lat, last_lon, last_pos_at
FROM groups
WHERE tenant_id = ? AND aliasname = ?''',
(tenant_id, aliasname)
).fetchall()
if not groups:
db.rollback()
return {
'success': False,
'error': 'Gruppe mit diesem Aliasnamen nicht gefunden'
}, 404
if len(groups) > 1:
db.rollback()
return {
'success': False,
'error': 'Aliasname ist nicht eindeutig'
}, 409
group = groups[0]
stored_timestamp = GroupPositionService.parse_timestamp(
group['last_pos_at']
)
if stored_timestamp is not None and timestamp < stored_timestamp:
db.rollback()
return {
'success': True,
'updated': False,
'reason': 'stale_timestamp',
'group_id': group['id'],
'aliasname': group['aliasname'],
'stored_timestamp': GroupPositionService.format_db_timestamp(
stored_timestamp
)
}, 200
pos_at = GroupPositionService.format_db_timestamp(timestamp)
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.commit()
except Exception:
db.rollback()
raise
# Den Prozess-Cache aktualisieren, damit Initialloads auf allen
# Workern die neue Position sehen. Die gemeinsame Revision wird dabei
# erhöht.
try:
GroupsService.update_cache_entry(tenant_id, group['id'], {
'last_lat': lat,
'last_lon': lon,
'last_pos_at': pos_at
})
except Exception:
current_app.logger.exception(
'Gruppenposition konnte nicht im Cache aktualisiert werden '
'(tenant=%s group=%s)', tenant_id, group['id']
)
try:
log_transaction('group.position_api', 'group', group['id'], {
'lat': lat,
'lon': lon,
'timestamp': pos_at,
'source': 'api'
})
except Exception:
current_app.logger.exception(
'API-Positionsänderung konnte nicht protokolliert werden '
'(tenant=%s group=%s)', tenant_id, group['id']
)
ts_ms = int(timestamp.timestamp() * 1000)
distributed = True
try:
message = WSMessage(
sender_id=None,
receiver_id=group['id'],
code=300,
ts=ts_ms,
msg=json.dumps({
'group_id': group['id'],
'lat': lat,
'lon': lon,
'ts': ts_ms,
'source': 'api'
}, ensure_ascii=False)
)
broker.deliver_server_message(tenant_id, message)
except Exception:
distributed = False
current_app.logger.exception(
'Code-300-Nachricht konnte nicht verteilt werden '
'(tenant=%s group=%s)', tenant_id, group['id']
)
return {
'success': True,
'updated': True,
'group_id': group['id'],
'aliasname': group['aliasname'],
'lat': lat,
'lon': lon,
'timestamp': pos_at,
'ts': ts_ms,
'distributed': distributed
}, 200