228 lines
7.3 KiB
Python
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
|