diff --git a/CMBNet/README_CMBNet.md b/CMBNet/README_CMBNet.md index 5e90cce..e810412 100644 --- a/CMBNet/README_CMBNet.md +++ b/CMBNet/README_CMBNet.md @@ -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 //api/groups/position +Content-Type: application/json + +{ + "lat": 50.701243, + "lon": 7.153290, + "timestamp": "2026-11-04T12:00:00Z", + "token": "", + "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 "" +``` + ## Erste Einrichtung Nach der Initialisierung der Datenbank müssen noch Mandanten und ein Admin-Account angelegt werden. diff --git a/CMBNet/cmbnet/__init__.py b/CMBNet/cmbnet/__init__.py index 28313b9..cf6e882 100644 --- a/CMBNet/cmbnet/__init__.py +++ b/CMBNet/cmbnet/__init__.py @@ -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='/') app.register_blueprint(views_bp, url_prefix='/') @@ -153,6 +154,7 @@ def create_app(config_name=None): app.register_blueprint(api_init_bp, url_prefix='//api') app.register_blueprint(api_auth_bp, url_prefix='//api') app.register_blueprint(api_groups_bp, url_prefix='//api') + app.register_blueprint(api_positions_bp, url_prefix='//api') # WebSocket Routes laden from cmbnet.ws import routes diff --git a/CMBNet/cmbnet/admin/accounts.py b/CMBNet/cmbnet/admin/accounts.py index 4213198..5245fc3 100644 --- a/CMBNet/cmbnet/admin/accounts.py +++ b/CMBNet/cmbnet/admin/accounts.py @@ -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') diff --git a/CMBNet/cmbnet/admin/api.py b/CMBNet/cmbnet/admin/api.py index 86fbb06..987b3bc 100644 --- a/CMBNet/cmbnet/admin/api.py +++ b/CMBNet/cmbnet/admin/api.py @@ -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/', 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') diff --git a/CMBNet/cmbnet/api/__init__.py b/CMBNet/cmbnet/api/__init__.py index 351629f..cff9f7e 100644 --- a/CMBNet/cmbnet/api/__init__.py +++ b/CMBNet/cmbnet/api/__init__.py @@ -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 diff --git a/CMBNet/cmbnet/api/positions.py b/CMBNet/cmbnet/api/positions.py new file mode 100644 index 0000000..4458af3 --- /dev/null +++ b/CMBNet/cmbnet/api/positions.py @@ -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 diff --git a/CMBNet/cmbnet/db/database.py b/CMBNet/cmbnet/db/database.py index 1ddba90..2a5c651 100644 --- a/CMBNet/cmbnet/db/database.py +++ b/CMBNet/cmbnet/db/database.py @@ -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() diff --git a/CMBNet/cmbnet/services/api_token_service.py b/CMBNet/cmbnet/services/api_token_service.py new file mode 100644 index 0000000..1c60869 --- /dev/null +++ b/CMBNet/cmbnet/services/api_token_service.py @@ -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() diff --git a/CMBNet/cmbnet/services/group_position_service.py b/CMBNet/cmbnet/services/group_position_service.py new file mode 100644 index 0000000..6b21adc --- /dev/null +++ b/CMBNet/cmbnet/services/group_position_service.py @@ -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 diff --git a/CMBNet/cmbnet/ws/broker.py b/CMBNet/cmbnet/ws/broker.py index fedb157..7f8f29e 100644 --- a/CMBNet/cmbnet/ws/broker.py +++ b/CMBNet/cmbnet/ws/broker.py @@ -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. diff --git a/CMBNet/migrations/schema.sql b/CMBNet/migrations/schema.sql index 66f62d1..c32a637 100644 --- a/CMBNet/migrations/schema.sql +++ b/CMBNet/migrations/schema.sql @@ -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); diff --git a/CMBNet/scripts/test_group_position_api.py b/CMBNet/scripts/test_group_position_api.py new file mode 100755 index 0000000..7f48151 --- /dev/null +++ b/CMBNet/scripts/test_group_position_api.py @@ -0,0 +1,394 @@ +#!/usr/bin/env python3 +""" +Testskript für den externen Gruppenpositions-Endpunkt. + +Der Endpunkt erwartet einen JSON-POST an: + + //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()) diff --git a/CMBNet/static/css/admin.css b/CMBNet/static/css/admin.css index 42e4fec..9d61f53 100644 --- a/CMBNet/static/css/admin.css +++ b/CMBNet/static/css/admin.css @@ -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); diff --git a/CMBNet/static/js/sw.js b/CMBNet/static/js/sw.js index 7734d97..9685119 100644 --- a/CMBNet/static/js/sw.js +++ b/CMBNet/static/js/sw.js @@ -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, diff --git a/CMBNet/static/js/views/admin_dashboard.js b/CMBNet/static/js/views/admin_dashboard.js index ef5fbe2..cc643e0 100644 --- a/CMBNet/static/js/views/admin_dashboard.js +++ b/CMBNet/static/js/views/admin_dashboard.js @@ -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); diff --git a/CMBNet/templates/admin/dashboard.html b/CMBNet/templates/admin/dashboard.html index fe0249f..b12bc45 100644 --- a/CMBNet/templates/admin/dashboard.html +++ b/CMBNet/templates/admin/dashboard.html @@ -13,6 +13,43 @@ +
+

API-Zugriffstoken

+

+ Mit diesen Tokens können externe Systeme Gruppenpositionen über die + API melden. Tokens sind mandantenweit gültig und sollten geheim + gehalten werden. +

+ {% if api_tokens %} + + + + + + + + + + + {% for token in api_tokens %} + + + + + + + {% endfor %} + +
TokenErstelltErstellerAktion
{{ token.token }}{{ token.created_at }}{{ token.created_by_name or '-' }} + +
+ {% else %} +

Noch keine API-Zugriffstoken vorhanden.

+ {% endif %} + +
+

Broker Status

Aktive WebSocket-Verbindungen