diff --git a/backend/app/access/policy.py b/backend/app/access/policy.py index 3756a24..0720120 100644 --- a/backend/app/access/policy.py +++ b/backend/app/access/policy.py @@ -240,27 +240,33 @@ 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. +def room_default(conn, actor: UUID, kind: str, resource_id: UUID) -> Rights: + """Rights of the current members of the rooms a case or matter is shared with. - Only an active room, an active membership and an active account count. The personal - room is never shared. Anything unclear gives no rights. + A room is a team. The rights of one share are the role of the person in that room, + capped by the share (`read` or `edit`). Several shares add up. Only an active room, + an active membership and an active account count. Anything unclear gives no rights. """ - if resource.get("visibility") != "room": - return Rights() - row = conn.execute( + rows = 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' + SELECT m.role, s.access + FROM room_shares s + JOIN room_memberships m ON m.room_id = s.room_id AND m.subject_id = %s AND m.status = 'active' + JOIN data_rooms r ON r.id = s.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' + WHERE s.resource_kind = %s AND s.resource_id = %s """, - (resource["home_scope_id"], actor), - ).fetchone() - if row is None: - return Rights() - return ROOM_RIGHTS.get(row["role"], Rights()) + (actor, kind, resource_id), + ).fetchall() + result = Rights() + for row in rows: + rights = ROOM_RIGHTS.get(row["role"], Rights()) + if row["access"] == "read": + rights = Rights(read=rights.read) + elif row["access"] != "edit": + rights = Rights() + result = result.union(rights) + return result def case_rights(conn, actor: UUID, case: dict) -> Rights: @@ -270,7 +276,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"]).union(room_default(conn, actor, case)) + base = _direct_grant(conn, actor, "case", case["id"]).union(room_default(conn, actor, "case", case["id"])) return base.without(_exceptions(conn, actor, "case", case["id"], None)) @@ -287,7 +293,7 @@ def matter_rights(conn, actor: UUID, matter: dict, context: Ctx | None) -> Right if matter["owner_subject_id"] == actor: base = Rights.full() else: - base = _direct_grant(conn, actor, "matter", matter["id"]).union(room_default(conn, actor, matter)) + base = _direct_grant(conn, actor, "matter", matter["id"]).union(room_default(conn, actor, "matter", matter["id"])) return base.without(_exceptions(conn, actor, "matter", matter["id"], None)) if context.kind == "case": @@ -614,10 +620,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 (EXISTS ( + SELECT 1 FROM room_shares sh + JOIN room_memberships sm ON sm.room_id = sh.room_id AND sm.subject_id = %(actor)s AND sm.status = 'active' + JOIN data_rooms sr ON sr.id = sh.room_id AND sr.kind = 'organization' AND sr.status = 'active' + WHERE sh.resource_kind = 'case' AND sh.resource_id = c.id )) OR ( c.rights_mode = 'inherit_parent' AND c.parent_case_id IS NOT NULL AND EXISTS ( @@ -631,10 +638,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' + OR (EXISTS ( + SELECT 1 FROM room_shares sh + JOIN room_memberships sm ON sm.room_id = sh.room_id AND sm.subject_id = %(actor)s AND sm.status = 'active' + JOIN data_rooms sr ON sr.id = sh.room_id AND sr.kind = 'organization' AND sr.status = 'active' + WHERE sh.resource_kind = 'case' AND sh.resource_id = p.id )) ) ) @@ -666,10 +674,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 room_shares sh + JOIN room_memberships sm ON sm.room_id = sh.room_id AND sm.subject_id = %(actor)s AND sm.status = 'active' + JOIN data_rooms sr ON sr.id = sh.room_id AND sr.kind = 'organization' AND sr.status = 'active' + WHERE sh.resource_kind = 'matter' AND sh.resource_id = m.id )) OR EXISTS ( SELECT 1 FROM matter_case_links l @@ -683,10 +692,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' + OR (EXISTS ( + SELECT 1 FROM room_shares sh + JOIN room_memberships sm ON sm.room_id = sh.room_id AND sm.subject_id = %(actor)s AND sm.status = 'active' + JOIN data_rooms sr ON sr.id = sh.room_id AND sr.kind = 'organization' AND sr.status = 'active' + WHERE sh.resource_kind = 'case' AND sh.resource_id = c.id )) ) ) diff --git a/backend/app/api/deps.py b/backend/app/api/deps.py index 8c26d4d..567b386 100644 --- a/backend/app/api/deps.py +++ b/backend/app/api/deps.py @@ -21,7 +21,7 @@ from psycopg import Connection from app.access.policy import ensure_member_or_personal from app.auth.security import hash_secret, read_session_token -from app.core.errors import forbidden, password_change_required, unauthorized +from app.core.errors import forbidden, password_change_required, scope_changed, unauthorized from app.core.timeutil import utcnow @@ -108,7 +108,7 @@ def get_principal(request: Request, conn: Connection = Depends(get_conn)) -> Pri except ValueError as exc: raise forbidden("Der Datenraum ist nicht gewählt.") from exc if kind != row["scope_kind"] or scope_id != row["scope_id"]: - raise forbidden("Der gewählte Datenraum entspricht nicht mehr der Sitzung.") + raise scope_changed() room = ensure_member_or_personal(conn, row["account_id"], kind, scope_id) return Principal( account_id=row["account_id"], diff --git a/backend/app/api/rooms.py b/backend/app/api/rooms.py index b2b4d4c..037e680 100644 --- a/backend/app/api/rooms.py +++ b/backend/app/api/rooms.py @@ -95,6 +95,21 @@ def _drop_edit_rights_in_room(conn, subject_id: UUID, room_id: UUID) -> None: ) +def _drop_shares_of(conn, room_id: UUID, subject_id: UUID) -> None: + """Whoever leaves a team, or may no longer write in it, takes the shares of their own entries with them.""" + conn.execute( + """ + DELETE FROM room_shares s + WHERE s.room_id = %s + AND ( + (s.resource_kind = 'case' AND s.resource_id IN (SELECT id FROM cases WHERE owner_subject_id = %s)) + OR (s.resource_kind = 'matter' AND s.resource_id IN (SELECT id FROM matters WHERE owner_subject_id = %s)) + ) + """, + (room_id, subject_id, subject_id), + ) + + 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.") @@ -108,6 +123,7 @@ def _set_role(conn, actor: UUID, room_id: UUID, subject_id: UUID, role: str, *, ) if role == "reader": _drop_edit_rights_in_room(conn, subject_id, room_id) + _drop_shares_of(conn, room_id, subject_id) _audit_membership(conn, actor, room_id, subject_id, "membership_added" if added else "membership_role_changed", role) @@ -270,23 +286,27 @@ def transfer_owner( @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.""" + """Own cases and matters: shared with this room (`room`) or filed here but not shared (`private`).""" _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( + for table, kind in (("cases", "case"), ("matters", "matter")): + row = 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 + SELECT + count(*) FILTER (WHERE EXISTS ( + SELECT 1 FROM room_shares s + WHERE s.resource_kind = %s AND s.resource_id = t.id AND s.room_id = %s)) AS shared, + count(*) FILTER (WHERE t.home_scope_id = %s AND NOT EXISTS ( + SELECT 1 FROM room_shares s + WHERE s.resource_kind = %s AND s.resource_id = t.id AND s.room_id = %s)) AS filed + FROM {table} t + WHERE t.owner_subject_id = %s AND t.deleted_at IS NULL """, - (room_id, principal.account_id), - ).fetchall() - counts = {"private": 0, "room": 0} - counts.update({row["visibility"]: row["n"] for row in rows}) - result[key] = counts + (kind, room_id, room_id, kind, room_id, principal.account_id), + ).fetchone() + result[table] = {"room": row["shared"], "private": row["filed"]} return JSONResponse(result, headers=_NO_STORE) @@ -297,21 +317,39 @@ def set_my_content( 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`: share every own entry filed in this room with it. `private`: end all own shares to it.""" _room(conn, room_id) - if room_role(conn, principal.account_id, room_id) is None: + role = room_role(conn, principal.account_id, room_id) + if role 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 body.visibility == "room": + if role not in {"member", "manager"}: + raise forbidden("Als Leser kannst du nichts mit dem Datenraum teilen.") + for table, kind in (("cases", "case"), ("matters", "matter")): + rows = conn.execute( + f""" + INSERT INTO room_shares (resource_kind, resource_id, room_id, access, created_by) + SELECT %s, t.id, %s, 'edit', %s FROM {table} t + WHERE t.home_scope_id = %s AND t.owner_subject_id = %s AND t.deleted_at IS NULL + ON CONFLICT DO NOTHING + RETURNING id + """, + (kind, room_id, principal.account_id, room_id, principal.account_id), + ).fetchall() + changed += len(rows) + else: + for table, kind in (("cases", "case"), ("matters", "matter")): + rows = conn.execute( + f""" + DELETE FROM room_shares s + WHERE s.room_id = %s AND s.resource_kind = %s + AND s.resource_id IN (SELECT id FROM {table} WHERE owner_subject_id = %s) + RETURNING s.id + """, + (room_id, kind, principal.account_id), + ).fetchall() + changed += len(rows) if changed: audit( conn, @@ -417,6 +455,16 @@ def remove_member( "UPDATE room_memberships SET status = 'removed' WHERE room_id = %s AND subject_id = %s", (room_id, subject_id), ) + _drop_shares_of(conn, room_id, subject_id) + # The removed person works in the personal room again; own entries stay visible there. + conn.execute( + """ + UPDATE auth_sessions + SET scope_kind = 'personal', scope_id = account_id, epoch = epoch + 1 + WHERE account_id = %s AND scope_id = %s AND revoked_at IS NULL + """, + (subject_id, room_id), + ) _audit_membership(conn, principal.account_id, room_id, subject_id, "membership_removed") return Response(status_code=204) diff --git a/backend/app/api/roomshare.py b/backend/app/api/roomshare.py index cb755b9..bfd2720 100644 --- a/backend/app/api/roomshare.py +++ b/backend/app/api/roomshare.py @@ -1,55 +1,94 @@ -"""Room share of a case or matter: shared with the room members by role, or private.""" +"""Room shares of a case or matter. A room is a team: the owner shares an entry with any of the +rooms he is a member of, independent of where the entry is filed.""" from __future__ import annotations from uuid import UUID -from fastapi import APIRouter, Depends +from fastapi import APIRouter, Depends, Response from fastapi.responses import JSONResponse from psycopg import Connection -from app.access.policy import ROOM_RIGHTS +from app.access.policy import ROOM_RIGHTS, 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 +from app.api.schemas import ExclusionIn, RoomShareIn +from app.ops import _shareable, set_person_exclusion, share_with_room, unshare_from_room router = APIRouter() _NO_STORE = {"Cache-Control": "no-store"} +def _capped(role: str, access: str) -> Rights: + rights = ROOM_RIGHTS.get(role, Rights()) + return Rights(read=rights.read) if access == "read" else rights + + def _view(conn, actor: UUID, kind: str, resource_id: UUID) -> dict: - resource = _shareable(conn, actor, kind, resource_id) - members = conn.execute( + _shareable(conn, actor, kind, resource_id) + shares = 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 + SELECT s.room_id, s.access, r.name, r.status + FROM room_shares s JOIN data_rooms r ON r.id = s.room_id + WHERE s.resource_kind = %s AND s.resource_id = %s + ORDER BY r.name, r.id """, - (kind, resource_id, resource["home_scope_id"], actor), + (kind, resource_id), + ).fetchall() + result = [] + for share in shares: + 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, share["room_id"], actor), + ).fetchall() + result.append( + { + "room_id": str(share["room_id"]), + "room_name": share["name"], + "archived": share["status"] != "active", + "access": share["access"], + "members": [ + { + "subject_id": str(row["subject_id"]), + "display_name": row["display_name"], + "role": row["role"], + "excluded": row["excluded"], + "rights": { + "read": _capped(row["role"], share["access"]).read, + "edit": _capped(row["role"], share["access"]).edit, + }, + } + for row in members + ], + } + ) + shared_ids = {item["room_id"] for item in result} + candidates = conn.execute( + """ + SELECT r.id, r.name, m.role + FROM room_memberships m JOIN data_rooms r ON r.id = m.room_id + WHERE m.subject_id = %s AND m.status = 'active' AND m.role IN ('member', 'manager') + AND r.kind = 'organization' AND r.status = 'active' + ORDER BY r.name, r.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 + "shares": result, + "available": [ + {"id": str(row["id"]), "name": row["name"]} for row in candidates if str(row["id"]) not in shared_ids ], } @@ -61,14 +100,25 @@ def _register(kind: str, plural: str) -> None: 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") + @router.put(base + "/rooms/{room_id}", name=f"put_{kind}_room_share") def put_share( resource_id: UUID, - body: VisibilityIn, + room_id: UUID, + body: RoomShareIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn), ): - return set_visibility(conn, principal.account_id, kind, resource_id, body.visibility) + return share_with_room(conn, principal.account_id, kind, resource_id, room_id, body.access) + + @router.delete(base + "/rooms/{room_id}", status_code=204, name=f"delete_{kind}_room_share") + def delete_share( + resource_id: UUID, + room_id: UUID, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), + ): + unshare_from_room(conn, principal.account_id, kind, resource_id, room_id) + return Response(status_code=204) @router.put(base + "/people/{subject_id}", name=f"put_{kind}_room_share_person") def put_person( @@ -84,5 +134,3 @@ def _register(kind: str, plural: str) -> None: _register("case", "cases") _register("matter", "matters") - - diff --git a/backend/app/api/schemas.py b/backend/app/api/schemas.py index 7103fd0..facd4e5 100644 --- a/backend/app/api/schemas.py +++ b/backend/app/api/schemas.py @@ -72,6 +72,10 @@ class VisibilityIn(APIModel): visibility: Literal["private", "room"] +class RoomShareIn(APIModel): + access: Literal["read", "edit"] = "edit" + + class ExclusionIn(APIModel): excluded: bool diff --git a/backend/app/core/errors.py b/backend/app/core/errors.py index d560a6a..e1782d5 100644 --- a/backend/app/core/errors.py +++ b/backend/app/core/errors.py @@ -54,6 +54,15 @@ def unsupported(detail: str) -> Problem: return Problem(422, "Nicht unterstützt", detail, "unsupported") +def scope_changed() -> Problem: + return Problem( + 403, + "Datenraum gewechselt", + "Der gewählte Datenraum entspricht nicht mehr der Sitzung. Die Ansicht wird neu geladen.", + "scope_changed", + ) + + def password_change_required() -> Problem: return Problem( 403, diff --git a/backend/app/ops.py b/backend/app/ops.py index 4bffa41..8b13ad0 100644 --- a/backend/app/ops.py +++ b/backend/app/ops.py @@ -8,7 +8,7 @@ from uuid import UUID, uuid4 from psycopg.types.json import Json -from app.access.roles import ensure_can_create +from app.access.roles import ensure_can_create, room_role from app.access.policy import ( Ctx, Rights, @@ -75,15 +75,27 @@ def _placement(context: Ctx, placement: Ctx | None) -> tuple[Ctx, Ctx]: def default_visibility(conn, scope_id: UUID) -> str: - """New cases and matters follow the room preset. The personal room is always private.""" + """Whether new cases and matters are shared with their room at once. The personal room never is.""" 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 _auto_share(conn, actor: UUID, kind: str, resource: dict) -> None: + if default_visibility(conn, resource["home_scope_id"]) == "room": + conn.execute( + """ + INSERT INTO room_shares (resource_kind, resource_id, room_id, access, created_by) + VALUES (%s, %s, %s, 'edit', %s) + ON CONFLICT DO NOTHING + """, + (kind, resource["id"], resource["home_scope_id"], actor), + ) + + 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.""" + """The own case or matter. Only the owner decides which rooms it is shared with.""" if kind == "case": resource = get_case(conn, resource_id) elif kind == "matter": @@ -92,31 +104,71 @@ def _shareable(conn, actor: UUID, kind: str, resource_id: UUID) -> dict: 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.") +def _target_room(conn, actor: UUID, room_id: UUID) -> dict: + room = conn.execute("SELECT id, kind, status FROM data_rooms WHERE id = %s", (room_id,)).fetchone() + if room is None or room["kind"] != "organization" or room["status"] != "active": + raise not_found() + if room_role(conn, actor, room_id) not in {"member", "manager"}: + raise forbidden("Du kannst nur mit Datenräumen teilen, in denen du Mitglied oder Verwalter bist.") + return room + + +def share_with_room(conn, actor: UUID, kind: str, resource_id: UUID, room_id: UUID, access: str) -> dict: + if access not in {"read", "edit"}: + raise unprocessable("Die Freigabeart 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} + _target_room(conn, actor, room_id) + existing = conn.execute( + "SELECT access FROM room_shares WHERE resource_kind = %s AND resource_id = %s AND room_id = %s", + (kind, resource_id, room_id), + ).fetchone() + conn.execute( + """ + INSERT INTO room_shares (resource_kind, resource_id, room_id, access, created_by) + VALUES (%s, %s, %s, %s, %s) + ON CONFLICT (resource_kind, resource_id, room_id) DO UPDATE SET access = EXCLUDED.access + """, + (kind, resource_id, room_id, access, actor), + ) + if existing is None or existing["access"] != access: + audit( + conn, + actor, + resource["home_scope_id"], + "room_shared" if existing is None else "room_share_changed", + kind, + resource_id, + detail={"room_id": str(room_id), "access": access}, + ) + return {"room_id": str(room_id), "access": access} + + +def unshare_from_room(conn, actor: UUID, kind: str, resource_id: UUID, room_id: UUID) -> None: + resource = _shareable(conn, actor, kind, resource_id) + row = conn.execute( + "DELETE FROM room_shares WHERE resource_kind = %s AND resource_id = %s AND room_id = %s RETURNING id", + (kind, resource_id, room_id), + ).fetchone() + if row is None: + raise not_found() + audit(conn, actor, resource["home_scope_id"], "room_unshared", kind, resource_id, detail={"room_id": str(room_id)}) 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.""" + """Take one person out of the room shares 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), + """ + SELECT 1 FROM room_shares s + JOIN room_memberships m ON m.room_id = s.room_id AND m.subject_id = %s AND m.status = 'active' + WHERE s.resource_kind = %s AND s.resource_id = %s + """, + (subject_id, kind, resource_id), ).fetchone() if member is None: raise not_found() @@ -157,12 +209,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, visibility + content_order, content_order_dir ) - VALUES (%s, %s, %s, %s, 'explicit', 'date', 'asc', %s) + VALUES (%s, %s, %s, %s, 'explicit', 'date', 'asc') RETURNING * """, - (scope_id, actor, actor, title, default_visibility(conn, scope_id)), + (scope_id, actor, actor, title), ).fetchone() else: parent, _rights = require_case(conn, actor, parent_case_id, "edit") @@ -174,16 +226,14 @@ 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, visibility + content_order, content_order_dir ) - VALUES (%s, %s, %s, %s, %s, %s, 'date', 'asc', %s) + VALUES (%s, %s, %s, %s, %s, %s, 'date', 'asc') RETURNING * """, - ( - parent["home_scope_id"], actor, actor, title, parent["id"], rights_mode, - default_visibility(conn, parent["home_scope_id"]), - ), + (parent["home_scope_id"], actor, actor, title, parent["id"], rights_mode), ).fetchone() + _auto_share(conn, actor, "case", row) audit(conn, actor, row["home_scope_id"], "case_created", "case", row["id"]) return row @@ -425,11 +475,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, visibility + home_scope_id, owner_subject_id, created_by, title, content_order, content_order_dir ) - VALUES (%s, %s, %s, %s, 'date', 'asc', %s) RETURNING * + VALUES (%s, %s, %s, %s, 'date', 'asc') RETURNING * """, - (scope_id, actor, actor, title, default_visibility(conn, scope_id)), + (scope_id, actor, actor, title), ).fetchone() else: parent, _rights = require_matter(conn, actor, parent_matter_id, context, "edit") @@ -439,12 +489,13 @@ 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, visibility + content_order, content_order_dir ) - VALUES (%s, %s, %s, %s, %s, 'date', 'asc', %s) RETURNING * + VALUES (%s, %s, %s, %s, %s, 'date', 'asc') RETURNING * """, - (parent["home_scope_id"], actor, actor, title, parent["id"], default_visibility(conn, parent["home_scope_id"])), + (parent["home_scope_id"], actor, actor, title, parent["id"]), ).fetchone() + _auto_share(conn, actor, "matter", row) audit(conn, actor, row["home_scope_id"], "matter_created", "matter", row["id"], context) return row diff --git a/backend/app/present.py b/backend/app/present.py index 17eb56f..d5646c4 100644 --- a/backend/app/present.py +++ b/backend/app/present.py @@ -634,7 +634,6 @@ 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(), } @@ -780,7 +779,6 @@ 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", @@ -1055,6 +1053,9 @@ LABELS = { "invitation_revoked": "Einladung widerrufen", "invitation_accepted": "Einladung angenommen", "visibility_changed": "Raumfreigabe geändert", + "room_shared": "Mit Datenraum geteilt", + "room_share_changed": "Freigabe an Datenraum geändert", + "room_unshared": "Freigabe an Datenraum beendet", "person_excluded": "Person von der Raumfreigabe ausgenommen", "person_included": "Person wieder in die Raumfreigabe aufgenommen", "room_owner_changed": "Eigentümer des Datenraums gewechselt", diff --git a/backend/migrations/20261021T150000Z_room_shares.sql b/backend/migrations/20261021T150000Z_room_shares.sql new file mode 100644 index 0000000..aba6d26 --- /dev/null +++ b/backend/migrations/20261021T150000Z_room_shares.sql @@ -0,0 +1,32 @@ +-- Raum als Team: Eine Akte oder ein Vorgang wird mit beliebigen Datenräumen geteilt, +-- unabhängig vom Heimatraum. Der Heimatraum bleibt Ablage. Die Freigabe zum Heimatraum +-- aus 20261021T090000Z_room_access.sql wird übernommen, danach entfallen die Spalten. + +CREATE TABLE room_shares ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + resource_kind text NOT NULL, + resource_id uuid NOT NULL, + room_id uuid NOT NULL REFERENCES data_rooms (id), + -- Obergrenze der Freigabe: 'edit' = Rechte nach Raumrolle, 'read' = höchstens Lesen. + access text NOT NULL DEFAULT 'edit', + created_by uuid NOT NULL REFERENCES auth_accounts (id), + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT room_shares_kind CHECK (resource_kind IN ('case', 'matter')), + CONSTRAINT room_shares_access CHECK (access IN ('read', 'edit')), + UNIQUE (resource_kind, resource_id, room_id) +); + +CREATE INDEX room_shares_room ON room_shares (room_id); + +INSERT INTO room_shares (resource_kind, resource_id, room_id, access, created_by) +SELECT 'case', c.id, c.home_scope_id, 'edit', c.owner_subject_id +FROM cases c +WHERE c.visibility = 'room'; + +INSERT INTO room_shares (resource_kind, resource_id, room_id, access, created_by) +SELECT 'matter', m.id, m.home_scope_id, 'edit', m.owner_subject_id +FROM matters m +WHERE m.visibility = 'room'; + +ALTER TABLE cases DROP CONSTRAINT cases_visibility, DROP COLUMN visibility; +ALTER TABLE matters DROP CONSTRAINT matters_visibility, DROP COLUMN visibility; diff --git a/backend/tests/test_room_access.py b/backend/tests/test_room_access.py index 2fc2110..bcfaccb 100644 --- a/backend/tests/test_room_access.py +++ b/backend/tests/test_room_access.py @@ -1,4 +1,4 @@ -"""Raumfreigabe: Mitglieder erhalten Rechte an Akten und Vorgängen ihres Raums nach Rolle.""" +"""Raum als Team: Akten und Vorgänge werden mit Datenräumen geteilt, unabhängig vom Heimatraum.""" from __future__ import annotations @@ -15,21 +15,42 @@ def _second_client(): return TestClient(app) -def _make(db, email: str, name: str, *, superadmin: bool = False): - account = create_account(db, email, name, PASSWORD, is_superadmin=superadmin) +def _make(db, email: str, name: str): + account = create_account(db, email, name, PASSWORD) db.commit() return account +def _actor(client, db, key: str, email: str, *, main: bool = False) -> Actor: + actor = Actor(client if main else _second_client(), email, key.title()) + _make(db, actor.email, actor.name) + actor.login() + return actor + + +def _id(db, email: str) -> str: + row = db.execute("SELECT id FROM auth_accounts WHERE email = %s", (email,)).fetchone() + db.rollback() + return str(row["id"]) + + +def _share(actor: Actor, plural: str, resource_id: str, room: str, access: str = "edit", status: int = 200): + return actor.request("PUT", f"/api/v1/{plural}/{resource_id}/room-share/rooms/{room}", json={"access": access}, status=status) + + +def _unshare(actor: Actor, plural: str, resource_id: str, room: str, status: int = 204): + return actor.request("DELETE", f"/api/v1/{plural}/{resource_id}/room-share/rooms/{room}", status=status) + + @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 + actors = { + "ada": _actor(client, db, "ada", "ada-raum@example.test", main=True), + "ben": _actor(client, db, "ben", "ben-raum@example.test"), + "cem": _actor(client, db, "cem", "cem-raum@example.test"), + "dan": _actor(client, db, "dan", "dan-raum@example.test"), + } ada = actors["ada"] room = ada.request("POST", "/api/v1/rooms", json={"name": "Werkstatt"}, status=201) assert room["default_visibility"] == "room" @@ -40,14 +61,11 @@ def world(client, db): 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"] +def test_a_new_entry_follows_the_room_preset_and_rights_follow_the_role(world, db): + ada, ben, cem, dan, room = world["ada"], world["ben"], world["cem"], world["dan"], world["room"] 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" + view = ada.request("GET", f"/api/v1/cases/{shared['id']}/room-share") + assert [(s["room_name"], s["access"]) for s in view["shares"]] == [("Werkstatt", "edit")] assert ben.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == { "read": True, "edit": True, "share": False, "delete": False, @@ -56,170 +74,235 @@ def test_the_room_share_gives_rights_by_role(world, db): "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 "Gemeinsame Akte" in {item["title"] for item in ben.request("GET", "/api/v1/cases")["items"]} 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, - ) + 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"] +def test_unsharing_and_leaving_take_the_rights_back_at_once(world, db): + ada, ben, room = world["ada"], world["ben"], world["room"] 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"}) + _unshare(ada, "cases", case["id"], room) 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"}) + _share(ada, "cases", case["id"], 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) + ada.request("DELETE", f"/api/v1/rooms/{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"] +def test_an_archived_room_shares_nothing_until_it_is_restored(world, db): + ada, ben, room = world["ada"], world["ben"], world["room"] 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.execute("UPDATE data_rooms SET status = 'archived' WHERE id = %s", (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.execute("UPDATE data_rooms SET status = 'active' WHERE id = %s", (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"] +def test_the_owner_sees_all_own_entries_whatever_happens_to_the_room(world, db): + ada, ben, room = world["ada"], world["ben"], world["room"] + mine = ada.request("POST", "/api/v1/cases", json={"title": "Meine Akte im Raum"}, status=201) + personal = Actor(ada.client, ada.email, ada.name) + personal_body = personal.login() + personal.request("POST", "/api/v1/cases", json={"title": "Meine persönliche Akte"}, status=201) + # Ben owns an entry filed in the room; Ada, the owner of the room, does not see it. + ben.use_room(room) + bens = ben.request("POST", "/api/v1/cases", json={"title": "Bens Akte"}, status=201) + + def titles(actor): + return {item["title"] for item in actor.request("GET", "/api/v1/cases")["items"]} + + assert {"Meine Akte im Raum", "Meine persönliche Akte"} <= titles(personal) + assert "Bens Akte" in titles(personal) # shared with the room by the preset + _unshare(ben, "cases", bens["id"], room) + assert "Bens Akte" not in titles(personal) + assert "Bens Akte" in titles(ben) + + # Ben leaves the room, the room is archived: he still sees and edits what he owns. + personal.request("DELETE", f"/api/v1/rooms/{room}/members/{_id(db, ben.email)}", status=204) + # Ben's old room headers no longer fit his session; he is told to reload, then lists everything he owns. + assert ben.request("GET", "/api/v1/cases", status=403)["code"] == "scope_changed" + body = ben.request("GET", "/api/v1/auth/session") + assert body["scope"]["kind"] == "personal" + ben.scope, ben.csrf = body["scope"], body["csrf_token"] + assert "Bens Akte" in titles(ben) + ben.request("GET", f"/api/v1/cases/{bens['id']}") + db.execute("UPDATE data_rooms SET status = 'archived' WHERE id = %s", (room,)) + db.commit() + assert {"Meine Akte im Raum", "Meine persönliche Akte"} <= titles(personal) + personal.request("GET", f"/api/v1/cases/{mine['id']}") + assert personal_body["account"]["email"] == ada.email + + +def test_one_member_can_be_excluded(world, db): + ada, ben, cem, dan = world["ada"], world["ben"], world["cem"], world["dan"] 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}) + assert {(m["display_name"], m["role"]) for m in view["shares"][0]["members"]} == {("Ben", "member"), ("Cem", "reader")} + base = f"/api/v1/cases/{case['id']}/room-share/people" + ada.request("PUT", f"{base}/{_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}) + assert any(m["excluded"] for m in ada.request("GET", f"/api/v1/cases/{case['id']}/room-share")["shares"][0]["members"]) + ada.request("PUT", f"{base}/{_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) + ada.request("PUT", f"{base}/{_id(db, ada.email)}", json={"excluded": True}, status=422) + ada.request("PUT", f"{base}/{_id(db, dan.email)}", json={"excluded": True}, status=404) + ben.request("PUT", f"{base}/{_id(db, cem.email)}", json={"excluded": True}, status=404) -def test_matters_and_their_contents_follow_the_room_role(world, db): +def test_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, - ) + case = ada.request("POST", "/api/v1/cases", json={"title": "Akte mit Notiz"}, 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, - ) + context = {"kind": "case", "id": case["id"]} + ben.request("PATCH", f"/api/v1/notes/{note['id']}", json={"expected_version": note["version"], "document": document("Von Ben ergänzt"), "context": context}) + cem.request("PATCH", f"/api/v1/notes/{note['id']}", json={"expected_version": note["version"] + 1, "document": document("Nein"), "context": context}, 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"]) + assert any(i["title"] == "Notiz in der Akte" for i 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"] +def test_a_standalone_matter_is_shared_like_a_case(world, db): + ada, ben, cem, room = world["ada"], world["ben"], world["cem"], world["room"] 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"}) + _unshare(ada, "matters", matter["id"], room) 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"] +def test_subcases_follow_their_parent(world, db): + ada, ben, room = world["ada"], world["ben"], world["room"] 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, + "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"}) + _unshare(ada, "cases", parent["id"], room) + _unshare(ada, "cases", child["id"], room) 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_an_entry_in_the_personal_room_can_be_shared_with_a_team(world, db): + ada, ben, dan, room = world["ada"], world["ben"], world["dan"], world["room"] + personal = Actor(ada.client, ada.email, ada.name) + personal.login() + case = personal.request("POST", "/api/v1/cases", json={"title": "Aus dem persönlichen Raum"}, status=201) + assert personal.request("GET", f"/api/v1/cases/{case['id']}/room-share")["shares"] == [] + ben.request("GET", f"/api/v1/cases/{case['id']}", status=404) + shared = personal.request("GET", f"/api/v1/cases/{case['id']}/room-share") + assert [item["name"] for item in shared["available"]] == ["Werkstatt"] + _share(personal, "cases", case["id"], room) + ben.request("GET", f"/api/v1/cases/{case['id']}") + dan.request("GET", f"/api/v1/cases/{case['id']}", status=404) -def test_existing_content_stays_private_and_the_bulk_action_changes_only_own(world, db): - ada, ben = world["ada"], world["ben"] +def test_one_matter_goes_to_the_lawyer_and_the_rest_of_the_case_stays_hidden(client, db): + ada = _actor(client, db, "ada", "ada-anwalt@example.test", main=True) + lawyer = _actor(client, db, "anwalt", "anwalt@example.test") + team = ada.request("POST", "/api/v1/rooms", json={"name": "Anwalt Müller", "default_visibility": "private"}, status=201) + ada.request("POST", f"/api/v1/rooms/{team['id']}/members", json={"email": lawyer.email, "role": "member"}) + case = ada.request("POST", "/api/v1/cases", json={"title": "Vermietung"}, status=201) + shared = ada.request("POST", "/api/v1/matters", json={"title": "Mietminderung"}, status=201) + hidden = ada.request("POST", "/api/v1/matters", json={"title": "Eigenbedarf intern"}, status=201) + for matter in (shared, hidden): + ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201) + note_on(ada, "Schreiben des Mieters", "Minderung", case["id"]) + _share(ada, "matters", shared["id"], team["id"], access="edit") + + lawyer.request("GET", f"/api/v1/cases/{case['id']}", status=404) + assert lawyer.request("GET", "/api/v1/cases")["items"] == [] + listed = {item["title"] for item in lawyer.request("GET", "/api/v1/matters")["items"]} + assert listed == {"Mietminderung"} + lawyer.request("GET", f"/api/v1/matters/{hidden['id']}", status=404) + assert lawyer.request("GET", f"/api/v1/matters/{shared['id']}")["rights"]["edit"] is True + + +def test_the_share_caps_the_role_and_several_rooms_add_up(world, db): + ada, ben, room = world["ada"], world["ben"], world["room"] + other = ada.request("POST", "/api/v1/rooms", json={"name": "Zweites Team", "default_visibility": "private"}, status=201) + ada.request("POST", f"/api/v1/rooms/{other['id']}/members", json={"email": ben.email, "role": "member"}) + case = ada.request("POST", "/api/v1/cases", json={"title": "Begrenzt"}, status=201) + _share(ada, "cases", case["id"], room, access="read") + assert ben.request("GET", f"/api/v1/cases/{case['id']}")["rights"]["edit"] is False + _share(ada, "cases", case["id"], other["id"], access="edit") + assert ben.request("GET", f"/api/v1/cases/{case['id']}")["rights"]["edit"] is True + _unshare(ada, "cases", case["id"], other["id"]) + assert ben.request("GET", f"/api/v1/cases/{case['id']}")["rights"]["edit"] is False + _unshare(ada, "cases", case["id"], other["id"], status=404) + + +def test_only_the_owner_shares_and_only_into_rooms_where_he_writes(world, db): + ada, ben, cem, dan, room = world["ada"], world["ben"], world["cem"], world["dan"], world["room"] + case = ada.request("POST", "/api/v1/cases", json={"title": "Nur Ada teilt"}, status=201) + ben.request("PUT", f"/api/v1/cases/{case['id']}/room-share/rooms/{room}", json={"access": "edit"}, status=404) + ben.request("DELETE", f"/api/v1/cases/{case['id']}/room-share/rooms/{room}", status=404) + bens = ben.request("GET", "/api/v1/auth/session") # Ben may share his own entries into rooms he writes in + assert any(r["id"] == room for r in bens["rooms"]) + ben.use_room(room) + own = ben.request("POST", "/api/v1/cases", json={"title": "Bens"}, status=201) + # A reader may not share into the room; an outsider cannot even see it. + cem.use_room(room) + cem_own = Actor(cem.client, cem.email, cem.name) + cem_own.login() + mine = cem_own.request("POST", "/api/v1/cases", json={"title": "Von Cem"}, status=201) + cem_own.request("PUT", f"/api/v1/cases/{mine['id']}/room-share/rooms/{room}", json={"access": "edit"}, status=403) + dan_own = Actor(dan.client, dan.email, dan.name) + dan_own.login() + theirs = dan_own.request("POST", "/api/v1/cases", json={"title": "Von Dan"}, status=201) + dan_own.request("PUT", f"/api/v1/cases/{theirs['id']}/room-share/rooms/{room}", json={"access": "edit"}, status=403) + assert own["title"] == "Bens" + + +def test_leaving_the_team_takes_the_own_shares_along(world, db): + ada, ben, cem, room = world["ada"], world["ben"], world["cem"], world["room"] + ben.use_room(room) + bens = ben.request("POST", "/api/v1/cases", json={"title": "Bens Freigabe"}, status=201) + cem.request("GET", f"/api/v1/cases/{bens['id']}") + ada.request("PATCH", f"/api/v1/rooms/{room}/members/{_id(db, ben.email)}", json={"role": "reader"}) + cem.request("GET", f"/api/v1/cases/{bens['id']}", status=404) + ben.request("GET", f"/api/v1/cases/{bens['id']}") + + +def test_the_bulk_action_and_the_exposure_count_own_entries(world, db): + ada, ben, room = world["ada"], world["ben"], world["room"] 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.execute("DELETE FROM room_shares WHERE resource_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} + assert ada.request("GET", f"/api/v1/rooms/{room}/exposure")["cases"] == {"room": 0, "private": 1} + assert ada.request("POST", f"/api/v1/rooms/{room}/my-content/visibility", json={"visibility": "room"}) == {"changed": 1} ben.request("GET", f"/api/v1/cases/{old['id']}") - ben.use_room(world["room"]) + assert ada.request("GET", f"/api/v1/rooms/{room}/exposure")["cases"] == {"room": 1, "private": 0} + ben.use_room(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"}) + ada.request("POST", f"/api/v1/rooms/{room}/my-content/visibility", json={"visibility": "private"}) + ben.request("GET", f"/api/v1/cases/{old['id']}", status=404) ben.request("GET", f"/api/v1/cases/{theirs['id']}") - world["dan"].request("GET", f"/api/v1/rooms/{world['room']}/exposure", status=403) + world["dan"].request("GET", f"/api/v1/rooms/{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() +def test_a_room_can_start_without_sharing(client, db): + ada = _actor(client, db, "ada", "ada-start@example.test", main=True) + ben = _actor(client, db, "ben", "ben-start@example.test") 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) diff --git a/docs/architecture/API_REFERENZ.md b/docs/architecture/API_REFERENZ.md index 6263778..a58f2ae 100644 --- a/docs/architecture/API_REFERENZ.md +++ b/docs/architecture/API_REFERENZ.md @@ -66,9 +66,10 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R** | 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 | +| GET | `/api/v1/rooms/{id}/exposure` | S+R, Mitglied | eigene Akten und Vorgänge: mit dem Raum geteilt (`room`) oder dort abgelegt, aber nicht geteilt (`private`) | +| POST | `/api/v1/rooms/{id}/my-content/visibility` | S+R, Mitglied | `room`: alle eigenen im Raum abgelegten Akten und Vorgänge mit dem Raum teilen; `private`: alle eigenen Freigaben an diesen Raum beenden | +| GET | `/api/v1/cases/{id}/room-share`, `/api/v1/matters/{id}/room-share` | S+R, Owner | Freigaben des Eintrags an Datenräume (mit Mitgliedern, Rolle, Ausnahme) und die Räume, mit denen er noch teilen kann | +| PUT / DELETE | `/api/v1/cases/{id}/room-share/rooms/{room_id}`, `/api/v1/matters/{id}/room-share/rooms/{room_id}` | S+R, Owner | mit dem Raum teilen (`access`: `edit` = Rechte nach Rolle, `read` = höchstens Lesen) oder die Freigabe beenden; nur in Räumen, in denen der Owner Mitglied oder Verwalter ist | | 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 | diff --git a/docs/architecture/BENUTZERVERWALTUNG.md b/docs/architecture/BENUTZERVERWALTUNG.md index b864829..b1c1198 100644 --- a/docs/architecture/BENUTZERVERWALTUNG.md +++ b/docs/architecture/BENUTZERVERWALTUNG.md @@ -35,7 +35,7 @@ Grants auf Objekte anderer Räume bleiben unberührt. - **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. +- **Raumfreigabe:** Ein Raum ist ein Team. Der Owner teilt eine Akte, Unterakte oder einen Vorgang mit einem oder mehreren seiner Räume, unabhängig davon, wo der Eintrag abgelegt ist. Mitglieder erhalten Rechte nach Rolle (Leser lesen; Mitglied und Verwalter bearbeiten; Weitergeben und Löschen nie), die Freigabe kann auf „nur lesen“ begrenzt werden, einzelne Personen lassen sich ausnehmen. Ein einzelner Vorgang lässt sich teilen, ohne die Akte offenzulegen (Beispiel: nur die Vorgänge, die der Anwalt sehen soll). Die Voreinstellung eines Raums teilt neu angelegte Einträge, die in diesem Raum entstehen, automatisch mit ihm. Der Owner sieht seine Einträge unabhängig von Raum und Mitgliedschaft. Wer ein Team verlässt oder Leser wird, nimmt seine Freigaben an dieses Team mit; wer aus einem Raum entfernt wird, arbeitet danach im persönlichen Raum. Beim ersten weiteren Mitglied zeigt die Oberfläche, was bereits mit dem Raum geteilt ist. Bestehende Freigaben wurden übernommen, nicht geteilte Einträge blieben 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. diff --git a/docs/architecture/DATENMODELL_IST.md b/docs/architecture/DATENMODELL_IST.md index dee88a4..6c50b07 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: `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. +**Stand:** 19.10.2026, nach den Migrationen in `backend/migrations/` (letzte: `20261021T150000Z_room_shares.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. @@ -22,7 +22,7 @@ Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TE | `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 | +| `room_shares` | `resource_kind` (`case`/`matter`), `resource_id`, `room_id`, `access` (`read`/`edit`), `created_by` | Freigabe einer Akte oder eines Vorgangs an einen Datenraum (Team); eindeutig je Eintrag und Raum. Endet, wenn der Freigebende den Raum verlässt oder Leser wird | | `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 346f6fa..208b502 100644 --- a/docs/architecture/RECHTEMODELL_IST.md +++ b/docs/architecture/RECHTEMODELL_IST.md @@ -93,7 +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). +- **Raumfreigabe** (Tabelle `room_shares`): Der Owner teilt eine Akte oder einen Vorgang mit beliebigen Datenräumen, in denen er Mitglied oder Verwalter ist. Der Heimatraum spielt dafür keine Rolle. Aktive Mitglieder eines aktiven Raums erhalten Rechte nach Rolle: Leser lesen, Mitglied und Verwalter lesen und bearbeiten, Weitergeben und Löschen nie (`ROOM_RIGHTS`, `room_default` in `policy.py`). Die Obergrenze der Freigabe (`access = read`) begrenzt auf Lesen. Mehrere Freigaben addieren sich, danach wirken Ausnahmen. Eine Personenausnahme (Grant mit `is_exception` auf eine Person, Kontext leer) nimmt eine Person aus. Elemente und Aufgaben ohne Akte oder Vorgang bleiben beim Owner. Die Rechte der Akte reichen in Vorgänge und Inhalte wie bisher; ein Vorgang kann einzeln geteilt werden, ohne dass die Akte sichtbar wird. Der Owner sieht seine Einträge unabhängig von Raum und Mitgliedschaft. Das Löschen von Akte und Vorgang verlangt Owner oder ausdrückliches Löschrecht, nicht mehr nur Bearbeiten (schließt R-01 des Reviews). - 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 decf618..c8d1151 100644 --- a/docs/product/TSUMUGU_PRODUCT_SPEC.md +++ b/docs/product/TSUMUGU_PRODUCT_SPEC.md @@ -436,11 +436,11 @@ 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 +### R-01 – Datenräume als Teams, 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. +**Beschluss:** Der Nutzer bestätigt: (1) Ein Datenraum ist ein **Team**, kein Ablageort einer Akte. Jede Person kann mehrere Rä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. Er verwaltet Mitglieder, Rollen, Name, Archivierung und Übertragung, liest aber über diese Rolle keine fremden Inhalte. Der Raum ist übertragbar; der Betreiber kann protokolliert einspringen. (3) **Raumfreigabe:** Der Owner einer Akte, Unterakte oder eines Vorgangs teilt sie mit einem oder mehreren seiner Räume, unabhängig davon, wo der Eintrag abgelegt ist. Die Mitglieder erhalten Rechte nach ihrer Rolle im Raum: Leser lesen, Mitglied und Verwalter bearbeiten. Die Freigabe kann auf „nur lesen“ begrenzt werden. Der Owner kann einzelne Personen ausnehmen. Weitergeben, Löschen und Eigentum bleiben beim Owner. Ein Vorgang lässt sich einzeln teilen, ohne dass die Akte oder die übrigen Vorgänge sichtbar werden. (4) Der Owner sieht seine Einträge unabhängig von jedem Raum. -**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). +**Begründung und Auswirkungen:** Die Akte bleibt der Rechteanker (F-01, S-01); die Raumfreigabe ist eine zweite, dynamische Rechtequelle neben den Einzelfreigaben je Person. Der Heimatraum eines Eintrags ist nur noch Ablage und Mandantengrenze (Technische Spezifikation 4.1) und bestimmt keine Rechte. Bestehende Freigaben der ersten Fassung (Freigabe an den Heimatraum) wurden in Raumfreigaben übernommen; Einträge ohne Freigabe 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. Verlässt eine Person ein Team oder wird sie Leser, enden ihre Freigaben an dieses Team. Umsetzungsstand: [BENUTZERVERWALTUNG.md](../architecture/BENUTZERVERWALTUNG.md). ## 6. Fortschreibung diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx index cda9b7b..c77636d 100644 --- a/frontend/src/App.jsx +++ b/frontend/src/App.jsx @@ -52,6 +52,21 @@ export function App() { }; }, []); + useEffect(() => { + // The server moved the session to another data room (removed, archived). Reload the session. + function onScopeChanged() { + api("/api/v1/auth/session") + .then((data) => { + applySession(data); + setSession(data); + navigate("/"); + }) + .catch(() => {}); + } + window.addEventListener("tsumugu:scope-changed", onScopeChanged); + return () => window.removeEventListener("tsumugu:scope-changed", onScopeChanged); + }, []); + async function refresh() { const data = await api("/api/v1/auth/session"); applySession(data); diff --git a/frontend/src/admin/RoomShare.jsx b/frontend/src/admin/RoomShare.jsx index 83b9200..4d1c6a6 100644 --- a/frontend/src/admin/RoomShare.jsx +++ b/frontend/src/admin/RoomShare.jsx @@ -3,26 +3,26 @@ 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. +// The owner of a case or matter shares it with rooms. A room is a team: the share reaches +// the members by their role there, whatever room the entry is filed in. export function RoomShare({ resource, id, onChange }) { const [view, setView] = useState(null); const [error, setError] = useState(""); - const [hidden, setHidden] = useState(false); + const [choice, setChoice] = useState(""); + const [open, setOpen] = useState(""); 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); + setError(err.message); } } useEffect(() => { - setHidden(false); setView(null); + setChoice(""); load(); }, [path]); @@ -37,45 +37,77 @@ export function RoomShare({ resource, id, onChange }) { } } - if (hidden) return null; - const shared = view?.visibility === "room"; + const put = (roomId, access) => api(`${path}/rooms/${roomId}`, { method: "PUT", body: { access } }); return ( -
-

Im Datenraum

+
+

Mit Datenräumen teilen

+

+ Ein Datenraum ist ein Team. Teilst du diesen Eintrag mit ihm, erhalten die Mitglieder Rechte nach ihrer Rolle. Wo der Eintrag + abgelegt ist, spielt dafür keine Rolle. Weitergeben und Löschen bleiben bei dir. +

{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.shares.length ? (
    - {view.members.map((member) => ( -
  • - {member.display_name} - {roleLabel(member.role)} · {member.excluded ? "ausgenommen" : roomRightsText(member.rights)} - + + {open === share.room_id ? ( +
      + {share.members.map((member) => ( +
    • + {member.display_name} · {roleLabel(member.role)} · {member.excluded ? "ausgenommen" : roomRightsText(member.rights)}{" "} + +
    • + ))} + {!share.members.length ?
    • Außer dir gibt es keine Mitglieder.
    • : null} +
    + ) : null}
  • ))}
- ) : null} + ) : ( +

Dieser Eintrag ist mit keinem Datenraum geteilt.

+ )} + {view.available.length ? ( +
{ + event.preventDefault(); + if (choice) run(async () => { await put(choice, "edit"); setChoice(""); }); + }} + > + + +
+ ) : ( +

Es gibt keinen weiteren Datenraum, in dem du Mitglied oder Verwalter bist.

+ )} ) : !error ? (

Wird geladen …

diff --git a/frontend/src/api.js b/frontend/src/api.js index 3af0986..f356bc3 100644 --- a/frontend/src/api.js +++ b/frontend/src/api.js @@ -62,6 +62,9 @@ export async function api(path, { method = "GET", body, form } = {}) { error.status = response.status; error.code = data?.code; if (response.status === 401) clearSession(); + if (data?.code === "scope_changed" && typeof window !== "undefined") { + window.dispatchEvent(new Event("tsumugu:scope-changed")); + } throw error; } return data; diff --git a/frontend/src/pages/Rooms.jsx b/frontend/src/pages/Rooms.jsx index d9cee4a..72a0c03 100644 --- a/frontend/src/pages/Rooms.jsx +++ b/frontend/src/pages/Rooms.jsx @@ -23,9 +23,9 @@ function RoleSelect({ value, onChange, disabled = false, label }) { function VisibilitySelect({ value, onChange, disabled = false }) { return ( - onChange(event.target.value)} disabled={disabled} aria-label="Neue Einträge im Datenraum"> + + ); } @@ -164,7 +164,7 @@ function RoomAdmin({ room, onRenamed, onArchived }) { {room.is_owner ? ( ) : null} @@ -208,12 +208,12 @@ function RoomAdmin({ room, onRenamed, onArchived }) {

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? + {summary.cases} Akte(n) und {summary.matters} Vorgang/Vorgänge von dir sind mit diesem Raum geteilt. Neue Mitglieder erhalten Rechte nach ihrer Rolle. + Willst du die Freigaben so lassen?

- - + +
@@ -344,7 +344,7 @@ export function Rooms() {

Datenräume

- 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. + Ein Raum ist privat, bis du Personen aufnimmst. Ein Raum ist ein Team: Du teilst Akten und Vorgänge mit ihm, die Mitglieder erhalten Rechte nach ihrer Rolle.