From 037c0724a87ec8365b1cb36935651b63c271e39f Mon Sep 17 00:00:00 2001 From: Lars Date: Tue, 20 Oct 2026 12:49:23 +0200 Subject: [PATCH] =?UTF-8?q?Erg=C3=A4nze=20die=20Benutzerverwaltung,=20dami?= =?UTF-8?q?t=20der=20Betreiber=20Konten,=20Rollen=20und=20Zug=C3=A4nge=20v?= =?UTF-8?q?erwalten=20kann.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Der Betreiber legt Konten mit Einmal-Passwort an, deaktiviert und aktiviert sie, setzt Passwörter zurück, beendet Sitzungen und vergibt die Betreiberrolle; der letzte Betreiber und das eigene Konto sind geschützt. Nutzer ändern ihr Passwort und sehen ihre Geräte. Räume kennen neben Mitglied und Verwalter die Rolle Leser, die nichts anlegt und keine Bearbeiten- oder Freigeben-Grants erhält. Verwalter pflegen Mitglieder, Rollen und Einladungen mit Rolle; der Betreiber sieht Räume ohne Inhalte und liest das Verwaltungsprotokoll. Die Login-Begrenzung steht in der Datenbank, unbekannte Konten laufen durch einen Zeitausgleich. Die lokale Suite läuft mit 116 Tests grün, der Frontend-Build und 16 Node-Tests ebenfalls. Die Oberfläche wurde noch nicht im Browser bedient. Co-Authored-By: Claude Sonnet 5.5 --- backend/app/access/roles.py | 94 ++++ backend/app/api/accounts.py | 250 ++++++++++ backend/app/api/deps.py | 23 +- backend/app/api/rooms.py | 464 ++++++++++++++++++ backend/app/api/routes.py | 267 ++-------- backend/app/api/schemas.py | 32 +- backend/app/auth/accounts.py | 198 +++++++- backend/app/auth/security.py | 28 ++ backend/app/core/errors.py | 9 + backend/app/main.py | 4 + backend/app/ops.py | 16 + backend/app/present.py | 21 + .../20261020T150000Z_user_admin.sql | 31 ++ backend/tests/conftest.py | 5 +- backend/tests/test_accounts.py | 3 +- backend/tests/test_room_roles.py | 210 ++++++++ backend/tests/test_user_admin.py | 261 ++++++++++ docs/README.md | 1 + docs/architecture/API_REFERENZ.md | 33 +- docs/architecture/BENUTZERVERWALTUNG.md | 52 ++ docs/architecture/DATENMODELL_IST.md | 11 +- docs/architecture/RECHTEMODELL_IST.md | 1 + frontend/src/App.jsx | 23 +- frontend/src/admin/Account.jsx | 105 ++++ frontend/src/admin/Admin.jsx | 128 +++++ frontend/src/admin/InviteAccept.jsx | 76 +++ frontend/src/admin/Users.jsx | 281 +++++++++++ frontend/src/admin/admin-core.js | 59 +++ frontend/src/admin/admin-core.test.mjs | 51 ++ frontend/src/admin/widgets.jsx | 85 ++++ frontend/src/pages/Rooms.jsx | 238 +++++++-- frontend/src/pages/Settings.jsx | 27 +- frontend/src/pages/Shell.jsx | 2 +- frontend/src/pages/Users.jsx | 92 ---- 34 files changed, 2790 insertions(+), 391 deletions(-) create mode 100644 backend/app/access/roles.py create mode 100644 backend/app/api/accounts.py create mode 100644 backend/app/api/rooms.py create mode 100644 backend/migrations/20261020T150000Z_user_admin.sql create mode 100644 backend/tests/test_room_roles.py create mode 100644 backend/tests/test_user_admin.py create mode 100644 docs/architecture/BENUTZERVERWALTUNG.md create mode 100644 frontend/src/admin/Account.jsx create mode 100644 frontend/src/admin/Admin.jsx create mode 100644 frontend/src/admin/InviteAccept.jsx create mode 100644 frontend/src/admin/Users.jsx create mode 100644 frontend/src/admin/admin-core.js create mode 100644 frontend/src/admin/admin-core.test.mjs create mode 100644 frontend/src/admin/widgets.jsx delete mode 100644 frontend/src/pages/Users.jsx diff --git a/backend/app/access/roles.py b/backend/app/access/roles.py new file mode 100644 index 0000000..453043c --- /dev/null +++ b/backend/app/access/roles.py @@ -0,0 +1,94 @@ +"""Fixed role bundles. Rights are read from the current database state, never from the session. + +Platform: operator or user. Data room: member, manager or reader. There is no role editor. +An operator has no read right on content. Unknown role or status is refused. +""" + +from __future__ import annotations + +from uuid import UUID + +from app.core.errors import forbidden + +ROOM_ROLES = ("member", "manager", "reader") + +ROOM_ROLE_LABELS = { + "member": "Mitglied", + "manager": "Verwalter", + "reader": "Leser", +} + + +def is_operator(conn, account_id: UUID) -> bool: + row = conn.execute( + "SELECT is_superadmin FROM auth_accounts WHERE id = %s AND status = 'active'", + (account_id,), + ).fetchone() + return bool(row and row["is_superadmin"]) + + +def require_operator(conn, account_id: UUID) -> None: + if not is_operator(conn, account_id): + raise forbidden("Das darf nur der Betreiber.") + + +def room_role(conn, account_id: UUID, room_id: UUID) -> str | None: + """The active role of an account in an organization room, or None.""" + row = conn.execute( + """ + SELECT m.role + FROM room_memberships m + JOIN data_rooms r ON r.id = m.room_id + WHERE m.room_id = %s AND m.subject_id = %s AND m.status = 'active' AND r.kind = 'organization' + """, + (room_id, account_id), + ).fetchone() + if row is None or row["role"] not in ROOM_ROLES: + return None + return row["role"] + + +def require_room_manager(conn, account_id: UUID, room_id: UUID) -> None: + if room_role(conn, account_id, room_id) != "manager": + raise forbidden("Das darf nur ein Verwalter dieses Datenraums.") + + +def require_room_write(conn, account_id: UUID, room: dict) -> None: + """Creating content needs the own personal room or a member or manager role.""" + if room["kind"] == "personal": + if room["id"] != account_id: + raise forbidden("Der persönliche Datenraum gehört zu einem anderen Konto.") + return + role = room_role(conn, account_id, room["id"]) + if role in {"member", "manager"}: + return + if role == "reader": + raise forbidden("Als Leser kannst du in diesem Datenraum nichts anlegen.") + raise forbidden("Du bist in diesem Datenraum nicht Mitglied.") + + +def count_active_operators(conn, *, lock: bool = False) -> int: + suffix = " FOR UPDATE" if lock else "" + rows = conn.execute(f"SELECT id FROM auth_accounts WHERE is_superadmin AND status = 'active'{suffix}").fetchall() + return len(rows) + + +def count_active_managers(conn, room_id: UUID, *, lock: bool = False) -> int: + suffix = " FOR UPDATE" if lock else "" + rows = conn.execute( + f""" + SELECT m.subject_id FROM room_memberships m + JOIN auth_accounts a ON a.id = m.subject_id + WHERE m.room_id = %s AND m.role = 'manager' AND m.status = 'active' AND a.status = 'active'{suffix} + """, + (room_id,), + ).fetchall() + return len(rows) + + +def ensure_can_create(conn, account_id: UUID, scope_id: UUID) -> None: + """Gate for every operation that creates content with this home room.""" + room = conn.execute("SELECT id, kind FROM data_rooms WHERE id = %s", (scope_id,)).fetchone() + if room is None: + raise forbidden("Der gewählte Datenraum ist nicht verfügbar.") + require_room_write(conn, account_id, room) diff --git a/backend/app/api/accounts.py b/backend/app/api/accounts.py new file mode 100644 index 0000000..6c18f73 --- /dev/null +++ b/backend/app/api/accounts.py @@ -0,0 +1,250 @@ +"""Account administration for the operator and the own account (password, sessions).""" + +from __future__ import annotations + +from uuid import UUID + +from fastapi import APIRouter, Depends, Response +from fastapi.responses import JSONResponse +from psycopg import Connection + +from app.access.policy import audit +from app.access.roles import require_operator +from app.api.deps import Principal, get_conn, get_principal, get_session +from app.api.schemas import AccountIn, AccountPatchIn, PasswordChangeIn +from app.auth.accounts import ( + change_own_password, + create_account, + generate_password, + reset_password, + revoke_sessions, + set_display_name, + set_operator, + set_status, +) +from app.core.errors import not_found, unprocessable +from app.core.timeutil import dump_dt + +router = APIRouter() + +_NO_STORE = {"Cache-Control": "no-store"} + + +def _account_item(row) -> dict: + return { + "id": str(row["id"]), + "email": row["email"], + "display_name": row["display_name"], + "is_superadmin": row["is_superadmin"], + "status": row["status"], + "must_change_password": row["must_change_password"], + "created_at": dump_dt(row["created_at"]), + "last_login_at": dump_dt(row["last_login_at"]), + } + + +@router.get("/api/v1/accounts") +def accounts( + status: str | None = None, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + require_operator(conn, principal.account_id) + if status not in {None, "active", "disabled"}: + raise unprocessable("Der Statusfilter ist ungültig.") + rows = conn.execute( + """ + SELECT id, email, display_name, is_superadmin, status, must_change_password, created_at, last_login_at + FROM auth_accounts + WHERE origin = 'operator' AND (%s::text IS NULL OR status = %s::text) + ORDER BY status, display_name, email + """, + (status, status), + ).fetchall() + return {"items": [_account_item(row) for row in rows], "next_cursor": None} + + +@router.get("/api/v1/accounts/{account_id}") +def account_detail(account_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): + require_operator(conn, principal.account_id) + row = conn.execute( + """ + SELECT id, email, display_name, is_superadmin, status, must_change_password, created_at, last_login_at + FROM auth_accounts WHERE id = %s AND origin = 'operator' + """, + (account_id,), + ).fetchone() + if row is None: + raise not_found() + rooms = conn.execute( + """ + SELECT r.id, r.name, r.status, m.role + FROM room_memberships m + JOIN data_rooms r ON r.id = m.room_id + WHERE m.subject_id = %s AND m.status = 'active' AND r.kind = 'organization' + ORDER BY r.name, r.id + """, + (account_id,), + ).fetchall() + sessions = conn.execute( + """ + SELECT count(*) AS n FROM auth_sessions + WHERE account_id = %s AND revoked_at IS NULL AND expires_at > now() + """, + (account_id,), + ).fetchone() + body = _account_item(row) + body["rooms"] = [ + {"id": str(room["id"]), "name": room["name"], "status": room["status"], "role": room["role"]} for room in rooms + ] + body["active_sessions"] = sessions["n"] + return JSONResponse(body, headers=_NO_STORE) + + +@router.post("/api/v1/accounts") +def post_account(body: AccountIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): + require_operator(conn, principal.account_id) + password = body.password or generate_password() + account = create_account( + conn, + body.email, + body.display_name, + password, + is_superadmin=body.is_operator, + must_change_password=True, + ) + audit(conn, principal.account_id, None, "account_created", "account", account["id"]) + if body.is_operator: + audit(conn, principal.account_id, None, "operator_granted", "account", account["id"]) + payload = { + "id": str(account["id"]), + "email": account["email"], + "display_name": account["display_name"], + "is_superadmin": account["is_superadmin"], + "status": account["status"], + "must_change_password": True, + } + if not body.password: + payload["temporary_password"] = password + return JSONResponse( + status_code=201, + content=payload, + headers={"Location": f"/api/v1/accounts/{account['id']}", **_NO_STORE}, + ) + + +@router.patch("/api/v1/accounts/{account_id}") +def patch_account( + account_id: UUID, + body: AccountPatchIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + require_operator(conn, principal.account_id) + exists = conn.execute("SELECT 1 FROM auth_accounts WHERE id = %s AND origin = 'operator'", (account_id,)).fetchone() + if exists is None: + raise not_found() + if body.display_name is not None: + set_display_name(conn, principal.account_id, account_id, body.display_name) + if body.is_operator is not None: + set_operator(conn, principal.account_id, account_id, body.is_operator) + if body.status is not None: + set_status(conn, principal.account_id, account_id, body.status) + row = conn.execute( + """ + SELECT id, email, display_name, is_superadmin, status, must_change_password, created_at, last_login_at + FROM auth_accounts WHERE id = %s + """, + (account_id,), + ).fetchone() + return _account_item(row) + + +@router.post("/api/v1/accounts/{account_id}/password-reset") +def post_password_reset( + account_id: UUID, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + require_operator(conn, principal.account_id) + password = reset_password(conn, principal.account_id, account_id) + return JSONResponse({"temporary_password": password}, headers=_NO_STORE) + + +@router.post("/api/v1/accounts/{account_id}/sessions/revoke") +def post_revoke_sessions( + account_id: UUID, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + require_operator(conn, principal.account_id) + if conn.execute("SELECT 1 FROM auth_accounts WHERE id = %s", (account_id,)).fetchone() is None: + raise not_found() + count = revoke_sessions(conn, account_id) + audit(conn, principal.account_id, None, "sessions_revoked", "account", account_id, detail={"count": count}) + return {"revoked": count} + + +@router.post("/api/v1/auth/password", status_code=204) +def post_own_password( + body: PasswordChangeIn, + session: dict = Depends(get_session), + conn: Connection = Depends(get_conn), +): + change_own_password(conn, session["account_id"], session["id"], body.current_password, body.new_password) + return Response(status_code=204) + + +@router.get("/api/v1/auth/sessions") +def own_sessions(session: dict = Depends(get_session), conn: Connection = Depends(get_conn)): + rows = conn.execute( + """ + SELECT id, label, created_at, last_seen_at, expires_at + FROM auth_sessions + WHERE account_id = %s AND revoked_at IS NULL AND expires_at > now() + ORDER BY created_at DESC, id + """, + (session["account_id"],), + ).fetchall() + return JSONResponse( + { + "items": [ + { + "id": str(row["id"]), + "label": row["label"] or "Browser", + "created_at": dump_dt(row["created_at"]), + "last_seen_at": dump_dt(row["last_seen_at"]), + "expires_at": dump_dt(row["expires_at"]), + "current": row["id"] == session["id"], + } + for row in rows + ] + }, + headers=_NO_STORE, + ) + + +@router.delete("/api/v1/auth/sessions/{session_id}", status_code=204) +def end_own_session(session_id: UUID, session: dict = Depends(get_session), conn: Connection = Depends(get_conn)): + if session_id == session["id"]: + raise unprocessable("Diese Sitzung beendest du mit Abmelden.") + row = conn.execute( + """ + UPDATE auth_sessions SET revoked_at = now() + WHERE id = %s AND account_id = %s AND revoked_at IS NULL + RETURNING id + """, + (session_id, session["account_id"]), + ).fetchone() + if row is None: + raise not_found() + audit(conn, session["account_id"], None, "session_ended", "session", session_id) + return Response(status_code=204) + + +@router.post("/api/v1/auth/sessions/revoke-others") +def end_other_sessions(session: dict = Depends(get_session), conn: Connection = Depends(get_conn)): + count = revoke_sessions(conn, session["account_id"], keep=session["id"]) + audit(conn, session["account_id"], None, "sessions_revoked", "account", session["account_id"], detail={"count": count}) + return {"revoked": count} + diff --git a/backend/app/api/deps.py b/backend/app/api/deps.py index 47ccdf2..8c26d4d 100644 --- a/backend/app/api/deps.py +++ b/backend/app/api/deps.py @@ -2,7 +2,9 @@ from __future__ import annotations +import secrets from dataclasses import dataclass +from datetime import timedelta from pathlib import Path @@ -19,10 +21,19 @@ from psycopg import Connection from app.access.policy import ensure_member_or_personal from app.auth.security import hash_secret, read_session_token -from app.core.errors import forbidden, unauthorized +from app.core.errors import forbidden, password_change_required, unauthorized from app.core.timeutil import utcnow +# While a one-time password is set, only these routes answer. +PASSWORD_CHANGE_PATHS = frozenset({ + "/api/v1/auth/session", + "/api/v1/auth/password", + "/api/v1/auth/logout", +}) +SEEN_INTERVAL = timedelta(minutes=5) + + @dataclass(frozen=True) class Principal: account_id: UUID @@ -58,7 +69,8 @@ def _session_row(conn: Connection, request: Request) -> dict: row = conn.execute( """ SELECT s.id, s.account_id, s.csrf_token, s.scope_kind, s.scope_id, s.epoch, - s.expires_at, s.revoked_at, a.email, a.display_name, a.status AS account_status + s.expires_at, s.revoked_at, s.last_seen_at, a.email, a.display_name, + a.status AS account_status, a.must_change_password FROM auth_sessions s JOIN auth_accounts a ON a.id = s.account_id WHERE s.secret_hash = %s @@ -69,10 +81,15 @@ def _session_row(conn: Connection, request: Request) -> dict: raise unauthorized() if row["account_status"] != "active": raise unauthorized() + if row["must_change_password"] and request.url.path not in PASSWORD_CHANGE_PATHS: + raise password_change_required() if request.method not in {"GET", "HEAD", "OPTIONS"}: sent = request.headers.get("x-csrf-token") or "" - if not sent or sent != row["csrf_token"]: + if not sent or not secrets.compare_digest(sent, row["csrf_token"]): raise forbidden("Die Anfrage konnte der Sitzung nicht zugeordnet werden.") + seen = row["last_seen_at"] + if seen is None or utcnow() - seen > SEEN_INTERVAL: + conn.execute("UPDATE auth_sessions SET last_seen_at = now() WHERE id = %s", (row["id"],)) return row diff --git a/backend/app/api/rooms.py b/backend/app/api/rooms.py new file mode 100644 index 0000000..5fd0a81 --- /dev/null +++ b/backend/app/api/rooms.py @@ -0,0 +1,464 @@ +"""Data rooms: members, roles, invitations, and the operator's room overview and audit.""" + +from __future__ import annotations + +from datetime import timedelta +from uuid import UUID, uuid4 + +from fastapi import APIRouter, Depends, Response +from fastapi.responses import JSONResponse +from psycopg import Connection + +from app.access.policy import account_by_email, audit +from app.access.roles import ( + ROOM_ROLES, + count_active_managers, + require_operator, + require_room_manager, +) +from app.api.deps import Principal, get_conn, get_principal +from app.api.schemas import ( + InvitationIn, + MemberIn, + MemberRoleIn, + OperatorManagerIn, + RoomIn, + RoomPatchIn, +) +from app.auth.accounts import normalize_email +from app.auth.security import hash_secret, new_secret +from app.core.errors import forbidden, not_found, unprocessable +from app.core.timeutil import dump_dt, utcnow +from app.present import LABELS + +router = APIRouter() + +_NO_STORE = {"Cache-Control": "no-store"} +INVITATION_DAYS = 7 + + +def _created(path: str, payload: dict) -> JSONResponse: + return JSONResponse(status_code=201, content=payload, headers={"Location": path, **_NO_STORE}) + + +def _room(conn, room_id: UUID) -> dict: + row = conn.execute("SELECT * FROM data_rooms WHERE id = %s AND kind = 'organization'", (room_id,)).fetchone() + if row is None: + raise not_found() + return row + + +def _audit_membership(conn, actor: UUID, room_id: UUID, subject_id: UUID, action: str, role: str | None = None) -> None: + audit( + conn, + actor, + room_id, + action, + "membership", + subject_id, + detail={"room_id": str(room_id), **({"role": role} if role else {})}, + ) + + +def _drop_edit_rights_in_room(conn, subject_id: UUID, room_id: UUID) -> None: + """A reader neither edits nor shares objects of this room. Read grants stay.""" + conn.execute( + """ + UPDATE access_grants g + SET can_edit = false, can_share = false + WHERE g.grantee_subject_id = %s AND NOT g.is_exception AND (g.can_edit OR g.can_share) + AND ( + (g.resource_kind = 'case' AND g.resource_id IN (SELECT id FROM cases WHERE home_scope_id = %s)) + OR (g.resource_kind = 'matter' AND g.resource_id IN (SELECT id FROM matters WHERE home_scope_id = %s)) + OR (g.resource_kind = 'element' AND g.resource_id IN (SELECT id FROM elements WHERE home_scope_id = %s)) + OR (g.resource_kind = 'task' AND g.resource_id IN (SELECT id FROM tasks WHERE home_scope_id = %s)) + OR (g.resource_kind = 'deadline' AND g.resource_id IN (SELECT id FROM deadlines WHERE home_scope_id = %s)) + ) + """, + (subject_id, room_id, room_id, room_id, room_id, room_id), + ) + + +def _set_role(conn, actor: UUID, room_id: UUID, subject_id: UUID, role: str, *, added: bool) -> None: + if role not in ROOM_ROLES: + raise unprocessable("Diese Raumrolle gibt es nicht.") + conn.execute( + """ + INSERT INTO room_memberships (room_id, subject_id, role, status) + VALUES (%s, %s, %s, 'active') + ON CONFLICT (room_id, subject_id) DO UPDATE SET role = EXCLUDED.role, status = 'active' + """, + (room_id, subject_id, role), + ) + if role == "reader": + _drop_edit_rights_in_room(conn, subject_id, room_id) + _audit_membership(conn, actor, room_id, subject_id, "membership_added" if added else "membership_role_changed", role) + + +def _membership(conn, room_id: UUID, subject_id: UUID, *, lock: bool = False) -> dict | None: + suffix = " FOR UPDATE" if lock else "" + return conn.execute( + f"SELECT role, status FROM room_memberships WHERE room_id = %s AND subject_id = %s{suffix}", + (room_id, subject_id), + ).fetchone() + + +@router.get("/api/v1/rooms") +def rooms( + include_archived: bool = False, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + from app.auth.accounts import list_rooms + + items = list_rooms(conn, principal.account_id) + if include_archived: + archived = conn.execute( + """ + SELECT r.id, r.name, m.role + FROM room_memberships m JOIN data_rooms r ON r.id = m.room_id + WHERE m.subject_id = %s AND m.status = 'active' AND r.kind = 'organization' AND r.status = 'archived' + ORDER BY r.name, r.id + """, + (principal.account_id,), + ).fetchall() + items += [ + {"id": str(row["id"]), "kind": "organization", "name": row["name"], "role": row["role"], "status": "archived"} + for row in archived + ] + return {"items": items, "next_cursor": None} + + +@router.post("/api/v1/rooms") +def create_room(body: RoomIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): + room_id = uuid4() + name = body.name.strip() + conn.execute( + "INSERT INTO data_rooms (id, kind, name, created_by) VALUES (%s, 'organization', %s, %s)", + (room_id, name, principal.account_id), + ) + conn.execute( + "INSERT INTO room_memberships (room_id, subject_id, role) VALUES (%s, %s, 'manager')", + (room_id, principal.account_id), + ) + audit(conn, principal.account_id, room_id, "room_created", "room", room_id) + return _created(f"/api/v1/rooms/{room_id}", {"id": str(room_id), "kind": "organization", "name": name}) + + +@router.patch("/api/v1/rooms/{room_id}") +def patch_room( + room_id: UUID, + body: RoomPatchIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + require_room_manager(conn, principal.account_id, room_id) + room = _room(conn, room_id) + if body.name is not None and body.name.strip() != room["name"]: + conn.execute("UPDATE data_rooms SET name = %s WHERE id = %s", (body.name.strip(), room_id)) + audit(conn, principal.account_id, room_id, "room_renamed", "room", room_id) + if body.status is not None and body.status != room["status"]: + conn.execute("UPDATE data_rooms SET status = %s WHERE id = %s", (body.status, room_id)) + if body.status == "archived": + # Sessions working in the room return to their personal room. + conn.execute( + """ + UPDATE auth_sessions + SET scope_kind = 'personal', scope_id = account_id, epoch = epoch + 1 + WHERE scope_id = %s AND revoked_at IS NULL + """, + (room_id,), + ) + audit( + conn, + principal.account_id, + room_id, + "room_archived" if body.status == "archived" else "room_restored", + "room", + room_id, + ) + row = _room(conn, room_id) + return {"id": str(row["id"]), "name": row["name"], "status": row["status"]} + + +@router.get("/api/v1/rooms/{room_id}/members") +def members(room_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): + require_room_manager(conn, principal.account_id, room_id) + rows = conn.execute( + """ + SELECT m.subject_id, m.role, a.email, a.display_name, a.status + FROM room_memberships m + JOIN auth_accounts a ON a.id = m.subject_id + WHERE m.room_id = %s AND m.status = 'active' + ORDER BY a.display_name, a.id + """, + (room_id,), + ).fetchall() + return { + "items": [ + { + "subject_id": str(row["subject_id"]), + "email": row["email"], + "display_name": row["display_name"], + "role": row["role"], + "account_status": row["status"], + } + for row in rows + ] + } + + +@router.post("/api/v1/rooms/{room_id}/members") +def add_member( + room_id: UUID, + body: MemberIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + require_room_manager(conn, principal.account_id, room_id) + account = account_by_email(conn, body.email) + if account is None or account["status"] != "active": + raise not_found() + existing = _membership(conn, room_id, account["id"], lock=True) + if existing and existing["status"] == "active" and existing["role"] == "manager" and body.role != "manager": + if count_active_managers(conn, room_id, lock=True) <= 1: + raise unprocessable("Der letzte Verwalter bleibt Verwalter.") + was_active = bool(existing and existing["status"] == "active") + _set_role(conn, principal.account_id, room_id, account["id"], body.role, added=not was_active) + return {"subject_id": str(account["id"]), "role": body.role} + + +@router.patch("/api/v1/rooms/{room_id}/members/{subject_id}") +def change_member_role( + room_id: UUID, + subject_id: UUID, + body: MemberRoleIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + require_room_manager(conn, principal.account_id, room_id) + count_active_managers(conn, room_id, lock=True) + current = _membership(conn, room_id, subject_id, lock=True) + if current is None or current["status"] != "active": + raise not_found() + if current["role"] == body.role: + return {"subject_id": str(subject_id), "role": body.role} + if current["role"] == "manager" and count_active_managers(conn, room_id) <= 1: + raise unprocessable("Der letzte Verwalter bleibt Verwalter.") + _set_role(conn, principal.account_id, room_id, subject_id, body.role, added=False) + return {"subject_id": str(subject_id), "role": body.role} + + +@router.delete("/api/v1/rooms/{room_id}/members/{subject_id}", status_code=204) +def remove_member( + room_id: UUID, + subject_id: UUID, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + require_room_manager(conn, principal.account_id, room_id) + count_active_managers(conn, room_id, lock=True) + current = _membership(conn, room_id, subject_id, lock=True) + if current is None or current["status"] != "active": + raise not_found() + if current["role"] == "manager" and count_active_managers(conn, room_id) <= 1: + raise unprocessable("Der letzte Verwalter kann den Datenraum nicht verlassen.") + conn.execute( + "UPDATE room_memberships SET status = 'removed' WHERE room_id = %s AND subject_id = %s", + (room_id, subject_id), + ) + _audit_membership(conn, principal.account_id, room_id, subject_id, "membership_removed") + return Response(status_code=204) + + +@router.post("/api/v1/invitations") +def invite( + body: InvitationIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + room = _room(conn, body.room_id) + require_room_manager(conn, principal.account_id, room["id"]) + email = normalize_email(body.email) + if account_by_email(conn, email): + raise unprocessable("Es gibt bereits ein Konto. Füge die Person als Mitglied hinzu.") + token = new_secret() + row = conn.execute( + """ + INSERT INTO auth_invitations (email, room_id, token_hash, invited_by, expires_at, role) + VALUES (%s, %s, %s, %s, %s, %s) + RETURNING id, expires_at + """, + (email, room["id"], hash_secret(token), principal.account_id, utcnow() + timedelta(days=INVITATION_DAYS), body.role), + ).fetchone() + audit(conn, principal.account_id, room["id"], "invitation_created", "invitation", row["id"], detail={"role": body.role}) + return _created( + f"/api/v1/invitations/{row['id']}", + {"id": str(row["id"]), "email": email, "role": body.role, "expires_at": dump_dt(row["expires_at"]), "token": token}, + ) + + +@router.get("/api/v1/rooms/{room_id}/invitations") +def invitations(room_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): + require_room_manager(conn, principal.account_id, room_id) + rows = conn.execute( + """ + SELECT id, email, role, expires_at, created_at + FROM auth_invitations + WHERE room_id = %s AND accepted_at IS NULL AND revoked_at IS NULL AND expires_at > now() + ORDER BY created_at DESC, id + """, + (room_id,), + ).fetchall() + return JSONResponse( + { + "items": [ + { + "id": str(row["id"]), + "email": row["email"], + "role": row["role"], + "expires_at": dump_dt(row["expires_at"]), + "created_at": dump_dt(row["created_at"]), + } + for row in rows + ] + }, + headers=_NO_STORE, + ) + + +@router.delete("/api/v1/rooms/{room_id}/invitations/{invitation_id}", status_code=204) +def revoke_invitation( + room_id: UUID, + invitation_id: UUID, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + require_room_manager(conn, principal.account_id, room_id) + row = conn.execute( + """ + UPDATE auth_invitations SET revoked_at = now() + WHERE id = %s AND room_id = %s AND accepted_at IS NULL AND revoked_at IS NULL + RETURNING id + """, + (invitation_id, room_id), + ).fetchone() + if row is None: + raise not_found() + audit(conn, principal.account_id, room_id, "invitation_revoked", "invitation", invitation_id) + return Response(status_code=204) + + +@router.get("/api/v1/admin/rooms") +def admin_rooms(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): + """Metadata only: names, state and who manages. No content.""" + require_operator(conn, principal.account_id) + rows = conn.execute( + """ + SELECT r.id, r.name, r.status, r.created_at, + (SELECT count(*) FROM room_memberships m WHERE m.room_id = r.id AND m.status = 'active') AS members, + COALESCE(( + SELECT json_agg(a.display_name ORDER BY a.display_name) + FROM room_memberships m JOIN auth_accounts a ON a.id = m.subject_id + WHERE m.room_id = r.id AND m.status = 'active' AND m.role = 'manager' AND a.status = 'active' + ), '[]'::json) AS managers + FROM data_rooms r + WHERE r.kind = 'organization' + ORDER BY r.name, r.id + """ + ).fetchall() + return { + "items": [ + { + "id": str(row["id"]), + "name": row["name"], + "status": row["status"], + "members": row["members"], + "managers": row["managers"], + "has_manager": bool(row["managers"]), + "created_at": dump_dt(row["created_at"]), + } + for row in rows + ], + "next_cursor": None, + } + + +@router.post("/api/v1/admin/rooms/{room_id}/managers") +def admin_assign_manager( + room_id: UUID, + body: OperatorManagerIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + """Only for a room without an active manager, so it does not stay orphaned.""" + require_operator(conn, principal.account_id) + _room(conn, room_id) + if count_active_managers(conn, room_id, lock=True) > 0: + raise forbidden("Dieser Datenraum hat bereits einen Verwalter.") + account = account_by_email(conn, body.email) + if account is None or account["status"] != "active": + raise not_found() + existing = _membership(conn, room_id, account["id"], lock=True) + _set_role( + conn, + principal.account_id, + room_id, + account["id"], + "manager", + added=not (existing and existing["status"] == "active"), + ) + return {"subject_id": str(account["id"]), "role": "manager"} + + +_ADMIN_KINDS = ("account", "session", "room", "membership", "invitation") + + +@router.get("/api/v1/admin/events") +def admin_events( + cursor: int = 0, + limit: int = 50, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + require_operator(conn, principal.account_id) + limit = max(1, min(limit, 100)) + cursor = max(0, cursor) + rows = conn.execute( + """ + SELECT e.id, e.action, e.resource_kind, e.resource_id, e.occurred_at, e.result, e.scope_id, + actor.display_name AS actor_name, + subject.display_name AS subject_name, + room.name AS room_name + FROM domain_events e + LEFT JOIN auth_accounts actor ON actor.id = e.actor_subject_id + LEFT JOIN auth_accounts subject ON subject.id = e.resource_id AND e.resource_kind IN ('account', 'membership') + LEFT JOIN data_rooms room ON room.id = COALESCE(e.scope_id, CASE WHEN e.resource_kind = 'room' THEN e.resource_id END) + AND room.kind = 'organization' + WHERE e.resource_kind = ANY(%s) + ORDER BY e.occurred_at DESC, e.id DESC + OFFSET %s LIMIT %s + """, + (list(_ADMIN_KINDS), cursor, limit + 1), + ).fetchall() + page = rows[:limit] + return JSONResponse( + { + "items": [ + { + "id": str(row["id"]), + "action": row["action"], + "label": LABELS.get(row["action"], "Ereignis"), + "resource_kind": row["resource_kind"], + "actor": row["actor_name"], + "subject": row["subject_name"], + "room": row["room_name"], + "occurred_at": dump_dt(row["occurred_at"]), + "result": row["result"], + } + for row in page + ], + "next_cursor": cursor + limit if len(rows) > limit else None, + }, + headers=_NO_STORE, + ) diff --git a/backend/app/api/routes.py b/backend/app/api/routes.py index aacfc4a..698cb0e 100644 --- a/backend/app/api/routes.py +++ b/backend/app/api/routes.py @@ -12,6 +12,7 @@ from psycopg import Connection from app.access.policy import ( Ctx, account_by_email, + audit, case_rights, deadline_rights, element_rights, @@ -34,7 +35,6 @@ from app.access.policy import ( from app.api.deps import Principal, get_conn, get_principal, get_session from app.api.schemas import ( AcceptInviteIn, - AccountIn, AnnotationIn, BootstrapIn, AssigneeIn, @@ -60,18 +60,15 @@ from app.api.schemas import ( ExternalIn, FulfillIn, GrantIn, - InvitationIn, LoginIn, MatterIn, MatterPatch, - MemberIn, BindingOrderIn, ContentOrderIn, ChapterMoveIn, DatesPatch, NoteIn, NotePatch, - RoomIn, ScopeIn, TaskDeadlineIn, ElementReferenceIn, @@ -82,14 +79,25 @@ from app.api.schemas import ( TaskIn, TaskPatch, ) -from app.auth.accounts import create_account, list_rooms, normalize_email, start_session +from app.auth.accounts import ( + clear_login_attempts, + create_account, + list_rooms, + login_blocked, + normalize_email, + record_failed_login, + start_session, +) from app.auth.security import ( clear_session_cookie, + device_label, hash_secret, + login_bucket, new_secret, session_expiry, set_session_cookie, verify_password, + verify_unknown_account, ) from app.core.errors import Problem, forbidden, not_found, too_many, unprocessable from app.core.timeutil import dump_date, dump_dt, utcnow @@ -160,7 +168,6 @@ from app.present import ( from app.seed import demo_public router = APIRouter() -_login_attempts: dict[str, list[datetime]] = {} def _chosen_home(conn, principal: Principal, requested: UUID | None) -> UUID: @@ -192,7 +199,7 @@ def _chapter_payload(row) -> dict: def _session_body(conn, account_id: UUID, scope_kind: str, scope_id: UUID, csrf: str, epoch: int) -> dict: account = conn.execute( - "SELECT id, email, display_name, is_superadmin FROM auth_accounts WHERE id = %s", + "SELECT id, email, display_name, is_superadmin, must_change_password FROM auth_accounts WHERE id = %s", (account_id,), ).fetchone() room = conn.execute("SELECT id, kind, name FROM data_rooms WHERE id = %s", (scope_id,)).fetchone() @@ -202,6 +209,7 @@ def _session_body(conn, account_id: UUID, scope_kind: str, scope_id: UUID, csrf: "email": account["email"], "display_name": account["display_name"], "is_superadmin": account["is_superadmin"], + "must_change_password": account["must_change_password"], }, "scope": {"kind": scope_kind, "id": str(room["id"]), "name": room["name"]}, "rooms": list_rooms(conn, account_id), @@ -210,28 +218,28 @@ def _session_body(conn, account_id: UUID, scope_kind: str, scope_id: UUID, csrf: } -def _limit_login(key: str) -> None: - now = utcnow() - window = [item for item in _login_attempts.get(key, []) if now - item < timedelta(minutes=10)] - if len(window) >= 8: - _login_attempts[key] = window - raise too_many() - window.append(now) - _login_attempts[key] = window - - @router.post("/api/v1/auth/login") def login(body: LoginIn, request: Request, conn: Connection = Depends(get_conn)): email = normalize_email(body.email) - _limit_login(f"{request.client.host if request.client else 'local'}:{email}") + bucket = login_bucket(request.client.host if request.client else "local", email) + if login_blocked(conn, bucket): + raise too_many() account = conn.execute( "SELECT * FROM auth_accounts WHERE email = %s", (email,), ).fetchone() - if account is None or account["status"] != "active" or not verify_password(body.password, account["password_hash"]): + if account is None or account["status"] != "active": + # Same time and same answer as a wrong password. + verify_unknown_account(body.password) + valid = False + else: + valid = verify_password(body.password, account["password_hash"]) + if not valid: + record_failed_login(conn, bucket) raise Problem(401, "Anmeldung fehlgeschlagen", "E-Mail oder Passwort ist nicht richtig.", "unauthorized") + clear_login_attempts(conn, bucket) settings = request.app.state.settings - token, csrf = start_session(conn, settings, account["id"]) + token, csrf = start_session(conn, settings, account["id"], device_label(request.headers.get("user-agent"))) payload = _session_body(conn, account["id"], "personal", account["id"], csrf, 1) response = JSONResponse(payload) set_session_cookie(response, request, settings, token) @@ -241,6 +249,7 @@ def login(body: LoginIn, request: Request, conn: Connection = Depends(get_conn)) @router.post("/api/v1/auth/logout", status_code=204) def logout(request: Request, session: dict = Depends(get_session), conn: Connection = Depends(get_conn)): conn.execute("UPDATE auth_sessions SET revoked_at = now() WHERE id = %s", (session["id"],)) + audit(conn, session["account_id"], None, "session_ended", "session", session["id"]) response = Response(status_code=204) clear_session_cookie(response, request, request.app.state.settings) return response @@ -303,99 +312,13 @@ def bootstrap(body: BootstrapIn, request: Request, conn: Connection = Depends(ge raise not_found() account = create_account(conn, body.email, body.display_name, body.password, is_superadmin=True) settings = request.app.state.settings - token, csrf = start_session(conn, settings, account["id"]) + token, csrf = start_session(conn, settings, account["id"], device_label(request.headers.get("user-agent"))) payload = _session_body(conn, account["id"], "personal", account["id"], csrf, 1) response = JSONResponse(status_code=201, content=payload) set_session_cookie(response, request, settings, token) return response -def _require_superadmin(conn: Connection, principal: Principal) -> None: - row = conn.execute( - "SELECT is_superadmin FROM auth_accounts WHERE id = %s", - (principal.account_id,), - ).fetchone() - if row is None or not row["is_superadmin"]: - raise forbidden("Nur der Betreiber kann Nutzer anlegen.") - - -@router.get("/api/v1/accounts") -def accounts(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): - _require_superadmin(conn, principal) - rows = conn.execute( - """ - SELECT id, email, display_name, is_superadmin, created_at - FROM auth_accounts - WHERE origin = 'operator' AND status = 'active' - ORDER BY display_name, email - """ - ).fetchall() - return { - "items": [ - { - "id": str(row["id"]), - "email": row["email"], - "display_name": row["display_name"], - "is_superadmin": row["is_superadmin"], - "created_at": dump_dt(row["created_at"]), - } - for row in rows - ], - "next_cursor": None, - } - - -@router.post("/api/v1/accounts") -def post_account(body: AccountIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): - _require_superadmin(conn, principal) - account = create_account(conn, body.email, body.display_name, body.password) - return _created( - f"/api/v1/accounts/{account['id']}", - { - "id": str(account["id"]), - "email": account["email"], - "display_name": account["display_name"], - "is_superadmin": account["is_superadmin"], - }, - ) - - -@router.post("/api/v1/invitations") -def invite( - body: InvitationIn, - principal: Principal = Depends(get_principal), - conn: Connection = Depends(get_conn), -): - room = conn.execute("SELECT * FROM data_rooms WHERE id = %s", (body.room_id,)).fetchone() - if room is None or room["kind"] != "organization": - raise not_found() - membership = conn.execute( - """ - SELECT role FROM room_memberships - WHERE room_id = %s AND subject_id = %s AND status = 'active' - """, - (room["id"], principal.account_id), - ).fetchone() - if membership is None or membership["role"] != "manager": - raise forbidden() - email = normalize_email(body.email) - if account_by_email(conn, email): - raise unprocessable("Es gibt bereits ein Konto. Füge die Person als Mitglied hinzu.") - token = new_secret() - row = conn.execute( - """ - INSERT INTO auth_invitations (email, room_id, token_hash, invited_by, expires_at) - VALUES (%s, %s, %s, %s, %s) - RETURNING id, expires_at - """, - (email, room["id"], hash_secret(token), principal.account_id, utcnow() + timedelta(days=7)), - ).fetchone() - return _created( - f"/api/v1/invitations/{row['id']}", - {"id": str(row["id"]), "email": email, "expires_at": row["expires_at"].isoformat(), "token": token}, - ) - - @router.post("/api/v1/invitations/{invitation_id}/accept") def accept_invite( invitation_id: UUID, @@ -404,7 +327,12 @@ def accept_invite( conn: Connection = Depends(get_conn), ): row = conn.execute("SELECT * FROM auth_invitations WHERE id = %s", (invitation_id,)).fetchone() - if row is None or row["accepted_at"] is not None or row["expires_at"] <= utcnow(): + if ( + row is None + or row["accepted_at"] is not None + or row["revoked_at"] is not None + or row["expires_at"] <= utcnow() + ): raise not_found() if row["token_hash"] != hash_secret(body.token): raise not_found() @@ -412,135 +340,20 @@ def accept_invite( conn.execute( """ INSERT INTO room_memberships (room_id, subject_id, role) - VALUES (%s, %s, 'member') + VALUES (%s, %s, %s) """, - (row["room_id"], account["id"]), + (row["room_id"], account["id"], row["role"]), ) conn.execute("UPDATE auth_invitations SET accepted_at = now() WHERE id = %s", (invitation_id,)) + audit(conn, account["id"], row["room_id"], "invitation_accepted", "invitation", invitation_id) settings = request.app.state.settings - token, csrf = start_session(conn, settings, account["id"]) + token, csrf = start_session(conn, settings, account["id"], device_label(request.headers.get("user-agent"))) payload = _session_body(conn, account["id"], "personal", account["id"], csrf, 1) response = JSONResponse(status_code=201, content=payload) set_session_cookie(response, request, settings, token) return response -@router.get("/api/v1/rooms") -def rooms(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): - return {"items": list_rooms(conn, principal.account_id), "next_cursor": None} - - -@router.post("/api/v1/rooms") -def create_room(body: RoomIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): - from uuid import uuid4 - - room_id = uuid4() - conn.execute( - """ - INSERT INTO data_rooms (id, kind, name, created_by) - VALUES (%s, 'organization', %s, %s) - """, - (room_id, body.name.strip(), principal.account_id), - ) - conn.execute( - """ - INSERT INTO room_memberships (room_id, subject_id, role) - VALUES (%s, %s, 'manager') - """, - (room_id, principal.account_id), - ) - return _created(f"/api/v1/rooms/{room_id}", {"id": str(room_id), "kind": "organization", "name": body.name.strip()}) - - -@router.get("/api/v1/rooms/{room_id}/members") -def members(room_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): - _require_manager(conn, principal, room_id) - rows = conn.execute( - """ - SELECT m.subject_id, m.role, a.email, a.display_name - FROM room_memberships m - JOIN auth_accounts a ON a.id = m.subject_id - WHERE m.room_id = %s AND m.status = 'active' - ORDER BY a.display_name, a.id - """, - (room_id,), - ).fetchall() - return { - "items": [ - { - "subject_id": str(row["subject_id"]), - "email": row["email"], - "display_name": row["display_name"], - "role": row["role"], - } - for row in rows - ] - } - - -@router.post("/api/v1/rooms/{room_id}/members") -def add_member( - room_id: UUID, - body: MemberIn, - principal: Principal = Depends(get_principal), - conn: Connection = Depends(get_conn), -): - _require_manager(conn, principal, room_id) - account = account_by_email(conn, body.email) - if account is None or account["status"] != "active": - raise not_found() - conn.execute( - """ - INSERT INTO room_memberships (room_id, subject_id, role, status) - VALUES (%s, %s, %s, 'active') - ON CONFLICT (room_id, subject_id) DO UPDATE SET role = EXCLUDED.role, status = 'active' - """, - (room_id, account["id"], body.role), - ) - return {"subject_id": str(account["id"]), "role": body.role} - - -@router.delete("/api/v1/rooms/{room_id}/members/{subject_id}", status_code=204) -def remove_member( - room_id: UUID, - subject_id: UUID, - principal: Principal = Depends(get_principal), - conn: Connection = Depends(get_conn), -): - _require_manager(conn, principal, room_id) - if subject_id == principal.account_id: - managers = conn.execute( - """ - SELECT count(*) AS n FROM room_memberships - WHERE room_id = %s AND role = 'manager' AND status = 'active' - """, - (room_id,), - ).fetchone() - if managers["n"] <= 1: - raise unprocessable("Der letzte Verwalter kann den Datenraum nicht verlassen.") - conn.execute( - """ - UPDATE room_memberships SET status = 'removed' - WHERE room_id = %s AND subject_id = %s - """, - (room_id, subject_id), - ) - return Response(status_code=204) - - -def _require_manager(conn, principal: Principal, room_id: UUID) -> None: - membership = conn.execute( - """ - SELECT role FROM room_memberships - WHERE room_id = %s AND subject_id = %s AND status = 'active' - """, - (room_id, principal.account_id), - ).fetchone() - room = conn.execute("SELECT kind FROM data_rooms WHERE id = %s", (room_id,)).fetchone() - if room is None or room["kind"] != "organization" or membership is None or membership["role"] != "manager": - raise forbidden() - - @router.get("/api/v1/principals") def find_principal(email: str, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): account = account_by_email(conn, email) diff --git a/backend/app/api/schemas.py b/backend/app/api/schemas.py index 585eec5..36ac06a 100644 --- a/backend/app/api/schemas.py +++ b/backend/app/api/schemas.py @@ -27,9 +27,23 @@ class BootstrapIn(APIModel): class AccountIn(APIModel): + """Without a password the server generates a one-time password.""" + email: Email display_name: str = Field(min_length=1, max_length=120) - password: str = Field(min_length=10, max_length=200) + password: str | None = Field(default=None, min_length=10, max_length=200) + is_operator: bool = False + + +class AccountPatchIn(APIModel): + display_name: str | None = Field(default=None, min_length=1, max_length=120) + is_operator: bool | None = None + status: Literal["active", "disabled"] | None = None + + +class PasswordChangeIn(APIModel): + current_password: str = Field(min_length=1, max_length=200) + new_password: str = Field(min_length=10, max_length=200) class ScopeIn(APIModel): @@ -46,6 +60,7 @@ class AcceptInviteIn(APIModel): class InvitationIn(APIModel): email: Email room_id: UUID + role: Literal["member", "manager", "reader"] = "member" class RoomIn(APIModel): @@ -54,7 +69,20 @@ class RoomIn(APIModel): class MemberIn(APIModel): email: Email - role: Literal["member", "manager"] + role: Literal["member", "manager", "reader"] + + +class MemberRoleIn(APIModel): + role: Literal["member", "manager", "reader"] + + +class RoomPatchIn(APIModel): + name: str | None = Field(default=None, min_length=1, max_length=160) + status: Literal["active", "archived"] | None = None + + +class OperatorManagerIn(APIModel): + email: Email class ContextIn(APIModel): diff --git a/backend/app/auth/accounts.py b/backend/app/auth/accounts.py index 8e17bea..caed8d1 100644 --- a/backend/app/auth/accounts.py +++ b/backend/app/auth/accounts.py @@ -1,18 +1,42 @@ -"""Accounts, personal rooms and sessions.""" +"""Accounts, personal rooms, sessions and the administrative account actions.""" from __future__ import annotations +import secrets from uuid import UUID, uuid4 -from app.auth.security import hash_password, hash_secret, new_secret, session_expiry -from app.core.errors import unprocessable +from app.access.policy import audit +from app.access.roles import count_active_operators +from app.auth.security import ( + hash_password, + hash_secret, + new_secret, + session_expiry, + verify_password, +) +from app.core.errors import not_found, unprocessable from app.core.settings import Settings +MIN_PASSWORD = 10 +MAX_PASSWORD_BYTES = 72 + def normalize_email(email: str) -> str: return email.strip().lower() +def check_password_policy(password: str) -> None: + if len(password) < MIN_PASSWORD: + raise unprocessable(f"Das Passwort braucht mindestens {MIN_PASSWORD} Zeichen.") + if len(password.encode("utf-8")) > MAX_PASSWORD_BYTES: + raise unprocessable("Das Passwort ist zu lang. Erlaubt sind höchstens 72 Byte.") + + +def generate_password() -> str: + """A one-time password for hand-over. It is shown once and must be changed at the first login.""" + return secrets.token_urlsafe(12) + + def create_account( conn, email: str, @@ -21,21 +45,26 @@ def create_account( *, is_superadmin: bool = False, origin: str = "operator", + must_change_password: bool = False, ) -> dict: email = normalize_email(email) display_name = display_name.strip() if origin not in {"operator", "fixture"}: raise unprocessable("Die Kontenherkunft ist ungültig.") + check_password_policy(password) if conn.execute("SELECT 1 FROM auth_accounts WHERE email = %s", (email,)).fetchone(): raise unprocessable("Für diese E-Mail gibt es bereits ein Konto.") account_id = uuid4() password_hash = hash_password(password) conn.execute( """ - INSERT INTO auth_accounts (id, email, display_name, password_hash, is_superadmin, origin) - VALUES (%s, %s, %s, %s, %s, %s) + INSERT INTO auth_accounts ( + id, email, display_name, password_hash, is_superadmin, origin, + must_change_password, password_changed_at + ) + VALUES (%s, %s, %s, %s, %s, %s, %s, now()) """, - (account_id, email, display_name, password_hash, is_superadmin, origin), + (account_id, email, display_name, password_hash, is_superadmin, origin, must_change_password), ) conn.execute( """ @@ -45,26 +74,169 @@ def create_account( (account_id, account_id), ) return conn.execute( - "SELECT id, email, display_name, is_superadmin FROM auth_accounts WHERE id = %s", + """ + SELECT id, email, display_name, is_superadmin, status, must_change_password + FROM auth_accounts WHERE id = %s + """, (account_id,), ).fetchone() -def start_session(conn, settings: Settings, account_id: UUID) -> tuple[str, str]: +def start_session(conn, settings: Settings, account_id: UUID, label: str | None = None) -> tuple[str, str]: token = new_secret() csrf = new_secret() - conn.execute( + session = conn.execute( """ INSERT INTO auth_sessions ( - account_id, secret_hash, csrf_token, scope_kind, scope_id, expires_at + account_id, secret_hash, csrf_token, scope_kind, scope_id, expires_at, label, last_seen_at ) - VALUES (%s, %s, %s, 'personal', %s, %s) + VALUES (%s, %s, %s, 'personal', %s, %s, %s, now()) + RETURNING id """, - (account_id, hash_secret(token), csrf, account_id, session_expiry(settings)), - ) + (account_id, hash_secret(token), csrf, account_id, session_expiry(settings), (label or None) and label[:80]), + ).fetchone() + conn.execute("UPDATE auth_accounts SET last_login_at = now() WHERE id = %s", (account_id,)) + audit(conn, account_id, None, "session_started", "session", session["id"]) return token, csrf +def _account(conn, account_id: UUID, *, lock: bool = False) -> dict: + suffix = " FOR UPDATE" if lock else "" + row = conn.execute(f"SELECT * FROM auth_accounts WHERE id = %s{suffix}", (account_id,)).fetchone() + if row is None: + raise not_found() + return row + + +def revoke_sessions(conn, account_id: UUID, *, keep: UUID | None = None) -> int: + rows = conn.execute( + """ + UPDATE auth_sessions SET revoked_at = now() + WHERE account_id = %s AND revoked_at IS NULL AND (%s::uuid IS NULL OR id <> %s::uuid) + RETURNING id + """, + (account_id, keep, keep), + ).fetchall() + return len(rows) + + +def set_display_name(conn, actor: UUID, account_id: UUID, display_name: str) -> None: + name = " ".join(display_name.split()) + if not name or len(name) > 120: + raise unprocessable("Der Name ist ungültig.") + _account(conn, account_id) + conn.execute("UPDATE auth_accounts SET display_name = %s WHERE id = %s", (name, account_id)) + audit(conn, actor, None, "account_renamed", "account", account_id) + + +def set_status(conn, actor: UUID, account_id: UUID, status: str) -> None: + """Disable or enable. A disabled account keeps its content, owner links and audit trail.""" + if status not in {"active", "disabled"}: + raise unprocessable("Der Kontostatus ist ungültig.") + # Lock the operators first so two parallel changes cannot remove the last one. + operators = count_active_operators(conn, lock=True) + account = _account(conn, account_id, lock=True) + if account["status"] == status: + return + if status == "disabled": + if account_id == actor: + raise unprocessable("Du kannst dein eigenes Konto nicht deaktivieren.") + if account["is_superadmin"] and operators <= 1: + raise unprocessable("Der letzte Betreiber lässt sich nicht deaktivieren.") + conn.execute( + "UPDATE auth_accounts SET status = 'disabled', disabled_at = now(), disabled_by = %s WHERE id = %s", + (actor, account_id), + ) + revoke_sessions(conn, account_id) + audit(conn, actor, None, "account_disabled", "account", account_id) + else: + conn.execute( + "UPDATE auth_accounts SET status = 'active', disabled_at = NULL, disabled_by = NULL WHERE id = %s", + (account_id,), + ) + audit(conn, actor, None, "account_enabled", "account", account_id) + + +def set_operator(conn, actor: UUID, account_id: UUID, value: bool) -> None: + operators = count_active_operators(conn, lock=True) + account = _account(conn, account_id, lock=True) + if bool(account["is_superadmin"]) == value: + return + if value: + if account["status"] != "active": + raise unprocessable("Ein deaktiviertes Konto kann nicht Betreiber werden.") + conn.execute("UPDATE auth_accounts SET is_superadmin = true WHERE id = %s", (account_id,)) + # A raised role starts from a fresh login (Auth blueprint). + revoke_sessions(conn, account_id) + audit(conn, actor, None, "operator_granted", "account", account_id) + return + if account["status"] == "active" and operators <= 1: + raise unprocessable("Der letzte Betreiber lässt sich nicht zurückstufen.") + conn.execute("UPDATE auth_accounts SET is_superadmin = false WHERE id = %s", (account_id,)) + audit(conn, actor, None, "operator_revoked", "account", account_id) + + +def reset_password(conn, actor: UUID, account_id: UUID) -> str: + if account_id == actor: + raise unprocessable("Dein eigenes Passwort änderst du unter Mein Konto.") + account = _account(conn, account_id, lock=True) + if account["status"] != "active": + raise unprocessable("Für ein deaktiviertes Konto lässt sich kein Passwort setzen.") + password = generate_password() + conn.execute( + """ + UPDATE auth_accounts + SET password_hash = %s, must_change_password = true, password_changed_at = now() + WHERE id = %s + """, + (hash_password(password), account_id), + ) + revoke_sessions(conn, account_id) + audit(conn, actor, None, "password_reset", "account", account_id) + return password + + +def change_own_password(conn, account_id: UUID, session_id: UUID, current: str, new: str) -> None: + account = _account(conn, account_id, lock=True) + if not verify_password(current, account["password_hash"]): + raise unprocessable("Das aktuelle Passwort ist nicht richtig.") + check_password_policy(new) + if verify_password(new, account["password_hash"]): + raise unprocessable("Das neue Passwort muss sich vom bisherigen unterscheiden.") + conn.execute( + """ + UPDATE auth_accounts + SET password_hash = %s, must_change_password = false, password_changed_at = now() + WHERE id = %s + """, + (hash_password(new), account_id), + ) + revoke_sessions(conn, account_id, keep=session_id) + audit(conn, account_id, None, "password_changed", "account", account_id) + + +def login_blocked(conn, bucket: str, *, limit: int = 8, minutes: int = 10) -> bool: + row = conn.execute( + """ + SELECT count(*) AS n FROM auth_login_attempts + WHERE bucket = %s AND attempted_at > now() - make_interval(mins => %s) + """, + (bucket, minutes), + ).fetchone() + return row["n"] >= limit + + +def record_failed_login(conn, bucket: str) -> None: + """Committed at once: the failed request rolls back, the count must survive.""" + conn.execute("DELETE FROM auth_login_attempts WHERE attempted_at < now() - interval '1 day'") + conn.execute("INSERT INTO auth_login_attempts (bucket) VALUES (%s)", (bucket,)) + conn.commit() + + +def clear_login_attempts(conn, bucket: str) -> None: + conn.execute("DELETE FROM auth_login_attempts WHERE bucket = %s", (bucket,)) + + def list_rooms(conn, account_id: UUID) -> list[dict]: personal = conn.execute( "SELECT id, kind, name FROM data_rooms WHERE id = %s AND kind = 'personal'", diff --git a/backend/app/auth/security.py b/backend/app/auth/security.py index c0a30be..ba8d802 100644 --- a/backend/app/auth/security.py +++ b/backend/app/auth/security.py @@ -5,6 +5,7 @@ from __future__ import annotations import hashlib import secrets from datetime import timedelta +from functools import lru_cache import bcrypt from fastapi import Request, Response @@ -27,6 +28,33 @@ def verify_password(password: str, password_hash: str) -> bool: return False +@lru_cache +def _dummy_hash() -> str: + return hash_password("kein-konto-nur-zeitausgleich") + + +def verify_unknown_account(password: str) -> None: + """Spend the same time as a real check so the answer time does not reveal an account.""" + verify_password(password, _dummy_hash()) + + +def login_bucket(host: str, email: str) -> str: + """Rate-limit key. The address is never stored in the clear.""" + return hashlib.sha256(f"{host}|{email}".encode("utf-8")).hexdigest() + + +_BROWSERS = (("Edg/", "Edge"), ("OPR/", "Opera"), ("Firefox/", "Firefox"), ("Chrome/", "Chrome"), ("Safari/", "Safari")) +_SYSTEMS = (("Windows", "Windows"), ("iPhone", "iPhone"), ("iPad", "iPad"), ("Android", "Android"), ("Mac OS", "macOS"), ("Linux", "Linux")) + + +def device_label(user_agent: str | None) -> str: + """A short, readable hint for the session list. The full user agent is not kept.""" + agent = user_agent or "" + browser = next((name for marker, name in _BROWSERS if marker in agent), "Browser") + system = next((name for marker, name in _SYSTEMS if marker in agent), "") + return f"{browser} auf {system}" if system else browser + + def new_secret() -> str: return secrets.token_urlsafe(32) diff --git a/backend/app/core/errors.py b/backend/app/core/errors.py index e75273f..d560a6a 100644 --- a/backend/app/core/errors.py +++ b/backend/app/core/errors.py @@ -54,6 +54,15 @@ def unsupported(detail: str) -> Problem: return Problem(422, "Nicht unterstützt", detail, "unsupported") +def password_change_required() -> Problem: + return Problem( + 403, + "Passwortwechsel erforderlich", + "Bitte lege zuerst ein eigenes Passwort fest.", + "password_change_required", + ) + + def too_many() -> Problem: return Problem(429, "Zu viele Versuche", "Bitte kurz warten und es erneut versuchen.", "too_many_requests") diff --git a/backend/app/main.py b/backend/app/main.py index f69218f..b20107d 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -9,8 +9,10 @@ from fastapi import FastAPI, Request from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse +from app.api.accounts import router as accounts_router from app.api.correspondence import router as correspondence_router from app.api.export import router as export_router +from app.api.rooms import router as rooms_router from app.api.routes import router from app.api.sources import router as sources_router from app.core.errors import Problem, problem_response @@ -116,6 +118,8 @@ def create_app() -> FastAPI: ) app.include_router(router) + app.include_router(accounts_router) + app.include_router(rooms_router) app.include_router(sources_router) app.include_router(export_router) app.include_router(correspondence_router) diff --git a/backend/app/ops.py b/backend/app/ops.py index b936e6d..9ada096 100644 --- a/backend/app/ops.py +++ b/backend/app/ops.py @@ -8,6 +8,7 @@ from uuid import UUID, uuid4 from psycopg.types.json import Json +from app.access.roles import ensure_can_create from app.access.policy import ( Ctx, Rights, @@ -74,6 +75,7 @@ def _placement(context: Ctx, placement: Ctx | None) -> tuple[Ctx, Ctx]: def create_case(conn, actor: UUID, scope_id: UUID, title: str, parent_case_id: UUID | None, rights_mode: str) -> dict: + ensure_can_create(conn, actor, scope_id) title = title.strip() if parent_case_id is None: row = conn.execute( @@ -339,6 +341,7 @@ def set_chapter_date( def create_matter(conn, actor: UUID, scope_id: UUID, title: str, parent_matter_id: UUID | None, context: Ctx | None) -> dict: + ensure_can_create(conn, actor, scope_id) title = title.strip() if parent_matter_id is None: row = conn.execute( @@ -702,6 +705,12 @@ def _actor_rights_for(conn, actor: UUID, kind: str, resource_id: UUID, context: return rights +def _is_reader_of_home(conn, account_id: UUID, home_scope_id: UUID) -> bool: + from app.access.roles import room_role + + return room_role(conn, account_id, home_scope_id) == "reader" + + def grant_access( conn, actor: UUID, @@ -741,6 +750,8 @@ def grant_access( ).fetchone() if account is None: raise not_found() + if (can_edit or can_share) and _is_reader_of_home(conn, grantee_id, resource["home_scope_id"]): + raise unprocessable("Diese Person ist in dem Datenraum der Akte nur Leser und kann nicht bearbeiten oder freigeben.") existing = conn.execute( """ SELECT id, use_owner_sources FROM access_grants @@ -909,6 +920,7 @@ def create_note( received_on: date | None = None, communication_direction: str | None = None, ) -> dict: + ensure_can_create(conn, actor, scope_id) document = clean_document(document) target, rights_context = _placement(context, placement) require_container_edit(conn, actor, target, rights_context) @@ -999,6 +1011,7 @@ def add_annotation(conn, actor: UUID, binding_id: UUID, body: str, context: Ctx def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str, external_id: str, context: Ctx, placement: Ctx | None, chapter_id: UUID | None, document_on, sent_on, received_on, detail: dict | None = None, communication_direction: str | None = None) -> dict: + ensure_can_create(conn, actor, scope_id) from app.sourceregistry import accepts_reference if not accepts_reference(source): @@ -1023,6 +1036,7 @@ def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str, def create_file(conn, actor: UUID, scope_id: UUID, title: str, filename: str, data: bytes, context: Ctx, placement: Ctx | None, chapter_id: UUID | None, document_on, sent_on, received_on, media_root: str, max_bytes: int, rollback_files: list[Path], communication_direction: str | None = None) -> dict: + ensure_can_create(conn, actor, scope_id) if not data or len(data) > max_bytes: raise unprocessable("Die Datei ist leer oder zu groß.") content_type = sniff(data) @@ -1112,6 +1126,7 @@ def delete_element(conn, actor: UUID, element_id: UUID, expected: int, media_roo def create_task(conn, actor: UUID, scope_id: UUID, title: str, due_on: date | None, matter_id: UUID | None, context: Ctx | None) -> dict: + ensure_can_create(conn, actor, scope_id) if matter_id is not None: require_matter(conn, actor, matter_id, context, "edit") row = conn.execute( @@ -1217,6 +1232,7 @@ def assign_task(conn, actor: UUID, task_id: UUID, assignee_id: UUID | None, cont def create_deadline(conn, actor: UUID, scope_id: UUID, title: str, due_on: date, matter_id: UUID | None, context: Ctx | None) -> dict: + ensure_can_create(conn, actor, scope_id) if matter_id is not None: require_matter(conn, actor, matter_id, context, "edit") row = conn.execute( diff --git a/backend/app/present.py b/backend/app/present.py index 4e8a7ec..628be92 100644 --- a/backend/app/present.py +++ b/backend/app/present.py @@ -1031,4 +1031,25 @@ LABELS = { "chapter_moved": "Kapitel umgehängt", "content_order": "Ordnungsart geändert", "content_reordered": "Eigene Reihenfolge geändert", + "account_created": "Konto angelegt", + "account_renamed": "Kontoname geändert", + "account_disabled": "Konto deaktiviert", + "account_enabled": "Konto aktiviert", + "operator_granted": "Betreiberrolle vergeben", + "operator_revoked": "Betreiberrolle entzogen", + "password_reset": "Passwort zurückgesetzt", + "password_changed": "Passwort geändert", + "sessions_revoked": "Sitzungen beendet", + "session_started": "Angemeldet", + "session_ended": "Abgemeldet", + "room_created": "Datenraum angelegt", + "room_renamed": "Datenraum umbenannt", + "room_archived": "Datenraum archiviert", + "room_restored": "Datenraum wieder aktiviert", + "membership_added": "Mitglied hinzugefügt", + "membership_role_changed": "Raumrolle geändert", + "membership_removed": "Mitglied entfernt", + "invitation_created": "Einladung erstellt", + "invitation_revoked": "Einladung widerrufen", + "invitation_accepted": "Einladung angenommen", } diff --git a/backend/migrations/20261020T150000Z_user_admin.sql b/backend/migrations/20261020T150000Z_user_admin.sql new file mode 100644 index 0000000..eb006bc --- /dev/null +++ b/backend/migrations/20261020T150000Z_user_admin.sql @@ -0,0 +1,31 @@ +-- Benutzerverwaltung: Kontostatus, Sitzungsübersicht, persistente Login-Begrenzung, +-- Raumrolle "Leser" und Rollen in Einladungen. Bestehende Zeilen bleiben gültig. + +ALTER TABLE auth_accounts + ADD COLUMN must_change_password boolean NOT NULL DEFAULT false, + ADD COLUMN password_changed_at timestamptz, + ADD COLUMN last_login_at timestamptz, + ADD COLUMN disabled_at timestamptz, + ADD COLUMN disabled_by uuid REFERENCES auth_accounts (id); + +ALTER TABLE auth_sessions + ADD COLUMN last_seen_at timestamptz, + ADD COLUMN label text, + ADD CONSTRAINT auth_sessions_label_len CHECK (label IS NULL OR char_length(label) <= 80); + +-- Der Bucket ist ein Hash aus Adresse und E-Mail. Die Roh-E-Mail wird nie gespeichert. +CREATE TABLE auth_login_attempts ( + bucket text NOT NULL, + attempted_at timestamptz NOT NULL DEFAULT now() +); + +CREATE INDEX auth_login_attempts_bucket ON auth_login_attempts (bucket, attempted_at); + +ALTER TABLE room_memberships DROP CONSTRAINT room_memberships_role; +ALTER TABLE room_memberships + ADD CONSTRAINT room_memberships_role CHECK (role IN ('member', 'manager', 'reader')); + +ALTER TABLE auth_invitations + ADD COLUMN role text NOT NULL DEFAULT 'member', + ADD COLUMN revoked_at timestamptz, + ADD CONSTRAINT auth_invitations_role CHECK (role IN ('member', 'manager', 'reader')); diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py index 1fe3d3d..f52edf8 100644 --- a/backend/tests/conftest.py +++ b/backend/tests/conftest.py @@ -43,6 +43,7 @@ def _reset(settings) -> None: TRUNCATE TABLE media_operations, domain_events, + auth_login_attempts, auth_accounts, data_rooms RESTART IDENTITY CASCADE @@ -86,13 +87,9 @@ def client(database): @pytest.fixture(autouse=True) def clean(database, client): - from app.api import routes - - routes._login_attempts.clear() client.cookies.clear() _reset(database) yield - routes._login_attempts.clear() client.cookies.clear() _reset(database) diff --git a/backend/tests/test_accounts.py b/backend/tests/test_accounts.py index 96c276c..cb79872 100644 --- a/backend/tests/test_accounts.py +++ b/backend/tests/test_accounts.py @@ -35,7 +35,8 @@ def test_bootstrap_once_then_superadmin_creates_users(client): status=201, ) assert created["is_superadmin"] is False - assert "password" not in created + assert created["must_change_password"] is True + assert "password" not in created and "temporary_password" not in created listed = owner.request("GET", "/api/v1/accounts") assert {item["email"] for item in listed["items"]} == {"betreiber@example.test", "mitglied@example.test"} assert all("password_hash" not in item and "password" not in item for item in listed["items"]) diff --git a/backend/tests/test_room_roles.py b/backend/tests/test_room_roles.py new file mode 100644 index 0000000..2a492bf --- /dev/null +++ b/backend/tests/test_room_roles.py @@ -0,0 +1,210 @@ +"""Datenraumrollen (Mitglied, Verwalter, Leser), Einladungen, Betreiberübersicht.""" + +from __future__ import annotations + +from fastapi.testclient import TestClient + +from tests.support import ORIGIN, PASSWORD, Actor, register + + +def _second_client(): + from app.main import app + + return TestClient(app) + + +def _setup(client, db): + ada = Actor(client, "ada-rolle@example.test", "Ada Rolle") + ben = Actor(_second_client(), "ben-rolle@example.test", "Ben Rolle") + cem = Actor(_second_client(), "cem-rolle@example.test", "Cem Rolle") + for actor in (ada, ben, cem): + register(db, actor.email, actor.name) + actor.login() + room = ada.request("POST", "/api/v1/rooms", json={"name": "Verein"}, status=201) + ada.use_room(room["id"]) + return ada, ben, cem, room["id"] + + +def test_manager_sets_roles_and_a_reader_creates_nothing(client, db): + ada, ben, cem, room = _setup(client, db) + ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "reader"}) + ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": cem.email, "role": "member"}) + members = {item["email"]: item["role"] for item in ada.request("GET", f"/api/v1/rooms/{room}/members")["items"]} + assert members == {ada.email: "manager", ben.email: "reader", cem.email: "member"} + + ben.use_room(room) + cem.use_room(room) + refused = ben.request("POST", "/api/v1/cases", json={"title": "Nicht erlaubt"}, status=403) + assert "Leser" in refused["detail"] + ben.request("POST", "/api/v1/matters", json={"title": "Auch nicht"}, status=403) + cem.request("POST", "/api/v1/cases", json={"title": "Erlaubt"}, status=201) + + # The role is read from the database at every request. + ada.request("PATCH", f"/api/v1/rooms/{room}/members/{_subject(ada, room, ben.email)}", json={"role": "member"}) + ben.request("POST", "/api/v1/cases", json={"title": "Jetzt erlaubt"}, status=201) + ada.request("PATCH", f"/api/v1/rooms/{room}/members/{_subject(ada, room, ben.email)}", json={"role": "reader"}) + ben.request("POST", "/api/v1/cases", json={"title": "Wieder nicht"}, status=403) + + +def test_a_reader_gets_no_edit_grant_and_loses_existing_ones(client, db): + ada, ben, cem, room = _setup(client, db) + ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "member"}) + ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": cem.email, "role": "reader"}) + case = ada.request("POST", "/api/v1/cases", json={"title": "Gemeinsam"}, status=201) + refused = ada.request( + "POST", + f"/api/v1/cases/{case['id']}/grants", + json={"email": cem.email, "can_read": True, "can_edit": True, "can_share": False}, + status=422, + ) + assert "Leser" in refused["detail"] + ada.request( + "POST", + f"/api/v1/cases/{case['id']}/grants", + json={"email": cem.email, "can_read": True, "can_edit": False, "can_share": False}, + status=201, + ) + ada.request( + "POST", + f"/api/v1/cases/{case['id']}/grants", + json={"email": ben.email, "can_read": True, "can_edit": True, "can_share": True}, + status=201, + ) + ada.request("PATCH", f"/api/v1/rooms/{room}/members/{_subject(ada, room, ben.email)}", json={"role": "reader"}) + grant = db.execute( + "SELECT can_read, can_edit, can_share FROM access_grants WHERE grantee_subject_id = (SELECT id FROM auth_accounts WHERE email = %s)", + (ben.email,), + ).fetchone() + db.rollback() + assert grant == {"can_read": True, "can_edit": False, "can_share": False} + + +def test_the_last_manager_stays(client, db): + ada, ben, _cem, room = _setup(client, db) + me = _subject(ada, room, ada.email) + ada.request("PATCH", f"/api/v1/rooms/{room}/members/{me}", json={"role": "member"}, status=422) + ada.request("DELETE", f"/api/v1/rooms/{room}/members/{me}", status=422) + ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ada.email, "role": "reader"}, status=422) + ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "manager"}) + ada.request("PATCH", f"/api/v1/rooms/{room}/members/{me}", json={"role": "member"}) + # Ben is the only manager now. + ben.use_room(room) + ben.request("DELETE", f"/api/v1/rooms/{room}/members/{_subject(ben, room, ben.email)}", status=422) + ada.request("GET", f"/api/v1/rooms/{room}/members", status=403) + + +def test_a_removed_member_loses_the_room_at_once(client, db): + ada, ben, _cem, room = _setup(client, db) + ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "member"}) + ben.use_room(room) + ben.request("GET", "/api/v1/cases") + ada.request("DELETE", f"/api/v1/rooms/{room}/members/{_subject(ada, room, ben.email)}", status=204) + ben.request("GET", "/api/v1/cases", status=403) + + +def test_invitations_carry_a_role_and_can_be_revoked(client, db): + ada, ben, _cem, room = _setup(client, db) + invited = ada.request( + "POST", + "/api/v1/invitations", + json={"email": "neu-rolle@example.test", "room_id": room, "role": "reader"}, + status=201, + ) + assert invited["role"] == "reader" and invited["token"] + ada.request("POST", "/api/v1/invitations", json={"email": ben.email, "room_id": room}, status=422) + open_items = ada.request("GET", f"/api/v1/rooms/{room}/invitations")["items"] + assert [item["email"] for item in open_items] == ["neu-rolle@example.test"] + assert "token" not in open_items[0] + ben.request("GET", f"/api/v1/rooms/{room}/invitations", status=403) + + guest = _second_client() + accepted = guest.post( + f"/api/v1/invitations/{invited['id']}/accept", + json={"token": invited["token"], "display_name": "Neu Gast", "password": PASSWORD}, + headers={"Origin": ORIGIN}, + ) + assert accepted.status_code == 201, accepted.text + assert [(r["name"], r["role"]) for r in accepted.json()["rooms"] if r["kind"] == "organization"] == [("Verein", "reader")] + again = _second_client().post( + f"/api/v1/invitations/{invited['id']}/accept", + json={"token": invited["token"], "display_name": "Zweiter", "password": PASSWORD}, + headers={"Origin": ORIGIN}, + ) + assert again.status_code == 404 + + second = ada.request("POST", "/api/v1/invitations", json={"email": "widerruf@example.test", "room_id": room}, status=201) + ada.request("DELETE", f"/api/v1/rooms/{room}/invitations/{second['id']}", status=204) + refused = _second_client().post( + f"/api/v1/invitations/{second['id']}/accept", + json={"token": second["token"], "display_name": "Widerruf", "password": PASSWORD}, + headers={"Origin": ORIGIN}, + ) + assert refused.status_code == 404 + ada.request("DELETE", f"/api/v1/rooms/{room}/invitations/{second['id']}", status=404) + + +def test_rooms_are_renamed_archived_and_restored_by_a_manager(client, db): + ada, ben, _cem, room = _setup(client, db) + ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "member"}) + ben.request("PATCH", f"/api/v1/rooms/{room}", json={"name": "Fremd"}, status=403) + renamed = ada.request("PATCH", f"/api/v1/rooms/{room}", json={"name": "Verein e.V."}) + assert renamed["name"] == "Verein e.V." + ada.request("PATCH", f"/api/v1/rooms/{room}", json={"status": "archived"}) + # The session of the archiving manager moved back to the personal room. + ada.request("GET", "/api/v1/rooms", status=403) + body = ada.request("GET", "/api/v1/auth/session") + assert body["scope"]["kind"] == "personal" + ada.scope, ada.csrf = body["scope"], body["csrf_token"] + listed = ada.request("GET", "/api/v1/rooms", params={"include_archived": "true"})["items"] + assert any(item["id"] == room and item.get("status") == "archived" for item in listed) + ada.request("POST", "/api/v1/auth/session/scope", json={"kind": "organization", "id": room}, status=403) + ada.request("PATCH", f"/api/v1/rooms/{room}", json={"status": "active"}) + ada.use_room(room) + + +def test_operator_sees_rooms_without_content_and_fills_an_orphaned_room(client, db): + ada, ben, _cem, room = _setup(client, db) + operator = Actor(_second_client(), "betreiber-rolle@example.test", "Betreiber Rolle") + register(db, operator.email, operator.name, superadmin=True) + operator.login() + ada.request("POST", "/api/v1/cases", json={"title": "Nur für Ada"}, status=201) + overview = operator.request("GET", "/api/v1/admin/rooms")["items"] + row = next(item for item in overview if item["id"] == room) + assert row["managers"] == ["Ada Rolle"] and row["members"] == 1 and row["has_manager"] is True + assert "Nur für Ada" not in str(overview) + operator.request("GET", f"/api/v1/rooms/{room}/members", status=403) + ben.request("GET", "/api/v1/admin/rooms", status=403) + operator.request("POST", f"/api/v1/admin/rooms/{room}/managers", json={"email": ben.email}, status=403) + + db.execute("UPDATE auth_accounts SET status = 'disabled' WHERE email = %s", (ada.email,)) + db.commit() + assigned = operator.request("POST", f"/api/v1/admin/rooms/{room}/managers", json={"email": ben.email}) + assert assigned["role"] == "manager" + ben.use_room(room) + assert {item["email"] for item in ben.request("GET", f"/api/v1/rooms/{room}/members")["items"]} >= {ben.email} + + +def test_room_events_reach_the_operator_audit_without_secrets(client, db): + ada, ben, _cem, room = _setup(client, db) + operator = Actor(_second_client(), "audit-rolle@example.test", "Audit Rolle") + register(db, operator.email, operator.name, superadmin=True) + operator.login() + ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "reader"}) + invited = ada.request("POST", "/api/v1/invitations", json={"email": "audit-gast@example.test", "room_id": room}, status=201) + events = operator.request("GET", "/api/v1/admin/events", params={"limit": 50}) + actions = [item["action"] for item in events["items"]] + assert {"room_created", "membership_added", "invitation_created"} <= set(actions) + text = str(events) + assert "audit-gast@example.test" not in text and invited["token"] not in text + ben.request("GET", "/api/v1/admin/events", status=403) + page = operator.request("GET", "/api/v1/admin/events", params={"limit": 1}) + assert len(page["items"]) == 1 and page["next_cursor"] == 1 + + +def _subject(actor: Actor, room: str, email: str) -> str: + # A manager lists the members; Ada manages in these tests. Fall back to the account table. + from app.core.settings import get_settings + import psycopg + + with psycopg.connect(get_settings().dsn(), row_factory=psycopg.rows.dict_row) as conn: + return str(conn.execute("SELECT id FROM auth_accounts WHERE email = %s", (email,)).fetchone()["id"]) diff --git a/backend/tests/test_user_admin.py b/backend/tests/test_user_admin.py new file mode 100644 index 0000000..29ce585 --- /dev/null +++ b/backend/tests/test_user_admin.py @@ -0,0 +1,261 @@ +"""Kontoverwaltung: Einmal-Passwort, Deaktivieren, Betreiberrolle, Sitzungen, Login-Begrenzung.""" + +from __future__ import annotations + +import pytest +from fastapi.testclient import TestClient + +from app.auth.accounts import create_account +from tests.support import ORIGIN, PASSWORD, Actor + +NEW_PASSWORD = "Neues-Passwort-2026" + + +def register(conn, email: str, name: str, *, superadmin: bool = False): + """Accounts of the operator kind, because the account list hides fixture accounts.""" + account = create_account(conn, email, name, PASSWORD, is_superadmin=superadmin) + conn.commit() + return account + + +@pytest.fixture +def operator(client, db) -> Actor: + actor = Actor(client, "betreiber-admin@example.test", "Betreiber Admin") + register(db, actor.email, actor.name, superadmin=True) + actor.login() + return actor + + +def _user(client, db, email: str = "nutzer-admin@example.test", name: str = "Nutzer Admin") -> Actor: + actor = Actor(client, email, name) + register(db, actor.email, actor.name) + return actor + + +def _second_client(): + from app.main import app + + return TestClient(app) + + +def test_operator_creates_an_account_with_a_one_time_password(client, operator): + created = operator.request( + "POST", + "/api/v1/accounts", + json={"email": "neu@example.test", "display_name": "Neu"}, + status=201, + ) + temporary = created["temporary_password"] + assert len(temporary) >= 10 + assert created["must_change_password"] is True + + fresh = Actor(client, "neu@example.test", "Neu") + fresh.password = temporary + body = fresh.login() + assert body["account"]["must_change_password"] is True + refused = fresh.request("GET", "/api/v1/cases", status=403) + assert refused["code"] == "password_change_required" + fresh.request("GET", "/api/v1/auth/session") + + fresh.request( + "POST", + "/api/v1/auth/password", + json={"current_password": "falsch-falsch-1", "new_password": NEW_PASSWORD}, + status=422, + ) + fresh.request("POST", "/api/v1/auth/password", json={"current_password": temporary, "new_password": temporary}, status=422) + fresh.request("POST", "/api/v1/auth/password", json={"current_password": temporary, "new_password": "kurz"}, status=422) + fresh.request( + "POST", + "/api/v1/auth/password", + json={"current_password": temporary, "new_password": NEW_PASSWORD}, + status=204, + ) + fresh.request("GET", "/api/v1/cases") + assert fresh.request("GET", "/api/v1/auth/session")["account"]["must_change_password"] is False + + again = Actor(client, "neu@example.test", "Neu") + again.password = NEW_PASSWORD + again.login() + old = client.post( + "/api/v1/auth/login", + json={"email": "neu@example.test", "password": temporary}, + headers={"Origin": ORIGIN}, + ) + assert old.status_code == 401 + + +def test_only_the_operator_manages_accounts(client, db, operator): + user = _user(client, db) + target = operator.request("GET", "/api/v1/accounts")["items"][0]["id"] + user.login() + user.request("GET", "/api/v1/accounts", status=403) + user.request("GET", f"/api/v1/accounts/{target}", status=403) + user.request("PATCH", f"/api/v1/accounts/{target}", json={"status": "disabled"}, status=403) + user.request("POST", f"/api/v1/accounts/{target}/password-reset", status=403) + user.request("POST", f"/api/v1/accounts/{target}/sessions/revoke", status=403) + user.request("POST", "/api/v1/accounts", json={"email": "x@example.test", "display_name": "X"}, status=403) + + +def test_a_disabled_account_cannot_sign_in_and_its_sessions_end(client, db, operator): + user = _user(client, db) + other = _second_client() + victim = Actor(other, user.email, user.name) + victim.login() + victim.request("GET", "/api/v1/cases") + + operator.request("PATCH", f"/api/v1/accounts/{_id(operator, user.email)}", json={"status": "disabled"}) + victim.request("GET", "/api/v1/cases", status=401) + refused = client.post( + "/api/v1/auth/login", + json={"email": user.email, "password": PASSWORD}, + headers={"Origin": ORIGIN}, + ) + assert refused.status_code == 401 + + listed = operator.request("GET", "/api/v1/accounts", params={"status": "disabled"}) + assert [item["email"] for item in listed["items"]] == [user.email] + operator.request("PATCH", f"/api/v1/accounts/{_id(operator, user.email)}", json={"status": "active"}) + Actor(client, user.email, user.name).login() + + +def test_the_last_operator_and_the_own_account_are_protected(client, db, operator): + me = _id(operator, operator.email) + operator.request("PATCH", f"/api/v1/accounts/{me}", json={"status": "disabled"}, status=422) + operator.request("PATCH", f"/api/v1/accounts/{me}", json={"is_operator": False}, status=422) + user = _user(client, db) + other = _id(operator, user.email) + operator.request("PATCH", f"/api/v1/accounts/{other}", json={"is_operator": True}) + # A second operator exists now, so the first may step down. + operator.request("PATCH", f"/api/v1/accounts/{me}", json={"is_operator": False}) + promoted = Actor(client, user.email, user.name) + promoted.login() + promoted.request("PATCH", f"/api/v1/accounts/{promoted_id(promoted)}", json={"status": "disabled"}, status=422) + promoted.request("PATCH", f"/api/v1/accounts/{promoted_id(promoted)}", json={"is_operator": False}, status=422) + + +def test_granting_the_operator_role_ends_the_target_sessions(client, db, operator): + user = _user(client, db) + other = _second_client() + target = Actor(other, user.email, user.name) + target.login() + target.request("GET", "/api/v1/cases") + operator.request("PATCH", f"/api/v1/accounts/{_id(operator, user.email)}", json={"is_operator": True}) + target.request("GET", "/api/v1/cases", status=401) + fresh = Actor(other, user.email, user.name) + assert fresh.login()["account"]["is_superadmin"] is True + + +def test_password_reset_sets_a_one_time_password_and_ends_sessions(client, db, operator): + user = _user(client, db) + other = _second_client() + target = Actor(other, user.email, user.name) + target.login() + account_id = _id(operator, user.email) + operator.request("POST", f"/api/v1/accounts/{operator_id(operator)}/password-reset", status=422) + reset = operator.request("POST", f"/api/v1/accounts/{account_id}/password-reset") + target.request("GET", "/api/v1/cases", status=401) + renewed = Actor(other, user.email, user.name) + renewed.password = reset["temporary_password"] + assert renewed.login()["account"]["must_change_password"] is True + renewed.request("GET", "/api/v1/cases", status=403) + detail = operator.request("GET", f"/api/v1/accounts/{account_id}") + assert detail["must_change_password"] is True + assert detail["active_sessions"] == 1 + revoked = operator.request("POST", f"/api/v1/accounts/{account_id}/sessions/revoke") + assert revoked["revoked"] == 1 + renewed.request("GET", "/api/v1/auth/session", status=401) + + +def test_own_sessions_can_be_listed_and_ended(client, db): + user = _user(client, db) + user.login() + other = _second_client() + second = Actor(other, user.email, user.name) + second.login() + items = user.request("GET", "/api/v1/auth/sessions")["items"] + assert len(items) == 2 + assert sum(1 for item in items if item["current"]) == 1 + current = next(item for item in items if item["current"]) + foreign = next(item for item in items if not item["current"]) + user.request("DELETE", f"/api/v1/auth/sessions/{current['id']}", status=422) + user.request("DELETE", f"/api/v1/auth/sessions/{foreign['id']}", status=204) + second.request("GET", "/api/v1/cases", status=401) + third = Actor(other, user.email, user.name) + third.login() + assert user.request("POST", "/api/v1/auth/sessions/revoke-others")["revoked"] == 1 + third.request("GET", "/api/v1/cases", status=401) + user.request("GET", "/api/v1/cases") + + +def test_login_attempts_are_counted_in_the_database_without_the_address(client, db): + user = _user(client, db) + for _ in range(8): + response = client.post( + "/api/v1/auth/login", + json={"email": user.email, "password": "falsch-falsch-1"}, + headers={"Origin": ORIGIN}, + ) + assert response.status_code == 401 + blocked = client.post( + "/api/v1/auth/login", + json={"email": user.email, "password": PASSWORD}, + headers={"Origin": ORIGIN}, + ) + assert blocked.status_code == 429 + rows = db.execute("SELECT bucket FROM auth_login_attempts").fetchall() + assert len(rows) == 8 + assert all(user.email not in row["bucket"] and len(row["bucket"]) == 64 for row in rows) + db.rollback() + # Another address is a separate bucket and still works. + other = _user(client, db, "andere-adresse@example.test", "Andere") + Actor(client, other.email, other.name).login() + + +def test_unknown_and_wrong_password_answer_alike(client, db): + user = _user(client, db) + wrong = client.post( + "/api/v1/auth/login", + json={"email": user.email, "password": "falsch-falsch-1"}, + headers={"Origin": ORIGIN}, + ) + unknown = client.post( + "/api/v1/auth/login", + json={"email": "gibt-es-nicht@example.test", "password": "falsch-falsch-1"}, + headers={"Origin": ORIGIN}, + ) + assert wrong.status_code == unknown.status_code == 401 + assert wrong.json()["detail"] == unknown.json()["detail"] + + +def test_admin_actions_are_audited_without_secrets(client, db, operator): + created = operator.request( + "POST", + "/api/v1/accounts", + json={"email": "audit-ziel@example.test", "display_name": "Audit Ziel"}, + status=201, + ) + account_id = created["id"] + operator.request("POST", f"/api/v1/accounts/{account_id}/password-reset") + operator.request("PATCH", f"/api/v1/accounts/{account_id}", json={"status": "disabled"}) + rows = db.execute( + "SELECT action, detail FROM domain_events WHERE resource_kind = 'account' AND resource_id = %s ORDER BY occurred_at", + (account_id,), + ).fetchall() + assert [row["action"] for row in rows] == ["account_created", "password_reset", "account_disabled"] + text = str(rows) + str(db.execute("SELECT * FROM domain_events").fetchall()) + assert "audit-ziel@example.test" not in text + assert created["temporary_password"] not in text + + +def _id(actor: Actor, email: str) -> str: + items = actor.request("GET", "/api/v1/accounts")["items"] + return next(item["id"] for item in items if item["email"] == email) + + +def operator_id(actor: Actor) -> str: + return _id(actor, actor.email) + + +def promoted_id(actor: Actor) -> str: + return _id(actor, actor.email) diff --git a/docs/README.md b/docs/README.md index 93a4fe4..cd803ff 100644 --- a/docs/README.md +++ b/docs/README.md @@ -47,6 +47,7 @@ | [API_REFERENZ.md](architecture/API_REFERENZ.md) | tatsächlich registrierte Endpunkte (Ist) | 19.10.2026 | | [DATENMODELL_IST.md](architecture/DATENMODELL_IST.md) | Schema nach allen Migrationen (Ist) | 19.10.2026 | | [RECHTEMODELL_IST.md](architecture/RECHTEMODELL_IST.md) | implementierte Rechteauswertung (Ist) | 19.10.2026 | +| [BENUTZERVERWALTUNG.md](architecture/BENUTZERVERWALTUNG.md) | Konten, Rollen, Einmal-Passwort, Einladungen, Audit (Ist) und Abgrenzung zum Sicherheitskonzept | 20.10.2026 | | [ARCHITECTURE_DISCOVERY.md](architecture/ARCHITECTURE_DISCOVERY.md) | Ist-Aufnahme der Jinkendo-Familie vor Tsumugu, keine Beschlüsse | 15.10.2026 | | [TSUMUGU_CONNECTOR_STORAGE_VERTRAG_v0.1_2026-10-19.md](architecture/TSUMUGU_CONNECTOR_STORAGE_VERTRAG_v0.1_2026-10-19.md) | Umsetzungsvorschlag Source- und Storage-Vertrag | 19.10.2026 | | [Tsumugu_Connector_Suite_Architektur_v0.2.md](architecture/Tsumugu_Connector_Suite_Architektur_v0.2.md) | Zielarchitektur der Connector Suite, keine pauschale Beschlussübernahme | 19.10.2026 | diff --git a/docs/architecture/API_REFERENZ.md b/docs/architecture/API_REFERENZ.md index 0ca2adc..757fd73 100644 --- a/docs/architecture/API_REFERENZ.md +++ b/docs/architecture/API_REFERENZ.md @@ -31,28 +31,43 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R** | Methode | Pfad | Auth | Zweck | |---|---|---|---| -| POST | `/api/v1/auth/login` | – | E-Mail, Passwort → Session-Sicht und Cookie. 8 Versuche je IP+E-Mail in 10 min (Prozessspeicher) | +| POST | `/api/v1/auth/login` | – | E-Mail, Passwort → Session-Sicht und Cookie. 8 Fehlversuche je Bucket (Hash aus IP und E-Mail) in 10 min, gezählt in `auth_login_attempts` | | POST | `/api/v1/auth/logout` | S | Session widerrufen, Cookie löschen, 204 | | GET | `/api/v1/auth/session` | S | Konto, bestätigter Datenraum, Räume, CSRF-Token, Epoche | | POST | `/api/v1/auth/session/scope` | S | Datenraum wechseln (`kind`, `id`); erhöht die Epoche | | GET | `/api/v1/auth/bootstrap` | – | `{available: true}`, solange kein Betreiber existiert, sonst 404 | | POST | `/api/v1/auth/bootstrap` | – | erstes Konto als Betreiber anlegen, nur ohne vorhandenen Betreiber | | GET | `/api/v1/auth/demo` | – | Beispielkonten; nur Development mit Datenbank `*_test` und `SEED_DEMO=true`, sonst 404 | -| GET | `/api/v1/accounts` | S+R, B | aktive Betreiberkonten (`origin='operator'`) | -| POST | `/api/v1/accounts` | S+R, B | Konto mit Passwort anlegen, erhält persönlichen Raum | +| GET | `/api/v1/accounts` | S+R, B | Betreiberkonten (`origin='operator'`) mit Status, Rolle, letzter Anmeldung; Filter `status=active\|disabled` | +| GET | `/api/v1/accounts/{id}` | S+R, B | Detail mit Raummitgliedschaften und Zahl aktiver Sitzungen | +| POST | `/api/v1/accounts` | S+R, B | Konto anlegen, persönlicher Raum, `must_change_password`. Ohne `password` erzeugt der Server ein Einmal-Passwort und liefert es einmal als `temporary_password`. `is_operator` optional | +| PATCH | `/api/v1/accounts/{id}` | S+R, B | `display_name`, `is_operator`, `status` (`active`/`disabled`). Letzter Betreiber und eigenes Konto sind geschützt | +| POST | `/api/v1/accounts/{id}/password-reset` | S+R, B | neues Einmal-Passwort, beendet alle Sitzungen; nicht für das eigene Konto | +| POST | `/api/v1/accounts/{id}/sessions/revoke` | S+R, B | alle Sitzungen des Kontos beenden | +| POST | `/api/v1/auth/password` | S | eigenes Passwort ändern (`current_password`, `new_password`); beendet die anderen Sitzungen; 204. Erlaubt auch bei `must_change_password` | +| GET | `/api/v1/auth/sessions` | S | eigene aktive Sitzungen (Gerätehinweis, zuletzt aktiv) | +| DELETE | `/api/v1/auth/sessions/{id}` | S | eigene andere Sitzung beenden; die aktuelle über Abmelden | +| POST | `/api/v1/auth/sessions/revoke-others` | S | überall sonst abmelden | | GET | `/api/v1/principals?email=` | S+R | aktives Konto per E-Mail auflösen (ID, Anzeigename) | -| POST | `/api/v1/invitations` | S+R, M | Einladung in einen gemeinsamen Raum; Antwort enthält das Token einmalig. Keine Oberfläche | -| POST | `/api/v1/invitations/{id}/accept` | – | Token, Anzeigename, Passwort → Konto, Mitgliedschaft, Session | +| POST | `/api/v1/invitations` | S+R, M | Einladung in einen gemeinsamen Raum mit `role` (`member`/`manager`/`reader`); Antwort enthält das Token einmalig | +| POST | `/api/v1/invitations/{id}/accept` | – | Token, Anzeigename, Passwort → Konto, Mitgliedschaft mit der Rolle der Einladung, Session. Widerrufene, benutzte oder abgelaufene Einladung: 404 | ## Datenräume | Methode | Pfad | Auth | Zweck | |---|---|---|---| -| GET | `/api/v1/rooms` | S+R | wählbare Räume | +| GET | `/api/v1/rooms` | S+R | wählbare Räume; `include_archived=true` ergänzt die archivierten Räume der Person | | POST | `/api/v1/rooms` | S+R | gemeinsamen Raum anlegen, Anlegende Person wird Verwalter | -| GET | `/api/v1/rooms/{id}/members` | S+R, M | Mitglieder | -| POST | `/api/v1/rooms/{id}/members` | S+R, M | bestehendes Konto als `member` oder `manager` aufnehmen | -| DELETE | `/api/v1/rooms/{id}/members/{subject_id}` | S+R, M | Mitgliedschaft beenden; letzter Verwalter bleibt. Keine Oberfläche | +| PATCH | `/api/v1/rooms/{id}` | S+R, M | `name`, `status` (`active`/`archived`). Archivieren setzt Sitzungen im Raum auf den persönlichen Raum zurück | +| GET | `/api/v1/rooms/{id}/members` | S+R, M | Mitglieder mit Rolle und Kontostatus | +| POST | `/api/v1/rooms/{id}/members` | S+R, M | bestehendes Konto als `member`, `manager` oder `reader` aufnehmen oder dessen Rolle setzen | +| PATCH | `/api/v1/rooms/{id}/members/{subject_id}` | S+R, M | Rolle ändern; letzter Verwalter bleibt. Rückstufung auf `reader` entzieht Bearbeiten- und Freigeben-Grants auf Objekte des Raums | +| DELETE | `/api/v1/rooms/{id}/members/{subject_id}` | S+R, M | Mitgliedschaft beenden; letzter Verwalter bleibt | +| GET | `/api/v1/rooms/{id}/invitations` | S+R, M | offene Einladungen ohne Token | +| DELETE | `/api/v1/rooms/{id}/invitations/{invitation_id}` | S+R, M | Einladung widerrufen | +| GET | `/api/v1/admin/rooms` | S+R, B | alle gemeinsamen Räume mit Zustand, Mitgliederzahl, Verwaltern; keine Inhalte | +| POST | `/api/v1/admin/rooms/{id}/managers` | S+R, B | Verwalter einsetzen, nur wenn der Raum keinen aktiven Verwalter hat | +| GET | `/api/v1/admin/events` | S+R, B | Verwaltungsprotokoll (`cursor`, `limit`) für Konto, Sitzung, Raum, Mitgliedschaft, Einladung | ## Akten diff --git a/docs/architecture/BENUTZERVERWALTUNG.md b/docs/architecture/BENUTZERVERWALTUNG.md new file mode 100644 index 0000000..41c3afe --- /dev/null +++ b/docs/architecture/BENUTZERVERWALTUNG.md @@ -0,0 +1,52 @@ +# Benutzerverwaltung, Rollen und Rechte (Ist, 20.10.2026) + +Erster Schnitt der Administration. Er baut auf den vorhandenen Mechanismen auf (Kontext-Grants, Datenräume, Audit über `domain_events`) und führt kein neues Fachmodell ein. Die Auswertung der Objektrechte bleibt unverändert, siehe [RECHTEMODELL_IST.md](RECHTEMODELL_IST.md). + +## Rollen + +Feste Bündel, kein Rolleneditor (Technische Spezifikation 5.2). Rollen werden bei jeder Anfrage aus der Datenbank gelesen, nicht in der Session gehalten (`backend/app/access/roles.py`). + +| Ebene | Rolle | Darf | +|---|---|---| +| Plattform | Betreiber (`is_superadmin`, mehrere möglich) | Konten anlegen, deaktivieren und aktivieren, Passwort zurücksetzen, Sitzungen beenden, Betreiberrolle vergeben und entziehen, Räume mit Verwaltern sehen, Verwalter in einen Raum ohne Verwalter einsetzen, Verwaltungsprotokoll lesen. **Kein Leserecht auf Inhalte.** | +| Plattform | Nutzer | eigenes Passwort ändern, eigene Sitzungen ansehen und beenden | +| Datenraum | Verwalter (`manager`) | Mitglieder und Rollen verwalten, Einladungen, Raum umbenennen, archivieren und wieder aktivieren | +| Datenraum | Mitglied (`member`) | Inhalte im Raum anlegen. Objektrechte weiter nur per Grant | +| Datenraum | Leser (`reader`) | Raum wählen und freigegebene Inhalte lesen. Legt im Raum nichts an. Erhält für Objekte dieses Raums keine Bearbeiten- oder Freigeben-Grants | + +### Schutzregeln + +- Der letzte aktive Betreiber lässt sich weder deaktivieren noch zurückstufen. Niemand deaktiviert das eigene Konto. +- Der letzte aktive Verwalter eines Raums bleibt Verwalter. Er kann weder zurückgestuft noch entfernt werden. +- Wer zum Betreiber befördert wird, verliert alle Sitzungen und meldet sich neu an. +- Konten werden **deaktiviert, nicht gelöscht**. Inhalte, Owner-Bezüge und Protokoll bleiben. Löschen oder Anonymisieren ist ein eigener späterer Schnitt. + +### Wirkung der Leser-Rolle + +Grants hängen am Objekt, nicht am Raum. Der Leser begrenzt daher drei Stellen, ohne die Policy-Auswertung zu ändern: + +1. Anlegen von Akte, Vorgang, Notiz, Datei, Referenz, Aufgabe und Frist mit diesem Heimatraum (`ensure_can_create` in `ops.py`). +2. Vergabe neuer Bearbeiten- oder Freigeben-Grants an einen Leser für Objekte dieses Raums (`grant_access`). +3. Beim Zurückstufen auf Leser werden dessen vorhandene Bearbeiten- und Freigeben-Grants auf Objekte dieses Raums in derselben Transaktion entzogen. Lese-Grants bleiben. + +Grants auf Objekte anderer Räume bleiben unberührt. + +## Zugang + +- **Einmal-Passwort:** Der Betreiber legt ein Konto an oder setzt das Passwort zurück. Tsumugu erzeugt ein Passwort und zeigt es einmal an. Das Konto steht auf `must_change_password`, bis die Person ein eigenes festgelegt hat. Bis dahin antworten nur `auth/session`, `auth/password` und `auth/logout`, alles andere mit 403 `password_change_required`. +- **Einladungslink:** Ein Verwalter erstellt eine Einladung mit Rolle. Der Link enthält das Token im URL-Fragment (`/invite/{id}#{token}`), es erreicht also keinen Server-Log. Der Link gilt 7 Tage und einmal und lässt sich widerrufen. Es gibt keinen E-Mail-Versand. +- **Passwortregel:** mindestens 10 Zeichen, höchstens 72 UTF-8-Byte (bcrypt). Beim Ändern des eigenen Passworts enden alle anderen Sitzungen. + +## Anmeldung + +- Die Versuchsbegrenzung steht in der Tabelle `auth_login_attempts` (8 Fehlversuche in 10 Minuten je Bucket). Der Bucket ist ein SHA-256 aus Adresse und E-Mail, die Roh-E-Mail wird nicht gespeichert. Ein erfolgreicher Login löscht den Bucket. +- Unbekannte und deaktivierte Konten laufen durch einen bcrypt-Vergleich und erhalten dieselbe Antwort wie ein falsches Passwort. +- Der CSRF-Vergleich ist konstantzeitlich. `last_seen_at` wird höchstens alle 5 Minuten geschrieben. + +## Audit + +Alle schreibenden Aktionen schreiben in `domain_events`, ohne E-Mail, Passwort und Token. Ressourcenarten: `account`, `session`, `room`, `membership`, `invitation`. Der Betreiber liest sie unter `GET /api/v1/admin/events`. Nicht protokolliert werden fehlgeschlagene Anmeldungen (die Begrenzung zählt sie in `auth_login_attempts`). + +## Bewusst nicht enthalten (Sicherheitskonzept) + +MFA (später optional für alle Konten), Leerlaufablauf und Rotation der Sitzung, Änderung der Sitzungsdauer von 14 Tagen, Härtung des Web-Bootstraps für das erste Betreiberkonto (R-04), Mindestlänge 15, Einschränkung von `GET /api/v1/principals`, E-Mail-Versand, Löschen und Anonymisieren von Konten, Übertragung von Ownership. diff --git a/docs/architecture/DATENMODELL_IST.md b/docs/architecture/DATENMODELL_IST.md index 60acfd9..b1f72d3 100644 --- a/docs/architecture/DATENMODELL_IST.md +++ b/docs/architecture/DATENMODELL_IST.md @@ -1,6 +1,6 @@ # Tsumugu – Datenmodell (Ist-Stand) -**Stand:** 19.10.2026, nach den Migrationen in `backend/migrations/` (letzte: `20261020T120000Z_connector_probe_status.sql`). Entstanden im Code-Review vom 18.10.2026 und für die Connector-Grundlage nachgezogen. Die Arten `connectors.kind` und `external_references.source` prüft die Registrierung. Die früheren Prüflisten in der Datenbank sind entfernt. `url` bleibt eine Referenz ohne Connector. +**Stand:** 19.10.2026, nach den Migrationen in `backend/migrations/` (letzte: `20261020T150000Z_user_admin.sql`). Entstanden im Code-Review vom 18.10.2026 und für die Connector-Grundlage nachgezogen. Die Arten `connectors.kind` und `external_references.source` prüft die Registrierung. Die früheren Prüflisten in der Datenbank sind entfernt. `url` bleibt eine Referenz ohne Connector. Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TECHNICAL_SPEC.md). Diese Datei beschreibt, was tatsächlich angelegt ist. Bei jeder neuen Migration nachziehen. @@ -16,11 +16,12 @@ Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TE | Tabelle | Wesentliche Spalten | Regeln | |---|---|---| -| `auth_accounts` | `id`, `email` (unique), `display_name`, `password_hash` (bcrypt), `status` (`active`/`disabled`), `is_superadmin`, `origin` (`operator`/`fixture`) | Konten mit `origin='fixture'` entfernt der Start in jeder Umgebung | -| `auth_sessions` | `id`, `account_id`, `secret_hash` (SHA-256, unique), `csrf_token`, `scope_kind`, `scope_id`, `epoch`, `expires_at`, `revoked_at` | der bestätigte Datenraum steht in der Session | -| `auth_invitations` | `email`, `room_id`, `token_hash`, `invited_by`, `expires_at`, `accepted_at` | 7 Tage gültig | +| `auth_accounts` | `id`, `email` (unique), `display_name`, `password_hash` (bcrypt), `status` (`active`/`disabled`), `is_superadmin`, `origin` (`operator`/`fixture`), `must_change_password`, `password_changed_at`, `last_login_at`, `disabled_at`, `disabled_by` | Konten mit `origin='fixture'` entfernt der Start in jeder Umgebung | +| `auth_sessions` | `id`, `account_id`, `secret_hash` (SHA-256, unique), `csrf_token`, `scope_kind`, `scope_id`, `epoch`, `expires_at`, `revoked_at`, `last_seen_at`, `label` (kurzer Gerätehinweis) | der bestätigte Datenraum steht in der Session | +| `auth_invitations` | `email`, `room_id`, `token_hash`, `invited_by`, `expires_at`, `accepted_at`, `role`, `revoked_at` | 7 Tage gültig | | `data_rooms` | `id`, `kind` (`personal`/`organization`), `name`, `status` (`active`/`archived`), `created_by` | persönlicher Raum: `id = account_id` | -| `room_memberships` | PK (`room_id`, `subject_id`), `role` (`member`/`manager`), `status` (`active`/`removed`) | – | +| `room_memberships` | PK (`room_id`, `subject_id`), `role` (`member`/`manager`/`reader`), `status` (`active`/`removed`) | – | +| `auth_login_attempts` | `bucket` (SHA-256 aus Adresse und E-Mail), `attempted_at` | zählt Fehlversuche; erfolgreicher Login löscht den Bucket | ## Struktur diff --git a/docs/architecture/RECHTEMODELL_IST.md b/docs/architecture/RECHTEMODELL_IST.md index 4316f09..1fc71c8 100644 --- a/docs/architecture/RECHTEMODELL_IST.md +++ b/docs/architecture/RECHTEMODELL_IST.md @@ -93,6 +93,7 @@ Danach Abzug der jeweiligen Ausnahme. - Die Chronologie zeigt nur Ereignisse, deren Ressource im Seitenkontext lesbar ist (`_event_title`). - Breadcrumbs nennen nur lesbare Stationen. Bei mehreren lesbaren Aktenzuordnungen ohne gewählten Kontext erscheint keine Hauptakte. - Betreiber- und Verwalterrolle verleihen kein Leserecht auf persönliche Inhalte. +- Plattform- und Raumrollen (Betreiber, Verwalter, Mitglied, Leser) und ihre Schutzregeln beschreibt [BENUTZERVERWALTUNG.md](BENUTZERVERWALTUNG.md). Der Leser legt im Raum nichts an und erhält dort keine Bearbeiten- oder Freigeben-Grants; die Auswertung der Objektrechte bleibt unverändert. - Ein Quellabruf prüft zuerst das Leserecht im Kontext. Danach wird nur der an der Referenz gebundene Zugang des Owners verwendet. Eine Suche ohne `connector_id` nimmt bei mehreren eigenen Instanzen nicht die zuletzt angelegte. Ein Empfänger erhält weder Zugangsdaten noch die übrigen Treffer des Owners. Ein Entzug gilt beim nächsten Abruf, weil jedes Lesen die Rechte erneut prüft. ## 6. Bekannte Abweichungen diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx index 64c61bd..cda9b7b 100644 --- a/frontend/src/App.jsx +++ b/frontend/src/App.jsx @@ -11,7 +11,10 @@ import { Rooms } from "./pages/Rooms.jsx"; import { Search } from "./pages/Search.jsx"; import { Sources } from "./pages/Sources.jsx"; import { ConnectorConfig } from "./sources/connector-config.jsx"; -import { Users } from "./pages/Users.jsx"; +import { Account, ForcedPasswordChange } from "./admin/Account.jsx"; +import { AdminEvents, AdminRooms } from "./admin/Admin.jsx"; +import { InviteAccept } from "./admin/InviteAccept.jsx"; +import { UserDetail, Users } from "./admin/Users.jsx"; import { Work } from "./pages/Work.jsx"; import { Settings } from "./pages/Settings.jsx"; import { Reader } from "./pages/Reader.jsx"; @@ -88,6 +91,19 @@ export function App() { const value = { session, setSession, refresh, changeScope, logout }; + if (session?.account?.must_change_password) { + return ( + +
+ +
+ +
+
+
+ ); + } + return (
@@ -95,6 +111,7 @@ export function App() {
: } /> + } /> : }> } /> } /> @@ -109,6 +126,10 @@ export function App() { } /> } /> } /> + } /> + } /> + } /> + } /> } /> diff --git a/frontend/src/admin/Account.jsx b/frontend/src/admin/Account.jsx new file mode 100644 index 0000000..eeb3055 --- /dev/null +++ b/frontend/src/admin/Account.jsx @@ -0,0 +1,105 @@ +import { useContext, useEffect, useState } from "react"; +import { api } from "../api.js"; +import { SessionContext } from "../session.js"; +import { ErrorNote } from "../pages/widgets.jsx"; +import { formatWhen } from "./admin-core.js"; +import { PasswordForm } from "./widgets.jsx"; + +export function Account() { + const { session } = useContext(SessionContext); + const [sessions, setSessions] = useState([]); + const [notice, setNotice] = useState(""); + const [error, setError] = useState(""); + + async function load() { + const data = await api("/api/v1/auth/sessions"); + setSessions(data.items); + } + + useEffect(() => { + load().catch((err) => setError(err.message)); + }, []); + + async function end(id) { + setError(""); + try { + await api(`/api/v1/auth/sessions/${id}`, { method: "DELETE" }); + await load(); + } catch (err) { + setError(err.message); + } + } + + async function endOthers() { + setError(""); + setNotice(""); + try { + const result = await api("/api/v1/auth/sessions/revoke-others", { method: "POST" }); + setNotice(result.revoked ? `${result.revoked} andere Sitzung(en) beendet.` : "Es gibt keine anderen Sitzungen."); + await load(); + } catch (err) { + setError(err.message); + } + } + + const others = sessions.filter((item) => !item.current); + + return ( +
+
+
+

Mein Konto

+

{session.account.display_name} · {session.account.email}

+
+
+ + {notice ?

{notice}

: null} +
+

Passwort ändern

+

Beim Ändern werden deine anderen Sitzungen beendet.

+ { setNotice("Das Passwort ist geändert."); await load(); }} /> +
+
+

Angemeldete Geräte

+
    + {sessions.map((item) => ( +
  • + {item.label}{item.current ? " (dieses Gerät)" : ""} + Angemeldet {formatWhen(item.created_at)} · zuletzt aktiv {formatWhen(item.last_seen_at)} + {item.current ? null : } +
  • + ))} +
+ {others.length ? ( +
+ +
+ ) : null} +
+
+ ); +} + +// While a one-time password is set, this is the only screen. +export function ForcedPasswordChange() { + const { session, refresh, logout } = useContext(SessionContext); + return ( +
+
+
+

