Files
tsumugu/backend/app/api/accounts.py
T
LarsandClaude Sonnet 5.5 6d7b7c5f85
Deploy Development / deploy (push) Successful in 45s
Test Suite / pytest-backend (push) Successful in 5m20s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Führe Hauptnutzer und Mitarbeiter ein, damit der Betreiber Kunden und Hauptnutzer ihre Teams verwalten.
Eine Einladung erzeugt jetzt ein Mitarbeiter-Konto mit dem Eigentümer des Raums als Förderer. Mitarbeiter arbeiten nur in den eingeladenen Räumen nach ihrer Rolle, legen keine Räume und im persönlichen Raum nichts an und starten ihre Sitzung im Team-Raum. Einladen darf nur der Eigentümer als Hauptnutzer; nur ein Hauptnutzer kann Raum-Eigentümer sein. Hauptnutzer sehen unter Mein Team die Personen in ihren Räumen und verwalten ihre Mitarbeiter (deaktivieren, Einmal-Passwort, aus Räumen entfernen). Der Betreiber sieht die Team-Übersicht mit CSV-Export und macht einen Mitarbeiter zum Hauptnutzer.

Eine zentrale Prüfstelle für Grenzen (access/limits.py) wird beim Anlegen von Räumen und beim Aufnehmen und Einladen von Mitgliedern aufgerufen; Tarife folgen später.

Die lokale Suite läuft mit 143 Tests grün, der Frontend-Build und 24 Node-Tests ebenfalls. Die Oberfläche wurde noch nicht im Browser bedient.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 09:03:40 +02:00

274 lines
9.9 KiB
Python

"""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 (
promote_to_main,
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"]),
"account_kind": row["account_kind"],
"sponsor_id": str(row["sponsor_id"]) if row["sponsor_id"] else None,
"sponsor_name": row.get("sponsor_name"),
}
@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,
account_kind, sponsor_id,
(SELECT s.display_name FROM auth_accounts s WHERE s.id = auth_accounts.sponsor_id) AS sponsor_name
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,
account_kind, sponsor_id,
(SELECT s.display_name FROM auth_accounts s WHERE s.id = auth_accounts.sponsor_id) AS sponsor_name
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"]
employees = conn.execute(
"""
SELECT id, display_name, email, status FROM auth_accounts
WHERE sponsor_id = %s ORDER BY display_name, id
""",
(account_id,),
).fetchall()
body["employees"] = [
{"id": str(e["id"]), "display_name": e["display_name"], "email": e["email"], "status": e["status"]} for e in employees
]
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,
"account_kind": account["account_kind"],
}
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.account_kind == "main":
promote_to_main(conn, principal.account_id, account_id)
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,
account_kind, sponsor_id,
(SELECT s.display_name FROM auth_accounts s WHERE s.id = auth_accounts.sponsor_id) AS sponsor_name
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}