From 1c2f045e7dcbb4fa7884b98d99349ac2571712d9 Mon Sep 17 00:00:00 2001 From: Lars Date: Tue, 20 Oct 2026 15:40:30 +0200 Subject: [PATCH] =?UTF-8?q?F=C3=BChre=20Raum-Eigent=C3=BCmer=20und=20Raumf?= =?UTF-8?q?reigabe=20ein,=20damit=20aus=20einem=20privaten=20Raum=20ein=20?= =?UTF-8?q?Mehrbenutzer-Raum=20wird.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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 --- backend/app/access/policy.py | 67 ++++- backend/app/api/rooms.py | 183 +++++++++++++- backend/app/api/roomshare.py | 88 +++++++ backend/app/api/schemas.py | 18 ++ backend/app/auth/accounts.py | 42 +++- backend/app/main.py | 2 + backend/app/ops.py | 111 +++++++-- backend/app/present.py | 7 + backend/app/seed.py | 6 +- .../20261021T090000Z_room_access.sql | 21 ++ backend/tests/test_rights.py | 2 +- backend/tests/test_room_access.py | 231 ++++++++++++++++++ backend/tests/test_room_roles.py | 40 ++- backend/tests/test_tracking.py | 2 +- docs/architecture/API_REFERENZ.md | 8 +- docs/architecture/BENUTZERVERWALTUNG.md | 10 +- docs/architecture/DATENMODELL_IST.md | 4 +- docs/architecture/RECHTEMODELL_IST.md | 1 + docs/product/TSUMUGU_PRODUCT_SPEC.md | 6 + frontend/src/admin/RoomShare.jsx | 85 +++++++ frontend/src/admin/admin-core.js | 18 ++ frontend/src/admin/admin-core.test.mjs | 26 ++ frontend/src/pages/Cases.jsx | 2 + frontend/src/pages/Matters.jsx | 2 + frontend/src/pages/Rooms.jsx | 167 +++++++++++-- 25 files changed, 1088 insertions(+), 61 deletions(-) create mode 100644 backend/app/api/roomshare.py create mode 100644 backend/migrations/20261021T090000Z_room_access.sql create mode 100644 backend/tests/test_room_access.py create mode 100644 frontend/src/admin/RoomShare.jsx diff --git a/backend/app/access/policy.py b/backend/app/access/policy.py index b2deb9c..3756a24 100644 --- a/backend/app/access/policy.py +++ b/backend/app/access/policy.py @@ -35,6 +35,14 @@ class Rights: return cls() return cls(bool(row["can_read"]), bool(row["can_edit"]), bool(row["can_share"]), bool(row["can_delete"])) + def union(self, other: Rights) -> Rights: + return Rights( + self.read or other.read, + self.edit or other.edit, + self.share or other.share, + self.delete or other.delete, + ) + def without(self, blocked: Rights) -> Rights: return Rights( self.read and not blocked.read, @@ -50,6 +58,15 @@ class Rights: return {"read": self.read, "edit": self.edit, "share": self.share, "delete": self.delete} +# The room share: what a room role may do with a case or matter that is shared with the room. +# Sharing, deleting and ownership never come from a room role. An unknown role gets nothing. +ROOM_RIGHTS = { + "reader": Rights(read=True), + "member": Rights(read=True, edit=True), + "manager": Rights(read=True, edit=True), +} + + @dataclass(frozen=True) class Ctx: kind: str @@ -223,6 +240,29 @@ def _exceptions(conn, actor: UUID, kind: str, resource_id: UUID, context: Ctx | return blocked +def room_default(conn, actor: UUID, resource: dict) -> Rights: + """Rights of the current room members on a case or matter that is shared with the room. + + Only an active room, an active membership and an active account count. The personal + room is never shared. Anything unclear gives no rights. + """ + if resource.get("visibility") != "room": + return Rights() + row = conn.execute( + """ + SELECT m.role + FROM room_memberships m + JOIN data_rooms r ON r.id = m.room_id AND r.kind = 'organization' AND r.status = 'active' + JOIN auth_accounts a ON a.id = m.subject_id AND a.status = 'active' + WHERE m.room_id = %s AND m.subject_id = %s AND m.status = 'active' + """, + (resource["home_scope_id"], actor), + ).fetchone() + if row is None: + return Rights() + return ROOM_RIGHTS.get(row["role"], Rights()) + + def case_rights(conn, actor: UUID, case: dict) -> Rights: if case["parent_case_id"] is not None and case["rights_mode"] == "inherit_parent": parent = get_case(conn, case["parent_case_id"]) @@ -230,7 +270,7 @@ def case_rights(conn, actor: UUID, case: dict) -> Rights: elif case["owner_subject_id"] == actor: base = Rights.full() else: - base = _direct_grant(conn, actor, "case", case["id"]) + base = _direct_grant(conn, actor, "case", case["id"]).union(room_default(conn, actor, case)) return base.without(_exceptions(conn, actor, "case", case["id"], None)) @@ -244,7 +284,10 @@ def _linked(conn, matter_id: UUID, case_id: UUID) -> bool: def matter_rights(conn, actor: UUID, matter: dict, context: Ctx | None) -> Rights: if context is None: - base = Rights.full() if matter["owner_subject_id"] == actor else _direct_grant(conn, actor, "matter", matter["id"]) + if matter["owner_subject_id"] == actor: + base = Rights.full() + else: + base = _direct_grant(conn, actor, "matter", matter["id"]).union(room_default(conn, actor, matter)) return base.without(_exceptions(conn, actor, "matter", matter["id"], None)) if context.kind == "case": @@ -571,6 +614,11 @@ def list_cases(conn, actor: UUID) -> list[dict]: AND g.grantee_subject_id = %(actor)s AND NOT g.is_exception AND g.can_read AND g.context_id IS NULL ) + OR (c.visibility = 'room' AND EXISTS ( + SELECT 1 FROM room_memberships m + JOIN data_rooms r ON r.id = m.room_id AND r.kind = 'organization' AND r.status = 'active' + WHERE m.room_id = c.home_scope_id AND m.subject_id = %(actor)s AND m.status = 'active' + )) OR ( c.rights_mode = 'inherit_parent' AND c.parent_case_id IS NOT NULL AND EXISTS ( SELECT 1 FROM cases p @@ -583,6 +631,11 @@ def list_cases(conn, actor: UUID) -> list[dict]: AND g.grantee_subject_id = %(actor)s AND NOT g.is_exception AND g.can_read AND g.context_id IS NULL ) + OR (p.visibility = 'room' AND EXISTS ( + SELECT 1 FROM room_memberships pm + JOIN data_rooms r ON r.id = pm.room_id AND r.kind = 'organization' AND r.status = 'active' + WHERE pm.room_id = p.home_scope_id AND pm.subject_id = %(actor)s AND pm.status = 'active' + )) ) ) ) @@ -613,6 +666,11 @@ def list_matters(conn, actor: UUID) -> list[tuple[dict, list[dict]]]: AND g.grantee_subject_id = %(actor)s AND NOT g.is_exception AND g.can_read AND g.context_id IS NULL ) + OR (m.visibility = 'room' AND EXISTS ( + SELECT 1 FROM room_memberships mm + JOIN data_rooms r ON r.id = mm.room_id AND r.kind = 'organization' AND r.status = 'active' + WHERE mm.room_id = m.home_scope_id AND mm.subject_id = %(actor)s AND mm.status = 'active' + )) OR EXISTS ( SELECT 1 FROM matter_case_links l JOIN cases c ON c.id = l.case_id AND c.deleted_at IS NULL @@ -625,6 +683,11 @@ def list_matters(conn, actor: UUID) -> list[tuple[dict, list[dict]]]: AND g.grantee_subject_id = %(actor)s AND NOT g.is_exception AND g.can_read AND g.context_id IS NULL ) + OR (c.visibility = 'room' AND EXISTS ( + SELECT 1 FROM room_memberships cm + JOIN data_rooms r ON r.id = cm.room_id AND r.kind = 'organization' AND r.status = 'active' + WHERE cm.room_id = c.home_scope_id AND cm.subject_id = %(actor)s AND cm.status = 'active' + )) ) ) ) diff --git a/backend/app/api/rooms.py b/backend/app/api/rooms.py index 5fd0a81..b2b4d4c 100644 --- a/backend/app/api/rooms.py +++ b/backend/app/api/rooms.py @@ -15,6 +15,7 @@ from app.access.roles import ( 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 ( @@ -22,8 +23,11 @@ from app.api.schemas import ( MemberIn, MemberRoleIn, OperatorManagerIn, + OperatorOwnerIn, + OwnerIn, RoomIn, RoomPatchIn, + VisibilityIn, ) from app.auth.accounts import normalize_email from app.auth.security import hash_secret, new_secret @@ -41,6 +45,18 @@ 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: @@ -115,7 +131,7 @@ def rooms( if include_archived: archived = conn.execute( """ - SELECT r.id, r.name, m.role + 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 @@ -123,7 +139,14 @@ def rooms( (principal.account_id,), ).fetchall() items += [ - {"id": str(row["id"]), "kind": "organization", "name": row["name"], "role": row["role"], "status": "archived"} + { + "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} @@ -134,15 +157,21 @@ def create_room(body: RoomIn, principal: Principal = Depends(get_principal), con 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), + """ + 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}) + 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}") @@ -157,7 +186,20 @@ def patch_room( 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. @@ -178,12 +220,115 @@ def patch_room( room_id, ) row = _room(conn, room_id) - return {"id": str(row["id"]), "name": row["name"], "status": row["status"]} + 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 @@ -202,6 +347,7 @@ def members(room_id: UUID, principal: Principal = Depends(get_principal), conn: "display_name": row["display_name"], "role": row["role"], "account_status": row["status"], + "is_owner": row["subject_id"] == owner_id, } for row in rows ] @@ -220,6 +366,8 @@ def add_member( 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.") @@ -243,6 +391,7 @@ def change_member_role( 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) @@ -261,6 +410,7 @@ def remove_member( 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( @@ -411,6 +561,27 @@ def admin_assign_manager( 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") diff --git a/backend/app/api/roomshare.py b/backend/app/api/roomshare.py new file mode 100644 index 0000000..cb755b9 --- /dev/null +++ b/backend/app/api/roomshare.py @@ -0,0 +1,88 @@ +"""Room share of a case or matter: shared with the room members by role, or private.""" + +from __future__ import annotations + +from uuid import UUID + +from fastapi import APIRouter, Depends +from fastapi.responses import JSONResponse +from psycopg import Connection + +from app.access.policy import ROOM_RIGHTS +from app.api.deps import Principal, get_conn, get_principal +from app.api.schemas import ExclusionIn, VisibilityIn +from app.ops import _shareable, set_person_exclusion, set_visibility + +router = APIRouter() + +_NO_STORE = {"Cache-Control": "no-store"} + + +def _view(conn, actor: UUID, kind: str, resource_id: UUID) -> dict: + resource = _shareable(conn, actor, kind, resource_id) + members = conn.execute( + """ + SELECT m.subject_id, m.role, a.display_name, + EXISTS ( + SELECT 1 FROM access_grants g + WHERE g.is_exception AND g.grantee_subject_id = m.subject_id + AND g.resource_kind = %s AND g.resource_id = %s AND g.context_kind IS NULL + ) AS excluded + FROM room_memberships m + JOIN auth_accounts a ON a.id = m.subject_id + WHERE m.room_id = %s AND m.status = 'active' AND m.subject_id <> %s + ORDER BY a.display_name, a.id + """, + (kind, resource_id, resource["home_scope_id"], actor), + ).fetchall() + return { + "id": str(resource_id), + "visibility": resource["visibility"], + "members": [ + { + "subject_id": str(row["subject_id"]), + "display_name": row["display_name"], + "role": row["role"], + "excluded": row["excluded"], + "rights": { + "read": ROOM_RIGHTS[row["role"]].read if row["role"] in ROOM_RIGHTS else False, + "edit": ROOM_RIGHTS[row["role"]].edit if row["role"] in ROOM_RIGHTS else False, + }, + } + for row in members + ], + } + + +def _register(kind: str, plural: str) -> None: + base = f"/api/v1/{plural}/{{resource_id}}/room-share" + + @router.get(base, name=f"get_{kind}_room_share") + def get_share(resource_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): + return JSONResponse(_view(conn, principal.account_id, kind, resource_id), headers=_NO_STORE) + + @router.put(base, name=f"put_{kind}_room_share") + def put_share( + resource_id: UUID, + body: VisibilityIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), + ): + return set_visibility(conn, principal.account_id, kind, resource_id, body.visibility) + + @router.put(base + "/people/{subject_id}", name=f"put_{kind}_room_share_person") + def put_person( + resource_id: UUID, + subject_id: UUID, + body: ExclusionIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), + ): + set_person_exclusion(conn, principal.account_id, kind, resource_id, subject_id, body.excluded) + return {"subject_id": str(subject_id), "excluded": body.excluded} + + +_register("case", "cases") +_register("matter", "matters") + + diff --git a/backend/app/api/schemas.py b/backend/app/api/schemas.py index 36ac06a..7103fd0 100644 --- a/backend/app/api/schemas.py +++ b/backend/app/api/schemas.py @@ -65,6 +65,23 @@ class InvitationIn(APIModel): class RoomIn(APIModel): name: str = Field(min_length=1, max_length=160) + default_visibility: Literal["private", "room"] = "room" + + +class VisibilityIn(APIModel): + visibility: Literal["private", "room"] + + +class ExclusionIn(APIModel): + excluded: bool + + +class OwnerIn(APIModel): + subject_id: UUID + + +class OperatorOwnerIn(APIModel): + email: Email class MemberIn(APIModel): @@ -79,6 +96,7 @@ class MemberRoleIn(APIModel): class RoomPatchIn(APIModel): name: str | None = Field(default=None, min_length=1, max_length=160) status: Literal["active", "archived"] | None = None + default_visibility: Literal["private", "room"] | None = None class OperatorManagerIn(APIModel): diff --git a/backend/app/auth/accounts.py b/backend/app/auth/accounts.py index caed8d1..fc4cac4 100644 --- a/backend/app/auth/accounts.py +++ b/backend/app/auth/accounts.py @@ -68,10 +68,10 @@ def create_account( ) conn.execute( """ - INSERT INTO data_rooms (id, kind, name, created_by) - VALUES (%s, 'personal', 'Persönlicher Raum', %s) + INSERT INTO data_rooms (id, kind, name, created_by, owner_id) + VALUES (%s, 'personal', 'Persönlicher Raum', %s, %s) """, - (account_id, account_id), + (account_id, account_id, account_id), ) return conn.execute( """ @@ -141,6 +141,12 @@ def set_status(conn, actor: UUID, account_id: UUID, status: str) -> None: if status == "disabled": if account_id == actor: raise unprocessable("Du kannst dein eigenes Konto nicht deaktivieren.") + owned = _owned_shared_rooms(conn, account_id) + if owned: + raise unprocessable( + f"Das Konto ist Eigentümer von {owned} Datenraum(en) mit weiteren Mitgliedern. " + "Der Eigentümer überträgt sie zuerst, oder der Betreiber setzt einen neuen Eigentümer ein." + ) if account["is_superadmin"] and operators <= 1: raise unprocessable("Der letzte Betreiber lässt sich nicht deaktivieren.") conn.execute( @@ -237,6 +243,21 @@ def clear_login_attempts(conn, bucket: str) -> None: conn.execute("DELETE FROM auth_login_attempts WHERE bucket = %s", (bucket,)) +def _owned_shared_rooms(conn, account_id: UUID) -> int: + row = conn.execute( + """ + SELECT count(*) AS n FROM data_rooms r + WHERE r.kind = 'organization' AND r.status = 'active' AND r.owner_id = %s + AND EXISTS ( + SELECT 1 FROM room_memberships m + WHERE m.room_id = r.id AND m.status = 'active' AND m.subject_id <> %s + ) + """, + (account_id, account_id), + ).fetchone() + return int(row["n"]) + + 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'", @@ -247,7 +268,8 @@ def list_rooms(conn, account_id: UUID) -> list[dict]: rooms.append({"id": str(personal["id"]), "kind": personal["kind"], "name": personal["name"], "role": "owner"}) shared = conn.execute( """ - SELECT r.id, r.kind, r.name, m.role + SELECT r.id, r.kind, r.name, m.role, r.owner_id, r.default_visibility, + (SELECT count(*) FROM room_memberships x WHERE x.room_id = r.id AND x.status = 'active') AS members 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.status = 'active' AND r.kind = 'organization' @@ -256,5 +278,15 @@ def list_rooms(conn, account_id: UUID) -> list[dict]: (account_id,), ).fetchall() for room in shared: - rooms.append({"id": str(room["id"]), "kind": room["kind"], "name": room["name"], "role": room["role"]}) + rooms.append( + { + "id": str(room["id"]), + "kind": room["kind"], + "name": room["name"], + "role": room["role"], + "is_owner": room["owner_id"] == account_id, + "private": room["members"] <= 1, + "default_visibility": room["default_visibility"], + } + ) return rooms diff --git a/backend/app/main.py b/backend/app/main.py index b20107d..309893e 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -13,6 +13,7 @@ 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.roomshare import router as roomshare_router from app.api.routes import router from app.api.sources import router as sources_router from app.core.errors import Problem, problem_response @@ -120,6 +121,7 @@ def create_app() -> FastAPI: app.include_router(router) app.include_router(accounts_router) app.include_router(rooms_router) + app.include_router(roomshare_router) app.include_router(sources_router) app.include_router(export_router) app.include_router(correspondence_router) diff --git a/backend/app/ops.py b/backend/app/ops.py index 9ada096..4bffa41 100644 --- a/backend/app/ops.py +++ b/backend/app/ops.py @@ -74,6 +74,81 @@ def _placement(context: Ctx, placement: Ctx | None) -> tuple[Ctx, Ctx]: return target, context if context.kind == "case" or placement is not None else None +def default_visibility(conn, scope_id: UUID) -> str: + """New cases and matters follow the room preset. The personal room is always private.""" + room = conn.execute("SELECT kind, default_visibility FROM data_rooms WHERE id = %s", (scope_id,)).fetchone() + if room is not None and room["kind"] == "organization" and room["default_visibility"] == "room": + return "room" + return "private" + + +def _shareable(conn, actor: UUID, kind: str, resource_id: UUID) -> dict: + """The own case or matter of an organization room. Only the owner changes its room share.""" + if kind == "case": + resource = get_case(conn, resource_id) + elif kind == "matter": + resource = get_matter(conn, resource_id) + else: + raise unprocessable("Die Raumfreigabe gilt für Akten und Vorgänge.") + if resource is None or resource["owner_subject_id"] != actor: + raise not_found() + room = conn.execute("SELECT kind FROM data_rooms WHERE id = %s", (resource["home_scope_id"],)).fetchone() + if room is None or room["kind"] != "organization": + raise unprocessable("Im persönlichen Datenraum gibt es keine Raumfreigabe.") + return resource + + +def set_visibility(conn, actor: UUID, kind: str, resource_id: UUID, value: str) -> dict: + if value not in {"private", "room"}: + raise unprocessable("Die Sichtbarkeit ist ungültig.") + resource = _shareable(conn, actor, kind, resource_id) + table = "cases" if kind == "case" else "matters" + if resource["visibility"] != value: + conn.execute(f"UPDATE {table} SET visibility = %s WHERE id = %s", (value, resource_id)) + audit(conn, actor, resource["home_scope_id"], "visibility_changed", kind, resource_id, detail={"visibility": value}) + return {"id": str(resource_id), "visibility": value} + + +def set_person_exclusion(conn, actor: UUID, kind: str, resource_id: UUID, subject_id: UUID, excluded: bool) -> None: + """Take one room member out of the room share of an own case or matter.""" + resource = _shareable(conn, actor, kind, resource_id) + if subject_id == actor: + raise unprocessable("Du kannst dich nicht selbst ausnehmen.") + member = conn.execute( + "SELECT 1 FROM room_memberships WHERE room_id = %s AND subject_id = %s AND status = 'active'", + (resource["home_scope_id"], subject_id), + ).fetchone() + if member is None: + raise not_found() + conn.execute( + """ + DELETE FROM access_grants + WHERE is_exception AND grantee_subject_id = %s AND resource_kind = %s AND resource_id = %s + AND context_kind IS NULL + """, + (subject_id, kind, resource_id), + ) + if excluded: + conn.execute( + """ + INSERT INTO access_grants ( + grantee_subject_id, resource_kind, resource_id, + can_read, can_edit, can_share, can_delete, is_exception, created_by + ) + VALUES (%s, %s, %s, true, true, true, true, true, %s) + """, + (subject_id, kind, resource_id, actor), + ) + audit( + conn, + actor, + resource["home_scope_id"], + "person_excluded" if excluded else "person_included", + kind, + resource_id, + ) + + 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() @@ -82,12 +157,12 @@ def create_case(conn, actor: UUID, scope_id: UUID, title: str, parent_case_id: U """ INSERT INTO cases ( home_scope_id, owner_subject_id, created_by, title, rights_mode, - content_order, content_order_dir + content_order, content_order_dir, visibility ) - VALUES (%s, %s, %s, %s, 'explicit', 'date', 'asc') + VALUES (%s, %s, %s, %s, 'explicit', 'date', 'asc', %s) RETURNING * """, - (scope_id, actor, actor, title), + (scope_id, actor, actor, title, default_visibility(conn, scope_id)), ).fetchone() else: parent, _rights = require_case(conn, actor, parent_case_id, "edit") @@ -99,12 +174,15 @@ def create_case(conn, actor: UUID, scope_id: UUID, title: str, parent_case_id: U """ INSERT INTO cases ( home_scope_id, owner_subject_id, created_by, title, parent_case_id, rights_mode, - content_order, content_order_dir + content_order, content_order_dir, visibility ) - VALUES (%s, %s, %s, %s, %s, %s, 'date', 'asc') + VALUES (%s, %s, %s, %s, %s, %s, 'date', 'asc', %s) RETURNING * """, - (parent["home_scope_id"], actor, actor, title, parent["id"], rights_mode), + ( + parent["home_scope_id"], actor, actor, title, parent["id"], rights_mode, + default_visibility(conn, parent["home_scope_id"]), + ), ).fetchone() audit(conn, actor, row["home_scope_id"], "case_created", "case", row["id"]) return row @@ -347,11 +425,11 @@ def create_matter(conn, actor: UUID, scope_id: UUID, title: str, parent_matter_i row = conn.execute( """ INSERT INTO matters ( - home_scope_id, owner_subject_id, created_by, title, content_order, content_order_dir + home_scope_id, owner_subject_id, created_by, title, content_order, content_order_dir, visibility ) - VALUES (%s, %s, %s, %s, 'date', 'asc') RETURNING * + VALUES (%s, %s, %s, %s, 'date', 'asc', %s) RETURNING * """, - (scope_id, actor, actor, title), + (scope_id, actor, actor, title, default_visibility(conn, scope_id)), ).fetchone() else: parent, _rights = require_matter(conn, actor, parent_matter_id, context, "edit") @@ -361,11 +439,11 @@ def create_matter(conn, actor: UUID, scope_id: UUID, title: str, parent_matter_i """ INSERT INTO matters ( home_scope_id, owner_subject_id, created_by, title, parent_matter_id, - content_order, content_order_dir + content_order, content_order_dir, visibility ) - VALUES (%s, %s, %s, %s, %s, 'date', 'asc') RETURNING * + VALUES (%s, %s, %s, %s, %s, 'date', 'asc', %s) RETURNING * """, - (parent["home_scope_id"], actor, actor, title, parent["id"]), + (parent["home_scope_id"], actor, actor, title, parent["id"], default_visibility(conn, parent["home_scope_id"])), ).fetchone() audit(conn, actor, row["home_scope_id"], "matter_created", "matter", row["id"], context) return row @@ -520,8 +598,9 @@ def move_bindings_chapter( def delete_case(conn, actor: UUID, case_id: UUID, expected: int) -> None: - case, rights = require_case(conn, actor, case_id, "edit") - if not rights.edit: + case, rights = require_case(conn, actor, case_id, "read") + # Deleting the container is the owner's right. Editing, also through the room share, is not enough. + if case["owner_subject_id"] != actor and not rights.delete: raise forbidden() children = conn.execute( "SELECT id FROM cases WHERE parent_case_id = %s AND deleted_at IS NULL", @@ -536,7 +615,9 @@ def delete_case(conn, actor: UUID, case_id: UUID, expected: int) -> None: def delete_matter(conn, actor: UUID, matter_id: UUID, expected: int, context: Ctx | None) -> None: - matter, _rights = require_matter(conn, actor, matter_id, context, "edit") + matter, rights = require_matter(conn, actor, matter_id, context, "read") + if matter["owner_subject_id"] != actor and not rights.delete: + raise forbidden() children = conn.execute( "SELECT id FROM matters WHERE parent_matter_id = %s AND deleted_at IS NULL", (matter_id,), diff --git a/backend/app/present.py b/backend/app/present.py index 628be92..17eb56f 100644 --- a/backend/app/present.py +++ b/backend/app/present.py @@ -634,6 +634,7 @@ def case_summary(case: dict, rights) -> dict: "rights_mode": case["rights_mode"], "parent_case_id": str(case["parent_case_id"]) if case["parent_case_id"] else None, "home_scope_id": str(case["home_scope_id"]), + "visibility": case.get("visibility", "private"), "rights": rights.as_dict(), } @@ -779,6 +780,7 @@ def matter_detail(conn, actor: UUID, matter: dict, rights, context: Ctx | None) "parent_title": matter_title_if_readable(conn, actor, matter["parent_matter_id"]), "home_scope_id": str(matter["home_scope_id"]), "home_scope_name": room_name(conn, matter["home_scope_id"]), + "visibility": matter.get("visibility", "private"), "is_owner": matter["owner_subject_id"] == actor, "content_order": matter.get("content_order") or "position", "content_order_dir": matter.get("content_order_dir") or "asc", @@ -1052,4 +1054,9 @@ LABELS = { "invitation_created": "Einladung erstellt", "invitation_revoked": "Einladung widerrufen", "invitation_accepted": "Einladung angenommen", + "visibility_changed": "Raumfreigabe geändert", + "person_excluded": "Person von der Raumfreigabe ausgenommen", + "person_included": "Person wieder in die Raumfreigabe aufgenommen", + "room_owner_changed": "Eigentümer des Datenraums gewechselt", + "room_default_changed": "Voreinstellung des Datenraums geändert", } diff --git a/backend/app/seed.py b/backend/app/seed.py index d467e86..c80c09d 100644 --- a/backend/app/seed.py +++ b/backend/app/seed.py @@ -87,11 +87,11 @@ def seed_demo(settings: Settings | None = None) -> bool: ben = create_account(conn, BEN_EMAIL, "Ben Beispiel", BEN_PASSWORD, origin="fixture") room = conn.execute( """ - INSERT INTO data_rooms (id, kind, name, created_by) - VALUES (gen_random_uuid(), 'organization', 'Haushalt Musterstraße', %s) + INSERT INTO data_rooms (id, kind, name, created_by, owner_id) + VALUES (gen_random_uuid(), 'organization', 'Haushalt Musterstraße', %s, %s) RETURNING id """, - (ada["id"],), + (ada["id"], ada["id"]), ).fetchone() conn.execute( "INSERT INTO room_memberships (room_id, subject_id, role) VALUES (%s, %s, 'manager'), (%s, %s, 'member')", diff --git a/backend/migrations/20261021T090000Z_room_access.sql b/backend/migrations/20261021T090000Z_room_access.sql new file mode 100644 index 0000000..bfd2f7d --- /dev/null +++ b/backend/migrations/20261021T090000Z_room_access.sql @@ -0,0 +1,21 @@ +-- Raum-Eigentümer und Raumfreigabe. Bestehende Akten und Vorgänge bleiben privat. + +ALTER TABLE data_rooms + ADD COLUMN owner_id uuid REFERENCES auth_accounts (id), + ADD COLUMN default_visibility text NOT NULL DEFAULT 'private', + ADD CONSTRAINT data_rooms_default_visibility CHECK (default_visibility IN ('private', 'room')); + +UPDATE data_rooms SET owner_id = created_by; + +ALTER TABLE data_rooms + ADD CONSTRAINT data_rooms_owner CHECK (kind = 'personal' OR owner_id IS NOT NULL); + +CREATE INDEX data_rooms_owner ON data_rooms (owner_id) WHERE kind = 'organization'; + +ALTER TABLE cases + ADD COLUMN visibility text NOT NULL DEFAULT 'private', + ADD CONSTRAINT cases_visibility CHECK (visibility IN ('private', 'room')); + +ALTER TABLE matters + ADD COLUMN visibility text NOT NULL DEFAULT 'private', + ADD CONSTRAINT matters_visibility CHECK (visibility IN ('private', 'room')); diff --git a/backend/tests/test_rights.py b/backend/tests/test_rights.py index 844c273..6eff1c2 100644 --- a/backend/tests/test_rights.py +++ b/backend/tests/test_rights.py @@ -14,7 +14,7 @@ def test_manager_does_not_read_a_personal_case(client, db): ada = Actor(client, "ada@example.test", "Ada") ada.login() private = case_of(ada, "Persoenliche Akte") - room = ada.request("POST", "/api/v1/rooms", json={"name": "Haushalt"}, status=201) + room = ada.request("POST", "/api/v1/rooms", json={"name": "Haushalt", "default_visibility": "private"}, status=201) ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": "ben@example.test", "role": "manager"}) ben = Actor(client, "ben@example.test", "Ben") ben.login() diff --git a/backend/tests/test_room_access.py b/backend/tests/test_room_access.py new file mode 100644 index 0000000..2fc2110 --- /dev/null +++ b/backend/tests/test_room_access.py @@ -0,0 +1,231 @@ +"""Raumfreigabe: Mitglieder erhalten Rechte an Akten und Vorgängen ihres Raums nach Rolle.""" + +from __future__ import annotations + +import pytest +from fastapi.testclient import TestClient + +from app.auth.accounts import create_account +from tests.support import PASSWORD, Actor, document, matter_of, note_on + + +def _second_client(): + from app.main import app + + return TestClient(app) + + +def _make(db, email: str, name: str, *, superadmin: bool = False): + account = create_account(db, email, name, PASSWORD, is_superadmin=superadmin) + db.commit() + return account + + +@pytest.fixture +def world(client, db): + """Ada owns the room; Ben is a member, Cem a reader, Dan is outside.""" + actors = {} + for key, email in (("ada", "ada-raum"), ("ben", "ben-raum"), ("cem", "cem-raum"), ("dan", "dan-raum")): + actor = Actor(client if key == "ada" else _second_client(), f"{email}@example.test", key.title()) + _make(db, actor.email, actor.name) + actor.login() + actors[key] = actor + ada = actors["ada"] + room = ada.request("POST", "/api/v1/rooms", json={"name": "Werkstatt"}, status=201) + assert room["default_visibility"] == "room" + ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": actors["ben"].email, "role": "member"}) + ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": actors["cem"].email, "role": "reader"}) + ada.use_room(room["id"]) + actors["room"] = room["id"] + return actors + + +def _id(db, email: str) -> str: + return str(db.execute("SELECT id FROM auth_accounts WHERE email = %s", (email,)).fetchone()["id"]) + + +def test_the_room_share_gives_rights_by_role(world, db): + ada, ben, cem, dan = world["ada"], world["ben"], world["cem"], world["dan"] + shared = ada.request("POST", "/api/v1/cases", json={"title": "Gemeinsame Akte"}, status=201) + assert ada.request("GET", f"/api/v1/cases/{shared['id']}/room-share")["visibility"] == "room" + + assert ben.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == { + "read": True, "edit": True, "share": False, "delete": False, + } + assert cem.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == { + "read": True, "edit": False, "share": False, "delete": False, + } + dan.request("GET", f"/api/v1/cases/{shared['id']}", status=404) + + titles = {item["title"] for item in ben.request("GET", "/api/v1/cases")["items"]} + assert "Gemeinsame Akte" in titles + assert dan.request("GET", "/api/v1/cases")["items"] == [] + + version = ben.request("GET", f"/api/v1/cases/{shared['id']}")["version"] + ben.request("PATCH", f"/api/v1/cases/{shared['id']}", json={"expected_version": version, "title": "Von Ben geändert"}) + cem.request("PATCH", f"/api/v1/cases/{shared['id']}", json={"expected_version": version + 1, "title": "Nein"}, status=403) + ben.request("POST", f"/api/v1/cases/{shared['id']}/delete", json={"expected_version": version + 1}, status=403) + ben.request( + "POST", + f"/api/v1/cases/{shared['id']}/grants", + json={"email": dan.email, "can_read": True}, + status=403, + ) + + +def test_private_cases_stay_private_and_the_owner_role_reads_nothing(world, db): + ada, ben, cem = world["ada"], world["ben"], world["cem"] + ada.request("POST", "/api/v1/cases", json={"title": "Vorab privat"}, status=201) + own = ada.request("POST", "/api/v1/cases", json={"title": "Wird privat"}, status=201) + ada.request("PUT", f"/api/v1/cases/{own['id']}/room-share", json={"visibility": "private"}) + for member in (ben, cem): + member.request("GET", f"/api/v1/cases/{own['id']}", status=404) + + # Ben creates his own case. Ada owns the room but is no reader of Ben's private case. + ben.use_room(world["room"]) + mine = ben.request("POST", "/api/v1/cases", json={"title": "Bens Akte"}, status=201) + ben.request("PUT", f"/api/v1/cases/{mine['id']}/room-share", json={"visibility": "private"}) + ada.request("GET", f"/api/v1/cases/{mine['id']}", status=404) + assert "Bens Akte" not in {item["title"] for item in ada.request("GET", "/api/v1/cases")["items"]} + # Only the owner of a case changes its room share. + ada.request("PUT", f"/api/v1/cases/{mine['id']}/room-share", json={"visibility": "room"}, status=404) + + +def test_leaving_the_room_or_going_private_takes_the_rights_back_at_once(world, db): + ada, ben = world["ada"], world["ben"] + case = ada.request("POST", "/api/v1/cases", json={"title": "Zeitweise sichtbar"}, status=201) + ben.request("GET", f"/api/v1/cases/{case['id']}") + ada.request("PUT", f"/api/v1/cases/{case['id']}/room-share", json={"visibility": "private"}) + ben.request("GET", f"/api/v1/cases/{case['id']}", status=404) + ada.request("PUT", f"/api/v1/cases/{case['id']}/room-share", json={"visibility": "room"}) + ben.request("GET", f"/api/v1/cases/{case['id']}") + ada.request("DELETE", f"/api/v1/rooms/{world['room']}/members/{_id(db, ben.email)}", status=204) + ben.request("GET", f"/api/v1/cases/{case['id']}", status=404) + assert ben.request("GET", "/api/v1/cases")["items"] == [] + + +def test_an_archived_room_and_a_disabled_account_share_nothing(world, db): + ada, ben = world["ada"], world["ben"] + case = ada.request("POST", "/api/v1/cases", json={"title": "Archivtest"}, status=201) + ben.request("GET", f"/api/v1/cases/{case['id']}") + db.execute("UPDATE data_rooms SET status = 'archived' WHERE id = %s", (world["room"],)) + db.commit() + ben.request("GET", f"/api/v1/cases/{case['id']}", status=404) + db.execute("UPDATE data_rooms SET status = 'active' WHERE id = %s", (world["room"],)) + db.commit() + ben.request("GET", f"/api/v1/cases/{case['id']}") + + +def test_one_member_can_be_excluded_from_the_room_share(world, db): + ada, ben, cem = world["ada"], world["ben"], world["cem"] + case = ada.request("POST", "/api/v1/cases", json={"title": "Ohne Ben"}, status=201) + view = ada.request("GET", f"/api/v1/cases/{case['id']}/room-share") + assert {(m["display_name"], m["role"]) for m in view["members"]} == {("Ben", "member"), ("Cem", "reader")} + ada.request("PUT", f"/api/v1/cases/{case['id']}/room-share/people/{_id(db, ben.email)}", json={"excluded": True}) + ben.request("GET", f"/api/v1/cases/{case['id']}", status=404) + cem.request("GET", f"/api/v1/cases/{case['id']}") + assert any(m["excluded"] for m in ada.request("GET", f"/api/v1/cases/{case['id']}/room-share")["members"]) + ada.request("PUT", f"/api/v1/cases/{case['id']}/room-share/people/{_id(db, ben.email)}", json={"excluded": False}) + ben.request("GET", f"/api/v1/cases/{case['id']}") + ada.request("PUT", f"/api/v1/cases/{case['id']}/room-share/people/{_id(db, ada.email)}", json={"excluded": True}, status=422) + ada.request("PUT", f"/api/v1/cases/{case['id']}/room-share/people/{_id(db, world['dan'].email)}", json={"excluded": True}, status=404) + ben.request("PUT", f"/api/v1/cases/{case['id']}/room-share/people/{_id(db, cem.email)}", json={"excluded": True}, status=404) + + +def test_matters_and_their_contents_follow_the_room_role(world, db): + ada, ben, cem, dan = world["ada"], world["ben"], world["cem"], world["dan"] + case = ada.request("POST", "/api/v1/cases", json={"title": "Akte mit Vorgang"}, status=201) + matter = ada.request( + "POST", + "/api/v1/matters", + json={"title": "Vorgang im Raum", "context": {"kind": "case", "id": case["id"]}}, + status=201, + ) + note = note_on(ada, "Notiz in der Akte", "Raumtext", case["id"]) + detail = ben.request("GET", f"/api/v1/cases/{case['id']}") + assert any(b["element"]["title"] == "Notiz in der Akte" for b in detail["bindings"]) + ben.request( + "PATCH", + f"/api/v1/notes/{note['id']}", + json={"expected_version": note["version"], "document": document("Von Ben ergänzt"), "context": {"kind": "case", "id": case["id"]}}, + ) + cem.request( + "PATCH", + f"/api/v1/notes/{note['id']}", + json={"expected_version": note["version"] + 1, "document": document("Nein"), "context": {"kind": "case", "id": case["id"]}}, + status=403, + ) + dan.request("GET", f"/api/v1/cases/{case['id']}", status=404) + assert dan.request("GET", "/api/v1/search", params={"q": "Notiz in der Akte"})["items"] == [] + assert any(item["title"] == "Notiz in der Akte" for item in cem.request("GET", "/api/v1/search", params={"q": "Notiz in der Akte"})["items"]) + + +def test_a_standalone_matter_is_shared_by_its_own_setting(world, db): + ada, ben, cem = world["ada"], world["ben"], world["cem"] + matter = matter_of(ada, "Eigener Vorgang") + assert ben.request("GET", f"/api/v1/matters/{matter['id']}")["rights"]["edit"] is True + assert cem.request("GET", f"/api/v1/matters/{matter['id']}")["rights"] == { + "read": True, "edit": False, "share": False, "delete": False, + } + ben.request("POST", f"/api/v1/matters/{matter['id']}/delete", json={"expected_version": matter["version"]}, status=403) + ada.request("PUT", f"/api/v1/matters/{matter['id']}/room-share", json={"visibility": "private"}) + ben.request("GET", f"/api/v1/matters/{matter['id']}", status=404) + assert "Eigener Vorgang" not in {item["title"] for item in ben.request("GET", "/api/v1/matters")["items"]} + + +def test_subcases_follow_their_parent_and_sub_matters_the_case(world, db): + ada, ben = world["ada"], world["ben"] + parent = ada.request("POST", "/api/v1/cases", json={"title": "Eltern"}, status=201) + child = ada.request( + "POST", + "/api/v1/cases", + json={"title": "Kind", "parent_case_id": parent["id"], "rights_mode": "inherit_parent"}, + status=201, + ) + ben.request("GET", f"/api/v1/cases/{child['id']}") + ada.request("PUT", f"/api/v1/cases/{parent['id']}/room-share", json={"visibility": "private"}) + ben.request("GET", f"/api/v1/cases/{child['id']}", status=404) + + +def test_the_personal_room_is_never_shared(client, db): + ada = Actor(client, "ada-privat@example.test", "Ada Privat") + _make(db, ada.email, ada.name) + ada.login() + case = ada.request("POST", "/api/v1/cases", json={"title": "Persönlich"}, status=201) + assert db.execute("SELECT visibility FROM cases WHERE id = %s", (case["id"],)).fetchone()["visibility"] == "private" + db.rollback() + ada.request("PUT", f"/api/v1/cases/{case['id']}/room-share", json={"visibility": "room"}, status=422) + + +def test_existing_content_stays_private_and_the_bulk_action_changes_only_own(world, db): + ada, ben = world["ada"], world["ben"] + old = ada.request("POST", "/api/v1/cases", json={"title": "Bestand"}, status=201) + db.execute("UPDATE cases SET visibility = 'private' WHERE id = %s", (old["id"],)) + db.commit() + ben.request("GET", f"/api/v1/cases/{old['id']}", status=404) + exposure = ada.request("GET", f"/api/v1/rooms/{world['room']}/exposure") + assert exposure["cases"] == {"private": 1, "room": 0} + assert ada.request("POST", f"/api/v1/rooms/{world['room']}/my-content/visibility", json={"visibility": "room"}) == {"changed": 1} + ben.request("GET", f"/api/v1/cases/{old['id']}") + ben.use_room(world["room"]) + theirs = ben.request("POST", "/api/v1/cases", json={"title": "Bens"}, status=201) + ada.request("POST", f"/api/v1/rooms/{world['room']}/my-content/visibility", json={"visibility": "private"}) + ben.request("GET", f"/api/v1/cases/{theirs['id']}") + world["dan"].request("GET", f"/api/v1/rooms/{world['room']}/exposure", status=403) + + +def test_a_room_can_start_private(client, db): + ada = Actor(client, "ada-start@example.test", "Ada Start") + ben = Actor(_second_client(), "ben-start@example.test", "Ben Start") + for actor in (ada, ben): + _make(db, actor.email, actor.name) + actor.login() + room = ada.request("POST", "/api/v1/rooms", json={"name": "Privat", "default_visibility": "private"}, status=201) + ada.use_room(room["id"]) + case = ada.request("POST", "/api/v1/cases", json={"title": "Nur ich"}, status=201) + ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": ben.email, "role": "member"}) + ben.request("GET", f"/api/v1/cases/{case['id']}", status=404) + ada.request("PATCH", f"/api/v1/rooms/{room['id']}", json={"default_visibility": "room"}) + other = ada.request("POST", "/api/v1/cases", json={"title": "Jetzt geteilt"}, status=201) + ben.request("GET", f"/api/v1/cases/{other['id']}") + ben.request("PATCH", f"/api/v1/rooms/{room['id']}", json={"default_visibility": "private"}, status=403) diff --git a/backend/tests/test_room_roles.py b/backend/tests/test_room_roles.py index 2a492bf..6d91251 100644 --- a/backend/tests/test_room_roles.py +++ b/backend/tests/test_room_roles.py @@ -86,13 +86,51 @@ def test_the_last_manager_stays(client, db): 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 owns the room and stays manager until she hands it over. + ada.request("PATCH", f"/api/v1/rooms/{room}/members/{me}", json={"role": "member"}, status=422) + ada.request("POST", f"/api/v1/rooms/{room}/owner", json={"subject_id": _subject(ada, room, ben.email)}) ada.request("PATCH", f"/api/v1/rooms/{room}/members/{me}", json={"role": "member"}) - # Ben is the only manager now. + # Ben is owner and 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_owner_transfer_and_operator_step_in(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_id = _subject(ben, room, ben.email) + ben.request("POST", f"/api/v1/rooms/{room}/owner", json={"subject_id": ben_id}, status=403) + ada.request("POST", f"/api/v1/rooms/{room}/owner", json={"subject_id": _subject(ada, room, cem.email)}, status=422) + ada.request("POST", f"/api/v1/rooms/{room}/owner", json={"subject_id": _subject(ada, room, ada.email)}, status=422) + # Ada cannot leave or be demoted while she owns the room, and cannot be disabled while members depend on it. + ada_id = _subject(ada, room, ada.email) + db.execute("UPDATE auth_accounts SET origin = 'operator' WHERE id = %s", (ada_id,)) + db.commit() + operator = Actor(_second_client(), "betreiber-eigner@example.test", "Betreiber Eigner") + register(db, operator.email, operator.name, superadmin=True) + operator.login() + operator.request("PATCH", f"/api/v1/accounts/{ada_id}", json={"status": "disabled"}, status=422) + operator.request("POST", f"/api/v1/admin/rooms/{room}/owner", json={"email": ben.email}, status=403) + + ada.request("POST", f"/api/v1/rooms/{room}/owner", json={"subject_id": ben_id}) + ben.request("GET", f"/api/v1/rooms/{room}/members") + owners = [r for r in ben.request("GET", "/api/v1/auth/session")["rooms"] if r["id"] == room] + assert owners[0]["is_owner"] is True + ada.request("PATCH", f"/api/v1/rooms/{room}", json={"status": "archived"}, status=403) + ben.request("PATCH", f"/api/v1/rooms/{room}", json={"default_visibility": "private"}) + + # The old owner may be disabled now; the room keeps its owner. A disabled owner is replaced by the operator. + operator.request("PATCH", f"/api/v1/accounts/{ada_id}", json={"status": "disabled"}) + db.execute("UPDATE data_rooms SET owner_id = %s WHERE id = %s", (ada_id, room)) + db.commit() + stepped = operator.request("POST", f"/api/v1/admin/rooms/{room}/owner", json={"email": ben.email}) + assert stepped["owner_id"] == ben_id + events = operator.request("GET", "/api/v1/admin/events", params={"limit": 100})["items"] + assert "room_owner_changed" in [item["action"] for item in events] + + 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"}) diff --git a/backend/tests/test_tracking.py b/backend/tests/test_tracking.py index a4de25e..4fcd4f7 100644 --- a/backend/tests/test_tracking.py +++ b/backend/tests/test_tracking.py @@ -81,7 +81,7 @@ def test_t_anchor_assignee_sees_the_task_but_not_the_hidden_matter(client, db): ada = Actor(client, "ada@example.test", "Ada") ada.login() matter = ada.request("POST", "/api/v1/matters", json={"title": "Geheimer Vorgang Anker"}, status=201) - room = ada.request("POST", "/api/v1/rooms", json={"name": "Gleicher Raum"}, status=201) + room = ada.request("POST", "/api/v1/rooms", json={"name": "Gleicher Raum", "default_visibility": "private"}, status=201) ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": "ben@example.test", "role": "member"}) ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": "cara@example.test", "role": "member"}) ada.use_room(room["id"]) diff --git a/docs/architecture/API_REFERENZ.md b/docs/architecture/API_REFERENZ.md index 757fd73..6263778 100644 --- a/docs/architecture/API_REFERENZ.md +++ b/docs/architecture/API_REFERENZ.md @@ -58,13 +58,19 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R** |---|---|---|---| | 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 | -| PATCH | `/api/v1/rooms/{id}` | S+R, M | `name`, `status` (`active`/`archived`). Archivieren setzt Sitzungen im Raum auf den persönlichen Raum zurück | +| PATCH | `/api/v1/rooms/{id}` | S+R, M / E | `name` (Verwalter); `status` und `default_visibility` nur der Eigentümer (E). 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 | +| POST | `/api/v1/rooms/{id}/owner` | S+R, E | Raum an ein aktives Mitglied übertragen (Eigentümer); der neue Eigentümer wird Verwalter | +| GET | `/api/v1/rooms/{id}/exposure` | S+R, Mitglied | Zahl der eigenen Akten und Vorgänge im Raum je Sichtbarkeit | +| POST | `/api/v1/rooms/{id}/my-content/visibility` | S+R, Mitglied | `visibility` für alle eigenen Akten und Vorgänge des Raums setzen | +| GET / PUT | `/api/v1/cases/{id}/room-share`, `/api/v1/matters/{id}/room-share` | S+R, Owner | Raumfreigabe ansehen (Sichtbarkeit, Mitglieder mit Rolle und Ausnahme) oder setzen; im persönlichen Raum 422 | +| PUT | `/api/v1/cases/{id}/room-share/people/{subject_id}`, `/api/v1/matters/{id}/room-share/people/{subject_id}` | S+R, Owner | eine Person von der Raumfreigabe ausnehmen (`excluded`) | +| POST | `/api/v1/admin/rooms/{id}/owner` | S+R, B | Betreiber setzt einen Eigentümer ein, nur wenn der bisherige nicht mehr handeln kann (Konto deaktiviert oder nicht mehr Mitglied) | | 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 | diff --git a/docs/architecture/BENUTZERVERWALTUNG.md b/docs/architecture/BENUTZERVERWALTUNG.md index 41c3afe..b864829 100644 --- a/docs/architecture/BENUTZERVERWALTUNG.md +++ b/docs/architecture/BENUTZERVERWALTUNG.md @@ -23,7 +23,7 @@ Feste Bündel, kein Rolleneditor (Technische Spezifikation 5.2). Rollen werden b ### Wirkung der Leser-Rolle -Grants hängen am Objekt, nicht am Raum. Der Leser begrenzt daher drei Stellen, ohne die Policy-Auswertung zu ändern: +Einzelfreigaben (Grants) hängen am Objekt, nicht am Raum. Der Leser begrenzt daher zusätzlich zur Raumfreigabe (siehe unten, dort liest er nur) drei Stellen: 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`). @@ -31,6 +31,14 @@ Grants hängen am Objekt, nicht am Raum. Der Leser begrenzt daher drei Stellen, Grants auf Objekte anderer Räume bleiben unberührt. +## Datenräume, Eigentümer und Raumfreigabe (seit 21.10.2026) + +- **Mehrere Räume:** Jede Person kann beliebig viele gemeinsame Datenräume anlegen. Ein Raum mit nur dem Eigentümer als Mitglied ist **privat**, mit weiteren Mitgliedern **Mehrbenutzer**. Der persönliche Raum bleibt unverändert. +- **Eigentümer** (`data_rooms.owner_id`): der Ersteller. Er ist stets Verwalter, lässt sich nicht entfernen oder zurückstufen und überträgt den Raum an ein aktives Mitglied. Nur er archiviert und stellt wieder her und ändert die Voreinstellung für neue Einträge. Ein Konto, das einen Raum mit weiteren Mitgliedern besitzt, lässt sich erst nach Übertragung deaktivieren. Ist der Eigentümer nicht mehr handlungsfähig, setzt der Betreiber einen neuen ein (protokolliert). Die Eigentümerrolle verleiht kein Leserecht. +- **Raumfreigabe:** Neue Akten und Vorgänge folgen der Voreinstellung des Raums (`room` oder `private`). Bei `room` erhalten Mitglieder Rechte nach Rolle (Leser lesen; Mitglied und Verwalter bearbeiten; Weitergeben und Löschen nie). Der Owner einer Akte stellt sie privat, nimmt einzelne Personen aus oder setzt alle eigenen Einträge eines Raums auf einmal. Beim ersten weiteren Mitglied zeigt die Oberfläche, was dadurch sichtbar wird, und bietet an, zuerst privat zu stellen. Bestehende Akten und Vorgänge blieben bei der Einführung privat. +- **Quellzugänge:** Die Raumfreigabe gibt keine Paperless- oder Mail-Zugänge des Owners frei. Dafür bleibt die ausdrückliche Freigabe mit der Option nötig. +- **Löschen:** Akte und Vorgang löscht nur der Owner (oder wer ein Löschrecht hat), nicht jeder Bearbeiter. + ## 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`. diff --git a/docs/architecture/DATENMODELL_IST.md b/docs/architecture/DATENMODELL_IST.md index b1f72d3..dee88a4 100644 --- a/docs/architecture/DATENMODELL_IST.md +++ b/docs/architecture/DATENMODELL_IST.md @@ -1,6 +1,6 @@ # Tsumugu – Datenmodell (Ist-Stand) -**Stand:** 19.10.2026, nach den Migrationen in `backend/migrations/` (letzte: `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. +**Stand:** 19.10.2026, nach den Migrationen in `backend/migrations/` (letzte: `20261021T090000Z_room_access.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. @@ -21,6 +21,8 @@ Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TE | `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`/`reader`), `status` (`active`/`removed`) | – | +| `data_rooms` (Spalten seit 21.10.2026) | `owner_id` (Eigentümer; für persönliche Räume das Konto), `default_visibility` (`private`/`room`, Voreinstellung für neue Akten und Vorgänge) | Bestehende Räume `private`, Eigentümer aus `created_by` | +| `cases`, `matters` (Spalte seit 21.10.2026) | `visibility` (`private`/`room`) | Bestand bleibt `private`; neue Einträge folgen der Voreinstellung des Heimatraums | | `auth_login_attempts` | `bucket` (SHA-256 aus Adresse und E-Mail), `attempted_at` | zählt Fehlversuche; erfolgreicher Login löscht den Bucket | ## Struktur diff --git a/docs/architecture/RECHTEMODELL_IST.md b/docs/architecture/RECHTEMODELL_IST.md index 1fc71c8..346f6fa 100644 --- a/docs/architecture/RECHTEMODELL_IST.md +++ b/docs/architecture/RECHTEMODELL_IST.md @@ -93,6 +93,7 @@ Danach Abzug der jeweiligen Ausnahme. - Die Chronologie zeigt nur Ereignisse, deren Ressource im Seitenkontext lesbar ist (`_event_title`). - Breadcrumbs nennen nur lesbare Stationen. Bei mehreren lesbaren Aktenzuordnungen ohne gewählten Kontext erscheint keine Hauptakte. - Betreiber- und Verwalterrolle verleihen kein Leserecht auf persönliche Inhalte. +- **Raumfreigabe** (`cases.visibility`, `matters.visibility` = `room`): Aktive Mitglieder eines aktiven Datenraums erhalten an Akten und Vorgängen mit diesem Heimatraum Rechte nach Rolle: Leser lesen, Mitglied und Verwalter lesen und bearbeiten, Weitergeben und Löschen nie (`ROOM_RIGHTS`, `room_default` in `policy.py`). Die Rechte werden mit Einzelfreigaben vereinigt, danach wirken Ausnahmen. Eine Personenausnahme (Grant mit `is_exception` auf eine Person, Kontext leer) nimmt eine Person aus. Der persönliche Raum kennt keine Raumfreigabe; Elemente und Aufgaben ohne Akte oder Vorgang bleiben beim Owner. Das Löschen von Akte und Vorgang verlangt Owner oder ausdrückliches Löschrecht, nicht mehr nur Bearbeiten (schließt R-01). - 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. diff --git a/docs/product/TSUMUGU_PRODUCT_SPEC.md b/docs/product/TSUMUGU_PRODUCT_SPEC.md index f130c1c..decf618 100644 --- a/docs/product/TSUMUGU_PRODUCT_SPEC.md +++ b/docs/product/TSUMUGU_PRODUCT_SPEC.md @@ -436,6 +436,12 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G **Lieferung und Grenzen zu F-08b/c:** Der gemeinsame [Anforderungs- und Cursor-Auftrag vom 18.10.2026](TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md) konkretisiert Anlage-/Nachweisrollen, gesicherte Fassungen, Listen-/Chronologiedarstellung, Bestandsübergang, Kontextrechte und Export einschließlich vollständiger EML gemäß F-07c. Er ersetzt die historische Zurückstellung eines Hauptdokuments/Dokumentpakets für diese neue Lieferung; F-08a bleibt als Kapitelmodell erhalten. Detailregeln des Auftrags sind die aktuelle Umsetzungsausgestaltung, keine Behauptung bereits implementierter oder früher einzeln bestätigter Funktionen. Dieses Dokumentationspaket ändert keine Anwendung, Datenbank oder Bereitstellung. +### R-01 – Arbeitsräume, Raum-Eigentümer und Raumfreigabe: bestätigt am 20.10.2026 + +**Beschluss:** Der Nutzer bestätigt: (1) Jede Person kann mehrere Datenräume anlegen. Ein Raum ist privat, solange nur der Eigentümer Mitglied ist, und wird durch Aufnehmen von Personen zum Mehrbenutzer-Raum. Der persönliche Raum bleibt unverändert. (2) Der Ersteller ist Eigentümer, solange er die Rolle innehat. Der Eigentümer verwaltet Mitglieder, Rollen, Name, Archivierung und Übertragung, liest aber über diese Rolle keine fremden Inhalte. (3) **Raumstandard je Rolle:** Neue Akten und Vorgänge in einem Mehrbenutzer-Raum sind standardmäßig für die Mitglieder sichtbar; Leser lesen, Mitglieder und Verwalter bearbeiten. Der Eigentümer einer Akte kann sie privat halten oder einzelne Personen ausnehmen. Weitergeben, Löschen und Eigentum bleiben beim Eigentümer. (4) Der Raum ist übertragbar. Der Betreiber kann protokolliert einspringen, wenn der Eigentümer nicht mehr handeln kann. + +**Begründung und Auswirkungen:** Die Akte bleibt der Rechteanker (F-01, S-01); die Raumfreigabe ist eine zweite, dynamische Rechtequelle an der Akte neben den Einzelfreigaben. Sie ersetzt F-01 nicht. Bestehende Akten und Vorgänge bleiben privat. Quellzugänge des Owners (Paperless, Mail) werden durch die Raumfreigabe nicht mitgegeben, sondern brauchen weiter die ausdrückliche Freigabe. Elemente und Aufgaben ohne Akte oder Vorgang bleiben beim Owner. Umsetzungsstand: [BENUTZERVERWALTUNG.md](../architecture/BENUTZERVERWALTUNG.md). + ## 6. Fortschreibung 16.10.2026, Arbeitsstand 0.1: Recovery vollständig gelesen, Repository-Unterlagen gezielt abgeglichen, ursprüngliche Nutzernachrichten geprüft und Ergänzungen gesichert. Historische Baseline unverändert übernommen. diff --git a/frontend/src/admin/RoomShare.jsx b/frontend/src/admin/RoomShare.jsx new file mode 100644 index 0000000..83b9200 --- /dev/null +++ b/frontend/src/admin/RoomShare.jsx @@ -0,0 +1,85 @@ +import { useEffect, useState } from "react"; +import { api } from "../api.js"; +import { ErrorNote } from "../pages/widgets.jsx"; +import { roleLabel, roomRightsText } from "./admin-core.js"; + +// The owner of a case or matter in a shared room decides whether the room members see it. +export function RoomShare({ resource, id, onChange }) { + const [view, setView] = useState(null); + const [error, setError] = useState(""); + const [hidden, setHidden] = useState(false); + const path = `/api/v1/${resource}/${id}/room-share`; + + async function load() { + try { + setView(await api(path)); + } catch (err) { + // The personal room has no room share. Nothing to show then. + if (err.status === 422) setHidden(true); + else setError(err.message); + } + } + + useEffect(() => { + setHidden(false); + setView(null); + load(); + }, [path]); + + async function run(action) { + setError(""); + try { + await action(); + await load(); + await onChange?.(); + } catch (err) { + setError(err.message); + } + } + + if (hidden) return null; + const shared = view?.visibility === "room"; + + return ( +
+

Im Datenraum

+ + {view ? ( + <> + +

+ {shared + ? "Leser lesen, Mitglieder und Verwalter bearbeiten. Weitergeben und Löschen bleiben bei dir." + : "Nur du und ausdrücklich freigegebene Personen sehen diesen Eintrag."} +

+ {shared && view.members.length ? ( +
    + {view.members.map((member) => ( +
  • + {member.display_name} + {roleLabel(member.role)} · {member.excluded ? "ausgenommen" : roomRightsText(member.rights)} + +
  • + ))} +
+ ) : null} + + ) : !error ? ( +

Wird geladen …

+ ) : null} +
+ ); +} diff --git a/frontend/src/admin/admin-core.js b/frontend/src/admin/admin-core.js index 566fb2c..7c9f40e 100644 --- a/frontend/src/admin/admin-core.js +++ b/frontend/src/admin/admin-core.js @@ -57,3 +57,21 @@ export function formatWhen(value) { if (Number.isNaN(date.getTime())) return "unbekannt"; return date.toLocaleString("de-DE", { dateStyle: "medium", timeStyle: "short" }); } + +// What a room role may do with an entry that is shared with the room. +export function roomRightsText(rights) { + if (rights?.edit) return "liest und bearbeitet"; + if (rights?.read) return "liest"; + return "kein Zugriff"; +} + +// A private room becomes a multi-user room with its first other member. +export function isPrivateRoom(room) { + return room?.kind === "organization" && Boolean(room.private); +} + +export function exposureSummary(exposure) { + const cases = exposure?.cases?.room || 0; + const matters = exposure?.matters?.room || 0; + return { cases, matters, total: cases + matters }; +} diff --git a/frontend/src/admin/admin-core.test.mjs b/frontend/src/admin/admin-core.test.mjs index b0f1bb9..98ac92d 100644 --- a/frontend/src/admin/admin-core.test.mjs +++ b/frontend/src/admin/admin-core.test.mjs @@ -2,6 +2,9 @@ import assert from "node:assert/strict"; import test from "node:test"; import { accountState, + exposureSummary, + isPrivateRoom, + roomRightsText, inviteLink, lastManagerIds, parseInviteHash, @@ -49,3 +52,26 @@ test("only a single active manager is protected", () => { 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); }); + +test("a room is private until another member joins", () => { + assert.equal(isPrivateRoom({ kind: "organization", private: true }), true); + assert.equal(isPrivateRoom({ kind: "organization", private: false }), false); + assert.equal(isPrivateRoom({ kind: "personal", private: true }), false); + assert.equal(isPrivateRoom(null), false); +}); + +test("the room share is described by what the role may do", () => { + assert.equal(roomRightsText({ read: true, edit: true }), "liest und bearbeitet"); + assert.equal(roomRightsText({ read: true, edit: false }), "liest"); + assert.equal(roomRightsText({ read: false, edit: false }), "kein Zugriff"); + assert.equal(roomRightsText(undefined), "kein Zugriff"); +}); + +test("the exposure summary counts only what is shared with the room", () => { + assert.deepEqual(exposureSummary({ cases: { room: 2, private: 5 }, matters: { room: 1, private: 0 } }), { + cases: 2, + matters: 1, + total: 3, + }); + assert.equal(exposureSummary(null).total, 0); +}); diff --git a/frontend/src/pages/Cases.jsx b/frontend/src/pages/Cases.jsx index d6c9d00..26462c1 100644 --- a/frontend/src/pages/Cases.jsx +++ b/frontend/src/pages/Cases.jsx @@ -7,6 +7,7 @@ import { Modal } from "./Modal.jsx"; import "./Sources.jsx"; import { SourcePicker, moduleFor, sourceModules } from "../sources/registry.jsx"; import { ErrorNote, ShareBox } from "./widgets.jsx"; +import { RoomShare } from "../admin/RoomShare.jsx"; import { ContentBoard, DateField, DirectionChoice, MarkdownEditor, ObjectMenu, OrderChoice, RecordTree, SurfaceView, TargetLine, Trail, WorkLists, WorkSwitch, saveChapterOrder, writeSelection } from "./content.jsx"; import { ReadingPane } from "./ReadingPane.jsx"; import { StructureNavigator, Workspace, rememberScroll, restoreScroll, useWorkspaceLayout } from "./workspace.jsx"; @@ -669,6 +670,7 @@ export function CaseDetail() { /> setModal("")}> + {record.is_owner ? : null} diff --git a/frontend/src/pages/Matters.jsx b/frontend/src/pages/Matters.jsx index 104dbee..f22978b 100644 --- a/frontend/src/pages/Matters.jsx +++ b/frontend/src/pages/Matters.jsx @@ -13,6 +13,7 @@ import { ReadingPane } from "./ReadingPane.jsx"; import { StructureNavigator, Workspace, rememberScroll, restoreScroll, useWorkspaceLayout } from "./workspace.jsx"; import { NavIcon } from "./icons.jsx"; import { ExportPackage } from "./ExportPackage.jsx"; +import { RoomShare } from "../admin/RoomShare.jsx"; function pageContext(params) { const kind = params.get("context_kind"); @@ -617,6 +618,7 @@ export function MatterDetail() { /> setModal("")}> + {record.is_owner ? : null} setModal("")}> diff --git a/frontend/src/pages/Rooms.jsx b/frontend/src/pages/Rooms.jsx index 19fef92..d9cee4a 100644 --- a/frontend/src/pages/Rooms.jsx +++ b/frontend/src/pages/Rooms.jsx @@ -1,6 +1,14 @@ 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 { + ROOM_ROLES, + exposureSummary, + formatWhen, + inviteLink, + isPrivateRoom, + lastManagerIds, + roleLabel, +} from "../admin/admin-core.js"; import { OneTimeSecret } from "../admin/widgets.jsx"; import { SessionContext } from "../session.js"; import { ErrorNote } from "./widgets.jsx"; @@ -13,6 +21,15 @@ function RoleSelect({ value, onChange, disabled = false, label }) { ); } +function VisibilitySelect({ value, onChange, disabled = false }) { + return ( + + ); +} + function RoomAdmin({ room, onRenamed, onArchived }) { const [members, setMembers] = useState([]); const [invitations, setInvitations] = useState([]); @@ -23,9 +40,13 @@ function RoomAdmin({ room, onRenamed, onArchived }) { const [inviteRole, setInviteRole] = useState("member"); const [link, setLink] = useState(""); const [confirmArchive, setConfirmArchive] = useState(false); + const [exposure, setExposure] = useState(null); + const [heir, setHeir] = useState(""); const [error, setError] = useState(""); const [notice, setNotice] = useState(""); const guarded = lastManagerIds(members); + const ownerId = members.find((member) => member.is_owner)?.subject_id; + const others = members.filter((member) => !member.is_owner && member.account_status === "active"); async function load() { const [people, open] = await Promise.all([ @@ -39,6 +60,7 @@ function RoomAdmin({ room, onRenamed, onArchived }) { useEffect(() => { setName(room.name); setLink(""); + setExposure(null); load().catch((err) => setError(err.message)); }, [room.id]); @@ -73,15 +95,42 @@ function RoomAdmin({ room, onRenamed, onArchived }) { } } - async function add(event) { - event.preventDefault(); + async function addNow() { await run(async () => { await api(`/api/v1/rooms/${room.id}/members`, { method: "POST", body: { email, role } }); setEmail(""); + setExposure(null); markDirty(false); + await onRenamed(); }, "Das Mitglied ist hinzugefügt."); } + // The first other member turns a private room into a multi-user room. Show what becomes visible. + async function add(event) { + event.preventDefault(); + setError(""); + if (isPrivateRoom(room) || members.length <= 1) { + try { + const result = await api(`/api/v1/rooms/${room.id}/exposure`); + if (exposureSummary(result).total > 0) { + setExposure(result); + return; + } + } catch (err) { + setError(err.message); + return; + } + } + await addNow(); + } + + async function keepPrivateAndAdd() { + await run(async () => { + await api(`/api/v1/rooms/${room.id}/my-content/visibility`, { method: "POST", body: { visibility: "private" } }); + }); + await addNow(); + } + async function invite(event) { event.preventDefault(); setLink(""); @@ -96,9 +145,15 @@ function RoomAdmin({ room, onRenamed, onArchived }) { }); } + const summary = exposure ? exposureSummary(exposure) : null; + return (