Eigenes Passwort festlegen

+

+ {session.account.display_name}, dein Zugang ist mit einem Einmal-Passwort eingerichtet. Lege vor dem ersten Arbeiten ein + eigenes fest. +

+
+
+
+ +
+
+ +
+
+ ); +} diff --git a/frontend/src/admin/Admin.jsx b/frontend/src/admin/Admin.jsx new file mode 100644 index 0000000..3743678 --- /dev/null +++ b/frontend/src/admin/Admin.jsx @@ -0,0 +1,128 @@ +import { useEffect, useState } from "react"; +import { Link } from "react-router-dom"; +import { api } from "../api.js"; +import { ErrorNote } from "../pages/widgets.jsx"; +import { formatWhen } from "./admin-core.js"; + +// Operator overview of shared rooms. It shows names and managers, never content. +export function AdminRooms() { + const [items, setItems] = useState([]); + const [error, setError] = useState(""); + const [notice, setNotice] = useState(""); + const [assign, setAssign] = useState({ room: "", email: "" }); + + function load() { + return api("/api/v1/admin/rooms") + .then((data) => setItems(data.items)) + .catch((err) => setError(err.message)); + } + + useEffect(() => { + load(); + }, []); + + async function submit(event) { + event.preventDefault(); + setError(""); + setNotice(""); + try { + await api(`/api/v1/admin/rooms/${assign.room}/managers`, { method: "POST", body: { email: assign.email } }); + setNotice("Der Verwalter ist eingesetzt."); + setAssign({ room: "", email: "" }); + await load(); + } catch (err) { + setError(err.message); + } + } + + return ( +
+
+
+

