Führe Raum-Eigentümer und Raumfreigabe ein, damit aus einem privaten Raum ein Mehrbenutzer-Raum wird.

Jeder Datenraum hat einen Eigentümer, der Verwalter bleibt, den Raum übertragen kann und im Notfall vom Betreiber ersetzt wird. Neue Akten und Vorgänge folgen der Voreinstellung des Raums: Bei "im Raum teilen" lesen Leser sie und bearbeiten Mitglieder und Verwalter; Weitergeben und Löschen bleiben beim Owner, der eine Akte privat stellen oder einzelne Personen ausnehmen kann. Bestehende Akten bleiben privat. Beim ersten weiteren Mitglied zeigt die Oberfläche, was sichtbar wird.

Das Löschen von Akte und Vorgang verlangt jetzt den Owner statt nur das Bearbeitungsrecht und schließt damit R-01. Die Rechte der Raumfreigabe gelten nur bei aktivem Raum, aktiver Mitgliedschaft und aktivem Konto.

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

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
LarsandClaude Sonnet 5.5 committed 2026-10-20 15:40:30 +02:00
1 parent 037c0724a8
commit 1c2f045e7d
25 files changed
+1088 -61

No files matched your search

+65 -2
View File
@@ -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'
))
)
)
)
+177 -6
View File
@@ -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")
+88
View File
@@ -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")
+18
View File
@@ -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):
+37 -5
View File
@@ -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
+2
View File
@@ -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)
+96 -15
View File
@@ -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,),
+7
View File
@@ -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",
}
+3 -3
View File
@@ -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')",
@@ -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'));
+1 -1
View File
@@ -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()
+231
View File
@@ -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)
+39 -1
View File
@@ -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"})
+1 -1
View File
@@ -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"])
+7 -1
View File
@@ -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 |
+9 -1
View File
@@ -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`.
+3 -1
View File
@@ -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
+1
View File
@@ -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.
+6
View File
@@ -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.
+85
View File
@@ -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 (
<section className="card stack" aria-label="Raumfreigabe">
<h2>Im Datenraum</h2>
<ErrorNote error={error} />
{view ? (
<>
<label className="check">
<input
type="checkbox"
checked={shared}
onChange={(event) => run(() => api(path, { method: "PUT", body: { visibility: event.target.checked ? "room" : "private" } }))}
/>
Für die Mitglieder des Datenraums sichtbar
</label>
<p className="muted">
{shared
? "Leser lesen, Mitglieder und Verwalter bearbeiten. Weitergeben und Löschen bleiben bei dir."
: "Nur du und ausdrücklich freigegebene Personen sehen diesen Eintrag."}
</p>
{shared && view.members.length ? (
<ul className="index">
{view.members.map((member) => (
<li key={member.subject_id}>
<strong>{member.display_name}</strong>
<span>{roleLabel(member.role)} · {member.excluded ? "ausgenommen" : roomRightsText(member.rights)}</span>
<button
type="button"
className="quiet"
onClick={() => run(() => api(`${path}/people/${member.subject_id}`, { method: "PUT", body: { excluded: !member.excluded } }))}
>
{member.excluded ? "Wieder aufnehmen" : "Ausnehmen"}
</button>
</li>
))}
</ul>
) : null}
</>
) : !error ? (
<p className="muted">Wird geladen …</p>
) : null}
</section>
);
}
+18
View File
@@ -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 };
}
+26
View File
@@ -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);
});
+2
View File
@@ -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() {
/>
</Modal>
<Modal open={modal === "share"} title="Teilen" onClose={() => setModal("")}>
{record.is_owner ? <RoomShare resource="cases" id={id} onChange={load} /> : null}
<ShareBox path={`/api/v1/cases/${id}/grants`} grants={record.grants || []} onChange={load} allowSources={Boolean(record.is_owner)} />
</Modal>
</>
+2
View File
@@ -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() {
/>
</Modal>
<Modal open={modal === "share"} title="Teilen" onClose={() => setModal("")}>
{record.is_owner ? <RoomShare resource="matters" id={id} onChange={load} /> : null}
<ShareBox path={`/api/v1/matters/${id}/grants`} grants={record.grants || []} onChange={load} allowSources={Boolean(record.is_owner)} />
</Modal>
<Modal open={modal === "move"} title="Vorgang verschieben" onClose={() => setModal("")}>
+143 -24
View File
@@ -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 (
<select value={value} onChange={(event) => onChange(event.target.value)} disabled={disabled} aria-label="Neue Akten im Datenraum">
<option value="room">Für Mitglieder sichtbar</option>
<option value="private">Zunächst privat</option>
</select>
);
}
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 (
<section className="card stack" aria-label={`Verwaltung von ${room.name}`}>
<h2>{room.name}</h2>
<p className="muted">
{members.length <= 1 ? "Privater Raum: nur du bist Mitglied." : `Mehrbenutzer-Raum mit ${members.length} Mitgliedern.`}
{room.is_owner ? " Du bist Eigentümer." : ""}
</p>
<ErrorNote error={error} />
{notice ? <p className="notice" role="status">{notice}</p> : null}
@@ -107,22 +162,36 @@ function RoomAdmin({ room, onRenamed, onArchived }) {
<button type="submit" disabled={name.trim() === room.name}>Umbenennen</button>
</form>
{room.is_owner ? (
<label>
Neue Akten und Vorgänge in diesem Raum
<VisibilitySelect
value={room.default_visibility}
onChange={(next) => run(async () => {
await api(`/api/v1/rooms/${room.id}`, { method: "PATCH", body: { default_visibility: next } });
await onRenamed();
}, "Die Voreinstellung ist gespeichert.")}
/>
<span className="muted">Gilt für neu angelegte Einträge. Jeder Eigentümer einer Akte kann sie einzeln privat stellen.</span>
</label>
) : null}
<h3>Mitglieder</h3>
<ul className="index">
{members.map((member) => (
<li key={member.subject_id}>
<strong>{member.display_name}</strong>
<strong>{member.display_name}{member.is_owner ? " (Eigentümer)" : ""}</strong>
<span>{member.email}{member.account_status === "disabled" ? " · Konto deaktiviert" : ""}</span>
<RoleSelect
value={member.role}
label={`Rolle von ${member.display_name}`}
disabled={guarded.has(member.subject_id)}
disabled={member.is_owner || guarded.has(member.subject_id)}
onChange={(next) => run(() => api(`/api/v1/rooms/${room.id}/members/${member.subject_id}`, { method: "PATCH", body: { role: next } }), "Die Rolle ist geändert.")}
/>
<button
type="button"
className="quiet"
disabled={guarded.has(member.subject_id)}
disabled={member.is_owner || guarded.has(member.subject_id)}
onClick={() => run(() => api(`/api/v1/rooms/${room.id}/members/${member.subject_id}`, { method: "DELETE" }), "Das Mitglied ist entfernt.")}
>
Entfernen
@@ -130,17 +199,53 @@ function RoomAdmin({ room, onRenamed, onArchived }) {
</li>
))}
</ul>
{guarded.size ? <p className="muted">Der letzte Verwalter bleibt Verwalter. Ernenne zuerst eine weitere Person.</p> : null}
{ownerId ? <p className="muted">Der Eigentümer bleibt Verwalter. Übertrage den Raum, wenn jemand anderes ihn führen soll.</p> : null}
<ul className="muted">
{ROOM_ROLES.map((item) => <li key={item.value}><strong>{item.label}:</strong> {item.hint}</li>)}
</ul>
{summary ? (
<div className="card stack" role="alertdialog" aria-label="Sichtbarkeit bestätigen">
<h3>Dein Raum wird zum Mehrbenutzer-Raum</h3>
<p>
{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?
</p>
<div className="row">
<button type="button" onClick={addNow}>Sichtbar lassen und aufnehmen</button>
<button type="button" className="quiet" onClick={keepPrivateAndAdd}>Zuerst privat stellen und aufnehmen</button>
<button type="button" className="quiet" onClick={() => setExposure(null)}>Abbrechen</button>
</div>
</div>
) : null}
<form onSubmit={add} className="inline">
<input type="email" value={email} onChange={(event) => { setEmail(event.target.value); markDirty(true); }} placeholder="E-Mail eines bestehenden Kontos" aria-label="E-Mail eines bestehenden Kontos" required />
<RoleSelect value={role} onChange={setRole} label="Rolle des neuen Mitglieds" />
<button type="submit">Mitglied hinzufügen</button>
</form>
{room.is_owner && others.length ? (
<form
className="inline"
onSubmit={(event) => {
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.");
}}
>
<select value={heir} onChange={(event) => setHeir(event.target.value)} aria-label="Neuer Eigentümer">
<option value="">Eigentümer übertragen an …</option>
{others.map((member) => <option key={member.subject_id} value={member.subject_id}>{member.display_name}</option>)}
</select>
<button type="submit" className="quiet" disabled={!heir}>Übertragen</button>
</form>
) : null}
<h3>Einladungen</h3>
<p className="muted">Für Personen ohne Konto. Du erhältst einen Link, den du selbst weitergibst. Er gilt 7 Tage und einmal.</p>
{link ? <OneTimeSecret title="Einladungslink" value={link} onDone={() => setLink("")} /> : null}
@@ -161,18 +266,22 @@ function RoomAdmin({ room, onRenamed, onArchived }) {
</ul>
) : <p className="muted">Keine offenen Einladungen.</p>}
<h3>Archivieren</h3>
{confirmArchive ? (
<div className="row">
<button type="button" className="danger" onClick={archive}>Datenraum wirklich archivieren</button>
<button type="button" className="quiet" onClick={() => setConfirmArchive(false)}>Abbrechen</button>
</div>
) : (
<div className="row">
<button type="button" className="danger" onClick={() => setConfirmArchive(true)}>Datenraum archivieren</button>
</div>
)}
<p className="muted">Ein archivierter Datenraum lässt sich nicht mehr wählen. Seine Inhalte bleiben erhalten, du kannst ihn unten wieder aktivieren.</p>
{room.is_owner ? (
<>
<h3>Archivieren</h3>
{confirmArchive ? (
<div className="row">
<button type="button" className="danger" onClick={archive}>Datenraum wirklich archivieren</button>
<button type="button" className="quiet" onClick={() => setConfirmArchive(false)}>Abbrechen</button>
</div>
) : (
<div className="row">
<button type="button" className="danger" onClick={() => setConfirmArchive(true)}>Datenraum archivieren</button>
</div>
)}
<p className="muted">Ein archivierter Datenraum lässt sich nicht mehr wählen. Seine Inhalte bleiben erhalten, du kannst ihn unten wieder aktivieren.</p>
</>
) : null}
</section>
);
}
@@ -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 (
<main className="page">
<header className="page-head">
<div>
<h1>Datenräume</h1>
<p className="muted">Mitgliedschaft öffnet nicht die persönlichen Akten anderer. Freigaben stehen an der Akte oder am Vorgang.</p>
<p className="muted">
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.
</p>
</div>
</header>
<ul className="index">
{session.rooms.map((room) => (
<li key={room.id}>
<strong>{room.name}</strong>
<span>{room.kind === "personal" ? "Persönlich" : `Gemeinsam · ${roleLabel(room.role)}`}</span>
<span>{roomLabel(room)}</span>
</li>
))}
</ul>
<form onSubmit={create} className="inline">
<input value={name} onChange={(event) => { setName(event.target.value); markDirty(true); }} placeholder="Name des gemeinsamen Datenraums" aria-label="Name des gemeinsamen Datenraums" required />
<input value={name} onChange={(event) => { setName(event.target.value); markDirty(true); }} placeholder="Name des neuen Datenraums" aria-label="Name des neuen Datenraums" required />
<VisibilitySelect value={visibility} onChange={setVisibility} />
<button type="submit">Datenraum anlegen</button>
</form>
<ErrorNote error={error} />
@@ -258,7 +377,7 @@ export function Rooms() {
<li key={room.id}>
<strong>{room.name}</strong>
<span>{roleLabel(room.role)}</span>
{room.role === "manager" ? <button type="button" className="quiet" onClick={() => restore(room)}>Wieder aktivieren</button> : null}
{room.is_owner ? <button type="button" className="quiet" onClick={() => restore(room)}>Wieder aktivieren</button> : null}
</li>
))}
</ul>