{room.name}

+

+ {members.length <= 1 ? "Privater Raum: nur du bist Mitglied." : `Mehrbenutzer-Raum mit ${members.length} Mitgliedern.`} + {room.is_owner ? " Du bist Eigentümer." : ""} +

{notice ?

{notice}

: null} @@ -107,22 +162,36 @@ function RoomAdmin({ room, onRenamed, onArchived }) { + {room.is_owner ? ( + + ) : null} +

Mitglieder

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

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

: null} + {ownerId ?

Der Eigentümer bleibt Verwalter. Übertrage den Raum, wenn jemand anderes ihn führen soll.

: null}
    {ROOM_ROLES.map((item) =>
  • {item.label}: {item.hint}
  • )}
+ {summary ? ( +
+

Dein Raum wird zum Mehrbenutzer-Raum

+

+ {summary.cases} Akte(n) und {summary.matters} Vorgang/Vorgänge von dir sind für Mitglieder sichtbar, abhängig von deren Rolle. + Willst du sie so lassen? +

+
+ + + +
+
+ ) : null} +
{ setEmail(event.target.value); markDirty(true); }} placeholder="E-Mail eines bestehenden Kontos" aria-label="E-Mail eines bestehenden Kontos" required /> + {room.is_owner && others.length ? ( +
{ + event.preventDefault(); + if (!heir) return; + run(async () => { + await api(`/api/v1/rooms/${room.id}/owner`, { method: "POST", body: { subject_id: heir } }); + setHeir(""); + await onRenamed(); + }, "Der Raum ist übertragen."); + }} + > + + +
+ ) : null} +

