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:
1 parent
037c0724a8
commit
1c2f045e7d
25 files changed
+1088
-61
No files matched your search
@@ -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
@@ -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")
|
||||
|
||||
|
||||
|
||||
@@ -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")
|
||||
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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
|
||||
@@ -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
@@ -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,),
|
||||
|
||||
@@ -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
@@ -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'));
|
||||
@@ -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()
|
||||
|
||||
@@ -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)
|
||||
@@ -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"})
|
||||
|
||||
@@ -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"])
|
||||
|
||||
@@ -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 |
|
||||
|
||||
@@ -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`.
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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.
|
||||
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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>
|
||||
);
|
||||
}
|
||||
@@ -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 };
|
||||
}
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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>
|
||||
</>
|
||||
|
||||
@@ -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
@@ -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>
|
||||
|
||||
Reference in new issue
Block a user