Ergänze die Benutzerverwaltung, damit der Betreiber Konten, Rollen und Zugänge verwalten kann.
Deploy Development / deploy (push) Successful in 42s
Test Suite / pytest-backend (push) Successful in 3m28s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 20s

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 <noreply@anthropic.com>
This commit is contained in:
LarsandClaude Sonnet 5.5 committed 2026-10-20 12:49:23 +02:00
1 parent eb58dce4cd
commit 037c0724a8
34 files changed
+2790 -391

No files matched your search

+94
View File
@@ -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)
+250
View File
@@ -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}
+20 -3
View File
@@ -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
+464
View File
@@ -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,
)
+40 -227
View File
@@ -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)
+30 -2
View File
@@ -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):
+185 -13
View File
@@ -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'",
+28
View File
@@ -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)
+9
View File
@@ -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")
+4
View File
@@ -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)
+16
View File
@@ -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(
+21
View File
@@ -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",
}
@@ -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'));
+1 -4
View File
@@ -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)
+2 -1
View File
@@ -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"])
+210
View File
@@ -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"])
+261
View File
@@ -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)
+1
View File
@@ -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 |
+24 -9
View File
@@ -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
+52
View File
@@ -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.
+6 -5
View File
@@ -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
+1
View File
@@ -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
+22 -1
View File
@@ -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 (
<SessionContext.Provider value={value}>
<div className="app-root">
<EnvironmentBanner />
<div className="app-root__main">
<ForcedPasswordChange />
</div>
</div>
</SessionContext.Provider>
);
}
return (
<SessionContext.Provider value={value}>
<div className="app-root">
@@ -95,6 +111,7 @@ export function App() {
<div className="app-root__main">
<Routes>
<Route path="/login" element={session ? <Navigate to="/" replace /> : <Login />} />
<Route path="/invite/:id" element={<InviteAccept />} />
<Route element={session ? <Shell /> : <Navigate to="/login" replace />}>
<Route index element={<Overview />} />
<Route path="cases" element={<CaseList />} />
@@ -109,6 +126,10 @@ export function App() {
<Route path="sources" element={<Sources />} />
<Route path="sources/:connectorId" element={<ConnectorConfig />} />
<Route path="users" element={<Users />} />
<Route path="users/:id" element={<UserDetail />} />
<Route path="account" element={<Account />} />
<Route path="admin/rooms" element={<AdminRooms />} />
<Route path="admin/events" element={<AdminEvents />} />
<Route path="search" element={<Search />} />
</Route>
</Routes>
+105
View File
@@ -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 (
<main className="page">
<header className="page-head">
<div>
<h1>Mein Konto</h1>
<p className="muted">{session.account.display_name} · {session.account.email}</p>
</div>
</header>
<ErrorNote error={error} />
{notice ? <p className="notice" role="status">{notice}</p> : null}
<section className="card stack" aria-label="Passwort">
<h2>Passwort ändern</h2>
<p className="muted">Beim Ändern werden deine anderen Sitzungen beendet.</p>
<PasswordForm onDone={async () => { setNotice("Das Passwort ist geändert."); await load(); }} />
</section>
<section className="card stack" aria-label="Sitzungen">
<h2>Angemeldete Geräte</h2>
<ul className="index">
{sessions.map((item) => (
<li key={item.id}>
<strong>{item.label}{item.current ? " (dieses Gerät)" : ""}</strong>
<span>Angemeldet {formatWhen(item.created_at)} · zuletzt aktiv {formatWhen(item.last_seen_at)}</span>
{item.current ? null : <button type="button" className="quiet" onClick={() => end(item.id)}>Beenden</button>}
</li>
))}
</ul>
{others.length ? (
<div className="row">
<button type="button" className="danger" onClick={endOthers}>Überall sonst abmelden</button>
</div>
) : null}
</section>
</main>
);
}
// While a one-time password is set, this is the only screen.
export function ForcedPasswordChange() {
const { session, refresh, logout } = useContext(SessionContext);
return (
<main className="page">
<header className="page-head">
<div>
<h1>Eigenes Passwort festlegen</h1>
<p className="muted">
{session.account.display_name}, dein Zugang ist mit einem Einmal-Passwort eingerichtet. Lege vor dem ersten Arbeiten ein
eigenes fest.
</p>
</div>
</header>
<section className="card stack">
<PasswordForm submitLabel="Eigenes Passwort speichern" onDone={refresh} />
</section>
<div className="row">
<button type="button" className="quiet" onClick={logout}>Abmelden</button>
</div>
</main>
);
}
+128
View File
@@ -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 (
<main className="page">
<header className="page-head">
<div>
<p className="muted"><Link to="/settings">Verwaltung</Link></p>
<h1>Datenräume aller Konten</h1>
<p className="muted">Der Betreiber sieht Namen, Zustand und Verwalter, aber keine Inhalte.</p>
</div>
</header>
<ErrorNote error={error} />
{notice ? <p className="notice" role="status">{notice}</p> : null}
<ul className="index">
{items.map((room) => (
<li key={room.id}>
<strong>{room.name}</strong>
<span>
{room.status === "archived" ? "Archiviert · " : ""}
{room.members} Mitglied(er) · {room.has_manager ? `Verwalter: ${room.managers.join(", ")}` : "Kein aktiver Verwalter"}
</span>
{room.has_manager ? null : (
<button type="button" className="quiet" onClick={() => setAssign({ room: room.id, email: "" })}>Verwalter einsetzen</button>
)}
</li>
))}
</ul>
{!items.length ? <p className="muted">Es gibt noch keinen gemeinsamen Datenraum.</p> : null}
{assign.room ? (
<form onSubmit={submit} className="card stack" aria-label="Verwalter einsetzen">
<h2>Verwalter einsetzen</h2>
<p className="muted">Nur für Räume ohne aktiven Verwalter. Die Aktion wird protokolliert.</p>
<label>
E-Mail eines aktiven Kontos
<input type="email" value={assign.email} onChange={(event) => setAssign({ ...assign, email: event.target.value })} required />
</label>
<div className="row">
<button type="submit">Einsetzen</button>
<button type="button" className="quiet" onClick={() => setAssign({ room: "", email: "" })}>Abbrechen</button>
</div>
</form>
) : null}
</main>
);
}
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 (
<main className="page">
<header className="page-head">
<div>
<p className="muted"><Link to="/settings">Verwaltung</Link></p>
<h1>Verwaltungsprotokoll</h1>
<p className="muted">Konten, Anmeldungen, Datenräume, Rollen und Einladungen. Ohne E-Mail-Adressen und Geheimnisse.</p>
</div>
</header>
<ErrorNote error={error} />
<ul className="index">
{items.map((event) => (
<li key={event.id}>
<strong>{event.label}</strong>
<span>
{formatWhen(event.occurred_at)}
{event.actor ? ` · von ${event.actor}` : ""}
{event.subject ? ` · betrifft ${event.subject}` : ""}
{event.room ? ` · Raum ${event.room}` : ""}
</span>
</li>
))}
</ul>
{!items.length && !error ? <p className="muted">Noch keine Einträge.</p> : null}
{next !== null ? (
<div className="row">
<button type="button" className="quiet" onClick={() => load(next).catch((err) => setError(err.message))}>Weitere laden</button>
</div>
) : null}
</main>
);
}
+76
View File
@@ -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 (
<main className="page">
<header className="page-head">
<div>
<h1>Einladung annehmen</h1>
<p className="muted">Lege deinen Namen und ein Passwort fest. Danach bist du im eingeladenen Datenraum angemeldet.</p>
</div>
</header>
{!token ? (
<p className="error">Dem Link fehlt der Einladungsschlüssel. Bitte die einladende Person um einen neuen Link.</p>
) : (
<form onSubmit={submit} className="card stack">
<label>
Name
<input value={name} onChange={(event) => setName(event.target.value)} required maxLength={120} />
</label>
<label>
Passwort
<input type="password" autoComplete="new-password" value={password} onChange={(event) => setPassword(event.target.value)} required minLength={10} />
</label>
<label>
Passwort wiederholen
<input type="password" autoComplete="new-password" value={repeat} onChange={(event) => setRepeat(event.target.value)} required />
</label>
<ErrorNote error={error} />
<div className="row">
<button type="submit" disabled={pending}>{pending ? "Wird eingerichtet …" : "Konto einrichten"}</button>
</div>
</form>
)}
</main>
);
}
+281
View File
@@ -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 (
<main className="page">
<header className="page-head">
<div>
<h1>Nutzer</h1>
<p className="muted">Neue Konten legt der Betreiber an. Jedes Konto erhält einen eigenen persönlichen Datenraum.</p>
</div>
<button type="button" onClick={() => { setError(""); setIssued(null); setOpen(true); }}>Nutzer anlegen</button>
</header>
<ErrorNote error={open ? "" : error} />
{issued ? (
<OneTimeSecret
title={`Einmal-Passwort für ${issued.name}`}
value={issued.password}
hint={`Gib es ${issued.email} persönlich weiter. Beim ersten Anmelden legt die Person ein eigenes Passwort fest. Der Wert wird nicht wieder angezeigt.`}
onDone={() => setIssued(null)}
/>
) : null}
<label className="inline">
Anzeige
<select value={filter} onChange={(event) => setFilter(event.target.value)}>
<option value="">Alle Konten</option>
<option value="active">Aktiv</option>
<option value="disabled">Deaktiviert</option>
</select>
</label>
<div className="tiles">
{items.map((account) => {
const state = accountState(account);
return (
<Link key={account.id} to={`/users/${account.id}`} className="tile">
<span className="tile__kind">{accountRole(account)} · {state.label}</span>
<strong>{account.display_name}</strong>
<span>{account.email}</span>
<span>Letzte Anmeldung: {formatWhen(account.last_login_at)}</span>
</Link>
);
})}
</div>
{!items.length ? <p className="muted">Keine Konten in dieser Anzeige.</p> : null}
<Modal open={open} title="Nutzer anlegen" onClose={close}>
<form onSubmit={submit} className="stack">
<label>
Name
<input value={displayName} onChange={(event) => { setDisplayName(event.target.value); markDirty(true); }} required maxLength={120} />
</label>
<label>
E-Mail
<input type="email" autoComplete="off" value={email} onChange={(event) => { setEmail(event.target.value); markDirty(true); }} required />
</label>
<label className="check">
<input type="checkbox" checked={operator} onChange={(event) => setOperator(event.target.checked)} />
Als Betreiber anlegen
</label>
<p className="muted">Tsumugu erzeugt ein Einmal-Passwort und zeigt es dir danach einmal an.</p>
<ErrorNote error={error} />
<button type="submit" disabled={pending}>{pending ? "Wird angelegt …" : "Nutzer anlegen"}</button>
</form>
</Modal>
</main>
);
}
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 (
<main className="page">
<header className="page-head">
<div>
<p className="muted"><Link to="/users">Nutzer</Link></p>
<h1>{account?.display_name || "Konto"}</h1>
{account ? <p className="muted">{account.email} · {accountRole(account)} · {accountState(account).label}</p> : null}
</div>
</header>
<ErrorNote error={error} />
{notice ? <p className="notice" role="status">{notice}</p> : null}
{issued ? (
<OneTimeSecret
title="Neues Einmal-Passwort"
value={issued}
hint="Alle Sitzungen des Kontos sind beendet. Beim nächsten Anmelden legt die Person ein eigenes Passwort fest. Der Wert wird nicht wieder angezeigt."
onDone={() => setIssued("")}
/>
) : null}
{account ? (
<div className="stack">
<section className="card stack" aria-label="Stammdaten">
<h2>Stammdaten</h2>
<form
className="inline"
onSubmit={(event) => {
event.preventDefault();
run(() => patch({ display_name: name }), "Der Name ist gespeichert.");
}}
>
<input value={name} onChange={(event) => setName(event.target.value)} required maxLength={120} aria-label="Name" />
<button type="submit" disabled={name.trim() === account.display_name}>Name speichern</button>
</form>
<p className="muted">Letzte Anmeldung: {formatWhen(account.last_login_at)} · Aktive Sitzungen: {account.active_sessions}</p>
</section>
<section className="card stack" aria-label="Betreiberrolle">
<h2>Betreiberrolle</h2>
<p className="muted">Betreiber verwalten Konten und Räume. Sie erhalten dadurch keinen Zugriff auf Akten anderer.</p>
{confirm === "operator" ? (
<div className="row">
<button type="button" className="danger" onClick={() => run(() => patch({ is_operator: !account.is_superadmin }), "Die Rolle ist geändert.")}>
{account.is_superadmin ? "Betreiberrolle wirklich entziehen" : "Wirklich zum Betreiber machen"}
</button>
<button type="button" className="quiet" onClick={() => setConfirm("")}>Abbrechen</button>
</div>
) : (
<div className="row">
<button type="button" className="quiet" disabled={disabled} onClick={() => setConfirm("operator")}>
{account.is_superadmin ? "Betreiberrolle entziehen" : "Zum Betreiber machen"}
</button>
</div>
)}
{!account.is_superadmin ? <p className="muted">Beim Befördern wird die Person abgemeldet und meldet sich neu an.</p> : null}
</section>
<section className="card stack" aria-label="Zugang">
<h2>Zugang</h2>
<div className="row">
<button type="button" className="quiet" disabled={disabled || own} onClick={reset}>Passwort zurücksetzen</button>
<button
type="button"
className="quiet"
onClick={() => run(async () => {
const result = await api(`/api/v1/accounts/${id}/sessions/revoke`, { method: "POST" });
setNotice(`${result.revoked} Sitzung(en) beendet.`);
})}
>
Alle Sitzungen beenden
</button>
</div>
{own ? <p className="muted">Dein eigenes Passwort änderst du unter <Link to="/account">Mein Konto</Link>.</p> : null}
{disabled ? (
<div className="row">
<button type="button" onClick={() => run(() => patch({ status: "active" }), "Das Konto ist wieder aktiv.")}>Konto wieder aktivieren</button>
</div>
) : confirm === "disable" ? (
<div className="row">
<button type="button" className="danger" onClick={() => run(() => patch({ status: "disabled" }), "Das Konto ist deaktiviert.")}>Konto wirklich deaktivieren</button>
<button type="button" className="quiet" onClick={() => setConfirm("")}>Abbrechen</button>
</div>
) : (
<div className="row">
<button type="button" className="danger" disabled={own} onClick={() => setConfirm("disable")}>Konto deaktivieren</button>
</div>
)}
<p className="muted">Ein deaktiviertes Konto kann sich nicht anmelden. Seine Akten, Notizen und das Protokoll bleiben erhalten.</p>
</section>
<section className="card stack" aria-label="Datenräume">
<h2>Gemeinsame Datenräume</h2>
{account.rooms.length ? (
<ul className="index">
{account.rooms.map((room) => (
<li key={room.id}>
<strong>{room.name}</strong>
<span>{roleLabel(room.role)}{room.status === "archived" ? " · archiviert" : ""}</span>
</li>
))}
</ul>
) : (
<p className="muted">Keine Mitgliedschaft in einem gemeinsamen Datenraum.</p>
)}
</section>
</div>
) : null}
</main>
);
}
+59
View File
@@ -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" });
}
+51
View File
@@ -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);
});
+85
View File
@@ -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 (
<section className="card stack" role="status" aria-label={title}>
<h2>{title}</h2>
<label>
<span className="visually-hidden">{title}</span>
<input readOnly value={value} onFocus={(event) => event.target.select()} />
</label>
<p className="muted">{hint || "Dieser Wert wird nur jetzt angezeigt und nicht gespeichert."}</p>
<div className="row">
<button type="button" onClick={copy}>{copied ? "Kopiert" : "Kopieren"}</button>
{onDone ? <button type="button" className="quiet" onClick={onDone}>Fertig</button> : null}
</div>
</section>
);
}
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 (
<form onSubmit={submit} className="stack">
<label>
Aktuelles Passwort
<input type="password" autoComplete="current-password" value={current} onChange={(event) => setCurrent(event.target.value)} required />
</label>
<label>
Neues Passwort
<input type="password" autoComplete="new-password" value={next} onChange={(event) => setNext(event.target.value)} required minLength={10} />
<span className="muted">Mindestens 10 Zeichen.</span>
</label>
<label>
Neues Passwort wiederholen
<input type="password" autoComplete="new-password" value={repeat} onChange={(event) => setRepeat(event.target.value)} required />
</label>
<ErrorNote error={error} />
<div className="row">
<button type="submit" disabled={pending}>{pending ? "Wird gespeichert …" : submitLabel}</button>
</div>
</form>
);
}
+210 -28
View File
@@ -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 (
<select value={value} onChange={(event) => onChange(event.target.value)} disabled={disabled} aria-label={label}>
{ROOM_ROLES.map((role) => <option key={role.value} value={role.value}>{role.label}</option>)}
</select>
);
}
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 (
<section className="card stack" aria-label={`Verwaltung von ${room.name}`}>
<h2>{room.name}</h2>
<ErrorNote error={error} />
{notice ? <p className="notice" role="status">{notice}</p> : null}
<form onSubmit={rename} className="inline">
<input value={name} onChange={(event) => { setName(event.target.value); markDirty(true); }} aria-label="Name des Datenraums" required maxLength={160} />
<button type="submit" disabled={name.trim() === room.name}>Umbenennen</button>
</form>
<h3>Mitglieder</h3>
<ul className="index">
{members.map((member) => (
<li key={member.subject_id}>
<strong>{member.display_name}</strong>
<span>{member.email}{member.account_status === "disabled" ? " · Konto deaktiviert" : ""}</span>
<RoleSelect
value={member.role}
label={`Rolle von ${member.display_name}`}
disabled={guarded.has(member.subject_id)}
onChange={(next) => run(() => api(`/api/v1/rooms/${room.id}/members/${member.subject_id}`, { method: "PATCH", body: { role: next } }), "Die Rolle ist geändert.")}
/>
<button
type="button"
className="quiet"
disabled={guarded.has(member.subject_id)}
onClick={() => run(() => api(`/api/v1/rooms/${room.id}/members/${member.subject_id}`, { method: "DELETE" }), "Das Mitglied ist entfernt.")}
>
Entfernen
</button>
</li>
))}
</ul>
{guarded.size ? <p className="muted">Der letzte Verwalter bleibt Verwalter. Ernenne zuerst eine weitere Person.</p> : null}
<ul className="muted">
{ROOM_ROLES.map((item) => <li key={item.value}><strong>{item.label}:</strong> {item.hint}</li>)}
</ul>
<form onSubmit={add} className="inline">
<input type="email" value={email} onChange={(event) => { setEmail(event.target.value); markDirty(true); }} placeholder="E-Mail eines bestehenden Kontos" aria-label="E-Mail eines bestehenden Kontos" required />
<RoleSelect value={role} onChange={setRole} label="Rolle des neuen Mitglieds" />
<button type="submit">Mitglied hinzufügen</button>
</form>
<h3>Einladungen</h3>
<p className="muted">Für Personen ohne Konto. Du erhältst einen Link, den du selbst weitergibst. Er gilt 7 Tage und einmal.</p>
{link ? <OneTimeSecret title="Einladungslink" value={link} onDone={() => setLink("")} /> : null}
<form onSubmit={invite} className="inline">
<input type="email" value={inviteMail} onChange={(event) => { setInviteMail(event.target.value); markDirty(true); }} placeholder="E-Mail der eingeladenen Person" aria-label="E-Mail der eingeladenen Person" required />
<RoleSelect value={inviteRole} onChange={setInviteRole} label="Rolle der eingeladenen Person" />
<button type="submit">Einladung erstellen</button>
</form>
{invitations.length ? (
<ul className="index">
{invitations.map((item) => (
<li key={item.id}>
<strong>{item.email}</strong>
<span>{roleLabel(item.role)} · gültig bis {formatWhen(item.expires_at)}</span>
<button type="button" className="quiet" onClick={() => run(() => api(`/api/v1/rooms/${room.id}/invitations/${item.id}`, { method: "DELETE" }), "Die Einladung ist widerrufen.")}>Widerrufen</button>
</li>
))}
</ul>
) : <p className="muted">Keine offenen Einladungen.</p>}
<h3>Archivieren</h3>
{confirmArchive ? (
<div className="row">
<button type="button" className="danger" onClick={archive}>Datenraum wirklich archivieren</button>
<button type="button" className="quiet" onClick={() => setConfirmArchive(false)}>Abbrechen</button>
</div>
) : (
<div className="row">
<button type="button" className="danger" onClick={() => setConfirmArchive(true)}>Datenraum archivieren</button>
</div>
)}
<p className="muted">Ein archivierter Datenraum lässt sich nicht mehr wählen. Seine Inhalte bleiben erhalten, du kannst ihn unten wieder aktivieren.</p>
</section>
);
}
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 (
<main className="page">
<header className="page-head">
@@ -59,29 +234,36 @@ export function Rooms() {
{session.rooms.map((room) => (
<li key={room.id}>
<strong>{room.name}</strong>
<span>{room.kind === "personal" ? "Persönlich" : room.role === "manager" ? "Gemeinsam, Verwalter" : "Gemeinsam"}</span>
<span>{room.kind === "personal" ? "Persönlich" : `Gemeinsam · ${roleLabel(room.role)}`}</span>
</li>
))}
</ul>
<form onSubmit={create} className="inline">
<input value={name} onChange={(event) => { setName(event.target.value); markDirty(true); }} placeholder="Name des gemeinsamen Datenraums" required />
<input value={name} onChange={(event) => { setName(event.target.value); markDirty(true); }} placeholder="Name des gemeinsamen Datenraums" aria-label="Name des gemeinsamen Datenraums" required />
<button type="submit">Datenraum anlegen</button>
</form>
<ErrorNote error={error} />
{current?.kind === "organization" && current.role === "manager" ? (
<section className="card">
<h2>Mitglieder in {current.name}</h2>
<ul>
{members.map((member) => (
<li key={member.subject_id}>{member.display_name} · {member.email} · {member.role === "manager" ? "Verwalter" : "Mitglied"}</li>
<RoomAdmin key={current.id} room={current} onRenamed={refresh} onArchived={afterArchive} />
) : current?.kind === "organization" ? (
<p className="muted">Mitglieder und Rollen von {current.name} verwalten die Verwalter des Raums.</p>
) : (
<p className="muted">Wechsle in einen gemeinsamen Datenraum, um seine Mitglieder zu verwalten.</p>
)}
{archived.length ? (
<section className="card stack" aria-label="Archivierte Datenräume">
<h2>Archivierte Datenräume</h2>
<ul className="index">
{archived.map((room) => (
<li key={room.id}>
<strong>{room.name}</strong>
<span>{roleLabel(room.role)}</span>
{room.role === "manager" ? <button type="button" className="quiet" onClick={() => restore(room)}>Wieder aktivieren</button> : null}
</li>
))}
</ul>
<form onSubmit={addMember} className="inline">
<input type="email" value={email} onChange={(event) => setEmail(event.target.value)} placeholder="E-Mail eines bestehenden Kontos" required />
<button type="submit">Mitglied hinzufügen</button>
</form>
</section>
) : null}
<ErrorNote error={error} />
</main>
);
}
+22 -5
View File
@@ -23,12 +23,29 @@ export function Settings() {
<strong>Quellen</strong>
<span>Paperless und E-Mail</span>
</Link>
<Link className="tile" to="/account">
<span className="tile__kind">Verwaltung</span>
<strong>Mein Konto</strong>
<span>Passwort und Geräte</span>
</Link>
{session?.account?.is_superadmin ? (
<Link className="tile" to="/users">
<span className="tile__kind">Verwaltung</span>
<strong>Nutzer</strong>
<span>Konten anlegen</span>
</Link>
<>
<Link className="tile" to="/users">
<span className="tile__kind">Betreiber</span>
<strong>Nutzer</strong>
<span>Konten, Rollen, Zugang</span>
</Link>
<Link className="tile" to="/admin/rooms">
<span className="tile__kind">Betreiber</span>
<strong>Alle Datenräume</strong>
<span>Übersicht ohne Inhalte</span>
</Link>
<Link className="tile" to="/admin/events">
<span className="tile__kind">Betreiber</span>
<strong>Verwaltungsprotokoll</strong>
<span>Wer hat was geändert</span>
</Link>
</>
) : null}
</div>
</main>
+1 -1
View File
@@ -172,7 +172,7 @@ export function Shell() {
<span className="rail__label">Verwaltung</span>
</NavLink>
<div className="rail__user">
<span className="avatar" title={session.account.display_name}>{initials(session.account.display_name)}</span>
<NavLink to="/account" className="avatar" title="Mein Konto" aria-label="Mein Konto">{initials(session.account.display_name)}</NavLink>
<span className="rail__user-name">{session.account.display_name}</span>
<button type="button" className="icon-button rail__logout" aria-label="Abmelden" onClick={logout}>
<NavIcon name="logout" />
-92
View File
@@ -1,92 +0,0 @@
import { useEffect, useState } from "react";
import { api, markDirty } from "../api.js";
import { Modal } from "./Modal.jsx";
import { ErrorNote } from "./widgets.jsx";
export function Users() {
const [items, setItems] = useState([]);
const [open, setOpen] = useState(false);
const [email, setEmail] = useState("");
const [displayName, setDisplayName] = useState("");
const [password, setPassword] = useState("");
const [error, setError] = useState("");
const [pending, setPending] = useState(false);
function load() {
return api("/api/v1/accounts")
.then((data) => setItems(data.items))
.catch((err) => setError(err.message));
}
useEffect(() => {
load();
}, []);
function close() {
setOpen(false);
setError("");
markDirty(false);
}
async function submit(event) {
event.preventDefault();
setPending(true);
setError("");
try {
await api("/api/v1/accounts", {
method: "POST",
body: { email, display_name: displayName, password },
});
setEmail("");
setDisplayName("");
setPassword("");
markDirty(false);
setOpen(false);
await load();
} catch (err) {
setError(err.message);
} finally {
setPending(false);
}
}
return (
<main className="page">
<header className="page-head">
<div>
<h1>Nutzer</h1>
<p className="muted">Neue Konten legt der Betreiber an. Jedes Konto erhält einen eigenen persönlichen Datenraum.</p>
</div>
<button type="button" onClick={() => { setError(""); setOpen(true); }}>Nutzer anlegen</button>
</header>
<ErrorNote error={open ? "" : error} />
<div className="tiles">
{items.map((account) => (
<article key={account.id} className="tile">
<p className="tile__kind">{account.is_superadmin ? "Betreiber" : "Nutzer"}</p>
<h2>{account.display_name}</h2>
<p className="muted">{account.email}</p>
</article>
))}
</div>
<Modal open={open} title="Nutzer anlegen" onClose={close}>
<form onSubmit={submit} className="stack">
<label>
Name
<input value={displayName} onChange={(event) => { setDisplayName(event.target.value); markDirty(true); }} required maxLength={120} />
</label>
<label>
E-Mail
<input type="email" autoComplete="off" value={email} onChange={(event) => { setEmail(event.target.value); markDirty(true); }} required />
</label>
<label>
Passwort
<input type="password" autoComplete="new-password" value={password} onChange={(event) => { setPassword(event.target.value); markDirty(true); }} required minLength={10} />
</label>
<ErrorNote error={error} />
<button type="submit" disabled={pending}>{pending ? "Wird angelegt …" : "Nutzer anlegen"}</button>
</form>
</Modal>
</main>
);
}