Erlaube berechtigten Konten, verknüpfte Originale über die Zugänge des Owners zu lesen.
Deploy Development / deploy (push) Successful in 26s
Test Suite / pytest-backend (push) Successful in 1m51s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 9s

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
LarsandCursor committed 2026-10-18 21:47:30 +02:00
1 parent 562c0848b1
commit 75a3949f7c
14 files changed
+815 -93

No files matched your search

+1 -1
View File
@@ -4,4 +4,4 @@ Fachlich führend ist `docs/product/TSUMUGU_PRODUCT_SPEC.md`. Der technische Ent
Deployment und Ports: `docs/DEPLOYMENT.md`. Gearbeitet wird auf `develop`. Ein Push dorthin startet das Development-Deploy auf dem Raspberry Pi. Production entsteht nur durch einen Merge nach `main`.
Die Anwendung bleibt produktlokal: FastAPI, PostgreSQL, React. Keine gemeinsame Fachdatenbank mit anderen Jinkendo-Anwendungen. Finanzfunktionen, Paperless-Abgleich, KI und externer Anwaltszugang gehören nicht in diese Lieferung.
Die Anwendung bleibt produktlokal: FastAPI, PostgreSQL, React. Keine gemeinsame Fachdatenbank mit anderen Jinkendo-Anwendungen. Finanzfunktionen, Paperless-Abgleich, KI und ein Anwaltszugang ohne eigenes Konto gehören nicht in diese Lieferung. Eine berechtigte Person mit Konto kann freigegebene verknüpfte Dokumente und E-Mails über die Zugänge des Owners lesen, ohne eigene Paperless- oder IMAP-Verbindungen.
+62 -2
View File
@@ -11,6 +11,8 @@ from dataclasses import dataclass
from typing import Any
from uuid import UUID
from psycopg.types.json import Json
from app.core.errors import conflict, forbidden, not_found, unprocessable
SHARED_NOTICE = "Diese Änderung betrifft den gemeinsamen Inhalt der Notiz."
@@ -87,14 +89,17 @@ def audit(
resource_id: UUID,
context: Ctx | None = None,
occurred_on=None,
*,
result: str = "ok",
detail: dict | None = None,
) -> None:
conn.execute(
"""
INSERT INTO domain_events (
actor_subject_id, scope_id, action, resource_kind, resource_id,
context_kind, context_id, occurred_on
context_kind, context_id, occurred_on, result, detail
)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
""",
(
actor_id,
@@ -105,6 +110,8 @@ def audit(
context.kind if context else None,
context.id if context else None,
occurred_on,
result,
Json(detail) if detail is not None else None,
),
)
@@ -348,6 +355,59 @@ def _child_of(conn, matter_id: UUID, parent_id: UUID) -> bool:
return bool(matter and matter["parent_matter_id"] == parent_id)
def _rights_bearing_case(conn, case: dict) -> dict:
seen: set[UUID] = set()
current = case
while current["parent_case_id"] is not None and current["rights_mode"] == "inherit_parent":
if current["id"] in seen:
break
seen.add(current["id"])
parent = get_case(conn, current["parent_case_id"])
if parent is None:
break
current = parent
return current
def _source_grant(conn, actor: UUID, kind: str, resource_id: UUID) -> dict | None:
return conn.execute(
"""
SELECT can_read, use_owner_sources
FROM access_grants
WHERE NOT is_exception
AND grantee_subject_id = %s
AND resource_kind = %s
AND resource_id = %s
AND context_kind IS NULL
""",
(actor, kind, resource_id),
).fetchone()
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."""
if context is None or not element_rights(conn, actor, element, context).read:
return None
if context.kind == "case":
resource = get_case(conn, context.id)
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:
return None
if grant is None or not grant["can_read"] or not grant["use_owner_sources"]:
return None
return resource["owner_subject_id"]
def element_rights_via_case_or_direct(conn, actor: UUID, element: dict, context: Ctx | None) -> Rights:
"""Rights for an element bound to a matter when the caller names a case path.
+22 -2
View File
@@ -643,7 +643,16 @@ def post_case_grant(
if account is None:
raise not_found()
grant = grant_access(
conn, principal.account_id, "case", case_id, account["id"], body.can_read, body.can_edit, body.can_share, None
conn,
principal.account_id,
"case",
case_id,
account["id"],
body.can_read,
body.can_edit,
body.can_share,
None,
body.use_owner_sources,
)
return _created(f"/api/v1/grants/{grant['id']}", {"id": str(grant["id"])})
@@ -908,7 +917,16 @@ def post_matter_grant(
if account is None:
raise not_found()
grant = grant_access(
conn, principal.account_id, "matter", matter_id, account["id"], body.can_read, body.can_edit, body.can_share, None
conn,
principal.account_id,
"matter",
matter_id,
account["id"],
body.can_read,
body.can_edit,
body.can_share,
None,
body.use_owner_sources,
)
return _created(f"/api/v1/grants/{grant['id']}", {"id": str(grant["id"])})
@@ -1785,6 +1803,8 @@ def _visible_events(conn, actor: UUID, rows: list[dict], page: Ctx) -> list[dict
names: dict = {}
items = []
for event in rows:
if event["result"] != "ok":
continue
title = _event_title(conn, actor, event, page)
if title is None:
continue
+1
View File
@@ -167,6 +167,7 @@ class GrantIn(APIModel):
can_read: bool = True
can_edit: bool = False
can_share: bool = False
use_owner_sources: bool = False
class ExceptionIn(APIModel):
+48 -67
View File
@@ -5,10 +5,10 @@ from __future__ import annotations
from uuid import UUID
from fastapi import APIRouter, Depends
from fastapi.responses import Response
from fastapi.responses import JSONResponse, Response
from psycopg import Connection
from app.access.policy import Ctx, element_rights, get_element, parse_query_context
from app.access.policy import element_rights, get_element, parse_query_context
from app.api.deps import Principal, get_conn, get_principal
from app.api.routes import _created, _ctx_model
from app.api.schemas import ConnectorIn, ExternalIn
@@ -23,13 +23,19 @@ from app.sources import (
imap_messages,
imap_preview,
list_connectors,
load_imap_original,
paperless_content,
paperless_documents,
probe,
read_linked_mail,
read_linked_paperless,
save_connector,
)
_PRIVATE = {
"Cache-Control": "private, no-store",
"Referrer-Policy": "no-referrer",
"X-Content-Type-Options": "nosniff",
}
router = APIRouter()
@@ -63,27 +69,17 @@ def view_paperless(
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
element = get_element(conn, element_id)
if element is None or element["kind"] != "external_ref":
raise not_found()
rights = element_rights(conn, principal.account_id, element, parse_query_context(context_kind, context_id))
if not rights.read:
raise not_found()
ref = conn.execute(
"SELECT source, external_id FROM external_references WHERE element_id = %s",
(element_id,),
).fetchone()
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
if ref is None or ref["source"] != "paperless":
raise unprocessable("Nur ein Paperless-Dokument lässt sich hier als Datei ansehen.")
data, media_type, filename = paperless_content(conn, principal.account_id, ref["external_id"])
safe_name = (filename or f"paperless-{ref['external_id']}.pdf").replace('"', "")
data, media_type, filename = read_linked_paperless(conn, principal.account_id, element, context, ref)
safe_name = (filename or "dokument.pdf").replace('"', "")
return Response(
content=data,
media_type=media_type,
headers={
**_PRIVATE,
"Content-Disposition": f'inline; filename="{safe_name}"',
"X-Content-Type-Options": "nosniff",
"Cache-Control": "private, no-store",
},
)
@@ -96,52 +92,48 @@ def view_mail(
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
ref = _mail_ref(conn, principal, element_id, context_kind, context_id)
parsed, _raw = _complete_mail(conn, principal, ref)
return {
"title": parsed.subject,
"message_from": parsed.sender,
"message_to": parsed.recipient,
"message_cc": parsed.copy,
"text": parsed.text,
"text_truncated": False,
"complete": True,
"attachments": [
{
"index": index,
"filename": item.filename,
"content_type": item.media_type,
"byte_size": len(item.data),
}
for index, item in enumerate(parsed.attachments)
],
}
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
parsed, _raw = _complete_mail(conn, principal, element, context, ref)
return JSONResponse(
content={
"title": parsed.subject,
"message_from": parsed.sender,
"message_to": parsed.recipient,
"message_cc": parsed.copy,
"text": parsed.text,
"text_truncated": False,
"complete": True,
"attachments": [
{
"index": index,
"filename": item.filename,
"content_type": item.media_type,
"byte_size": len(item.data),
}
for index, item in enumerate(parsed.attachments)
],
},
headers={"Cache-Control": "private, no-store", "Referrer-Policy": "no-referrer"},
)
def _mail_ref(conn, principal: Principal, element_id: UUID, context_kind: str | None, context_id: str | None):
def _opened_ref(conn, principal: Principal, element_id: UUID, context_kind: str | None, context_id: str | None):
element = get_element(conn, element_id)
if element is None or element["kind"] != "external_ref":
raise not_found()
rights = element_rights(conn, principal.account_id, element, parse_query_context(context_kind, context_id))
context = parse_query_context(context_kind, context_id)
rights = element_rights(conn, principal.account_id, element, context)
if not rights.read:
raise not_found()
ref = conn.execute(
"SELECT source, external_id, detail FROM external_references WHERE element_id = %s",
(element_id,),
).fetchone()
return ref
return element, context, ref
def _complete_mail(conn, principal: Principal, ref):
detail = (ref or {}).get("detail") or {}
if ref is None or ref["source"] != "imap":
raise unprocessable("Das ist keine E-Mail.")
connector_id = detail.get("connector_id")
mailbox = str(detail.get("mailbox") or "").strip()
uid = _mail_uid(detail.get("uid"))
if not connector_id or not mailbox or uid is None:
raise unprocessable("Für diese E-Mail fehlt die Zuordnung zu Fach und Nachricht.")
raw = load_imap_original(conn, principal.account_id, UUID(str(connector_id)), mailbox, uid, str(ref["external_id"]))
def _complete_mail(conn, principal: Principal, element, context, ref):
raw = read_linked_mail(conn, principal.account_id, element, context, ref)
parsed = parse_mail(raw)
if parsed.missing:
names = ", ".join(parsed.missing[:5])
@@ -149,16 +141,6 @@ def _complete_mail(conn, principal: Principal, ref):
return parsed, raw
def _mail_uid(value) -> int | None:
if isinstance(value, bool):
return None
if isinstance(value, int) and value >= 1:
return value
if isinstance(value, str) and value.isdigit() and int(value) >= 1:
return int(value)
return None
@router.get("/api/v1/external-refs/{element_id}/mail/original")
def download_mail(
element_id: UUID,
@@ -167,8 +149,8 @@ def download_mail(
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
ref = _mail_ref(conn, principal, element_id, context_kind, context_id)
_parsed, raw = _complete_mail(conn, principal, ref)
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
_parsed, raw = _complete_mail(conn, principal, element, context, ref)
return _mail_bytes(raw, "message/rfc822", "nachricht.eml")
@@ -181,8 +163,8 @@ def download_mail_attachment(
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
ref = _mail_ref(conn, principal, element_id, context_kind, context_id)
parsed, _raw = _complete_mail(conn, principal, ref)
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
parsed, _raw = _complete_mail(conn, principal, element, context, ref)
if index < 0 or index >= len(parsed.attachments):
raise not_found()
item = parsed.attachments[index]
@@ -197,9 +179,8 @@ def _mail_bytes(data: bytes, media_type: str, filename: str, inline: bool = Fals
content=data,
media_type=media_type,
headers={
**_PRIVATE,
"Content-Disposition": disposition,
"X-Content-Type-Options": "nosniff",
"Cache-Control": "private, no-store",
},
)
+25 -7
View File
@@ -701,7 +701,18 @@ def _actor_rights_for(conn, actor: UUID, kind: str, resource_id: UUID, context:
return rights
def grant_access(conn, actor: UUID, kind: str, resource_id: UUID, grantee_id: UUID, can_read: bool, can_edit: bool, can_share: bool, context: Ctx | None) -> dict:
def grant_access(
conn,
actor: UUID,
kind: str,
resource_id: UUID,
grantee_id: UUID,
can_read: bool,
can_edit: bool,
can_share: bool,
context: Ctx | None,
use_owner_sources: bool = False,
) -> dict:
if grantee_id == actor:
raise unprocessable("Die eigene Berechtigung wird nicht als Freigabe gespeichert.")
if not can_read:
@@ -731,33 +742,40 @@ def grant_access(conn, actor: UUID, kind: str, resource_id: UUID, grantee_id: UU
raise not_found()
existing = conn.execute(
"""
SELECT id FROM access_grants
SELECT id, use_owner_sources FROM access_grants
WHERE NOT is_exception AND grantee_subject_id = %s
AND resource_kind = %s AND resource_id = %s AND context_kind IS NULL
""",
(grantee_id, kind, resource_id),
).fetchone()
if owner:
source_access = bool(use_owner_sources)
elif existing is None:
source_access = False
else:
source_access = bool(existing["use_owner_sources"])
if existing is None:
row = 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
can_read, can_edit, can_share, can_delete, is_exception, created_by,
use_owner_sources
)
VALUES (%s, %s, %s, %s, %s, %s, false, false, %s)
VALUES (%s, %s, %s, %s, %s, %s, false, false, %s, %s)
RETURNING *
""",
(grantee_id, kind, resource_id, can_read, can_edit, can_share, actor),
(grantee_id, kind, resource_id, can_read, can_edit, can_share, actor, source_access),
).fetchone()
else:
row = conn.execute(
"""
UPDATE access_grants
SET can_read = %s, can_edit = %s, can_share = %s
SET can_read = %s, can_edit = %s, can_share = %s, use_owner_sources = %s
WHERE id = %s
RETURNING *
""",
(can_read, can_edit, can_share, existing["id"]),
(can_read, can_edit, can_share, source_access, existing["id"]),
).fetchone()
audit(conn, actor, resource["home_scope_id"], "grant_created", kind, resource_id, context)
return row
+40 -8
View File
@@ -126,7 +126,32 @@ def _preview_meta(kind: str, content_type: str | None, source: str | None) -> di
return {"available": False, "media": "none", "source": source}
def _element_body(conn, element: dict) -> dict:
_HIDDEN_SOURCE_FIELDS = frozenset({
"connector_id",
"mailbox",
"uid",
"host",
"username",
"port",
"password",
"secret",
"base_url",
"server",
"security",
"open_url",
})
def _connector_owner(conn, raw) -> UUID | None:
try:
connector_id = UUID(str(raw))
except (TypeError, ValueError):
return None
row = conn.execute("SELECT owner_id FROM connectors WHERE id = %s", (connector_id,)).fetchone()
return row["owner_id"] if row else None
def _element_body(conn, actor: UUID, element: dict) -> dict:
payload = {
"id": str(element["id"]),
"kind": element["kind"],
@@ -169,11 +194,15 @@ def _element_body(conn, element: dict) -> dict:
(element["id"],),
).fetchone()
if ref is not None:
payload["external"] = {
"source": ref["source"],
"external_id": ref["external_id"],
"detail": ref["detail"] or {},
}
detail = dict(ref["detail"] or {})
connector_owner = _connector_owner(conn, detail.get("connector_id"))
revealed = actor == element["owner_subject_id"] or (connector_owner is not None and actor == connector_owner)
if not revealed:
detail = {key: value for key, value in detail.items() if key not in _HIDDEN_SOURCE_FIELDS}
external = {"source": ref["source"], "detail": detail}
if revealed:
external["external_id"] = ref["external_id"]
payload["external"] = external
payload["preview"] = _preview_meta("external_ref", None, ref["source"])
return payload
@@ -280,7 +309,7 @@ def binding_payload(conn, actor: UUID, binding: dict, context: Ctx) -> dict | No
rights = element_rights(conn, actor, element, context)
if not rights.read:
return None
body = _element_body(conn, element)
body = _element_body(conn, actor, element)
container = Ctx(binding["context_kind"], binding["context_id"])
_attach_references(conn, actor, element, context, container, body)
payload = {
@@ -300,7 +329,8 @@ def binding_payload(conn, actor: UUID, binding: dict, context: Ctx) -> dict | No
def _grants(conn, kind: str, resource_id: UUID) -> list[dict]:
rows = conn.execute(
"""
SELECT g.id, g.grantee_subject_id, g.can_read, g.can_edit, g.can_share, a.email, a.display_name
SELECT g.id, g.grantee_subject_id, g.can_read, g.can_edit, g.can_share, g.use_owner_sources,
a.email, a.display_name
FROM access_grants g
JOIN auth_accounts a ON a.id = g.grantee_subject_id
WHERE NOT g.is_exception AND g.resource_kind = %s AND g.resource_id = %s AND g.context_kind IS NULL
@@ -317,6 +347,7 @@ def _grants(conn, kind: str, resource_id: UUID) -> list[dict]:
"can_read": row["can_read"],
"can_edit": row["can_edit"],
"can_share": row["can_share"],
"use_owner_sources": row["use_owner_sources"],
}
for row in rows
]
@@ -958,6 +989,7 @@ LABELS = {
"deadline_fulfilled": "Frist erfüllt",
"grant_created": "Freigabe erteilt",
"grant_revoked": "Freigabe entzogen",
"source_read_mediated": "Verknüpftes Original gelesen",
"correspondence_document": "Dokumentdatum",
"correspondence_sent": "Versand",
"correspondence_received": "Zugang",
+138
View File
@@ -18,6 +18,7 @@ from uuid import UUID
from psycopg.types.json import Json
from app.access.policy import Ctx, audit, mediated_source_owner
from app.core.errors import Problem, not_found, unprocessable
from app.core.settings import get_settings
from app.mailpack import MailIdentityError, choose_message, identities_match, header_message_id
@@ -207,6 +208,10 @@ def paperless_content(conn, owner_id: UUID, document_id: str) -> tuple[bytes, st
).fetchone()
if row is None:
raise unprocessable("Paperless ist für dieses Konto nicht verbunden.")
return _paperless_bytes(row, document_id)
def _paperless_bytes(row, document_id: str) -> tuple[bytes, str, str]:
base = row["settings"]["base_url"].rstrip("/")
token = row["secret"]
misses = 0
@@ -228,6 +233,139 @@ def paperless_content(conn, owner_id: UUID, document_id: str) -> tuple[bytes, st
raise unprocessable("Paperless stellt diese Datei nicht zum Ansehen bereit.")
ORIGINAL_UNAVAILABLE = "Das Original ist über die Freigabe nicht abrufbar."
def read_linked_paperless(conn, actor_id: UUID, element: dict, context: Ctx | None, ref) -> tuple[bytes, str, str]:
"""The stored document. A grantee never uses a connector of their own account."""
detail = (ref or {}).get("detail") or {}
external_id = str((ref or {}).get("external_id") or "")
stored = _uuid(detail.get("connector_id"))
stored_owner = _connector_owner(conn, stored)
if element["owner_subject_id"] == actor_id or stored_owner == actor_id:
return paperless_content(conn, actor_id, external_id)
owner_id = mediated_source_owner(conn, actor_id, element, context)
if owner_id is None or not external_id.isdigit() or len(external_id) > 12:
raise unprocessable(ORIGINAL_UNAVAILABLE)
row = _mediated_paperless(conn, owner_id, stored, element)
if row is None:
_audit_mediated(conn, actor_id, element, context, "paperless", stored, "unavailable")
raise unprocessable(ORIGINAL_UNAVAILABLE)
try:
data, media, name = _paperless_bytes(row, external_id)
except Problem:
_audit_mediated(conn, actor_id, element, context, "paperless", row["id"], "unavailable")
raise unprocessable(ORIGINAL_UNAVAILABLE) from None
_audit_mediated(conn, actor_id, element, context, "paperless", row["id"], "ok")
if external_id and external_id in (name or ""):
name = "dokument.pdf"
return data, media, name or "dokument.pdf"
def read_linked_mail(conn, actor_id: UUID, element: dict, context: Ctx | None, ref) -> bytes:
"""The stored message. Mailbox, UID and connector come only from the saved reference."""
detail = (ref or {}).get("detail") or {}
if ref is None or ref["source"] != "imap":
raise unprocessable("Das ist keine E-Mail.")
connector_id = _uuid(detail.get("connector_id"))
mailbox = str(detail.get("mailbox") or "").strip()
uid = _mail_uid(detail.get("uid"))
external_id = str(ref["external_id"])
stored_owner = _connector_owner(conn, connector_id)
if element["owner_subject_id"] == actor_id or stored_owner == actor_id:
if connector_id is None or not mailbox or uid is None:
raise unprocessable("Für diese E-Mail fehlt die Zuordnung zu Fach und Nachricht.")
return load_imap_original(conn, actor_id, connector_id, mailbox, uid, external_id)
owner_id = mediated_source_owner(conn, actor_id, element, context)
if owner_id is None or connector_id is None or not mailbox or uid is None:
raise unprocessable(ORIGINAL_UNAVAILABLE)
row = _connector_for(conn, connector_id, owner_id, "imap")
if row is None:
_audit_mediated(conn, actor_id, element, context, "imap", connector_id, "unavailable")
raise unprocessable(ORIGINAL_UNAVAILABLE)
try:
raw = load_imap_original(conn, owner_id, connector_id, mailbox, uid, external_id)
except Problem:
_audit_mediated(conn, actor_id, element, context, "imap", connector_id, "unavailable")
raise unprocessable(ORIGINAL_UNAVAILABLE) from None
_audit_mediated(conn, actor_id, element, context, "imap", connector_id, "ok")
return raw
def _uuid(value) -> UUID | None:
if isinstance(value, UUID):
return value
try:
return UUID(str(value))
except (TypeError, ValueError):
return None
def _mail_uid(value) -> int | None:
if isinstance(value, bool):
return None
if isinstance(value, int) and value >= 1:
return value
if isinstance(value, str) and value.isdigit() and int(value) >= 1:
return int(value)
return None
def _connector_owner(conn, connector_id: UUID | None) -> UUID | None:
if connector_id is None:
return None
row = conn.execute("SELECT owner_id FROM connectors WHERE id = %s", (connector_id,)).fetchone()
return row["owner_id"] if row else None
def _connector_for(conn, connector_id: UUID, owner_id: UUID, kind: str):
return conn.execute(
"""
SELECT id, owner_id, kind, settings, secret
FROM connectors
WHERE id = %s AND owner_id = %s AND kind = %s
""",
(connector_id, owner_id, kind),
).fetchone()
def _mediated_paperless(conn, owner_id: UUID, stored: UUID | None, element: dict):
if stored is not None:
return _connector_for(conn, stored, owner_id, "paperless")
if element["owner_subject_id"] != owner_id:
return None
return conn.execute(
"""
SELECT id, owner_id, kind, settings, secret
FROM connectors
WHERE owner_id = %s AND kind = 'paperless'
ORDER BY created_at DESC
LIMIT 1
""",
(owner_id,),
).fetchone()
def _audit_mediated(conn, actor_id: UUID, element: dict, context: Ctx | None, source: str, connector_id, outcome: str) -> None:
audit(
conn,
actor_id,
element["home_scope_id"],
"source_read_mediated",
"element",
element["id"],
context,
result="ok" if outcome == "ok" else "unavailable",
detail={
"source": source,
"connector_id": str(connector_id) if connector_id else None,
"outcome": outcome,
},
)
if outcome != "ok":
conn.commit()
def _paperless_file(
base: str,
token: str,
@@ -0,0 +1,8 @@
-- Owner kann an einer Freigabe erlauben, verknüpfte Originale über die eigenen Zugänge zu lesen.
-- Bestehende Freigaben bleiben ohne diesen Abruf.
ALTER TABLE access_grants
ADD COLUMN use_owner_sources boolean NOT NULL DEFAULT false;
ALTER TABLE domain_events
ADD COLUMN detail jsonb;
+451
View File
@@ -0,0 +1,451 @@
"""Granted readers see linked originals only through the owner's stored connector."""
from __future__ import annotations
import json
import app.sources as sources
from tests.support import ORIGIN, Actor, register
OWNER_TOKEN = "owner-paperless-token"
GRANTEE_TOKEN = "grantee-paperless-token"
OWNER_MAIL = "owner-postfach-geheim"
GRANTEE_MAIL = "grantee-postfach-geheim"
UNAVAILABLE = "Das Original ist über die Freigabe nicht abrufbar."
class RecordingIMAP:
logins: list[str] = []
fetches: list[int] = []
def __init__(self, *args, **kwargs):
pass
def login(self, username, secret):
RecordingIMAP.logins.append(secret)
return "OK", [b"logged"]
def list(self):
return "OK", [b'(\\HasNoChildren) "/" "INBOX"']
def select(self, mailbox, readonly=False):
return "OK", [b"5"]
def uid(self, command, *args):
if command == "SEARCH":
return "OK", [b""]
uid = int(args[0])
spec = " ".join(str(part) for part in args[1:])
if "BODY.PEEK[]" in spec:
RecordingIMAP.fetches.append(uid)
raw = (
f"From: Ada Beispiel <ada@example.test>\r\n"
f"To: Kanzlei <kanzlei@example.test>\r\n"
f"Subject: Nachricht {uid}\r\n"
f"Date: Thu, 02 May 2024 08:00:00 +0000\r\n"
f"Message-ID: <{uid}@example.test>\r\n"
f"MIME-Version: 1.0\r\n"
f'Content-Type: multipart/mixed; boundary="grenze"\r\n'
f"\r\n"
f"--grenze\r\n"
f"Content-Type: text/plain; charset=utf-8\r\n"
f"\r\n"
f"Bitte die Einwendung pruefen.\r\n"
f"--grenze\r\n"
f"Content-Type: application/pdf\r\n"
f'Content-Disposition: attachment; filename="einwendung.pdf"\r\n'
f"\r\n"
f"%PDF\r\n"
f"--grenze--\r\n"
).encode()
return "OK", [(b"rfc822", raw)]
return "OK", [(b"body", b"From: Ada\r\n"), b")"]
def logout(self):
return "BYE", [b""]
def _reset_imap():
RecordingIMAP.logins = []
RecordingIMAP.fetches = []
def _paperless(actor: Actor, token: str, name: str) -> str:
return actor.request(
"POST",
"/api/v1/connectors",
json={"kind": "paperless", "name": name, "base_url": "https://paper.example.test", "token": token},
status=201,
)["id"]
def _mailbox(actor: Actor, password: str, name: str) -> str:
return actor.request(
"POST",
"/api/v1/connectors",
json={
"kind": "imap",
"name": name,
"host": "imap.example.test",
"port": 993,
"username": f"{name}@example.test",
"password": password,
"security": "ssl",
},
status=201,
)["id"]
def _raw(actor: Actor, path: str):
return actor.client.get(
path,
headers={
"Origin": ORIGIN,
"X-CSRF-Token": actor.csrf,
"X-Scope-Kind": actor.scope["kind"],
"X-Scope-Id": actor.scope["id"],
},
)
def _grant(actor: Actor, kind: str, resource_id: str, email: str, **flags):
body = {"email": email, "can_read": True, "can_edit": False, "can_share": False, "use_owner_sources": False}
body.update(flags)
return actor.request("POST", f"/api/v1/{kind}/{resource_id}/grants", json=body, status=201)
def _events(db):
return db.execute(
"""
SELECT action, result, detail
FROM domain_events
WHERE action = 'source_read_mediated'
ORDER BY occurred_at, id
"""
).fetchall()
def test_owner_alone_sets_source_access_and_a_delegate_cannot_change_it(client, db):
ada = Actor(client, "ada-flag@example.test", "Ada Flag")
ben = Actor(client, "ben-flag@example.test", "Ben Flag")
cleo = Actor(client, "cleo-flag@example.test", "Cleo Flag")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
register(db, cleo.email, cleo.name)
ada.login()
case = ada.request("POST", "/api/v1/cases", json={"title": "Streit"}, status=201)
_grant(ada, "cases", case["id"], ben.email, can_share=True, use_owner_sources=True)
ada_view = ada.request("GET", f"/api/v1/cases/{case['id']}")
ben_grant = next(item for item in ada_view["grants"] if item["email"] == ben.email)
assert ben_grant["use_owner_sources"] is True
ben.login()
_grant(ben, "cases", case["id"], cleo.email, use_owner_sources=True)
ada.login()
after_delegate = ada.request("GET", f"/api/v1/cases/{case['id']}")
cleo_grant = next(item for item in after_delegate["grants"] if item["email"] == cleo.email)
assert cleo_grant["use_owner_sources"] is False
_grant(ada, "cases", case["id"], cleo.email, use_owner_sources=True)
ben.login()
_grant(ben, "cases", case["id"], cleo.email, can_share=True, use_owner_sources=False)
ada.login()
kept = ada.request("GET", f"/api/v1/cases/{case['id']}")
cleo_grant = next(item for item in kept["grants"] if item["email"] == cleo.email)
assert cleo_grant["can_share"] is True
assert cleo_grant["use_owner_sources"] is True
_grant(ada, "cases", case["id"], cleo.email, use_owner_sources=False)
cleared = ada.request("GET", f"/api/v1/cases/{case['id']}")
cleo_grant = next(item for item in cleared["grants"] if item["email"] == cleo.email)
assert cleo_grant["use_owner_sources"] is False
def test_grantee_reads_linked_originals_only_through_the_owner(client, db, monkeypatch):
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\nverknuepft\n", "application/pdf", "vertrag.pdf")
return None
def fake_get(base, token, path, params):
calls.append({"token": token, "path": path, "query": params.get("query")})
if token == OWNER_TOKEN:
return {"count": 1, "results": [{"id": 15, "title": "Geheimes Archivdokument", "created": "2026-01-01"}]}
return {"count": 0, "results": []}
monkeypatch.setattr(sources, "_paperless_file", fake_file)
monkeypatch.setattr(sources, "_paperless_get", fake_get)
monkeypatch.setattr(sources, "_paperless_metadata", lambda *args, **kwargs: None)
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", RecordingIMAP)
_reset_imap()
ada = Actor(client, "ada-quelle@example.test", "Ada Quelle")
ben = Actor(client, "ben-quelle@example.test", "Ben Quelle")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
ada.login()
paper = _paperless(ada, OWNER_TOKEN, "Ada Archiv")
mailbox = _mailbox(ada, OWNER_MAIL, "Ada Post")
case = ada.request("POST", "/api/v1/cases", json={"title": "Akte"}, status=201)
matter = ada.request("POST", "/api/v1/matters", json={"title": "Vorgang"}, status=201)
other = ada.request("POST", "/api/v1/matters", json={"title": "Fremder Vorgang"}, 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, "correspondent": "Hausverwaltung"},
},
status=201,
)
letter = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Einwendung",
"source": "imap",
"external_id": "<2@example.test>",
"context": {"kind": "matter", "id": matter["id"]},
"detail": {
"connector_id": mailbox,
"mailbox": "INBOX",
"uid": 2,
"direction": "in",
"message_from": "Hausverwaltung",
},
},
status=201,
)
owner_file = _raw(ada, f"/api/v1/external-refs/{document['id']}/content?context_kind=case&context_id={case['id']}")
assert owner_file.status_code == 200
assert owner_file.content.startswith(b"%PDF")
assert calls[-1]["token"] == OWNER_TOKEN
assert "/api/documents/15/" in calls[-1]["path"]
owner_mail = ada.request(
"GET",
f"/api/v1/external-refs/{letter['id']}/mail",
params={"context_kind": "matter", "context_id": matter["id"]},
)
assert "Einwendung" in owner_mail["text"]
assert OWNER_MAIL in RecordingIMAP.logins
calls.clear()
_reset_imap()
ben.login()
_paperless(ben, GRANTEE_TOKEN, "Ben Archiv")
_mailbox(ben, GRANTEE_MAIL, "Ben Post")
ada.login()
_grant(ada, "cases", case["id"], ben.email)
_grant(ada, "matters", matter["id"], ben.email)
_grant(ada, "matters", other["id"], ben.email, use_owner_sources=True)
ben.login()
shown = ben.request("GET", f"/api/v1/matters/{matter['id']}")
visible = next(item for item in shown["bindings"] if item["element"]["title"] == "Einwendung")
detail = visible["element"]["external"]["detail"]
assert detail["direction"] == "in"
assert detail["message_from"] == "Hausverwaltung"
assert "connector_id" not in detail
assert "mailbox" not in detail
assert "uid" not in detail
assert "external_id" not in visible["element"]["external"]
dumped = json.dumps(shown)
assert OWNER_MAIL not in dumped
assert OWNER_TOKEN not in dumped
assert "imap.example.test" not in dumped
assert mailbox not in dumped
hidden = ben.request(
"GET",
f"/api/v1/external-refs/{document['id']}/content",
params={"context_kind": "case", "context_id": case["id"], "document": "999"},
status=422,
)
assert hidden["detail"] == UNAVAILABLE
assert calls == []
missed = ben.request(
"GET",
f"/api/v1/external-refs/{letter['id']}/mail",
params={"context_kind": "matter", "context_id": matter["id"], "uid": "9", "mailbox": "Geheim"},
status=422,
)
assert missed["detail"] == UNAVAILABLE
assert RecordingIMAP.logins == []
assert RecordingIMAP.fetches == []
ada.login()
_grant(ada, "cases", case["id"], ben.email, use_owner_sources=True)
_grant(ada, "matters", matter["id"], ben.email, use_owner_sources=True)
ben.login()
opened = _raw(
ben,
f"/api/v1/external-refs/{document['id']}/content?context_kind=case&context_id={case['id']}&document=999",
)
assert opened.status_code == 200
assert opened.content.startswith(b"%PDF")
assert opened.headers["x-content-type-options"] == "nosniff"
assert opened.headers["cache-control"] == "private, no-store"
assert opened.headers["referrer-policy"] == "no-referrer"
assert calls == [{"token": OWNER_TOKEN, "path": "/api/documents/15/preview/"}]
assert GRANTEE_TOKEN not in json.dumps(calls)
search = ben.request("GET", "/api/v1/sources/paperless/documents", params={"q": "Geheim"})
assert "Geheimes Archivdokument" not in json.dumps(search)
assert all(item["token"] != OWNER_TOKEN for item in calls if "query" in item)
mail = ben.request(
"GET",
f"/api/v1/external-refs/{letter['id']}/mail",
params={"context_kind": "matter", "context_id": matter["id"], "uid": "9", "connector_id": paper},
)
assert mail["text"] == "Bitte die Einwendung pruefen."
assert mail["attachments"][0]["filename"] == "einwendung.pdf"
assert RecordingIMAP.logins == [OWNER_MAIL]
assert RecordingIMAP.fetches == [2]
original = _raw(
ben,
f"/api/v1/external-refs/{letter['id']}/mail/original?context_kind=matter&context_id={matter['id']}",
)
assert original.status_code == 200
assert b"Message-ID: <2@example.test>" in original.content
attachment = _raw(
ben,
f"/api/v1/external-refs/{letter['id']}/mail/attachments/0?context_kind=matter&context_id={matter['id']}",
)
assert attachment.status_code == 200
assert attachment.content.startswith(b"%PDF")
assert attachment.headers["content-disposition"].startswith("inline;")
assert GRANTEE_MAIL not in RecordingIMAP.logins
page = ben.request("GET", f"/api/v1/matters/{matter['id']}/chronology")
chronology = json.dumps(page)
assert "source_read_mediated" in [item["action"] for item in page["items"]]
assert "Verknüpftes Original gelesen" in [item["label"] for item in page["items"]]
assert mailbox not in chronology
assert OWNER_MAIL not in chronology
quiet = len(RecordingIMAP.logins)
ben.request("GET", "/api/v1/sources/imap/mailboxes", params={"connector_id": mailbox}, status=404)
ben.request(
"GET",
f"/api/v1/external-refs/{letter['id']}/mail",
params={"context_kind": "matter", "context_id": other["id"]},
status=404,
)
ada.login()
ada.request(
"PUT",
"/api/v1/exceptions",
json={
"resource_kind": "element",
"resource_id": letter["id"],
"context": {"kind": "matter", "id": matter["id"]},
"remove_read": True,
},
)
grant_id = next(item["id"] for item in ada.request("GET", f"/api/v1/cases/{case['id']}")["grants"])
ben.login()
ben.request(
"GET",
f"/api/v1/external-refs/{letter['id']}/mail",
params={"context_kind": "matter", "context_id": matter["id"]},
status=404,
)
assert len(RecordingIMAP.logins) == quiet
ada.login()
ada.request("DELETE", f"/api/v1/grants/{grant_id}", status=204)
ben.login()
ben.request(
"GET",
f"/api/v1/external-refs/{document['id']}/content",
params={"context_kind": "case", "context_id": case["id"]},
status=404,
)
assert len(RecordingIMAP.logins) == quiet
assert [item["token"] for item in calls if "query" not in item] == [OWNER_TOKEN]
rows = _events(db)
blob = json.dumps(rows, default=str)
assert OWNER_TOKEN not in blob
assert OWNER_MAIL not in blob
assert "Bitte die Einwendung" not in blob
assert "imap.example.test" not in blob
assert any(row["result"] == "ok" and row["detail"]["source"] == "paperless" for row in rows)
assert any(row["result"] == "ok" and row["detail"]["connector_id"] == mailbox for row in rows)
def test_deleted_or_foreign_connector_is_not_used(client, db, monkeypatch):
calls = []
monkeypatch.setattr(
sources,
"_paperless_file",
lambda *args, **kwargs: calls.append("paperless") or (b"%PDF-1.4\n", "application/pdf", "x.pdf"),
)
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", RecordingIMAP)
_reset_imap()
ada = Actor(client, "ada-weg@example.test", "Ada Weg")
ben = Actor(client, "ben-weg@example.test", "Ben Weg")
cleo = Actor(client, "cleo-weg@example.test", "Cleo Weg")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
register(db, cleo.email, cleo.name)
ada.login()
paper = _paperless(ada, OWNER_TOKEN, "Ada Archiv")
ben.login()
foreign = _mailbox(ben, GRANTEE_MAIL, "Ben Post")
ada.login()
matter = ada.request("POST", "/api/v1/matters", json={"title": "Vorgang"}, status=201)
document = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Scan",
"source": "paperless",
"external_id": "15",
"context": {"kind": "matter", "id": matter["id"]},
"detail": {"connector_id": paper},
},
status=201,
)
foreign_mail = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Fremde Quelle",
"source": "imap",
"external_id": "<2@example.test>",
"context": {"kind": "matter", "id": matter["id"]},
"detail": {"connector_id": foreign, "mailbox": "INBOX", "uid": 2},
},
status=201,
)
_grant(ada, "matters", matter["id"], cleo.email, use_owner_sources=True)
ada.request("DELETE", f"/api/v1/connectors/{paper}", status=204)
cleo.login()
blocked = cleo.request(
"GET",
f"/api/v1/external-refs/{document['id']}/content",
params={"context_kind": "matter", "context_id": matter["id"]},
status=422,
)
assert blocked["detail"] == UNAVAILABLE
assert "paper.example.test" not in blocked["detail"]
assert calls == []
refused = cleo.request(
"GET",
f"/api/v1/external-refs/{foreign_mail['id']}/mail",
params={"context_kind": "matter", "context_id": matter["id"]},
status=422,
)
assert refused["detail"] == UNAVAILABLE
assert RecordingIMAP.logins == []
rows = _events(db)
assert rows
assert all(row["result"] == "unavailable" for row in rows)
assert OWNER_TOKEN not in json.dumps(rows, default=str)
assert GRANTEE_MAIL not in json.dumps(rows, default=str)
+1 -1
View File
@@ -378,7 +378,7 @@ Dieselbe Grenze gilt für Finanzobjekte. Eine unzugeordnete Zahlung sehen Owner
### 5.6 Anwalt und RLS
Der spätere Anwaltszugang kann ein Leserecht auf eine Zusammenstellung an ein weiteres Subjekt vergeben. Die Zugangsform bleibt offen und ist keine MVP-Funktion. Ein Exportpaket wäre ein eigenes Asset mit dem Stand zum Erzeugungszeitpunkt; auch das liegt außerhalb des MVP.
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.
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
@@ -670,7 +670,7 @@ export function CaseDetail() {
/>
</Modal>
<Modal open={modal === "share"} title="Teilen" onClose={() => setModal("")}>
<ShareBox path={`/api/v1/cases/${id}/grants`} grants={record.grants || []} onChange={load} />
<ShareBox path={`/api/v1/cases/${id}/grants`} grants={record.grants || []} onChange={load} allowSources={Boolean(record.is_owner)} />
</Modal>
</>
);
+1 -1
View File
@@ -618,7 +618,7 @@ export function MatterDetail() {
/>
</Modal>
<Modal open={modal === "share"} title="Teilen" onClose={() => setModal("")}>
<ShareBox path={`/api/v1/matters/${id}/grants`} grants={record.grants || []} onChange={load} />
<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("")}>
<MoveMatter
+16 -3
View File
@@ -320,17 +320,20 @@ function kindLabel(element) {
return kind;
}
export function ShareBox({ path, grants, onChange }) {
export function ShareBox({ path, grants, onChange, allowSources = false }) {
const [email, setEmail] = useState("");
const [canEdit, setCanEdit] = useState(true);
const [canShare, setCanShare] = useState(false);
const [useOwnerSources, setUseOwnerSources] = useState(false);
const [error, setError] = useState("");
async function submit(event) {
event.preventDefault();
setError("");
const body = { email, can_read: true, can_edit: canEdit, can_share: canShare };
if (allowSources) body.use_owner_sources = useOwnerSources;
try {
await api(path, { method: "POST", body: { email, can_read: true, can_edit: canEdit, can_share: canShare } });
await api(path, { method: "POST", body });
setEmail("");
onChange();
} catch (err) {
@@ -354,6 +357,12 @@ export function ShareBox({ path, grants, onChange }) {
</label>
<label className="check"><input type="checkbox" checked={canEdit} onChange={(event) => setCanEdit(event.target.checked)} /> Bearbeiten</label>
<label className="check"><input type="checkbox" checked={canShare} onChange={(event) => setCanShare(event.target.checked)} /> Weitergeben</label>
{allowSources ? (
<label className="check">
<input type="checkbox" checked={useOwnerSources} onChange={(event) => setUseOwnerSources(event.target.checked)} />
Verknüpfte Originale über meine Zugänge zeigen
</label>
) : null}
<button type="submit">Freigeben</button>
<ErrorNote error={error} />
</form>
@@ -362,7 +371,11 @@ export function ShareBox({ path, grants, onChange }) {
{grants.map((grant) => (
<li key={grant.id}>
<span>{grant.display_name} · {grant.email}</span>
<small>{grant.can_edit ? "Bearbeiten" : "Lesen"}{grant.can_share ? ", Weitergeben" : ""}</small>
<small>
{grant.can_edit ? "Bearbeiten" : "Lesen"}
{grant.can_share ? ", Weitergeben" : ""}
{grant.use_owner_sources ? ", Originale über meine Zugänge" : ""}
</small>
<button type="button" className="quiet" onClick={() => revoke(grant.id)}>Entziehen</button>
</li>
))}