API für Geo Positions Update mit Testscript

This commit is contained in:
concierge committed 2026-11-04 14:42:45 +01:00
1 parent 23a9df66f4
commit d54a986c14
16 files changed
+1027 -6

No files matched your search

+47
View File
@@ -101,6 +101,53 @@ Eine ausführliche Beschreibung des Protokolls, der Brokerlogik, der
Nebenläufigkeit und der aktuellen Abweichungen steht in
[`../doc/broker.md`](../doc/broker.md).
## Externe Gruppenpositions-API
Externe Systeme können die Position einer Gruppe per HTTP-POST melden:
```http
POST /<tenant>/api/groups/position
Content-Type: application/json
{
"lat": 50.701243,
"lon": 7.153290,
"timestamp": "2026-11-04T12:00:00Z",
"token": "<API-Zugriffstoken>",
"aliasname": "Gruppe 1"
}
```
Der Zeitstempel kann als ISO-8601-String oder als Unix-Zeit in Sekunden bzw.
Millisekunden angegeben werden; Zeitangaben ohne Zeitzone werden als UTC
interpretiert. Ist er älter als der in der Datenbank gespeicherte
`last_pos_at`, wird weder die Datenbank noch der Broker aktualisiert. Eine erfolgreiche Aktualisierung wird als Code-300-Nachricht an
Dispatcher, Beobachter und die betroffene Gruppe verteilt.
Die Zugriffstoken sind mandantenweit gültig und werden im Admin-Dashboard
unter **API-Zugriffstoken** angezeigt. Dort kann jeder Token einzeln gelöscht
und ein neuer zufälliger Token erzeugt werden. Ohne einen gültigen Token wird
der Request mit HTTP 401 abgewiesen.
Zum Testen des Endpunkts dient `scripts/test_group_position_api.py`. Es liest
Koordinaten aus `../data/rv-hnr.csv`, verwendet standardmäßig den ersten Token
und die erste Gruppe des Mandanten `RV` und prüft Aktualisierung, ältere
Zeitstempel und ungültige Tokens:
```bash
python scripts/test_group_position_api.py
```
Alternativ lassen sich Token und Gruppe explizit angeben:
```bash
python scripts/test_group_position_api.py \
--base-url http://127.0.0.1:5000 \
--tenant RV \
--alias "Gruppe 1" \
--token "<API-Zugriffstoken>"
```
## Erste Einrichtung
Nach der Initialisierung der Datenbank müssen noch Mandanten und ein Admin-Account angelegt werden.
+2
View File
@@ -140,6 +140,7 @@ def create_app(config_name=None):
from cmbnet.api.init import api_init_bp
from cmbnet.api.auth import api_auth_bp
from cmbnet.api.groups import api_groups_bp
from cmbnet.api.positions import api_positions_bp
app.register_blueprint(auth_bp, url_prefix='/<tenant>')
app.register_blueprint(views_bp, url_prefix='/<tenant>')
@@ -153,6 +154,7 @@ def create_app(config_name=None):
app.register_blueprint(api_init_bp, url_prefix='/<tenant>/api')
app.register_blueprint(api_auth_bp, url_prefix='/<tenant>/api')
app.register_blueprint(api_groups_bp, url_prefix='/<tenant>/api')
app.register_blueprint(api_positions_bp, url_prefix='/<tenant>/api')
# WebSocket Routes laden
from cmbnet.ws import routes
+9 -2
View File
@@ -1,9 +1,10 @@
"""
Accountverwaltung
"""
from flask import Blueprint, render_template, g
from flask import Blueprint, make_response, render_template, g
from cmbnet.auth import role_required
from cmbnet.db import get_db
from cmbnet.services.api_token_service import ApiTokenService
admin_accounts_bp = Blueprint('admin', __name__)
@@ -12,7 +13,13 @@ admin_accounts_bp = Blueprint('admin', __name__)
@role_required('Administrator')
def dashboard(**kwargs):
"""Admin Dashboard"""
return render_template('admin/dashboard.html')
response = make_response(render_template(
'admin/dashboard.html',
api_tokens=ApiTokenService.list_for_tenant(g.tenant_id)
))
# Die Seite enthält Zugriffstoken und darf nicht im Browser-Cache landen.
response.headers['Cache-Control'] = 'no-store'
return response
@admin_accounts_bp.route('/accounts')
+36
View File
@@ -10,6 +10,7 @@ from cmbnet.models.groups import GroupModel
from cmbnet.models.streets import StreetModel
from cmbnet.services.groups_service import GroupsService
from cmbnet.services.history_service import HistoryService
from cmbnet.services.api_token_service import ApiTokenService
from cmbnet.utils.helpers import log_transaction, notify_reload
from cmbnet.utils.csv_utils import parse_streets_csv, parse_house_numbers_csv
from cmbnet.ws import broker
@@ -85,6 +86,41 @@ def delete_account(account_id, **kwargs):
return jsonify({'success': True})
# === API-ZUGRIFFSTOKEN ===
@admin_api_bp.route('/api-tokens', methods=['GET'])
@role_required('Administrator')
def list_api_tokens(**kwargs):
"""Liefert alle Zugriffstoken des aktuellen Mandanten."""
response = jsonify(ApiTokenService.list_for_tenant(g.tenant_id))
response.headers['Cache-Control'] = 'no-store'
return response
@admin_api_bp.route('/api-tokens', methods=['POST'])
@role_required('Administrator')
def create_api_token(**kwargs):
"""Erzeugt einen neuen zufälligen Zugriffstoken."""
token = ApiTokenService.generate(
g.tenant_id, created_by_account_id=session.get('account_id')
)
if not token:
return jsonify({'error': 'Token konnte nicht erzeugt werden'}), 500
log_transaction('api_token.create', 'api_token', token['id'], {})
return jsonify({'success': True, 'token': token})
@admin_api_bp.route('/api-tokens/<int:token_id>', methods=['DELETE'])
@role_required('Administrator')
def delete_api_token(token_id, **kwargs):
"""Löscht einen Zugriffstoken."""
if not ApiTokenService.delete(g.tenant_id, token_id):
return jsonify({'error': 'Token nicht gefunden'}), 404
log_transaction('api_token.delete', 'api_token', token_id, {})
return jsonify({'success': True})
# === GRUPPEN ===
@admin_api_bp.route('/gruppen', methods=['POST'])
@role_required('Administrator')
+1
View File
@@ -1,4 +1,5 @@
from .init import api_init_bp
from .auth import api_auth_bp
from .positions import api_positions_bp
api_bp = api_init_bp
+91
View File
@@ -0,0 +1,91 @@
"""
Externe API für Gruppenpositionsmeldungen.
Der Endpunkt ist bewusst nicht an eine Browser-Session gebunden. Die
Authentifizierung erfolgt über einen mandantenweiten API-Token, der im
Admin-Dashboard verwaltet wird.
"""
import math
from flask import Blueprint, g, jsonify, request
from cmbnet.db import get_db
from cmbnet.services.api_token_service import ApiTokenService
from cmbnet.services.group_position_service import GroupPositionService
api_positions_bp = Blueprint('api_positions', __name__)
def _first_value(data, *keys):
"""Liefert den ersten vorhandenen Wert für mehrere mögliche Feldnamen."""
for key in keys:
if key in data:
return data[key]
return None
@api_positions_bp.route('/groups/position', methods=['POST'])
def update_group_position(tenant, **kwargs):
"""Übernimmt eine Gruppenposition aus einem externen System.
Erwarteter JSON-Body (alternative Feldnamen werden akzeptiert):
``{"lat": 50.7, "lon": 7.1, "timestamp": "2026-11-04T12:00:00Z",
"token": "...", "aliasname": "Gruppe 1"}``
"""
data = request.get_json(silent=True)
if not isinstance(data, dict):
return jsonify({'error': 'JSON-Body erforderlich'}), 400
token = _first_value(data, 'token', 'access_token', 'zugriffstoken')
if not isinstance(token, str) or not token.strip():
return jsonify({'error': 'Zugriffstoken fehlt'}), 401
token = token.strip()
# Token zuerst prüfen, damit Requests ohne gültigen Token unabhängig
# von den übrigen Feldern abgewiesen werden.
db = get_db()
tenant_row = db.execute(
'SELECT id, code FROM tenants WHERE code = ?',
(tenant,)
).fetchone()
if not tenant_row:
return jsonify({'error': 'Mandant nicht gefunden'}), 404
tenant_id = tenant_row['id']
if not ApiTokenService.validate(tenant_id, token):
return jsonify({'error': 'Ungültiger Zugriffstoken'}), 401
# Für Transaction-Logging und ggf. spätere Erweiterungen steht der
# Mandantenkontext auch ohne Login-Session zur Verfügung.
g.tenant_id = tenant_id
g.tenant_code = tenant_row['code']
aliasname = _first_value(
data, 'aliasname', 'group_alias', 'alias', 'gruppen_alias'
)
if not isinstance(aliasname, str) or not aliasname.strip():
return jsonify({'error': 'Gruppen-Aliasname fehlt'}), 400
aliasname = aliasname.strip()
try:
lat = float(_first_value(data, 'lat', 'latitude'))
lon = float(_first_value(data, 'lon', 'lng', 'longitude'))
except (TypeError, ValueError):
return jsonify({'error': 'Ungültige oder fehlende Koordinaten'}), 400
if not (math.isfinite(lat) and math.isfinite(lon)):
return jsonify({'error': 'Koordinaten müssen endliche Zahlen sein'}), 400
if not (-90 <= lat <= 90 and -180 <= lon <= 180):
return jsonify({'error': 'Koordinaten liegen außerhalb des gültigen Bereichs'}), 400
timestamp = GroupPositionService.parse_timestamp(
_first_value(data, 'timestamp', 'ts', 'time', 'zeitstempel')
)
if timestamp is None:
return jsonify({'error': 'Ungültiger oder fehlender Zeitstempel'}), 400
result, status = GroupPositionService.update_by_alias(
tenant_id, aliasname, lat, lon, timestamp
)
return jsonify(result), status
+20
View File
@@ -90,6 +90,25 @@ def ensure_ws_schema(db):
db.commit()
def ensure_api_schema(db):
"""Legt die Tabelle für die externen API-Zugriffstoken an."""
db.executescript('''
CREATE TABLE IF NOT EXISTS api_tokens (
id INTEGER PRIMARY KEY AUTOINCREMENT,
tenant_id INTEGER NOT NULL,
token TEXT UNIQUE NOT NULL,
created_by_account_id INTEGER,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (tenant_id) REFERENCES tenants(id),
FOREIGN KEY (created_by_account_id) REFERENCES accounts(id)
);
CREATE INDEX IF NOT EXISTS idx_api_tokens_tenant
ON api_tokens(tenant_id);
''')
db.commit()
def ensure_schema():
"""Ergänzt bestehende Datenbanken um das Gruppen-Account-Zuordnungsmodell.
@@ -100,6 +119,7 @@ def ensure_schema():
"""
db = get_db()
ensure_ws_schema(db)
ensure_api_schema(db)
groups_table = db.execute(
"SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'groups'"
).fetchone()
@@ -0,0 +1,81 @@
"""
Verwaltung der Zugriffstoken für die externe Gruppenpositions-API.
"""
import secrets
import sqlite3
from cmbnet.db import get_db
class ApiTokenService:
"""Erzeugt, liest, prüft und löscht mandantenweite API-Tokens."""
@staticmethod
def list_for_tenant(tenant_id):
"""Liefert alle Tokens eines Mandanten inklusive Ersteller."""
db = get_db()
rows = db.execute(
'''SELECT t.id, t.tenant_id, t.token, t.created_at,
t.created_by_account_id, a.name AS created_by_name
FROM api_tokens t
LEFT JOIN accounts a
ON a.id = t.created_by_account_id
AND a.tenant_id = t.tenant_id
WHERE t.tenant_id = ?
ORDER BY t.id''',
(tenant_id,)
).fetchall()
return [dict(row) for row in rows]
@staticmethod
def generate(tenant_id, created_by_account_id=None):
"""Erzeugt einen neuen zufälligen Token und speichert ihn."""
db = get_db()
for _ in range(10):
token = secrets.token_urlsafe(32)
try:
cursor = db.execute(
'''INSERT INTO api_tokens
(tenant_id, token, created_by_account_id)
VALUES (?, ?, ?)''',
(tenant_id, token, created_by_account_id)
)
db.commit()
row = db.execute(
'''SELECT t.id, t.tenant_id, t.token, t.created_at,
t.created_by_account_id, a.name AS created_by_name
FROM api_tokens t
LEFT JOIN accounts a
ON a.id = t.created_by_account_id
AND a.tenant_id = t.tenant_id
WHERE t.id = ?''',
(cursor.lastrowid,)
).fetchone()
return dict(row) if row else None
except sqlite3.IntegrityError:
# Eine Kollision ist bei 32 Byte Zufall praktisch
# ausgeschlossen, wird aber sauber erneut versucht.
db.rollback()
raise RuntimeError('Es konnte kein eindeutiger API-Token erzeugt werden')
@staticmethod
def delete(tenant_id, token_id):
"""Löscht einen Token. Gibt False zurück, wenn er nicht existiert."""
db = get_db()
cursor = db.execute(
'DELETE FROM api_tokens WHERE id = ? AND tenant_id = ?',
(token_id, tenant_id)
)
db.commit()
return cursor.rowcount > 0
@staticmethod
def validate(tenant_id, token):
"""Liefert den Token-Datensatz oder None bei ungültigem Token."""
if not token:
return None
db = get_db()
return db.execute(
'SELECT * FROM api_tokens WHERE tenant_id = ? AND token = ?',
(tenant_id, token)
).fetchone()
@@ -0,0 +1,227 @@
"""
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
+11
View File
@@ -859,6 +859,17 @@ class WebSocketBroker:
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.
+16
View File
@@ -126,6 +126,20 @@ CREATE TABLE IF NOT EXISTS ws_tokens (
FOREIGN KEY (account_id) REFERENCES accounts(id)
);
-- Zugriffstoken für die externe Gruppenpositions-API.
-- Die Tokens sind mandantenweit gültig und werden im Admin-Dashboard
-- verwaltet. Sie werden im Klartext gespeichert, damit sie dort angezeigt
-- werden können.
CREATE TABLE IF NOT EXISTS api_tokens (
id INTEGER PRIMARY KEY AUTOINCREMENT,
tenant_id INTEGER NOT NULL,
token TEXT UNIQUE NOT NULL,
created_by_account_id INTEGER,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (tenant_id) REFERENCES tenants(id),
FOREIGN KEY (created_by_account_id) REFERENCES accounts(id)
);
-- Prozessübergreifender WebSocket-Zustand
-- Bekannte Client-IDs, Account-Zuordnung, letzte Sequenznummer und
-- Verbindungsstatus. Die Tabelle überlebt Reconnects auf anderen Workern.
@@ -218,6 +232,8 @@ CREATE INDEX IF NOT EXISTS idx_streets_tenant ON streets(tenant_id);
CREATE INDEX IF NOT EXISTS idx_street_house_numbers_lookup
ON street_house_numbers(tenant_id, street_name, house_number);
CREATE INDEX IF NOT EXISTS idx_ws_tokens_token ON ws_tokens(token);
CREATE INDEX IF NOT EXISTS idx_api_tokens_tenant
ON api_tokens(tenant_id);
CREATE INDEX IF NOT EXISTS idx_ws_messages_ts ON ws_messages_store(ts);
CREATE INDEX IF NOT EXISTS idx_ws_clients_account
ON ws_clients(tenant_id, account_id);
+394
View File
@@ -0,0 +1,394 @@
#!/usr/bin/env python3
"""
Testskript für den externen Gruppenpositions-Endpunkt.
Der Endpunkt erwartet einen JSON-POST an:
/<tenant>/api/groups/position
Beispiel:
python scripts/test_group_position_api.py \
--base-url http://127.0.0.1:5000 \
--tenant RV \
--alias "Gruppe 1"
Ohne --token wird der erste API-Token des Mandanten aus der SQLite-Datenbank
gelesen. Ein Token kann im Admin-Dashboard unter "API-Zugriffstoken" erzeugt
werden.
Das Skript verwendet Koordinaten aus ../data/rv-hnr.csv und prüft:
1. Eine neue Position wird gespeichert und als Code 300 verteilt.
2. Ein älterer Zeitstempel wird verworfen.
3. Ein ungültiger Token wird abgelehnt.
4. Ein neuerer Zeitstempel überschreibt die Position wieder.
"""
import argparse
import csv
import json
import sqlite3
import sys
import urllib.error
import urllib.request
from datetime import datetime, timedelta, timezone
from pathlib import Path
PROJECT_DIR = Path(__file__).resolve().parent.parent
DEFAULT_DB = PROJECT_DIR / 'instance' / 'cmbnet.sqlite3'
DEFAULT_CSV = PROJECT_DIR.parent / 'data' / 'rv-hnr.csv'
def parse_args():
parser = argparse.ArgumentParser(
description='Testet den API-Endpunkt für externe Gruppenpositionen.'
)
parser.add_argument(
'--base-url', default='http://127.0.0.1:5000',
help='Basis-URL der Anwendung (Default: http://127.0.0.1:5000)'
)
parser.add_argument(
'--tenant', default='RV',
help='Mandanten-Code in der URL (Default: RV)'
)
parser.add_argument(
'--alias',
help='Gruppen-Aliasname. Ohne Angabe wird die erste Gruppe des Mandanten verwendet.'
)
parser.add_argument(
'--token',
help='API-Zugriffstoken. Ohne Angabe wird der erste Token aus der DB gelesen.'
)
parser.add_argument(
'--db', type=Path, default=DEFAULT_DB,
help=f'Pfad zur SQLite-Datenbank (Default: {DEFAULT_DB})'
)
parser.add_argument(
'--csv', type=Path, default=DEFAULT_CSV,
help=f'CSV-Datei mit Koordinaten (Default: {DEFAULT_CSV})'
)
parser.add_argument(
'--timeout', type=float, default=10.0,
help='HTTP-Timeout in Sekunden (Default: 10)'
)
parser.add_argument(
'--use-proxy', action='store_true',
help='Umgebungs-Proxy (http_proxy/https_proxy) verwenden. '
'Standardmäßig wird direkt verbunden, damit localhost-Tests '
'nicht über einen Proxy laufen.'
)
return parser.parse_args()
def load_coordinates(path, count=2):
"""Liest die ersten gültigen Koordinaten aus der Hausnummern-CSV."""
if not path.exists():
raise SystemExit(f'CSV-Datei nicht gefunden: {path}')
with path.open(encoding='utf-8-sig') as handle:
lines = [line for line in handle if line.strip()]
if not lines:
raise SystemExit(f'CSV-Datei ist leer: {path}')
# In rv-hnr.csv beginnt die Kopfzeile mit "#". Das Rautenzeichen wird
# entfernt, damit DictReader die Spaltennamen korrekt erkennt. Weitere
# Kommentarzeilen werden übersprungen.
if lines[0].lstrip().startswith('#'):
lines[0] = lines[0].lstrip()[1:]
lines = [lines[0]] + [
line for line in lines[1:]
if not line.lstrip().startswith('#')
]
reader = csv.DictReader(lines, delimiter=';')
if reader.fieldnames:
reader.fieldnames = [
name.strip().lstrip('#').strip() for name in reader.fieldnames
]
coordinates = []
for row in reader:
try:
lat = float(row.get('Latitude') or row.get('latitude') or '')
lon = float(row.get('Longitude') or row.get('longitude') or '')
except (TypeError, ValueError):
continue
coordinates.append({
'lat': lat,
'lon': lon,
'street': (row.get('Straßenname') or '').strip(),
'number': (row.get('Hausnummer') or '').strip()
})
if len(coordinates) >= count:
break
if len(coordinates) < count:
raise SystemExit(
f'Die CSV-Datei enthält weniger als {count} gültige Koordinaten.'
)
return coordinates
def parse_db_timestamp(value):
"""Parst den SQLite-Zeitstempel der Gruppe als UTC-datetime."""
if not value:
return None
text = str(value).strip().replace(' ', 'T')
try:
parsed = datetime.fromisoformat(text)
except ValueError:
return None
if parsed.tzinfo is None:
parsed = parsed.replace(tzinfo=timezone.utc)
return parsed.astimezone(timezone.utc)
def load_context(db_path, tenant_code, alias, token_override):
"""Liest Mandant, Gruppe und ggf. den ersten API-Token aus der DB."""
if not db_path.exists():
raise SystemExit(f'Datenbank nicht gefunden: {db_path}')
connection = sqlite3.connect(str(db_path))
connection.row_factory = sqlite3.Row
try:
tenant = connection.execute(
'SELECT id FROM tenants WHERE code = ?',
(tenant_code,)
).fetchone()
if not tenant:
raise SystemExit(f'Mandant nicht gefunden: {tenant_code}')
if alias:
group = connection.execute(
'''SELECT id, aliasname, last_pos_at
FROM groups
WHERE tenant_id = ? AND aliasname = ?''',
(tenant['id'], alias)
).fetchone()
else:
group = connection.execute(
'''SELECT id, aliasname, last_pos_at
FROM groups
WHERE tenant_id = ?
AND aliasname IS NOT NULL
AND TRIM(aliasname) <> ''
ORDER BY id
LIMIT 1''',
(tenant['id'],)
).fetchone()
if not group:
hint = f' mit Alias „{alias}“' if alias else ''
raise SystemExit(
f'Keine Gruppe{hint} im Mandanten {tenant_code} gefunden.'
)
token_row = None
if not token_override:
token_row = connection.execute(
'''SELECT id, token
FROM api_tokens
WHERE tenant_id = ?
ORDER BY id
LIMIT 1''',
(tenant['id'],)
).fetchone()
if not token_row:
raise SystemExit(
'Kein API-Zugriffstoken in der Datenbank. Bitte im '
'Admin-Dashboard unter „API-Zugriffstoken“ einen Token '
'erzeugen oder --token angeben.'
)
return tenant['id'], group, token_row
finally:
connection.close()
def read_group_position(db_path, tenant_id, group_id):
"""Liest die aktuelle Position direkt aus der Datenbank."""
connection = sqlite3.connect(str(db_path))
connection.row_factory = sqlite3.Row
try:
row = connection.execute(
'''SELECT last_lat, last_lon, last_pos_at
FROM groups
WHERE tenant_id = ? AND id = ?''',
(tenant_id, group_id)
).fetchone()
return dict(row) if row else None
finally:
connection.close()
def post_json(opener, url, payload, timeout):
"""Sendet einen JSON-POST und liefert (HTTP-Status, JSON-Antwort)."""
body = json.dumps(payload).encode('utf-8')
request = urllib.request.Request(
url,
data=body,
method='POST',
headers={
'Content-Type': 'application/json',
'Accept': 'application/json'
}
)
try:
with opener.open(request, timeout=timeout) as response:
raw = response.read().decode('utf-8')
return response.status, json.loads(raw) if raw else {}
except urllib.error.HTTPError as error:
raw = error.read().decode('utf-8', errors='replace')
try:
parsed = json.loads(raw) if raw else {}
except json.JSONDecodeError:
parsed = {'raw': raw[:1000]}
return error.code, parsed
except urllib.error.URLError as error:
raise SystemExit(
f'Server nicht erreichbar unter {url}: {error.reason}'
) from error
def format_timestamp(value):
return value.astimezone(timezone.utc).isoformat().replace('+00:00', 'Z')
def print_response(label, status, data):
print(f'\n{label}: HTTP {status}')
print(json.dumps(data, ensure_ascii=False, indent=2))
def main():
args = parse_args()
coordinates = load_coordinates(args.csv)
tenant_id, group, token_row = load_context(
args.db, args.tenant, args.alias, args.token
)
aliasname = group['aliasname']
token = args.token or token_row['token']
endpoint = (
f"{args.base_url.rstrip('/')}/{args.tenant}/api/groups/position"
)
if args.use_proxy:
opener = urllib.request.build_opener()
else:
# Tests gegen einen lokalen Flask-Server sollen nicht über einen
# eventuell gesetzten System-Proxy laufen.
opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
print(f'Endpunkt: {endpoint}')
print(f'Mandant: {args.tenant} (ID {tenant_id})')
print(f'Gruppe: {group["id"]} / {aliasname}')
if token_row:
print(f'Token: Datenbank-Token #{token_row["id"]}')
else:
print('Token: aus --token')
print(
f'CSV: {args.csv} '
f'({coordinates[0]["street"]} {coordinates[0]["number"]} u. a.)'
)
stored_timestamp = parse_db_timestamp(group['last_pos_at'])
now = datetime.now(timezone.utc).replace(microsecond=0)
base_timestamp = now
if stored_timestamp is not None and stored_timestamp >= base_timestamp:
base_timestamp = stored_timestamp + timedelta(seconds=1)
first_timestamp = base_timestamp
stale_timestamp = base_timestamp - timedelta(hours=1)
newer_timestamp = base_timestamp + timedelta(seconds=1)
failures = []
def send(label, coordinate, timestamp, token_value=None):
payload = {
'lat': coordinate['lat'],
'lon': coordinate['lon'],
'timestamp': format_timestamp(timestamp),
'token': token_value if token_value is not None else token,
'aliasname': aliasname
}
status, data = post_json(opener, endpoint, payload, args.timeout)
print_response(label, status, data)
return status, data
# 1. Neue Position setzen.
status, data = send('Neue Position', coordinates[0], first_timestamp)
if status != 200 or not data.get('updated'):
failures.append('Neue Position wurde nicht übernommen.')
if data.get('distributed') is not True:
failures.append('Code-300-Nachricht wurde nicht verteilt.')
position_after_first = read_group_position(
args.db, tenant_id, group['id']
)
# 2. Älteren Zeitstempel senden: darf nichts ändern.
status, data = send(
'Älterer Zeitstempel (muss verworfen werden)',
coordinates[1], stale_timestamp
)
if status != 200 or data.get('updated') is not False:
failures.append('Älterer Zeitstempel wurde nicht verworfen.')
if data.get('reason') != 'stale_timestamp':
failures.append('Antwort enthält nicht reason=stale_timestamp.')
position_after_stale = read_group_position(
args.db, tenant_id, group['id']
)
if position_after_first != position_after_stale:
failures.append(
'Die Datenbankposition wurde trotz älterem Zeitstempel geändert.'
)
# 3. Ungültigen Token testen.
status, data = send(
'Ungültiger Token (muss 401 liefern)',
coordinates[1], newer_timestamp, token_value='invalid-token'
)
if status != 401:
failures.append(f'Ungültiger Token lieferte HTTP {status} statt 401.')
# 4. Neuere Position setzen.
status, data = send('Neuere Position', coordinates[1], newer_timestamp)
if status != 200 or not data.get('updated'):
failures.append('Neuere Position wurde nicht übernommen.')
if data.get('distributed') is not True:
failures.append('Code-300-Nachricht wurde nicht verteilt.')
final_position = read_group_position(args.db, tenant_id, group['id'])
expected = coordinates[1]
if not final_position or final_position.get('last_lat') is None \
or final_position.get('last_lon') is None:
failures.append('Gruppe konnte nach dem Test nicht gelesen werden.')
else:
if abs(float(final_position['last_lat']) - expected['lat']) > 1e-9:
failures.append('Gespeicherte Latitude stimmt nicht mit der CSV überein.')
if abs(float(final_position['last_lon']) - expected['lon']) > 1e-9:
failures.append('Gespeicherte Longitude stimmt nicht mit der CSV überein.')
print('\n' + '=' * 70)
if failures:
print('Test fehlgeschlagen:')
for failure in failures:
print(f' - {failure}')
return 1
print('Alle Tests erfolgreich.')
print(
f'Aktuelle Position: {final_position["last_lat"]}, '
f'{final_position["last_lon"]} '
f'({expected["street"]} {expected["number"]})'
)
return 0
if __name__ == '__main__':
sys.exit(main())
+8
View File
@@ -8,6 +8,14 @@ table td {
padding: 0.25rem 0.5rem;
}
.api-token-value {
display: inline-block;
max-width: 32rem;
white-space: normal;
overflow-wrap: anywhere;
font-size: 0.82rem;
}
dialog article {
max-width: 600px;
width: min(90vw, 600px);
+11 -4
View File
@@ -5,7 +5,7 @@
* damit er sowohl die mobilen Views als auch die statischen Assets
* kontrolliert. Der Cache-Name wird pro App-Wurzel gebildet.
*/
const VERSION = 'cmbnet-pwa-v13';
const VERSION = 'cmbnet-pwa-v14';
const BASE = new URL('./', self.location).href;
const SHELL_CACHE = `${VERSION}-shell`;
const TILE_CACHE = `${VERSION}-tiles`;
@@ -124,16 +124,23 @@ function isTileRequest(url) {
async function handleNavigation(request) {
const cache = await caches.open(SHELL_CACHE);
const url = new URL(request.url);
// Admin-Seiten können sensible Daten wie API-Zugriffstoken enthalten und
// werden deshalb nicht im Service-Worker-Cache abgelegt.
const cacheable = !url.pathname.includes('/admin/');
try {
const response = await fetch(request);
if (response && response.ok) {
if (cacheable && response && response.ok) {
cache.put(request, response.clone()).catch(() => {});
}
return response;
} catch (error) {
const cached = await cache.match(request, {ignoreSearch: true});
if (cached) return cached;
if (cacheable) {
const cached = await cache.match(request, {ignoreSearch: true});
if (cached) return cached;
}
return new Response(offlineHtml(), {
status: 503,
+36
View File
@@ -49,5 +49,41 @@ async function loadBrokerStatus() {
}
}
async function createApiToken() {
try {
const response = await fetch(`${apiBase}/api-tokens`, {
method: 'POST'
});
const data = await response.json();
if (!response.ok || !data.success) {
throw new Error(data.error || 'Token konnte nicht erzeugt werden');
}
window.location.reload();
} catch (error) {
alert(error.message || 'Server nicht erreichbar');
}
}
async function deleteApiToken(tokenId) {
if (!confirm('Diesen Zugriffstoken wirklich löschen?')) return;
try {
const response = await fetch(`${apiBase}/api-tokens/${tokenId}`, {
method: 'DELETE'
});
const data = await response.json();
if (!response.ok || !data.success) {
throw new Error(data.error || 'Token konnte nicht gelöscht werden');
}
window.location.reload();
} catch (error) {
alert(error.message || 'Server nicht erreichbar');
}
}
const createApiTokenBtn = document.getElementById('createApiTokenBtn');
if (createApiTokenBtn) {
createApiTokenBtn.addEventListener('click', createApiToken);
}
loadBrokerStatus();
setInterval(loadBrokerStatus, 5000);
+37
View File
@@ -13,6 +13,43 @@
</ul>
</nav>
<section>
<h2>API-Zugriffstoken</h2>
<p>
Mit diesen Tokens können externe Systeme Gruppenpositionen über die
API melden. Tokens sind mandantenweit gültig und sollten geheim
gehalten werden.
</p>
{% if api_tokens %}
<table id="apiTokenTable">
<thead>
<tr>
<th>Token</th>
<th>Erstellt</th>
<th>Ersteller</th>
<th>Aktion</th>
</tr>
</thead>
<tbody>
{% for token in api_tokens %}
<tr>
<td><code class="api-token-value">{{ token.token }}</code></td>
<td>{{ token.created_at }}</td>
<td>{{ token.created_by_name or '-' }}</td>
<td>
<button type="button" class="secondary"
onclick="deleteApiToken({{ token.id }})">Löschen</button>
</td>
</tr>
{% endfor %}
</tbody>
</table>
{% else %}
<p id="apiTokenEmpty">Noch keine API-Zugriffstoken vorhanden.</p>
{% endif %}
<button type="button" id="createApiTokenBtn">Neuen Token generieren</button>
</section>
<section>
<h2>Broker Status</h2>
<p>Aktive WebSocket-Verbindungen</p>