Jeder Datenraum hat einen Eigentümer, der Verwalter bleibt, den Raum übertragen kann und im Notfall vom Betreiber ersetzt wird. Neue Akten und Vorgänge folgen der Voreinstellung des Raums: Bei "im Raum teilen" lesen Leser sie und bearbeiten Mitglieder und Verwalter; Weitergeben und Löschen bleiben beim Owner, der eine Akte privat stellen oder einzelne Personen ausnehmen kann. Bestehende Akten bleiben privat. Beim ersten weiteren Mitglied zeigt die Oberfläche, was sichtbar wird. Das Löschen von Akte und Vorgang verlangt jetzt den Owner statt nur das Bearbeitungsrecht und schließt damit R-01. Die Rechte der Raumfreigabe gelten nur bei aktivem Raum, aktiver Mitgliedschaft und aktivem Konto. Die lokale Suite läuft mit 128 Tests grün, der Frontend-Build und 19 Node-Tests ebenfalls. Die Oberfläche wurde noch nicht im Browser bedient. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
636 lines
24 KiB
Python
636 lines
24 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.roles import (
|
|
ROOM_ROLES,
|
|
count_active_managers,
|
|
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,
|
|
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:
|
|
room = _room(conn, room_id)
|
|
if 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 _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, 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)):
|
|
room_id = uuid4()
|
|
name = body.name.strip()
|
|
conn.execute(
|
|
"""
|
|
INSERT INTO data_rooms (id, kind, name, created_by, owner_id, default_visibility)
|
|
VALUES (%s, 'organization', %s, %s, %s, %s)
|
|
""",
|
|
(room_id, name, principal.account_id, principal.account_id, body.default_visibility),
|
|
)
|
|
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 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)):
|
|
"""How many of the own cases and matters in this room are private or shared with the room."""
|
|
_room(conn, room_id)
|
|
if room_role(conn, principal.account_id, room_id) is None:
|
|
raise forbidden()
|
|
result: dict = {}
|
|
for table, key in (("cases", "cases"), ("matters", "matters")):
|
|
rows = conn.execute(
|
|
f"""
|
|
SELECT visibility, count(*) AS n FROM {table}
|
|
WHERE home_scope_id = %s AND owner_subject_id = %s AND deleted_at IS NULL
|
|
GROUP BY visibility
|
|
""",
|
|
(room_id, principal.account_id),
|
|
).fetchall()
|
|
counts = {"private": 0, "room": 0}
|
|
counts.update({row["visibility"]: row["n"] for row in rows})
|
|
result[key] = counts
|
|
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),
|
|
):
|
|
"""Set the room share of every own case and matter in this room at once."""
|
|
_room(conn, room_id)
|
|
if room_role(conn, principal.account_id, room_id) is None:
|
|
raise forbidden()
|
|
changed = 0
|
|
for table in ("cases", "matters"):
|
|
rows = conn.execute(
|
|
f"""
|
|
UPDATE {table} SET visibility = %s
|
|
WHERE home_scope_id = %s AND owner_subject_id = %s AND deleted_at IS NULL AND visibility <> %s
|
|
RETURNING id
|
|
""",
|
|
(body.visibility, room_id, principal.account_id, body.visibility),
|
|
).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()
|
|
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,
|
|
}
|
|
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")
|
|
_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),
|
|
)
|
|
_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"}
|
|
|
|
|
|
@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()
|
|
_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,
|
|
)
|