Verwaltung

+

Datenräume aller Konten

+

Der Betreiber sieht Namen, Zustand und Verwalter, aber keine Inhalte.

+
+
+ + {notice ?

{notice}

: null} +
    + {items.map((room) => ( +
  • + {room.name} + + {room.status === "archived" ? "Archiviert · " : ""} + {room.members} Mitglied(er) · {room.has_manager ? `Verwalter: ${room.managers.join(", ")}` : "Kein aktiver Verwalter"} + + {room.has_manager ? null : ( + + )} +
  • + ))} +
+ {!items.length ?

Es gibt noch keinen gemeinsamen Datenraum.

: null} + {assign.room ? ( +
+

Verwalter einsetzen

+

Nur für Räume ohne aktiven Verwalter. Die Aktion wird protokolliert.

+ +
+ + +
+
+ ) : null} +
+ ); +} + +export function AdminEvents() { + const [items, setItems] = useState([]); + const [next, setNext] = useState(null); + const [error, setError] = useState(""); + + async function load(cursor = 0) { + const data = await api(`/api/v1/admin/events?cursor=${cursor}&limit=50`); + setItems((current) => (cursor ? [...current, ...data.items] : data.items)); + setNext(data.next_cursor); + } + + useEffect(() => { + load().catch((err) => setError(err.message)); + }, []); + + return ( +
+
+
+

Verwaltung

+

Verwaltungsprotokoll

+

Konten, Anmeldungen, Datenräume, Rollen und Einladungen. Ohne E-Mail-Adressen und Geheimnisse.

+
+
+ +
    + {items.map((event) => ( +
  • + {event.label} + + {formatWhen(event.occurred_at)} + {event.actor ? ` · von ${event.actor}` : ""} + {event.subject ? ` · betrifft ${event.subject}` : ""} + {event.room ? ` · Raum ${event.room}` : ""} + +
  • + ))} +
+ {!items.length && !error ?

Noch keine Einträge.

: null} + {next !== null ? ( +
+ +
+ ) : null} +
+ ); +} diff --git a/frontend/src/admin/InviteAccept.jsx b/frontend/src/admin/InviteAccept.jsx new file mode 100644 index 0000000..e182b48 --- /dev/null +++ b/frontend/src/admin/InviteAccept.jsx @@ -0,0 +1,76 @@ +import { useContext, useState } from "react"; +import { useLocation, useNavigate, useParams } from "react-router-dom"; +import { api, applySession } from "../api.js"; +import { SessionContext } from "../session.js"; +import { ErrorNote } from "../pages/widgets.jsx"; +import { parseInviteHash, passwordProblem } from "./admin-core.js"; + +export function InviteAccept() { + const { id } = useParams(); + const location = useLocation(); + const navigate = useNavigate(); + const { setSession } = useContext(SessionContext); + const token = parseInviteHash(location.hash); + const [name, setName] = useState(""); + const [password, setPassword] = useState(""); + const [repeat, setRepeat] = useState(""); + const [error, setError] = useState(""); + const [pending, setPending] = useState(false); + + async function submit(event) { + event.preventDefault(); + const problem = passwordProblem(password, repeat); + if (problem) { + setError(problem); + return; + } + setPending(true); + setError(""); + try { + const data = await api(`/api/v1/invitations/${id}/accept`, { + method: "POST", + body: { token, display_name: name, password }, + }); + applySession(data); + setSession(data); + navigate("/", { replace: true }); + } catch (err) { + setError(err.status === 404 ? "Die Einladung ist ungültig, abgelaufen oder bereits verwendet." : err.message); + } finally { + setPending(false); + } + } + + return ( +
+
+
+

Einladung annehmen

+

Lege deinen Namen und ein Passwort fest. Danach bist du im eingeladenen Datenraum angemeldet.

+
+
+ {!token ? ( +

Dem Link fehlt der Einladungsschlüssel. Bitte die einladende Person um einen neuen Link.

+ ) : ( +
+ + + + +
+ +
+ + )} +
+ ); +} diff --git a/frontend/src/admin/Users.jsx b/frontend/src/admin/Users.jsx new file mode 100644 index 0000000..ad43c5f --- /dev/null +++ b/frontend/src/admin/Users.jsx @@ -0,0 +1,281 @@ +import { useContext, useEffect, useState } from "react"; +import { Link, useParams } from "react-router-dom"; +import { api, markDirty } from "../api.js"; +import { Modal } from "../pages/Modal.jsx"; +import { ErrorNote } from "../pages/widgets.jsx"; +import { SessionContext } from "../session.js"; +import { accountRole, accountState, formatWhen, roleLabel } from "./admin-core.js"; +import { OneTimeSecret } from "./widgets.jsx"; + +export function Users() { + const [items, setItems] = useState([]); + const [filter, setFilter] = useState(""); + const [open, setOpen] = useState(false); + const [email, setEmail] = useState(""); + const [displayName, setDisplayName] = useState(""); + const [operator, setOperator] = useState(false); + const [error, setError] = useState(""); + const [pending, setPending] = useState(false); + const [issued, setIssued] = useState(null); + + function load(status = filter) { + const query = status ? `?status=${status}` : ""; + return api(`/api/v1/accounts${query}`) + .then((data) => setItems(data.items)) + .catch((err) => setError(err.message)); + } + + useEffect(() => { + load(); + }, [filter]); + + function close() { + setOpen(false); + setError(""); + markDirty(false); + } + + async function submit(event) { + event.preventDefault(); + setPending(true); + setError(""); + try { + const created = await api("/api/v1/accounts", { + method: "POST", + body: { email, display_name: displayName, is_operator: operator }, + }); + setIssued({ name: created.display_name, email: created.email, password: created.temporary_password }); + setEmail(""); + setDisplayName(""); + setOperator(false); + markDirty(false); + setOpen(false); + await load(); + } catch (err) { + setError(err.message); + } finally { + setPending(false); + } + } + + return ( +
+
+
+

Nutzer

+

Neue Konten legt der Betreiber an. Jedes Konto erhält einen eigenen persönlichen Datenraum.

+
+ +
+ + {issued ? ( + setIssued(null)} + /> + ) : null} + +
+ {items.map((account) => { + const state = accountState(account); + return ( + + {accountRole(account)} · {state.label} + {account.display_name} + {account.email} + Letzte Anmeldung: {formatWhen(account.last_login_at)} + + ); + })} +
+ {!items.length ?

Keine Konten in dieser Anzeige.

: null} + +
+ + + +

Tsumugu erzeugt ein Einmal-Passwort und zeigt es dir danach einmal an.

+ + + +
+
+ ); +} + +export function UserDetail() { + const { id } = useParams(); + const { session } = useContext(SessionContext); + const [account, setAccount] = useState(null); + const [name, setName] = useState(""); + const [error, setError] = useState(""); + const [notice, setNotice] = useState(""); + const [issued, setIssued] = useState(""); + const [confirm, setConfirm] = useState(""); + const own = session.account.id === id; + + async function load() { + const data = await api(`/api/v1/accounts/${id}`); + setAccount(data); + setName(data.display_name); + } + + useEffect(() => { + setAccount(null); + setIssued(""); + setNotice(""); + load().catch((err) => setError(err.message)); + }, [id]); + + async function run(action, message) { + setError(""); + setNotice(""); + setConfirm(""); + try { + await action(); + if (message) setNotice(message); + await load(); + } catch (err) { + setError(err.message); + } + } + + const patch = (body) => api(`/api/v1/accounts/${id}`, { method: "PATCH", body }); + + async function reset() { + setIssued(""); + await run(async () => { + const result = await api(`/api/v1/accounts/${id}/password-reset`, { method: "POST" }); + setIssued(result.temporary_password); + }); + } + + const disabled = account?.status === "disabled"; + + return ( +
+
+
+

Nutzer

+

{account?.display_name || "Konto"}

+ {account ?

{account.email} · {accountRole(account)} · {accountState(account).label}

: null} +
+
+ + {notice ?

{notice}

: null} + {issued ? ( + setIssued("")} + /> + ) : null} + {account ? ( +
+
+

Stammdaten

+
{ + event.preventDefault(); + run(() => patch({ display_name: name }), "Der Name ist gespeichert."); + }} + > + setName(event.target.value)} required maxLength={120} aria-label="Name" /> + +
+

Letzte Anmeldung: {formatWhen(account.last_login_at)} · Aktive Sitzungen: {account.active_sessions}

+
+ +
+

Betreiberrolle

+

Betreiber verwalten Konten und Räume. Sie erhalten dadurch keinen Zugriff auf Akten anderer.

+ {confirm === "operator" ? ( +
+ + +
+ ) : ( +
+ +
+ )} + {!account.is_superadmin ?

Beim Befördern wird die Person abgemeldet und meldet sich neu an.

: null} +
+ +
+

Zugang

+
+ + +
+ {own ?

Dein eigenes Passwort änderst du unter Mein Konto.

: null} + {disabled ? ( +
+ +
+ ) : confirm === "disable" ? ( +
+ + +
+ ) : ( +
+ +
+ )} +

Ein deaktiviertes Konto kann sich nicht anmelden. Seine Akten, Notizen und das Protokoll bleiben erhalten.

+
+ +
+

Gemeinsame Datenräume

+ {account.rooms.length ? ( +
    + {account.rooms.map((room) => ( +
  • + {room.name} + {roleLabel(room.role)}{room.status === "archived" ? " · archiviert" : ""} +
  • + ))} +
+ ) : ( +

Keine Mitgliedschaft in einem gemeinsamen Datenraum.

+ )} +
+
+ ) : null} +
+ ); +} diff --git a/frontend/src/admin/admin-core.js b/frontend/src/admin/admin-core.js new file mode 100644 index 0000000..566fb2c --- /dev/null +++ b/frontend/src/admin/admin-core.js @@ -0,0 +1,59 @@ +// Pure helpers for the user and room administration. No React, so Node can test them. + +export const ROOM_ROLES = [ + { value: "member", label: "Mitglied", hint: "Legt Inhalte im Raum an. Objektrechte nur per Freigabe." }, + { value: "manager", label: "Verwalter", hint: "Verwaltet Mitglieder, Rollen und Einladungen." }, + { value: "reader", label: "Leser", hint: "Liest freigegebene Inhalte. Legt nichts an und bearbeitet nichts." }, +]; + +export function roleLabel(role) { + if (role === "owner") return "Eigener Raum"; + return ROOM_ROLES.find((item) => item.value === role)?.label || "Unbekannt"; +} + +export function accountState(account) { + if (account.status === "disabled") return { key: "disabled", label: "Deaktiviert" }; + if (account.must_change_password) return { key: "pending", label: "Passwort offen" }; + return { key: "active", label: "Aktiv" }; +} + +export function accountRole(account) { + return account.is_superadmin ? "Betreiber" : "Nutzer"; +} + +const encoder = typeof TextEncoder === "undefined" ? null : new TextEncoder(); + +export function passwordProblem(password, repeat = null, current = "") { + if (password.length < 10) return "Das Passwort braucht mindestens 10 Zeichen."; + const bytes = encoder ? encoder.encode(password).length : password.length; + if (bytes > 72) return "Das Passwort ist zu lang. Erlaubt sind höchstens 72 Byte."; + if (repeat !== null && password !== repeat) return "Die beiden Passwörter sind nicht gleich."; + if (current && password === current) return "Das neue Passwort muss sich vom bisherigen unterscheiden."; + return ""; +} + +// The token travels in the fragment. A fragment is not sent to the server and stays out of its logs. +export function inviteLink(origin, invitation) { + return `${origin}/invite/${invitation.id}#${invitation.token}`; +} + +export function parseInviteHash(hash) { + const value = String(hash || "").replace(/^#/, "").trim(); + return value.length >= 20 ? value : ""; +} + +export function canArchive(room) { + return room?.kind === "organization" && room?.role === "manager"; +} + +export function lastManagerIds(members) { + const managers = members.filter((member) => member.role === "manager" && member.account_status === "active"); + return managers.length === 1 ? new Set([managers[0].subject_id]) : new Set(); +} + +export function formatWhen(value) { + if (!value) return "nie"; + const date = new Date(value); + if (Number.isNaN(date.getTime())) return "unbekannt"; + return date.toLocaleString("de-DE", { dateStyle: "medium", timeStyle: "short" }); +} diff --git a/frontend/src/admin/admin-core.test.mjs b/frontend/src/admin/admin-core.test.mjs new file mode 100644 index 0000000..b0f1bb9 --- /dev/null +++ b/frontend/src/admin/admin-core.test.mjs @@ -0,0 +1,51 @@ +import assert from "node:assert/strict"; +import test from "node:test"; +import { + accountState, + inviteLink, + lastManagerIds, + parseInviteHash, + passwordProblem, + roleLabel, +} from "./admin-core.js"; + +test("room roles have a German label and an unknown role is not guessed", () => { + assert.equal(roleLabel("reader"), "Leser"); + assert.equal(roleLabel("manager"), "Verwalter"); + assert.equal(roleLabel("owner"), "Eigener Raum"); + assert.equal(roleLabel("admin"), "Unbekannt"); +}); + +test("an account is shown as disabled, open for a password change, or active", () => { + assert.equal(accountState({ status: "disabled", must_change_password: true }).key, "disabled"); + assert.equal(accountState({ status: "active", must_change_password: true }).key, "pending"); + assert.equal(accountState({ status: "active", must_change_password: false }).key, "active"); +}); + +test("password rules match the server", () => { + assert.match(passwordProblem("kurz"), /mindestens 10/); + assert.match(passwordProblem("a".repeat(73)), /zu lang/); + assert.match(passwordProblem("ä".repeat(40)), /zu lang/); + assert.match(passwordProblem("lang-genug-123", "anders-lang-123"), /nicht gleich/); + assert.match(passwordProblem("gleich-bleibend-1", null, "gleich-bleibend-1"), /unterscheiden/); + assert.equal(passwordProblem("lang-genug-123", "lang-genug-123", "alt-passwort-1"), ""); +}); + +test("the invitation token stays in the fragment", () => { + const link = inviteLink("https://tsumugu.example", { id: "abc", token: "t".repeat(30) }); + assert.equal(link, `https://tsumugu.example/invite/abc#${"t".repeat(30)}`); + assert.equal(new URL(link).search, ""); + assert.equal(parseInviteHash(`#${"t".repeat(30)}`), "t".repeat(30)); + assert.equal(parseInviteHash("#kurz"), ""); + assert.equal(parseInviteHash(""), ""); +}); + +test("only a single active manager is protected", () => { + const members = [ + { subject_id: "a", role: "manager", account_status: "active" }, + { subject_id: "b", role: "member", account_status: "active" }, + ]; + assert.deepEqual([...lastManagerIds(members)], ["a"]); + assert.equal(lastManagerIds([...members, { subject_id: "c", role: "manager", account_status: "active" }]).size, 0); + assert.equal(lastManagerIds([{ subject_id: "a", role: "manager", account_status: "disabled" }]).size, 0); +}); diff --git a/frontend/src/admin/widgets.jsx b/frontend/src/admin/widgets.jsx new file mode 100644 index 0000000..1fb2b70 --- /dev/null +++ b/frontend/src/admin/widgets.jsx @@ -0,0 +1,85 @@ +import { useState } from "react"; +import { api } from "../api.js"; +import { ErrorNote } from "../pages/widgets.jsx"; +import { passwordProblem } from "./admin-core.js"; + +// A secret that is shown once: a one-time password or an invitation link. +export function OneTimeSecret({ title, value, hint, onDone }) { + const [copied, setCopied] = useState(false); + + async function copy() { + try { + await navigator.clipboard.writeText(value); + setCopied(true); + } catch { + setCopied(false); + } + } + + return ( +
+

