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

+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,),