Merge develop: Quellenfreigabe im Datenraum je Person
Deploy Production / deploy (push) Successful in 44s

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
LarsandClaude Opus 5.5 committed 2026-11-04 15:51:20 +01:00
commit cfa94fc84d
15 files changed
+362 -13

No files matched your search

+36 -7
View File
@@ -458,8 +458,35 @@ def _source_grant(conn, actor: UUID, kind: str, resource_id: UUID) -> dict | Non
).fetchone()
def room_source_access(conn, actor: UUID, kind: str, resource_id: UUID, owner_id: UUID) -> bool:
"""Whether a room the entry is shared with lets this member read the owner's linked originals.
The owner has switched it on for this person in that room. Only an active room, an active
membership with a reading role and an active account count.
"""
readers = [role for role, rights in ROOM_RIGHTS.items() if rights.read]
row = conn.execute(
"""
SELECT 1
FROM room_shares s
JOIN room_memberships m ON m.room_id = s.room_id AND m.subject_id = %s AND m.status = 'active'
JOIN data_rooms r ON r.id = s.room_id AND r.kind = 'organization' AND r.status = 'active'
JOIN auth_accounts a ON a.id = m.subject_id AND a.status = 'active'
JOIN room_source_access x ON x.room_id = s.room_id AND x.subject_id = m.subject_id AND x.owner_id = %s
WHERE s.resource_kind = %s AND s.resource_id = %s AND m.role = ANY(%s)
LIMIT 1
""",
(actor, owner_id, kind, resource_id, readers),
).fetchone()
return row is not None
def mediated_source_owner(conn, actor: UUID, element: dict, context: Ctx | None) -> UUID | None:
"""Owner whose stored connector may serve this reader. None unless the grant allows it."""
"""Owner whose stored connector may serve this reader.
None unless the owner allowed it, either on the personal grant or for this person in a room
the entry is shared with. Read rights and exceptions are checked first.
"""
if context is None or not element_rights(conn, actor, element, context).read:
return None
if context.kind == "case":
@@ -467,19 +494,21 @@ def mediated_source_owner(conn, actor: UUID, element: dict, context: Ctx | None)
if resource is None:
return None
resource = _rights_bearing_case(conn, resource)
grant = _source_grant(conn, actor, "case", resource["id"])
elif context.kind == "matter":
resource = get_matter(conn, context.id)
if resource is None:
return None
grant = _source_grant(conn, actor, "matter", resource["id"])
else:
return None
if resource["owner_subject_id"] == actor:
owner = resource["owner_subject_id"]
if owner == actor:
return None
if grant is None or not grant["can_read"] or not grant["use_owner_sources"]:
return None
return resource["owner_subject_id"]
grant = _source_grant(conn, actor, context.kind, resource["id"])
if grant is not None and grant["can_read"] and grant["use_owner_sources"]:
return owner
if room_source_access(conn, actor, context.kind, resource["id"], owner):
return owner
return None
def element_rights_via_case_or_direct(conn, actor: UUID, element: dict, context: Ctx | None) -> Rights:
+86
View File
@@ -30,6 +30,7 @@ from app.api.schemas import (
OwnerIn,
RoomIn,
RoomPatchIn,
SourceAccessIn,
VisibilityIn,
)
from app.auth.accounts import normalize_email
@@ -114,6 +115,27 @@ def _drop_shares_of(conn, room_id: UUID, subject_id: UUID) -> None:
""",
(room_id, subject_id, subject_id),
)
# Without own shares in the room there is nothing left to lend.
conn.execute(
"DELETE FROM room_source_access WHERE room_id = %s AND owner_id = %s",
(room_id, subject_id),
)
def _drop_source_access_to(conn, room_id: UUID, subject_id: UUID) -> None:
"""A person who leaves the team loses every source access lent to them there. A return starts without it."""
conn.execute(
"DELETE FROM room_source_access WHERE room_id = %s AND subject_id = %s",
(room_id, subject_id),
)
def _lent_to(conn, room_id: UUID, owner_id: UUID) -> set[UUID]:
rows = conn.execute(
"SELECT subject_id FROM room_source_access WHERE room_id = %s AND owner_id = %s",
(room_id, owner_id),
).fetchall()
return {row["subject_id"] for row in rows}
def _set_role(conn, actor: UUID, room_id: UUID, subject_id: UUID, role: str, *, added: bool) -> None:
@@ -391,6 +413,7 @@ def members(room_id: UUID, principal: Principal = Depends(get_principal), conn:
""",
(room_id,),
).fetchall()
lent = _lent_to(conn, room_id, principal.account_id)
return {
"items": [
{
@@ -400,6 +423,8 @@ def members(room_id: UUID, principal: Principal = Depends(get_principal), conn:
"role": row["role"],
"account_status": row["status"],
"is_owner": row["subject_id"] == owner_id,
"is_self": row["subject_id"] == principal.account_id,
"my_sources": row["subject_id"] in lent,
}
for row in rows
]
@@ -472,6 +497,7 @@ def remove_member(
(room_id, subject_id),
)
_drop_shares_of(conn, room_id, subject_id)
_drop_source_access_to(conn, room_id, subject_id)
# The removed person works in the personal room again; own entries stay visible there.
conn.execute(
"""
@@ -485,6 +511,66 @@ def remove_member(
return Response(status_code=204)
@router.put("/api/v1/rooms/{room_id}/source-access/{subject_id}")
def put_source_access(
room_id: UUID,
subject_id: UUID,
body: SourceAccessIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
"""Lend the own connectors to one member for the own entries shared with this room.
Only the person whose connectors are used decides. That is anyone who may share into the room.
"""
actor = principal.account_id
room = conn.execute(
"SELECT id, status FROM data_rooms WHERE id = %s AND kind = 'organization'", (room_id,)
).fetchone()
if room is None or room_role(conn, actor, room_id) is None:
raise not_found()
if room["status"] != "active":
raise unprocessable("Der Datenraum ist archiviert.")
if room_role(conn, actor, room_id) not in {"member", "manager"}:
raise forbidden("Quellen gibt frei, wer in diesem Datenraum teilen darf.")
if subject_id == actor:
raise unprocessable("Die eigenen Zugänge brauchen keine Freigabe.")
if room_role(conn, subject_id, room_id) is None:
raise not_found()
if body.enabled:
created = conn.execute(
"""
INSERT INTO room_source_access (room_id, owner_id, subject_id)
VALUES (%s, %s, %s)
ON CONFLICT DO NOTHING
RETURNING subject_id
""",
(room_id, actor, subject_id),
).fetchone()
changed = created is not None
else:
removed = conn.execute(
"""
DELETE FROM room_source_access
WHERE room_id = %s AND owner_id = %s AND subject_id = %s
RETURNING subject_id
""",
(room_id, actor, subject_id),
).fetchone()
changed = removed is not None
if changed:
audit(
conn,
actor,
room_id,
"room_source_access_granted" if body.enabled else "room_source_access_revoked",
"membership",
subject_id,
detail={"room_id": str(room_id)},
)
return {"subject_id": str(subject_id), "enabled": body.enabled}
@router.post("/api/v1/invitations")
def invite(
body: InvitationIn,
+6
View File
@@ -37,6 +37,11 @@ def _view(conn, actor: UUID, kind: str, resource_id: UUID) -> dict:
(kind, resource_id),
).fetchall()
result = []
lent = conn.execute(
"SELECT room_id, subject_id FROM room_source_access WHERE owner_id = %s",
(actor,),
).fetchall()
lent_pairs = {(row["room_id"], row["subject_id"]) for row in lent}
for share in shares:
members = conn.execute(
"""
@@ -65,6 +70,7 @@ def _view(conn, actor: UUID, kind: str, resource_id: UUID) -> dict:
"display_name": row["display_name"],
"role": row["role"],
"excluded": row["excluded"],
"sources": (share["room_id"], row["subject_id"]) in lent_pairs,
"rights": {
"read": _capped(row["role"], share["access"]).read,
"edit": _capped(row["role"], share["access"]).edit,
+4
View File
@@ -95,6 +95,10 @@ class ExclusionIn(APIModel):
excluded: bool
class SourceAccessIn(APIModel):
enabled: bool
class OwnerIn(APIModel):
subject_id: UUID
+2
View File
@@ -1078,6 +1078,8 @@ LABELS = {
"room_unshared": "Freigabe an Datenraum beendet",
"person_excluded": "Person von der Raumfreigabe ausgenommen",
"person_included": "Person wieder in die Raumfreigabe aufgenommen",
"room_source_access_granted": "Originale über eigene Zugänge im Datenraum freigegeben",
"room_source_access_revoked": "Originale über eigene Zugänge im Datenraum entzogen",
"room_owner_changed": "Eigentümer des Datenraums gewechselt",
"room_default_changed": "Voreinstellung des Datenraums geändert",
"room_download_policy_changed": "Download-Regel des Datenraums geändert",
@@ -0,0 +1,14 @@
-- Quellenfreigabe im Raum: Eine Person erlaubt einem Mitglied, die verknüpften Originale
-- ihrer mit diesem Raum geteilten Akten und Vorgänge über ihre eigenen Zugänge zu lesen.
-- Die Freigabe gilt je Raum, je verleihender Person und je Mitglied. Sie entsteht nur ausdrücklich.
CREATE TABLE room_source_access (
room_id uuid NOT NULL REFERENCES data_rooms (id),
owner_id uuid NOT NULL REFERENCES auth_accounts (id),
subject_id uuid NOT NULL REFERENCES auth_accounts (id),
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (room_id, owner_id, subject_id),
CONSTRAINT room_source_access_other CHECK (owner_id <> subject_id)
);
CREATE INDEX room_source_access_subject ON room_source_access (subject_id, room_id);
+178
View File
@@ -0,0 +1,178 @@
"""Room members read linked originals through the owner's connector only when the owner lends it to them."""
from __future__ import annotations
import json
import pytest
from fastapi.testclient import TestClient
import app.sources as sources
from app.auth.accounts import create_account
from tests.support import ORIGIN, PASSWORD, Actor
OWNER_TOKEN = "raum-owner-paperless-token"
UNAVAILABLE = "Das Original ist über die Freigabe nicht abrufbar."
def _second_client():
from app.main import app
return TestClient(app)
def _actor(client, db, key: str, email: str, *, main: bool = False) -> Actor:
actor = Actor(client if main else _second_client(), email, key.title())
create_account(db, actor.email, actor.name, PASSWORD)
db.commit()
actor.login()
return actor
def _id(db, email: str) -> str:
row = db.execute("SELECT id FROM auth_accounts WHERE email = %s", (email,)).fetchone()
db.rollback()
return str(row["id"])
def _raw(actor: Actor, path: str):
headers = {"Origin": ORIGIN, "X-CSRF-Token": actor.csrf}
if actor.scope is not None:
headers["X-Scope-Kind"] = actor.scope["kind"]
headers["X-Scope-Id"] = actor.scope["id"]
return actor.client.get(path, headers=headers)
def _lend(actor: Actor, room: str, subject: str, enabled: bool, status: int = 200):
return actor.request(
"PUT",
f"/api/v1/rooms/{room}/source-access/{subject}",
json={"enabled": enabled},
status=status,
)
@pytest.fixture
def world(client, db, monkeypatch):
"""Ada owns the room and a case with a Paperless document. Ben is a member, Cem a reader, Dan outside."""
calls = []
def fake_file(base, token, path, max_bytes=40 * 1024 * 1024):
calls.append({"token": token, "path": path})
if path.endswith("/preview/"):
return (b"%PDF-1.4\nraum\n", "application/pdf", "vertrag.pdf")
return None
monkeypatch.setattr(sources, "_paperless_file", fake_file)
monkeypatch.setattr(sources, "_paperless_metadata", lambda *args, **kwargs: None)
actors = {
"ada": _actor(client, db, "ada", "ada-rq@example.test", main=True),
"ben": _actor(client, db, "ben", "ben-rq@example.test"),
"cem": _actor(client, db, "cem", "cem-rq@example.test"),
"dan": _actor(client, db, "dan", "dan-rq@example.test"),
}
ada = actors["ada"]
room = ada.request("POST", "/api/v1/rooms", json={"name": "Mandat"}, status=201)["id"]
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": actors["ben"].email, "role": "member"})
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": actors["cem"].email, "role": "reader"})
ada.use_room(room)
actors["cem"].use_room(room)
actors["ben"].use_room(room)
paper = ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "paperless", "name": "Ada Archiv", "base_url": "https://paper.example.test", "token": OWNER_TOKEN},
status=201,
)["id"]
case = ada.request("POST", "/api/v1/cases", json={"title": "Mandatsakte"}, status=201)
document = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Vertrag",
"source": "paperless",
"external_id": "15",
"context": {"kind": "case", "id": case["id"]},
"detail": {"connector_id": paper},
},
status=201,
)
actors.update(
room=room,
case=case["id"],
path=f"/api/v1/external-refs/{document['id']}/content?context_kind=case&context_id={case['id']}",
calls=calls,
ids={key: _id(db, actors[key].email) for key in ("ada", "ben", "cem", "dan")},
)
return actors
def test_a_room_reader_reads_originals_only_after_the_owner_lends_them(world, db):
ada, cem, room, ids, calls = world["ada"], world["cem"], world["room"], world["ids"], world["calls"]
assert cem.request("GET", f"/api/v1/cases/{world['case']}")["rights"]["read"] is True
refused = _raw(cem, world["path"])
assert refused.status_code == 422
assert refused.json()["detail"] == UNAVAILABLE
assert calls == []
_lend(ada, room, ids["cem"], True)
members = ada.request("GET", f"/api/v1/rooms/{room}/members")["items"]
flags = {item["subject_id"]: item["my_sources"] for item in members}
assert flags[ids["cem"]] is True
assert flags[ids["ben"]] is False
share = ada.request("GET", f"/api/v1/cases/{world['case']}/room-share")
shown = {item["subject_id"]: item["sources"] for item in share["shares"][0]["members"]}
assert shown[ids["cem"]] is True
opened = _raw(cem, world["path"])
assert opened.status_code == 200, opened.text
assert opened.content.startswith(b"%PDF")
assert calls == [{"token": OWNER_TOKEN, "path": "/api/documents/15/preview/"}]
assert OWNER_TOKEN not in json.dumps(cem.request("GET", f"/api/v1/cases/{world['case']}"))
events = db.execute(
"SELECT result FROM domain_events WHERE action = 'source_read_mediated' AND actor_subject_id = %s",
(ids["cem"],),
).fetchall()
db.rollback()
assert [row["result"] for row in events] == ["ok"]
_lend(ada, room, ids["cem"], False)
assert _raw(cem, world["path"]).status_code == 422
def test_only_the_lending_person_decides_and_only_for_members(world):
ada, ben, cem, dan, room, ids = world["ada"], world["ben"], world["cem"], world["dan"], world["room"], world["ids"]
# Ben lends his own connectors to Cem. That does not open Ada's originals.
_lend(ben, room, ids["cem"], True)
assert _raw(cem, world["path"]).status_code == 422
# A reader cannot share into the room and so cannot lend.
_lend(cem, room, ids["ben"], True, status=403)
# Outsiders and non-members are not addressable.
_lend(dan, room, ids["cem"], True, status=404)
_lend(ada, room, ids["dan"], True, status=404)
_lend(ada, room, ids["ada"], True, status=422)
def test_exclusion_leaving_the_room_and_ending_the_share_close_the_access(world):
ada, cem, room, ids = world["ada"], world["cem"], world["room"], world["ids"]
_lend(ada, room, ids["cem"], True)
assert _raw(cem, world["path"]).status_code == 200
ada.request("PUT", f"/api/v1/cases/{world['case']}/room-share/people/{ids['cem']}", json={"excluded": True})
assert _raw(cem, world["path"]).status_code == 404
ada.request("PUT", f"/api/v1/cases/{world['case']}/room-share/people/{ids['cem']}", json={"excluded": False})
assert _raw(cem, world["path"]).status_code == 200
ada.request("DELETE", f"/api/v1/cases/{world['case']}/room-share/rooms/{room}", status=204)
assert _raw(cem, world["path"]).status_code == 404
ada.request("PUT", f"/api/v1/cases/{world['case']}/room-share/rooms/{room}", json={"access": "read"})
assert _raw(cem, world["path"]).status_code == 200
ada.request("DELETE", f"/api/v1/rooms/{room}/members/{ids['cem']}", status=204)
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": cem.email, "role": "reader"})
cem.use_room(room)
assert _raw(cem, world["path"]).status_code == 422
flags = {item["subject_id"]: item["my_sources"] for item in ada.request("GET", f"/api/v1/rooms/{room}/members")["items"]}
assert flags[ids["cem"]] is False
+3 -2
View File
@@ -62,7 +62,8 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
| POST | `/api/v1/rooms` | S+R | gemeinsamen Raum anlegen, Anlegende Person wird Verwalter |
| 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 / PUT | `/api/v1/rooms/{id}/download-policy` | S+R, Mitglied / E | je Rolle (`manager`, `member`, `reader`), ob das Original gespeichert oder geöffnet werden darf; `can_change` nennt, ob die Person ändern darf. Fremde und unbekannte Räume: 404. Audit `room_download_policy_changed` |
| GET | `/api/v1/rooms/{id}/members` | S+R, M | Mitglieder mit Rolle und Kontostatus |
| GET | `/api/v1/rooms/{id}/members` | S+R, M | Mitglieder mit Rolle und Kontostatus, `is_self` und `my_sources` (eigene Quellenfreigabe an die Person) |
| PUT | `/api/v1/rooms/{id}/source-access/{subject_id}` | S+R, Mitglied oder Verwalter | `enabled`: dem Mitglied die verknüpften Originale der eigenen, mit dem Raum geteilten Einträge über die eigenen Zugänge freigeben oder entziehen (protokolliert) |
| 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 |
@@ -212,7 +213,7 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
| GET | `/api/v1/external-refs/{id}/mail/attachments/{index}` | Anlage (`inline`, siehe Review R-03); mit `save=true` das Download-Recht |
| POST | `/api/v1/external-refs/{id}/assignment` | Owner ordnet eine mehrdeutige oder ungebundene Referenz bewusst einer eigenen Instanz zu |
Quelleninhalte einer eigenen Referenz laufen über die gebundene Instanz. Eine freigegebene Referenz mit `use_owner_sources` nutzt den gebundenen Zugang des Owners. Zugangsdaten und die übrigen Treffer dieses Zugangs werden nicht ausgeliefert. Eine Suche ohne `connector_id` wählt bei mehreren eigenen Instanzen nicht den zuletzt angelegten Zugang (Review R-10).
Quelleninhalte einer eigenen Referenz laufen über die gebundene Instanz. Eine freigegebene Referenz mit `use_owner_sources` oder mit einer Quellenfreigabe im Raum (`room_source_access`) nutzt den gebundenen Zugang des Owners. Zugangsdaten und die übrigen Treffer dieses Zugangs werden nicht ausgeliefert. Eine Suche ohne `connector_id` wählt bei mehreren eigenen Instanzen nicht den zuletzt angelegten Zugang (Review R-10).
## Übergabepaket
+1 -1
View File
@@ -36,7 +36,7 @@ Grants auf Objekte anderer Räume bleiben unberührt.
- **Mehrere Räume:** Jede Person kann beliebig viele gemeinsame Datenräume anlegen. Ein Raum mit nur dem Eigentümer als Mitglied ist **privat**, mit weiteren Mitgliedern **Mehrbenutzer**. Der persönliche Raum bleibt unverändert.
- **Eigentümer** (`data_rooms.owner_id`): der Ersteller. Er ist stets Verwalter, lässt sich nicht entfernen oder zurückstufen und überträgt den Raum an ein aktives Mitglied. Nur er archiviert und stellt wieder her und ändert die Voreinstellung für neue Einträge. Ein Konto, das einen Raum mit weiteren Mitgliedern besitzt, lässt sich erst nach Übertragung deaktivieren. Ist der Eigentümer nicht mehr handlungsfähig, setzt der Betreiber einen neuen ein (protokolliert). Die Eigentümerrolle verleiht kein Leserecht.
- **Raumfreigabe:** Ein Raum ist ein Team. Der Owner teilt eine Akte, Unterakte oder einen Vorgang mit einem oder mehreren seiner Räume, unabhängig davon, wo der Eintrag abgelegt ist. Mitglieder erhalten Rechte nach Rolle (Leser lesen; Mitglied und Verwalter bearbeiten; Weitergeben und Löschen nie), die Freigabe kann auf „nur lesen“ begrenzt werden, einzelne Personen lassen sich ausnehmen. Ein einzelner Vorgang lässt sich teilen, ohne die Akte offenzulegen (Beispiel: nur die Vorgänge, die der Anwalt sehen soll). Die Voreinstellung eines Raums teilt neu angelegte Einträge, die in diesem Raum entstehen, automatisch mit ihm. Der Owner sieht seine Einträge unabhängig von Raum und Mitgliedschaft. Wer ein Team verlässt oder Leser wird, nimmt seine Freigaben an dieses Team mit; wer aus einem Raum entfernt wird, arbeitet danach im persönlichen Raum. Beim ersten weiteren Mitglied zeigt die Oberfläche, was bereits mit dem Raum geteilt ist. Bestehende Freigaben wurden übernommen, nicht geteilte Einträge blieben privat.
- **Quellzugänge:** Die Raumfreigabe gibt keine Paperless- oder Mail-Zugänge des Owners frei. Dafür bleibt die ausdrückliche Freigabe mit der Option nötig.
- **Quellzugänge (seit 04.11.2026):** Die Raumfreigabe allein gibt keine Paperless- oder Mail-Zugänge des Owners frei. Wer in einem Raum teilen darf (Mitglied oder Verwalter), kann einem einzelnen Mitglied dort „Originale über meine Zugänge“ freigeben (Tabelle `room_source_access`). Die Person liest dann verknüpfte Originale aller Akten und Vorgänge dieses Owners, die mit dem Raum geteilt sind, über dessen Zugänge; sie erhält keine Zugangsdaten und kann nicht im Archiv oder Postfach suchen. Entscheiden kann nur die Person, deren Zugänge benutzt werden. Personenausnahmen, das Ende der Raumfreigabe und das Verlassen des Raums schließen den Abruf; wer aus dem Raum entfernt wird, verliert die Freigabe auch nach einer Rückkehr. Wird der Owner Leser oder verlässt er den Raum, enden seine Quellenfreigaben dort. Daneben bleibt die Einzelfreigabe mit der Option.
- **Löschen:** Akte und Vorgang löscht nur der Owner (oder wer ein Löschrecht hat), nicht jeder Bearbeiter.
## Zugang
+1
View File
@@ -26,6 +26,7 @@ Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TE
| `data_rooms` (Spalte seit 23.10.2026) | `download_roles` (jsonb: `manager`, `member`, `reader`) | Regel je Raum, nur der Eigentümer ändert sie |
| `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` |
| `room_shares` | `resource_kind` (`case`/`matter`), `resource_id`, `room_id`, `access` (`read`/`edit`), `created_by` | Freigabe einer Akte oder eines Vorgangs an einen Datenraum (Team); eindeutig je Eintrag und Raum. Endet, wenn der Freigebende den Raum verlässt oder Leser wird |
| `room_source_access` | PK (`room_id`, `owner_id`, `subject_id`), `created_at` | Quellenfreigabe im Raum: `owner_id` lässt `subject_id` die verknüpften Originale seiner mit dem Raum geteilten Einträge über seine Zugänge lesen. Entfällt, wenn die Person den Raum verlässt oder der Owner dort Leser wird oder ihn verlässt |
| `auth_login_attempts` | `bucket` (SHA-256 aus Adresse und E-Mail), `attempted_at` | zählt Fehlversuche; erfolgreicher Login löscht den Bucket |
## Struktur
+1 -1
View File
@@ -93,7 +93,7 @@ Danach Abzug der jeweiligen Ausnahme.
- Die Chronologie zeigt nur Ereignisse, deren Ressource im Seitenkontext lesbar ist (`_event_title`).
- Breadcrumbs nennen nur lesbare Stationen. Bei mehreren lesbaren Aktenzuordnungen ohne gewählten Kontext erscheint keine Hauptakte.
- Betreiber- und Verwalterrolle verleihen kein Leserecht auf persönliche Inhalte.
- **Raumfreigabe** (Tabelle `room_shares`): Der Owner teilt eine Akte oder einen Vorgang mit beliebigen Datenräumen, in denen er Mitglied oder Verwalter ist. Der Heimatraum spielt dafür keine Rolle. Aktive Mitglieder eines aktiven Raums erhalten Rechte nach Rolle: Leser lesen, Mitglied und Verwalter lesen und bearbeiten, Weitergeben und Löschen nie (`ROOM_RIGHTS`, `room_default` in `policy.py`). Die Obergrenze der Freigabe (`access = read`) begrenzt auf Lesen. Mehrere Freigaben addieren sich, danach wirken Ausnahmen. Eine Personenausnahme (Grant mit `is_exception` auf eine Person, Kontext leer) nimmt eine Person aus. Elemente und Aufgaben ohne Akte oder Vorgang bleiben beim Owner. Die Rechte der Akte reichen in Vorgänge und Inhalte wie bisher; ein Vorgang kann einzeln geteilt werden, ohne dass die Akte sichtbar wird. Der Owner sieht seine Einträge unabhängig von Raum und Mitgliedschaft. Das Löschen von Akte und Vorgang verlangt Owner oder ausdrückliches Löschrecht, nicht mehr nur Bearbeiten (schließt R-01 des Reviews).
- **Raumfreigabe** (Tabelle `room_shares`): Der Owner teilt eine Akte oder einen Vorgang mit beliebigen Datenräumen, in denen er Mitglied oder Verwalter ist. Der Heimatraum spielt dafür keine Rolle. Aktive Mitglieder eines aktiven Raums erhalten Rechte nach Rolle: Leser lesen, Mitglied und Verwalter lesen und bearbeiten, Weitergeben und Löschen nie (`ROOM_RIGHTS`, `room_default` in `policy.py`). Die Obergrenze der Freigabe (`access = read`) begrenzt auf Lesen. Mehrere Freigaben addieren sich, danach wirken Ausnahmen. Eine Personenausnahme (Grant mit `is_exception` auf eine Person, Kontext leer) nimmt eine Person aus. Elemente und Aufgaben ohne Akte oder Vorgang bleiben beim Owner. Die Rechte der Akte reichen in Vorgänge und Inhalte wie bisher; ein Vorgang kann einzeln geteilt werden, ohne dass die Akte sichtbar wird. Der Owner sieht seine Einträge unabhängig von Raum und Mitgliedschaft. Das Löschen von Akte und Vorgang verlangt Owner oder ausdrückliches Löschrecht, nicht mehr nur Bearbeiten (schließt R-01 des Reviews). Verknüpfte Originale über die Zugänge des Owners liest ein Mitglied nur mit ausdrücklicher Quellenfreigabe im Raum (`room_source_access`, `room_source_access()` und `mediated_source_owner` in `policy.py`) oder mit der Einzelfreigabe `use_owner_sources`.
- Kontoarten: Ein Mitarbeiter-Konto legt keine Räume an und keine Inhalte im persönlichen Raum an; es arbeitet in den eingeladenen Räumen nach Raumrolle (`ensure_can_create`, `require_main_user`). Raum-Eigentümer und Einladende sind Hauptnutzer. Beschreibung in [BENUTZERVERWALTUNG.md](BENUTZERVERWALTUNG.md).
- 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.
+1 -1
View File
@@ -378,7 +378,7 @@ Dieselbe Grenze gilt für Finanzobjekte. Eine unzugeordnete Zahlung sehen Owner
### 5.6 Anwalt und RLS
Ein registriertes Konto mit Leserecht an Akte oder Vorgang kann verknüpfte Paperless-Dokumente und E-Mails über die serverseitigen Zugänge des Owners lesen, wenn der Owner das an der Freigabe ausdrücklich einschaltet (`use_owner_sources`). Der Empfänger richtet dafür keine eigenen Quellen ein, erhält keine Secrets und kann das Archiv oder Postfach nicht durchsuchen. Ein Gastzugang ohne Konto bleibt offen und ist nicht Teil dieses Schnitts. Das Übergabepaket bleibt ein eigener Stand und nutzt weiter die Zugänge der exportierenden Person.
Ein registriertes Konto mit Leserecht an Akte oder Vorgang kann verknüpfte Paperless-Dokumente und E-Mails über die serverseitigen Zugänge des Owners lesen, wenn der Owner das an der Freigabe ausdrücklich einschaltet (`use_owner_sources`) oder es der Person in einem Datenraum, mit dem der Eintrag geteilt ist, ausdrücklich freigibt (`room_source_access`, seit 04.11.2026). Der Empfänger richtet dafür keine eigenen Quellen ein, erhält keine Secrets und kann das Archiv oder Postfach nicht durchsuchen. Ein Gastzugang ohne Konto bleibt offen und ist nicht Teil dieses Schnitts. Das Übergabepaket bleibt ein eigener Stand und nutzt weiter die Zugänge der exportierenden Person.
Vertrag ADR-06 und offener Punkt O1: vertrauliche Mehrraumdaten brauchen eine ausdrückliche RLS-Prüfung. Vorschlag: ab P1 App-Policy, zusammengesetzte Fremdschlüssel und eine Runtime-Rolle ohne DDL, Owner und `BYPASSRLS`. Vor dem ersten Produktivbetrieb mit echten Daten zusätzlich RLS als zweite Linie, mit transaktionslokalem Subjekt und einem Grant-Prädikat, das datenraumübergreifende Leserechte nur über `access_grants` zulässt. Pool-Rückgabe darf diesen Kontext nicht behalten. RLS ersetzt die App-Policy nicht. Ein stiller, auf die Scope-ID beschränkter RLS-Filter wäre ein Fehler, weil er bestätigte Freigaben aussperren oder, bei zu weiter Policy, fremde Akten öffnen würde.
+1 -1
View File
@@ -440,7 +440,7 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G
**Beschluss:** Der Nutzer bestätigt: (1) Ein Datenraum ist ein **Team**, kein Ablageort einer Akte. Jede Person kann mehrere Räume anlegen. Ein Raum ist privat, solange nur der Eigentümer Mitglied ist, und wird durch Aufnehmen von Personen zum Mehrbenutzer-Raum. Der persönliche Raum bleibt unverändert. (2) Der Ersteller ist Eigentümer, solange er die Rolle innehat. Er verwaltet Mitglieder, Rollen, Name, Archivierung und Übertragung, liest aber über diese Rolle keine fremden Inhalte. Der Raum ist übertragbar; der Betreiber kann protokolliert einspringen. (3) **Raumfreigabe:** Der Owner einer Akte, Unterakte oder eines Vorgangs teilt sie mit einem oder mehreren seiner Räume, unabhängig davon, wo der Eintrag abgelegt ist. Die Mitglieder erhalten Rechte nach ihrer Rolle im Raum: Leser lesen, Mitglied und Verwalter bearbeiten. Die Freigabe kann auf „nur lesen“ begrenzt werden. Der Owner kann einzelne Personen ausnehmen. Weitergeben, Löschen und Eigentum bleiben beim Owner. Ein Vorgang lässt sich einzeln teilen, ohne dass die Akte oder die übrigen Vorgänge sichtbar werden. (4) Der Owner sieht seine Einträge unabhängig von jedem Raum.
**Begründung und Auswirkungen:** Die Akte bleibt der Rechteanker (F-01, S-01); die Raumfreigabe ist eine zweite, dynamische Rechtequelle neben den Einzelfreigaben je Person. Der Heimatraum eines Eintrags ist nur noch Ablage und Mandantengrenze (Technische Spezifikation 4.1) und bestimmt keine Rechte. Bestehende Freigaben der ersten Fassung (Freigabe an den Heimatraum) wurden in Raumfreigaben übernommen; Einträge ohne Freigabe bleiben privat. Quellzugänge des Owners (Paperless, Mail) werden durch die Raumfreigabe nicht mitgegeben, sondern brauchen weiter die ausdrückliche Freigabe. Elemente und Aufgaben ohne Akte oder Vorgang bleiben beim Owner. Verlässt eine Person ein Team oder wird sie Leser, enden ihre Freigaben an dieses Team. Umsetzungsstand: [BENUTZERVERWALTUNG.md](../architecture/BENUTZERVERWALTUNG.md).
**Begründung und Auswirkungen:** Die Akte bleibt der Rechteanker (F-01, S-01); die Raumfreigabe ist eine zweite, dynamische Rechtequelle neben den Einzelfreigaben je Person. Der Heimatraum eines Eintrags ist nur noch Ablage und Mandantengrenze (Technische Spezifikation 4.1) und bestimmt keine Rechte. Bestehende Freigaben der ersten Fassung (Freigabe an den Heimatraum) wurden in Raumfreigaben übernommen; Einträge ohne Freigabe bleiben privat. Quellzugänge des Owners (Paperless, Mail) werden durch die Raumfreigabe nicht automatisch mitgegeben. Seit dem 04.11.2026 (Änderung durch den Nutzer) kann der Owner sie aber im Raum je Person ausdrücklich freigeben („Originale über meine Zugänge“): Die Freigabe gilt dann für alle seine mit diesem Raum geteilten Akten und Vorgänge, solange die Person dort aktives Mitglied mit Leserecht ist. Damit bleibt die Quellenfreigabe eine Entscheidung je Person, ohne sie an jeder Akte einzeln setzen zu müssen. Die Einzelfreigabe mit der Option bleibt daneben bestehen. Elemente und Aufgaben ohne Akte oder Vorgang bleiben beim Owner. Verlässt eine Person ein Team oder wird sie Leser, enden ihre Freigaben an dieses Team. Umsetzungsstand: [BENUTZERVERWALTUNG.md](../architecture/BENUTZERVERWALTUNG.md).
### R-02 – Betreiber, Hauptnutzer und Mitarbeiter: bestätigt am 22.10.2026
+11
View File
@@ -73,6 +73,14 @@ export function RoomShare({ resource, id, onChange }) {
{share.members.map((member) => (
<li key={member.subject_id}>
{member.display_name} · {roleLabel(member.role)} · {member.excluded ? "ausgenommen" : roomRightsText(member.rights)}{" "}
<label className="check">
<input
type="checkbox"
checked={Boolean(member.sources)}
onChange={(event) => run(() => api(`/api/v1/rooms/${share.room_id}/source-access/${member.subject_id}`, { method: "PUT", body: { enabled: event.target.checked } }))}
/>
Originale über meine Zugänge
</label>{" "}
<button
type="button"
className="quiet"
@@ -83,6 +91,9 @@ export function RoomShare({ resource, id, onChange }) {
</li>
))}
{!share.members.length ? <li>Außer dir gibt es keine Mitglieder.</li> : null}
{share.members.length ? (
<li>„Originale über meine Zugänge“ gilt für alle deine Einträge, die mit {share.room_name} geteilt sind.</li>
) : null}
</ul>
) : null}
</li>
+17
View File
@@ -191,6 +191,19 @@ export function RoomAdmin({ room, onRenamed, onArchived }) {
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.")}
/>
{member.is_self ? null : (
<label className="check">
<input
type="checkbox"
checked={Boolean(member.my_sources)}
onChange={(event) => run(
() => api(`/api/v1/rooms/${room.id}/source-access/${member.subject_id}`, { method: "PUT", body: { enabled: event.target.checked } }),
event.target.checked ? "Die Originale sind über deine Zugänge freigegeben." : "Die Freigabe der Originale ist entzogen.",
)}
/>
Originale über meine Zugänge
</label>
)}
<button
type="button"
className="quiet"
@@ -202,6 +215,10 @@ export function RoomAdmin({ room, onRenamed, onArchived }) {
</li>
))}
</ul>
<p className="muted">
„Originale über meine Zugänge“: Die Person liest verknüpfte Paperless-Dokumente und E-Mails deiner Akten und Vorgänge, die mit diesem Raum geteilt sind, über deine Zugänge. Sie
erhält keine Zugangsdaten und kann dein Archiv oder Postfach nicht durchsuchen.
</p>
{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>)}