Einladungen

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

{link ? setLink("")} /> : null} @@ -161,18 +266,22 @@ function RoomAdmin({ room, onRenamed, onArchived }) { ) :

Keine offenen Einladungen.

} -

Archivieren

- {confirmArchive ? ( -
- - -
- ) : ( -
- -
- )} -

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

+ {room.is_owner ? ( + <> +

Archivieren

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

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

+ + ) : null}
); } @@ -180,6 +289,7 @@ function RoomAdmin({ room, onRenamed, onArchived }) { export function Rooms() { const { session, refresh } = useContext(SessionContext); const [name, setName] = useState(""); + const [visibility, setVisibility] = useState("room"); const [archived, setArchived] = useState([]); const [error, setError] = useState(""); const current = session.rooms.find((room) => room.id === session.scope.id); @@ -197,7 +307,7 @@ export function Rooms() { event.preventDefault(); setError(""); try { - await api("/api/v1/rooms", { method: "POST", body: { name } }); + await api("/api/v1/rooms", { method: "POST", body: { name, default_visibility: visibility } }); setName(""); markDirty(false); await refresh(); @@ -222,24 +332,33 @@ export function Rooms() { await loadArchived(); } + function roomLabel(room) { + if (room.kind === "personal") return "Persönlich"; + const state = isPrivateRoom(room) ? "Privat" : "Mehrbenutzer"; + return `${state} · ${roleLabel(room.role)}${room.is_owner ? " · Eigentümer" : ""}`; + } + return (

Datenräume

-

Mitgliedschaft öffnet nicht die persönlichen Akten anderer. Freigaben stehen an der Akte oder am Vorgang.

+

+ Ein Raum ist privat, bis du Personen aufnimmst. Neue Akten sind dann je nach Rolle für Mitglieder sichtbar, außer du stellst sie privat. +

    {session.rooms.map((room) => (
  • {room.name} - {room.kind === "personal" ? "Persönlich" : `Gemeinsam · ${roleLabel(room.role)}`} + {roomLabel(room)}
  • ))}
- { setName(event.target.value); markDirty(true); }} placeholder="Name des gemeinsamen Datenraums" aria-label="Name des gemeinsamen Datenraums" required /> + { setName(event.target.value); markDirty(true); }} placeholder="Name des neuen Datenraums" aria-label="Name des neuen Datenraums" required /> + @@ -258,7 +377,7 @@ export function Rooms() {
  • {room.name} {roleLabel(room.role)} - {room.role === "manager" ? : null} + {room.is_owner ? : null}
  • ))}