API für Geo Positions Update mit Testscript
This commit is contained in:
1 parent
23a9df66f4
commit
d54a986c14
16 files changed
+1027
-6
No files matched your search
@@ -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
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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,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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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.
|
||||
|
||||
|
||||
Reference in new issue
Block a user