{title}

+ +

{hint || "Dieser Wert wird nur jetzt angezeigt und nicht gespeichert."}

+
+ + {onDone ? : null} +
+
+ ); +} + +export function PasswordForm({ onDone, submitLabel = "Passwort ändern" }) { + const [current, setCurrent] = useState(""); + const [next, setNext] = useState(""); + const [repeat, setRepeat] = useState(""); + const [error, setError] = useState(""); + const [pending, setPending] = useState(false); + + async function submit(event) { + event.preventDefault(); + const problem = passwordProblem(next, repeat, current); + if (problem) { + setError(problem); + return; + } + setPending(true); + setError(""); + try { + await api("/api/v1/auth/password", { method: "POST", body: { current_password: current, new_password: next } }); + setCurrent(""); + setNext(""); + setRepeat(""); + await onDone?.(); + } catch (err) { + setError(err.message); + } finally { + setPending(false); + } + } + + return ( +
+ + + + +
+ +
+ + ); +} diff --git a/frontend/src/pages/Rooms.jsx b/frontend/src/pages/Rooms.jsx index ad3a420..19fef92 100644 --- a/frontend/src/pages/Rooms.jsx +++ b/frontend/src/pages/Rooms.jsx @@ -1,25 +1,197 @@ import { useContext, useEffect, useState } from "react"; import { api, markDirty } from "../api.js"; +import { ROOM_ROLES, formatWhen, inviteLink, lastManagerIds, roleLabel } from "../admin/admin-core.js"; +import { OneTimeSecret } from "../admin/widgets.jsx"; import { SessionContext } from "../session.js"; import { ErrorNote } from "./widgets.jsx"; +function RoleSelect({ value, onChange, disabled = false, label }) { + return ( + + ); +} + +function RoomAdmin({ room, onRenamed, onArchived }) { + const [members, setMembers] = useState([]); + const [invitations, setInvitations] = useState([]); + const [name, setName] = useState(room.name); + const [email, setEmail] = useState(""); + const [role, setRole] = useState("member"); + const [inviteMail, setInviteMail] = useState(""); + const [inviteRole, setInviteRole] = useState("member"); + const [link, setLink] = useState(""); + const [confirmArchive, setConfirmArchive] = useState(false); + const [error, setError] = useState(""); + const [notice, setNotice] = useState(""); + const guarded = lastManagerIds(members); + + async function load() { + const [people, open] = await Promise.all([ + api(`/api/v1/rooms/${room.id}/members`), + api(`/api/v1/rooms/${room.id}/invitations`), + ]); + setMembers(people.items); + setInvitations(open.items); + } + + useEffect(() => { + setName(room.name); + setLink(""); + load().catch((err) => setError(err.message)); + }, [room.id]); + + async function run(action, message = "") { + setError(""); + setNotice(""); + try { + await action(); + if (message) setNotice(message); + await load(); + } catch (err) { + setError(err.message); + } + } + + async function rename(event) { + event.preventDefault(); + await run(async () => { + await api(`/api/v1/rooms/${room.id}`, { method: "PATCH", body: { name } }); + markDirty(false); + await onRenamed(); + }, "Der Name ist gespeichert."); + } + + async function archive() { + setError(""); + try { + await api(`/api/v1/rooms/${room.id}`, { method: "PATCH", body: { status: "archived" } }); + await onArchived(); + } catch (err) { + setError(err.message); + } + } + + async function add(event) { + event.preventDefault(); + await run(async () => { + await api(`/api/v1/rooms/${room.id}/members`, { method: "POST", body: { email, role } }); + setEmail(""); + markDirty(false); + }, "Das Mitglied ist hinzugefügt."); + } + + async function invite(event) { + event.preventDefault(); + setLink(""); + await run(async () => { + const created = await api("/api/v1/invitations", { + method: "POST", + body: { email: inviteMail, room_id: room.id, role: inviteRole }, + }); + setLink(inviteLink(window.location.origin, created)); + setInviteMail(""); + markDirty(false); + }); + } + + return ( +
+

{room.name}

+ + {notice ?

{notice}

: null} + +
+ { setName(event.target.value); markDirty(true); }} aria-label="Name des Datenraums" required maxLength={160} /> + +
+ +

Mitglieder

+
    + {members.map((member) => ( +
  • + {member.display_name} + {member.email}{member.account_status === "disabled" ? " · Konto deaktiviert" : ""} + run(() => api(`/api/v1/rooms/${room.id}/members/${member.subject_id}`, { method: "PATCH", body: { role: next } }), "Die Rolle ist geändert.")} + /> + +
  • + ))} +
