Files
Sternsinger/CMBNet/cmbnet/admin/api.py
T

538 lines
21 KiB
Python

"""
Admin API Endpunkte
"""
from flask import Blueprint, request, jsonify, g, session, current_app
from cmbnet.auth import role_required
from cmbnet.db import get_db
from cmbnet.auth import hash_password
from cmbnet.models.accounts import AccountModel
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.services.streets_service import StreetsService
from cmbnet.services.str2pl_service import Str2PlService
from cmbnet.utils.helpers import log_transaction, notify_reload
from cmbnet.utils.csv_utils import parse_house_numbers_csv
from cmbnet.ws import broker
from cmbnet.ws.protocol import WSMessage
import json
admin_api_bp = Blueprint('admin_api', __name__)
# === ACCOUNTS ===
@admin_api_bp.route('/accounts', methods=['POST'])
@role_required('Administrator')
def create_account(**kwargs):
data = request.get_json()
name = data.get('name', '').strip()
password = data.get('password', '')
role = data.get('role', 'Gast')
if not name or not password:
return jsonify({'error': 'Name und Passwort erforderlich'}), 400
existing = AccountModel.get_by_name_and_tenant(name, g.tenant_id)
if existing:
return jsonify({'error': 'Account existiert bereits'}), 400
password_hash = hash_password(password)
account_id = AccountModel.create(g.tenant_id, name, password_hash, role)
log_transaction('account.create', 'account', account_id, {'name': name, 'role': role})
notify_reload(f'Administration: Account „{name}“ wurde erstellt.')
return jsonify({'success': True, 'id': account_id})
@admin_api_bp.route('/accounts/<int:account_id>/role', methods=['POST'])
@role_required('Administrator')
def update_account_role(account_id, **kwargs):
data = request.get_json()
role = data.get('role')
account = AccountModel.get_by_id(account_id, g.tenant_id)
AccountModel.update_role(account_id, g.tenant_id, role)
log_transaction('account.role_change', 'account', account_id, {'role': role})
GroupsService.invalidate(g.tenant_id)
name = account['name'] if account else f'#{account_id}'
notify_reload(f'Administration: Rolle von Account „{name}“ wurde geändert.')
return jsonify({'success': True})
@admin_api_bp.route('/accounts/<int:account_id>/password', methods=['POST'])
@role_required('Administrator')
def reset_password(account_id, **kwargs):
data = request.get_json()
password = data.get('password', '')
if not password:
return jsonify({'error': 'Passwort erforderlich'}), 400
password_hash = hash_password(password)
account = AccountModel.get_by_id(account_id, g.tenant_id)
AccountModel.set_password(account_id, g.tenant_id, password_hash)
log_transaction('account.password_reset', 'account', account_id, {})
name = account['name'] if account else f'#{account_id}'
notify_reload(f'Administration: Passwort für Account „{name}“ wurde zurückgesetzt.')
return jsonify({'success': True})
@admin_api_bp.route('/accounts/<int:account_id>', methods=['DELETE'])
@role_required('Administrator')
def delete_account(account_id, **kwargs):
account = AccountModel.get_by_id(account_id, g.tenant_id)
AccountModel.delete(account_id, g.tenant_id)
log_transaction('account.delete', 'account', account_id, {})
GroupsService.invalidate(g.tenant_id)
name = account['name'] if account else f'#{account_id}'
notify_reload(f'Administration: Account „{name}“ wurde gelöscht.')
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')
def create_group(**kwargs):
data = request.get_json() or {}
aliasname = str(data.get('aliasname') or '').strip()
db = get_db()
group_id = GroupModel.create(g.tenant_id, aliasname, 'offen')
db.execute(
'INSERT INTO group_state_history (tenant_id, group_id, from_state, to_state, actor_account_id) VALUES (?, ?, ?, ?, ?)',
(g.tenant_id, group_id, None, 'offen', session['account_id'])
)
db.commit()
log_transaction('group.create', 'group', group_id, {'aliasname': aliasname})
GroupsService.invalidate(g.tenant_id)
GroupsService.load_from_db(g.tenant_id)
notify_reload(f'Administration: Gruppe „{aliasname or group_id}“ wurde erstellt.')
return jsonify({'success': True, 'id': group_id})
@admin_api_bp.route('/gruppen/<int:group_id>', methods=['POST'])
@role_required('Administrator')
def update_group(group_id, **kwargs):
data = request.get_json() or {}
db = get_db()
old = GroupModel.get_by_id(group_id, g.tenant_id)
if not old:
return jsonify({'error': 'Gruppe nicht gefunden'}), 404
updates = {}
if 'aliasname' in data:
updates['aliasname'] = data['aliasname']
allowed_states = {'offen', 'unterwegs', 'online', 'pausierend', 'fertig'}
state_changed = False
if 'state' in data:
new_state = data['state']
if new_state not in allowed_states:
return jsonify({'error': 'Ungültiger State'}), 400
if new_state != old['state']:
updates['state'] = new_state
state_changed = True
if not updates:
return jsonify({'success': True})
GroupModel.update(group_id, g.tenant_id, **updates)
if state_changed:
db.execute(
'INSERT INTO group_state_history (tenant_id, group_id, from_state, to_state, actor_account_id) VALUES (?, ?, ?, ?, ?)',
(g.tenant_id, group_id, old['state'], updates['state'], session['account_id'])
)
db.commit()
msg = WSMessage(sender_id=session['account_id'], code=200,
msg=json.dumps({'group_id': group_id, 'state': updates['state'], 'actor': session['account_id']}))
try:
broker.route_message(g.tenant_id, msg)
except Exception as e:
print(f'Broker error: {e}')
log_transaction('group.update', 'group', group_id, updates)
GroupsService.invalidate(g.tenant_id)
GroupsService.load_from_db(g.tenant_id)
display_name = updates.get('aliasname', old['aliasname']) or group_id
notify_reload(f'Administration: Gruppe „{display_name}“ wurde geändert.')
return jsonify({'success': True})
@admin_api_bp.route('/gruppen/<int:group_id>', methods=['DELETE'])
@role_required('Administrator')
def delete_group(group_id, **kwargs):
group = GroupModel.get_by_id(group_id, g.tenant_id)
GroupModel.delete(group_id, g.tenant_id)
log_transaction('group.delete', 'group', group_id, {})
GroupsService.invalidate(g.tenant_id)
display_name = (group['aliasname'] if group and group['aliasname'] else group_id)
notify_reload(f'Administration: Gruppe „{display_name}“ wurde gelöscht.')
return jsonify({'success': True})
@admin_api_bp.route('/gruppen/<int:group_id>/history')
@role_required('Administrator')
def group_history(group_id, **kwargs):
db = get_db()
history = db.execute(
'SELECT h.*, a.name as actor_name FROM group_state_history h LEFT JOIN accounts a ON h.actor_account_id = a.id WHERE h.group_id = ? AND h.tenant_id = ? ORDER BY h.created_at DESC',
(group_id, g.tenant_id)
).fetchall()
return jsonify([dict(row) for row in history])
@admin_api_bp.route('/gruppen/<int:group_id>/history/<int:hist_id>/revert', methods=['POST'])
@role_required('Administrator')
def revert_group_hist(group_id, hist_id, **kwargs):
success, msg = HistoryService.revert_group(g.tenant_id, group_id, hist_id, session['account_id'])
if not success:
return jsonify({'error': msg}), 400
notify_reload('Administration: Gruppenhistorie wurde wiederhergestellt.')
return jsonify({'success': True, 'message': msg})
@admin_api_bp.route('/gruppen/<int:group_id>/position/history/<int:hist_id>', methods=['POST'])
@role_required('Administrator')
def set_group_position_from_history(group_id, hist_id, **kwargs):
success, msg = HistoryService.set_group_position_from_history(
g.tenant_id, group_id, hist_id, session['account_id']
)
if not success:
return jsonify({'error': msg}), 400
notify_reload('Administration: Gruppenposition wurde aus der Historie gesetzt.')
return jsonify({'success': True, 'message': msg})
@admin_api_bp.route('/gruppen/<int:group_id>/position', methods=['DELETE'])
@role_required('Administrator')
def clear_group_position(group_id, **kwargs):
success, msg = HistoryService.clear_group_position(
g.tenant_id, group_id, session['account_id']
)
if not success:
return jsonify({'error': msg}), 400
notify_reload('Administration: Gruppenposition wurde gelöscht.')
return jsonify({'success': True, 'message': msg})
# === STRASSEN ===
@admin_api_bp.route('/strassen', methods=['POST'])
@role_required('Administrator')
def create_street(**kwargs):
data = request.get_json()
name = data.get('name', '').strip()
if not name:
return jsonify({'error': 'Name erforderlich'}), 400
zusatz = str(data.get('zusatz') or '').strip()
street_id = StreetModel.create(g.tenant_id, name,
hn_min=data.get('hn_min'),
hn_max=data.get('hn_max'),
bbox=data.get('bbox'),
state='unbearbeitet',
group_id=None,
zusatz=zusatz)
db = get_db()
db.execute(
'INSERT INTO street_state_history (tenant_id, street_id, from_state, to_state, group_id, actor_account_id) VALUES (?, ?, ?, ?, ?, ?)',
(g.tenant_id, street_id, None, 'unbearbeitet', None, session['account_id'])
)
db.commit()
log_transaction('street.create', 'street', street_id, {'name': name, 'zusatz': zusatz})
display_name = f'{name} {zusatz}'.strip()
notify_reload(f'Administration: Straße „{display_name}“ wurde erstellt.')
return jsonify({'success': True, 'id': street_id})
@admin_api_bp.route('/strassen/<int:street_id>', methods=['POST'])
@role_required('Administrator')
def update_street(street_id, **kwargs):
data = request.get_json()
db = get_db()
old = StreetModel.get_by_id(street_id, g.tenant_id)
if not old:
return jsonify({'error': 'Straße nicht gefunden'}), 404
changes = {}
for key in ['name', 'hn_min', 'hn_max', 'bbox', 'group_id', 'zusatz']:
if key in data:
if key == 'group_id' and (data[key] == '' or data[key] is None):
changes[key] = None
elif key == 'zusatz':
changes[key] = str(data[key] or '').strip()
elif key == 'name':
changes[key] = str(data[key] or '').strip()
elif key in ['hn_min', 'hn_max'] and data[key] != '' and data[key] is not None:
try:
changes[key] = int(data[key])
except:
changes[key] = data[key]
else:
changes[key] = data[key]
if 'state' in data and data['state'] != old['state']:
changes['state'] = data['state']
if data['state'] == 'unbearbeitet':
changes['group_id'] = None
db.execute(
'INSERT INTO street_state_history (tenant_id, street_id, from_state, to_state, group_id, actor_account_id) VALUES (?, ?, ?, ?, ?, ?)',
(g.tenant_id, street_id, old['state'], data['state'], changes.get('group_id', old['group_id']), session['account_id'])
)
# Code 100
msg = WSMessage(sender_id=session['account_id'], code=100,
msg=json.dumps({'name': old['name'], 'state': data['state'], 'actor': session['account_id'],
'street_id': street_id, 'group_id': changes.get('group_id', old['group_id'])}))
try:
broker.route_message(g.tenant_id, msg)
except:
pass
if changes:
StreetModel.update(street_id, g.tenant_id, **changes)
log_transaction('street.update', 'street', street_id, changes)
display_name = changes.get('name', old['name'])
notify_reload(f'Administration: Straße „{display_name}“ wurde geändert.')
db.commit()
return jsonify({'success': True})
@admin_api_bp.route('/strassen/<int:street_id>', methods=['DELETE'])
@role_required('Administrator')
def delete_street(street_id, **kwargs):
street = StreetModel.get_by_id(street_id, g.tenant_id)
StreetModel.delete(street_id, g.tenant_id)
log_transaction('street.delete', 'street', street_id, {})
name = street['name'] if street else f'#{street_id}'
notify_reload(f'Administration: Straße „{name}“ wurde gelöscht.')
return jsonify({'success': True})
@admin_api_bp.route('/strassen/bulk-delete', methods=['POST'])
@role_required('Administrator')
def bulk_delete_streets(**kwargs):
"""Löscht mehrere ausgewählte Straßen samt Hausnummern-Einträgen."""
data = request.get_json(silent=True)
if not isinstance(data, dict):
return jsonify({'error': 'JSON-Objekt erforderlich'}), 400
raw_ids = data.get('ids')
if not isinstance(raw_ids, list) or not raw_ids:
return jsonify({'error': 'Keine Straßen ausgewählt'}), 400
if len(raw_ids) > 10000:
return jsonify({'error': 'Zu viele Straßen auf einmal ausgewählt'}), 400
ids = []
for value in raw_ids:
if isinstance(value, bool):
return jsonify({'error': 'Ungültige Straßen-ID'}), 400
if isinstance(value, int):
street_id = value
elif isinstance(value, str) and value.strip().isdigit():
street_id = int(value.strip())
else:
return jsonify({'error': 'Ungültige Straßen-ID'}), 400
if street_id <= 0 or street_id > 9223372036854775807:
return jsonify({'error': 'Ungültige Straßen-ID'}), 400
if street_id not in ids:
ids.append(street_id)
result = StreetModel.delete_many(ids, g.tenant_id)
deleted_streets = result['streets']
if not deleted_streets:
return jsonify({'error': 'Keine passenden Straßen gefunden'}), 404
deleted_ids = [street['id'] for street in deleted_streets]
deleted_names = [street['name'] for street in deleted_streets]
log_transaction('street.bulk_delete', 'street', None, {
'ids': deleted_ids,
'names': deleted_names,
'house_numbers': result['house_numbers']
})
notify_reload(
f'Administration: {len(deleted_streets)} Straße(n) wurden gelöscht.'
)
return jsonify({
'success': True,
'deleted': len(deleted_streets),
'ids': deleted_ids,
'house_numbers_deleted': result['house_numbers']
})
@admin_api_bp.route('/strassen/str2pl', methods=['POST'])
@role_required('Administrator')
def generate_str2pl(**kwargs):
"""Erzeugt die mandantenspezifische Polyline-Datei neu.
Es werden immer alle Straßen des Mandanten aus der Datenbank
berücksichtigt; eine eventuelle Auswahl in der Oberfläche spielt keine
Rolle.
"""
try:
stats = Str2PlService.generate_for_tenant(g.tenant_id, g.tenant_code)
except FileNotFoundError as exc:
return jsonify({'error': str(exc)}), 400
except ValueError as exc:
return jsonify({'error': str(exc)}), 500
except OSError as exc:
current_app.logger.warning(
'Polyline-Datei konnte nicht geschrieben werden: %s', exc
)
return jsonify({'error': 'Polyline-Datei konnte nicht geschrieben werden'}), 500
log_transaction('street.str2pl_generate', 'street', None, stats)
notify_reload(
f'Administration: Polyline-Datei für Mandant {g.tenant_code} '
'wurde neu erzeugt.'
)
return jsonify({'success': True, **stats})
@admin_api_bp.route('/strassen/<int:street_id>/history')
@role_required('Administrator')
def street_history(street_id, **kwargs):
db = get_db()
history = db.execute(
'SELECT h.*, a.name as actor_name FROM street_state_history h LEFT JOIN accounts a ON h.actor_account_id = a.id WHERE h.street_id = ? AND h.tenant_id = ? ORDER BY h.created_at DESC',
(street_id, g.tenant_id)
).fetchall()
return jsonify([dict(row) for row in history])
@admin_api_bp.route('/strassen/<int:street_id>/history/<int:hist_id>/revert', methods=['POST'])
@role_required('Administrator')
def revert_street_hist(street_id, hist_id, **kwargs):
success, msg = HistoryService.revert_street(g.tenant_id, street_id, hist_id, session['account_id'])
if not success:
return jsonify({'error': msg}), 400
notify_reload('Administration: Straßenhistorie wurde wiederhergestellt.')
return jsonify({'success': True, 'message': msg})
@admin_api_bp.route('/strassen/import', methods=['POST'])
@role_required('Administrator')
def import_streets(**kwargs):
"""Importiert Straßen und Hausnummern aus einer gemeinsamen CSV-Datei."""
if 'file' not in request.files:
return jsonify({'error': 'Keine Datei'}), 400
file = request.files['file']
if file.filename == '':
return jsonify({'error': 'Keine Datei ausgewählt'}), 400
content = file.read()
if len(content) > 5_000_000:
return jsonify({'error': 'Datei zu groß'}), 400
house_numbers = parse_house_numbers_csv(content)
if not house_numbers:
return jsonify({
'error': 'Keine gültigen Einträge in der CSV gefunden. '
'Erwartete Spalten: Straßenname;Hausnummer;Longitude;Latitude'
}), 400
stats = StreetsService.import_from_house_numbers(
g.tenant_id, house_numbers, session['account_id']
)
log_transaction('street.import', 'street', None, stats)
notify_reload(
f'Administration: {stats["streets"]} Straßen und '
f'{stats["house_numbers"]} Hausnummern wurden importiert.'
)
return jsonify({
'success': True,
'count': stats['streets'],
'streets': stats['streets'],
'house_numbers': stats['house_numbers'],
})
@admin_api_bp.route('/strassen/<int:street_id>/split-options', methods=['GET'])
@role_required('Administrator')
def street_split_options(street_id, **kwargs):
"""Liefert die für eine Teilung wählbaren Hausnummern."""
options = StreetsService.get_split_options(street_id, g.tenant_id)
if options is None:
return jsonify({'error': 'Straße nicht gefunden'}), 404
return jsonify(options)
@admin_api_bp.route('/strassen/<int:street_id>/split', methods=['POST'])
@role_required('Administrator')
def split_street(street_id, **kwargs):
"""Teilt eine Straße an einer Hausnummer in zwei Abschnitte."""
data = request.get_json(silent=True) or {}
success, result = StreetsService.split_street(
street_id,
g.tenant_id,
data.get('house_number'),
session['account_id']
)
if not success:
return jsonify({'error': result}), 400
log_transaction('street.split', 'street', street_id, result)
notify_reload(
f'Administration: Straße „{result["lower"]["zusatz"]}“ / '
f'„{result["upper"]["zusatz"]}“ wurde geteilt.'
)
return jsonify({'success': True, **result})
@admin_api_bp.route('/broker/status')
@role_required('Administrator')
def broker_status(**kwargs):
"""Status aktiver WebSocket-Verbindungen aller Worker.
Die Verbindungsliste liegt in der gemeinsamen Tabelle ``ws_clients``.
Dadurch zeigt das Dashboard auch Clients, die an einem anderen
WSGI-Worker hängen.
"""
connections = broker.describe_connections(g.tenant_id)
result = []
for conn in connections:
result.append({
'client_id': conn['client_id'],
'account_id': conn['account_id'],
'account_name': conn['account_name'],
'role': conn['role'],
'authenticated': bool(conn['authenticated']),
'group_id': conn['group_id'],
'group_alias': conn['group_alias']
})
return jsonify({'connections': result})