Files
LarsandClaude Opus 5.5 15e0dc7e52
Deploy Development / deploy (push) Successful in 46s
Test Suite / pytest-backend (push) Successful in 6m39s
Test Suite / frontend-build (push) Successful in 24s
Test Suite / smoke-dev (push) Successful in 0s
Gib verknüpfte Originale im Datenraum je Person über die eigenen Zugänge frei, damit Raummitglieder Paperless-Dokumente und E-Mails geteilter Akten lesen können.
Die Raumfreigabe allein gab die Zugänge des Owners nicht weiter. Ein Leser im Raum sah die Akte,
aber kein Original. Neu ist room_source_access: Wer im Raum teilen darf, schaltet für ein Mitglied
„Originale über meine Zugänge“ ein. Das gilt für alle eigenen, mit dem Raum geteilten Einträge.
Ausnahmen, Ende der Raumfreigabe und Verlassen des Raums schließen den Abruf. Beschluss R-01 ist
entsprechend ergänzt.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 15:19:15 +01:00

798 lines
31 KiB
Python

"""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.limits import ensure_can_add_member, ensure_can_create_room
from app.access.roles import (
ROOM_ROLES,
account_kind,
count_active_managers,
require_main_user,
require_operator,
require_room_manager,
room_role,
)
from app.api.deps import Principal, get_conn, get_principal
from app.api.schemas import (
InvitationIn,
MemberIn,
MemberRoleIn,
OperatorManagerIn,
OperatorOwnerIn,
OwnerIn,
RoomIn,
RoomPatchIn,
SourceAccessIn,
VisibilityIn,
)
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 _require_owner(conn, account_id: UUID, room_id: UUID) -> dict:
# An unknown room and a room owned by someone else answer alike: no way to probe ids.
room = conn.execute(
"SELECT * FROM data_rooms WHERE id = %s AND kind = 'organization'", (room_id,)
).fetchone()
if room is None or room["owner_id"] != account_id:
raise forbidden("Das darf nur der Eigentümer des Datenraums.")
return room
def _protect_owner(room: dict, subject_id: UUID) -> None:
if room["owner_id"] == subject_id:
raise unprocessable("Der Eigentümer bleibt Verwalter. Übertrage den Datenraum zuerst.")
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 _drop_shares_of(conn, room_id: UUID, subject_id: UUID) -> None:
"""Whoever leaves a team, or may no longer write in it, takes the shares of their own entries with them."""
conn.execute(
"""
DELETE FROM room_shares s
WHERE s.room_id = %s
AND (
(s.resource_kind = 'case' AND s.resource_id IN (SELECT id FROM cases WHERE owner_subject_id = %s))
OR (s.resource_kind = 'matter' AND s.resource_id IN (SELECT id FROM matters WHERE owner_subject_id = %s))
)
""",
(room_id, subject_id, subject_id),
)
# Without own shares in the room there is nothing left to lend.
conn.execute(
"DELETE FROM room_source_access WHERE room_id = %s AND owner_id = %s",
(room_id, subject_id),
)
def _drop_source_access_to(conn, room_id: UUID, subject_id: UUID) -> None:
"""A person who leaves the team loses every source access lent to them there. A return starts without it."""
conn.execute(
"DELETE FROM room_source_access WHERE room_id = %s AND subject_id = %s",
(room_id, subject_id),
)
def _lent_to(conn, room_id: UUID, owner_id: UUID) -> set[UUID]:
rows = conn.execute(
"SELECT subject_id FROM room_source_access WHERE room_id = %s AND owner_id = %s",
(room_id, owner_id),
).fetchall()
return {row["subject_id"] for row in rows}
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)
_drop_shares_of(conn, room_id, subject_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, r.owner_id
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",
"is_owner": row["owner_id"] == principal.account_id,
}
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)):
require_main_user(conn, principal.account_id)
ensure_can_create_room(conn, principal.account_id)
room_id = uuid4()
name = body.name.strip()
conn.execute(
"""
INSERT INTO data_rooms (id, kind, name, created_by, owner_id, default_visibility, download_roles)
SELECT %s, 'organization', %s, %s, %s, %s,
jsonb_build_object(
'manager', COALESCE((download_defaults ->> 'manager')::boolean, true),
'member', COALESCE((download_defaults ->> 'member')::boolean, true),
'reader', COALESCE((download_defaults ->> 'reader')::boolean, true)
)
FROM auth_accounts WHERE id = %s
""",
(room_id, name, principal.account_id, principal.account_id, body.default_visibility, 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, "default_visibility": body.default_visibility},
)
@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.default_visibility is not None and body.default_visibility != room["default_visibility"]:
_require_owner(conn, principal.account_id, room_id)
conn.execute("UPDATE data_rooms SET default_visibility = %s WHERE id = %s", (body.default_visibility, room_id))
audit(
conn,
principal.account_id,
room_id,
"room_default_changed",
"room",
room_id,
detail={"visibility": body.default_visibility},
)
if body.status is not None and body.status != room["status"]:
_require_owner(conn, principal.account_id, room_id)
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"],
"default_visibility": row["default_visibility"],
}
def _set_owner(conn, actor: UUID, room_id: UUID, new_owner: UUID, previous: UUID | None) -> None:
conn.execute("UPDATE data_rooms SET owner_id = %s WHERE id = %s", (new_owner, room_id))
conn.execute(
"""
INSERT INTO room_memberships (room_id, subject_id, role, status)
VALUES (%s, %s, 'manager', 'active')
ON CONFLICT (room_id, subject_id) DO UPDATE SET role = 'manager', status = 'active'
""",
(room_id, new_owner),
)
audit(
conn,
actor,
room_id,
"room_owner_changed",
"room",
room_id,
detail={"from": str(previous) if previous else None, "to": str(new_owner)},
)
@router.post("/api/v1/rooms/{room_id}/owner")
def transfer_owner(
room_id: UUID,
body: OwnerIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
"""The owner hands the room to an active member. The new owner becomes manager."""
room = _require_owner(conn, principal.account_id, room_id)
target = _membership(conn, room_id, body.subject_id, lock=True)
account = conn.execute("SELECT status FROM auth_accounts WHERE id = %s", (body.subject_id,)).fetchone()
if target is None or target["status"] != "active" or account is None or account["status"] != "active":
raise unprocessable("Der Datenraum geht nur an ein aktives Mitglied.")
if account_kind(conn, body.subject_id) != "main":
raise unprocessable("Ein Mitarbeiter-Konto kann keinen Datenraum besitzen.")
if body.subject_id == room["owner_id"]:
raise unprocessable("Diese Person ist bereits Eigentümer.")
_set_owner(conn, principal.account_id, room_id, body.subject_id, room["owner_id"])
return {"owner_id": str(body.subject_id)}
@router.get("/api/v1/rooms/{room_id}/exposure")
def exposure(room_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
"""Own cases and matters: shared with this room (`room`) or filed here but not shared (`private`)."""
if room_role(conn, principal.account_id, room_id) is None:
raise forbidden()
result: dict = {}
for table, kind in (("cases", "case"), ("matters", "matter")):
row = conn.execute(
f"""
SELECT
count(*) FILTER (WHERE EXISTS (
SELECT 1 FROM room_shares s
WHERE s.resource_kind = %s AND s.resource_id = t.id AND s.room_id = %s)) AS shared,
count(*) FILTER (WHERE t.home_scope_id = %s AND NOT EXISTS (
SELECT 1 FROM room_shares s
WHERE s.resource_kind = %s AND s.resource_id = t.id AND s.room_id = %s)) AS filed
FROM {table} t
WHERE t.owner_subject_id = %s AND t.deleted_at IS NULL
""",
(kind, room_id, room_id, kind, room_id, principal.account_id),
).fetchone()
result[table] = {"room": row["shared"], "private": row["filed"]}
return JSONResponse(result, headers=_NO_STORE)
@router.post("/api/v1/rooms/{room_id}/my-content/visibility")
def set_my_content(
room_id: UUID,
body: VisibilityIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
"""`room`: share every own entry filed in this room with it. `private`: end all own shares to it."""
role = room_role(conn, principal.account_id, room_id)
if role is None:
raise forbidden()
changed = 0
if body.visibility == "room":
if role not in {"member", "manager"}:
raise forbidden("Als Leser kannst du nichts mit dem Datenraum teilen.")
for table, kind in (("cases", "case"), ("matters", "matter")):
rows = conn.execute(
f"""
INSERT INTO room_shares (resource_kind, resource_id, room_id, access, created_by)
SELECT %s, t.id, %s, 'edit', %s FROM {table} t
WHERE t.home_scope_id = %s AND t.owner_subject_id = %s AND t.deleted_at IS NULL
ON CONFLICT DO NOTHING
RETURNING id
""",
(kind, room_id, principal.account_id, room_id, principal.account_id),
).fetchall()
changed += len(rows)
else:
for table, kind in (("cases", "case"), ("matters", "matter")):
rows = conn.execute(
f"""
DELETE FROM room_shares s
WHERE s.room_id = %s AND s.resource_kind = %s
AND s.resource_id IN (SELECT id FROM {table} WHERE owner_subject_id = %s)
RETURNING s.id
""",
(room_id, kind, principal.account_id),
).fetchall()
changed += len(rows)
if changed:
audit(
conn,
principal.account_id,
room_id,
"visibility_changed",
"room",
room_id,
detail={"visibility": body.visibility, "count": changed},
)
return {"changed": changed}
@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)
owner_id = _room(conn, room_id)["owner_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()
lent = _lent_to(conn, room_id, principal.account_id)
return {
"items": [
{
"subject_id": str(row["subject_id"]),
"email": row["email"],
"display_name": row["display_name"],
"role": row["role"],
"account_status": row["status"],
"is_owner": row["subject_id"] == owner_id,
"is_self": row["subject_id"] == principal.account_id,
"my_sources": row["subject_id"] in lent,
}
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 body.role != "manager":
_protect_owner(_room(conn, room_id), account["id"])
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")
if not was_active:
ensure_can_add_member(conn, _room(conn, room_id)["owner_id"], room_id)
_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}
_protect_owner(_room(conn, room_id), subject_id)
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()
_protect_owner(_room(conn, room_id), subject_id)
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),
)
_drop_shares_of(conn, room_id, subject_id)
_drop_source_access_to(conn, room_id, subject_id)
# The removed person works in the personal room again; own entries stay visible there.
conn.execute(
"""
UPDATE auth_sessions
SET scope_kind = 'personal', scope_id = account_id, epoch = epoch + 1
WHERE account_id = %s AND scope_id = %s AND revoked_at IS NULL
""",
(subject_id, room_id),
)
_audit_membership(conn, principal.account_id, room_id, subject_id, "membership_removed")
return Response(status_code=204)
@router.put("/api/v1/rooms/{room_id}/source-access/{subject_id}")
def put_source_access(
room_id: UUID,
subject_id: UUID,
body: SourceAccessIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
"""Lend the own connectors to one member for the own entries shared with this room.
Only the person whose connectors are used decides. That is anyone who may share into the room.
"""
actor = principal.account_id
room = conn.execute(
"SELECT id, status FROM data_rooms WHERE id = %s AND kind = 'organization'", (room_id,)
).fetchone()
if room is None or room_role(conn, actor, room_id) is None:
raise not_found()
if room["status"] != "active":
raise unprocessable("Der Datenraum ist archiviert.")
if room_role(conn, actor, room_id) not in {"member", "manager"}:
raise forbidden("Quellen gibt frei, wer in diesem Datenraum teilen darf.")
if subject_id == actor:
raise unprocessable("Die eigenen Zugänge brauchen keine Freigabe.")
if room_role(conn, subject_id, room_id) is None:
raise not_found()
if body.enabled:
created = conn.execute(
"""
INSERT INTO room_source_access (room_id, owner_id, subject_id)
VALUES (%s, %s, %s)
ON CONFLICT DO NOTHING
RETURNING subject_id
""",
(room_id, actor, subject_id),
).fetchone()
changed = created is not None
else:
removed = conn.execute(
"""
DELETE FROM room_source_access
WHERE room_id = %s AND owner_id = %s AND subject_id = %s
RETURNING subject_id
""",
(room_id, actor, subject_id),
).fetchone()
changed = removed is not None
if changed:
audit(
conn,
actor,
room_id,
"room_source_access_granted" if body.enabled else "room_source_access_revoked",
"membership",
subject_id,
detail={"room_id": str(room_id)},
)
return {"subject_id": str(subject_id), "enabled": body.enabled}
@router.post("/api/v1/invitations")
def invite(
body: InvitationIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
# Only the owner, a main user, brings new people in; they become employee accounts.
room = _require_owner(conn, principal.account_id, body.room_id)
require_main_user(conn, principal.account_id)
ensure_can_add_member(conn, room["owner_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 o.display_name FROM auth_accounts o WHERE o.id = r.owner_id) AS owner_name,
EXISTS (
SELECT 1 FROM auth_accounts o
JOIN room_memberships om ON om.subject_id = o.id AND om.room_id = r.id AND om.status = 'active'
WHERE o.id = r.owner_id AND o.status = 'active'
) AS owner_active,
(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"],
"owner": row["owner_name"],
"owner_active": row["owner_active"],
"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"}
@router.post("/api/v1/admin/rooms/{room_id}/owner")
def admin_set_owner(
room_id: UUID,
body: OperatorOwnerIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
"""The operator steps in only when the owner can no longer act: disabled or not a member any more."""
require_operator(conn, principal.account_id)
room = _room(conn, room_id)
owner = conn.execute("SELECT status FROM auth_accounts WHERE id = %s", (room["owner_id"],)).fetchone()
active_owner = bool(owner and owner["status"] == "active" and room_role(conn, room["owner_id"], room_id))
if active_owner:
raise forbidden("Der Eigentümer ist aktiv. Er überträgt den Datenraum selbst.")
account = account_by_email(conn, body.email)
if account is None or account["status"] != "active":
raise not_found()
if account_kind(conn, account["id"]) != "main":
raise unprocessable("Ein Mitarbeiter-Konto kann keinen Datenraum besitzen.")
_set_owner(conn, principal.account_id, room_id, account["id"], room["owner_id"])
return {"owner_id": str(account["id"])}
_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,
)