+ {guarded.size ?

Der letzte Verwalter bleibt Verwalter. Ernenne zuerst eine weitere Person.

: null} +
    + {ROOM_ROLES.map((item) =>
  • {item.label}: {item.hint}
  • )} +
+ +
+ { setEmail(event.target.value); markDirty(true); }} placeholder="E-Mail eines bestehenden Kontos" aria-label="E-Mail eines bestehenden Kontos" required /> + + + + +

Einladungen

+

Für Personen ohne Konto. Du erhältst einen Link, den du selbst weitergibst. Er gilt 7 Tage und einmal.

+ {link ? setLink("")} /> : null} +
+ { setInviteMail(event.target.value); markDirty(true); }} placeholder="E-Mail der eingeladenen Person" aria-label="E-Mail der eingeladenen Person" required /> + + + + {invitations.length ? ( +
    + {invitations.map((item) => ( +
  • + {item.email} + {roleLabel(item.role)} · gültig bis {formatWhen(item.expires_at)} + +
  • + ))} +
+ ) :

Keine offenen Einladungen.

} + +

Archivieren

+ {confirmArchive ? ( +
+ + +
+ ) : ( +
+ +
+ )} +

Ein archivierter Datenraum lässt sich nicht mehr wählen. Seine Inhalte bleiben erhalten, du kannst ihn unten wieder aktivieren.

+
+ ); +} + export function Rooms() { const { session, refresh } = useContext(SessionContext); const [name, setName] = useState(""); - const [email, setEmail] = useState(""); - const [members, setMembers] = useState([]); + const [archived, setArchived] = useState([]); const [error, setError] = useState(""); const current = session.rooms.find((room) => room.id === session.scope.id); + async function loadArchived() { + const data = await api("/api/v1/rooms?include_archived=true"); + setArchived(data.items.filter((room) => room.status === "archived")); + } + useEffect(() => { - if (!current || current.kind !== "organization" || current.role !== "manager") { - setMembers([]); - return; - } - api(`/api/v1/rooms/${current.id}/members`) - .then((data) => setMembers(data.items)) - .catch((err) => setError(err.message)); - }, [current?.id, current?.role]); + loadArchived().catch((err) => setError(err.message)); + }, [session.rooms.length]); async function create(event) { event.preventDefault(); @@ -34,19 +206,22 @@ export function Rooms() { } } - async function addMember(event) { - event.preventDefault(); + async function restore(room) { setError(""); try { - await api(`/api/v1/rooms/${current.id}/members`, { method: "POST", body: { email, role: "member" } }); - setEmail(""); - const data = await api(`/api/v1/rooms/${current.id}/members`); - setMembers(data.items); + await api(`/api/v1/rooms/${room.id}`, { method: "PATCH", body: { status: "active" } }); + await refresh(); + await loadArchived(); } catch (err) { setError(err.message); } } + async function afterArchive() { + await refresh(); + await loadArchived(); + } + return (
@@ -59,29 +234,36 @@ export function Rooms() { {session.rooms.map((room) => (
  • {room.name} - {room.kind === "personal" ? "Persönlich" : room.role === "manager" ? "Gemeinsam, Verwalter" : "Gemeinsam"} + {room.kind === "personal" ? "Persönlich" : `Gemeinsam · ${roleLabel(room.role)}`}
  • ))}
    - { setName(event.target.value); markDirty(true); }} placeholder="Name des gemeinsamen Datenraums" required /> + { setName(event.target.value); markDirty(true); }} placeholder="Name des gemeinsamen Datenraums" aria-label="Name des gemeinsamen Datenraums" required />
    + {current?.kind === "organization" && current.role === "manager" ? ( -
    -

    Mitglieder in {current.name}

    -
      - {members.map((member) => ( -
    • {member.display_name} · {member.email} · {member.role === "manager" ? "Verwalter" : "Mitglied"}
    • + + ) : current?.kind === "organization" ? ( +

      Mitglieder und Rollen von {current.name} verwalten die Verwalter des Raums.

      + ) : ( +

      Wechsle in einen gemeinsamen Datenraum, um seine Mitglieder zu verwalten.

      + )} + {archived.length ? ( +
      +

      Archivierte Datenräume

      +
        + {archived.map((room) => ( +
      • + {room.name} + {roleLabel(room.role)} + {room.role === "manager" ? : null} +
      • ))}
      -
      - setEmail(event.target.value)} placeholder="E-Mail eines bestehenden Kontos" required /> - -
      ) : null} -
    ); } diff --git a/frontend/src/pages/Settings.jsx b/frontend/src/pages/Settings.jsx index bcdbc60..925af73 100644 --- a/frontend/src/pages/Settings.jsx +++ b/frontend/src/pages/Settings.jsx @@ -23,12 +23,29 @@ export function Settings() { Quellen Paperless und E-Mail + + Verwaltung + Mein Konto + Passwort und Geräte + {session?.account?.is_superadmin ? ( - - Verwaltung - Nutzer - Konten anlegen - + <> + + Betreiber + Nutzer + Konten, Rollen, Zugang + + + Betreiber + Alle Datenräume + Übersicht ohne Inhalte + + + Betreiber + Verwaltungsprotokoll + Wer hat was geändert + + ) : null}
    diff --git a/frontend/src/pages/Shell.jsx b/frontend/src/pages/Shell.jsx index e8f57f0..b5b2e29 100644 --- a/frontend/src/pages/Shell.jsx +++ b/frontend/src/pages/Shell.jsx @@ -172,7 +172,7 @@ export function Shell() { Verwaltung
    - {initials(session.account.display_name)} + {initials(session.account.display_name)} {session.account.display_name} - - -
    - {items.map((account) => ( -
    -

    {account.is_superadmin ? "Betreiber" : "Nutzer"}

    -

    {account.display_name}

    -

    {account.email}

    -
    - ))} -
    - -
    - - - - - - -
    - - ); -}