Files
tsumugu/backend/app/present.py
T
LarsandCursor 528fc191e8
Deploy Development / deploy (push) Successful in 21s
Zeige die Strukturhierarchie direkt auf Akte und Vorgang.
Unterakten, Teilvorgaenge, Kapitel und Querverweise sind sichtbar und lassen sich oeffnen.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-16 22:48:26 +02:00

501 lines
18 KiB
Python

"""Response shapes. Hidden objects are omitted, not counted and not titled."""
from __future__ import annotations
from uuid import UUID
from app.access.policy import (
Ctx,
case_rights,
deadline_rights,
display_name,
element_rights,
get_case,
get_element,
get_matter,
matter_rights,
matter_title_if_readable,
readable_matter_contexts,
room_name,
task_rights,
visible_bindings_for_element,
)
from app.access.policy import SHARED_NOTICE
from app.core.timeutil import dump_date, dump_dt
def rights_dict(rights) -> dict:
return rights.as_dict()
def _chapters(conn, kind: str, container_id: UUID) -> list[dict]:
column = "case_id" if kind == "case" else "matter_id"
rows = conn.execute(
f"SELECT id, title, position FROM chapters WHERE {column} = %s ORDER BY position, created_at",
(container_id,),
).fetchall()
return [{"id": str(row["id"]), "title": row["title"], "position": row["position"]} for row in rows]
def _annotations(conn, binding_id: UUID) -> list[dict]:
rows = conn.execute(
"""
SELECT a.id, a.body, a.created_at, p.display_name
FROM context_annotations a
JOIN auth_accounts p ON p.id = a.author_subject_id
WHERE a.binding_id = %s
ORDER BY a.created_at, a.id
""",
(binding_id,),
).fetchall()
return [
{
"id": str(row["id"]),
"body": row["body"],
"author_display_name": row["display_name"],
"created_at": dump_dt(row["created_at"]),
}
for row in rows
]
def _dates(conn, element: dict) -> dict:
row = conn.execute(
"SELECT document_on, sent_on, received_on FROM correspondence_dates WHERE element_id = %s",
(element["id"],),
).fetchone()
return {
"document_on": dump_date(row["document_on"]) if row else None,
"sent_on": dump_date(row["sent_on"]) if row else None,
"received_on": dump_date(row["received_on"]) if row else None,
"recorded_at": dump_dt(element["created_at"]),
}
def _element_body(conn, element: dict) -> dict:
payload = {
"id": str(element["id"]),
"kind": element["kind"],
"title": element["title"],
"version": element["version"],
"owner_subject_id": str(element["owner_subject_id"]),
"dates": _dates(conn, element),
}
if element["kind"] == "note":
body = conn.execute(
"SELECT document_json FROM note_bodies WHERE element_id = %s",
(element["id"],),
).fetchone()
payload["document"] = body["document_json"] if body else {"version": 1, "blocks": []}
elif element["kind"] == "file":
asset = conn.execute(
"""
SELECT original_filename, content_type, byte_size, status
FROM media_assets WHERE element_id = %s
""",
(element["id"],),
).fetchone()
if asset is not None:
payload["file"] = {
"filename": asset["original_filename"],
"content_type": asset["content_type"],
"byte_size": asset["byte_size"],
"status": asset["status"],
}
elif element["kind"] == "external_ref":
ref = conn.execute(
"SELECT source, external_id, detail FROM external_references WHERE element_id = %s",
(element["id"],),
).fetchone()
if ref is not None:
payload["external"] = {
"source": ref["source"],
"external_id": ref["external_id"],
"detail": ref["detail"] or {},
}
return payload
def _exception(conn, kind: str, resource_id: UUID, context: Ctx | None) -> dict | None:
if context is None:
return None
row = conn.execute(
"""
SELECT can_read, can_edit, can_share
FROM access_grants
WHERE is_exception AND grantee_subject_id IS NULL
AND resource_kind = %s AND resource_id = %s
AND context_kind = %s AND context_id = %s
""",
(kind, resource_id, context.kind, context.id),
).fetchone()
if row is None:
return {"remove_read": False, "remove_edit": False, "remove_share": False}
return {"remove_read": row["can_read"], "remove_edit": row["can_edit"], "remove_share": row["can_share"]}
def binding_payload(conn, actor: UUID, binding: dict, context: Ctx) -> dict | None:
element = get_element(conn, binding["element_id"])
if element is None:
return None
rights = element_rights(conn, actor, element, context)
if not rights.read:
return None
payload = {
"id": str(binding["id"]),
"position": binding["position"],
"chapter_id": str(binding["chapter_id"]) if binding["chapter_id"] else None,
"rights": rights.as_dict(),
"annotations": _annotations(conn, binding["id"]),
"element": _element_body(conn, element),
}
if element["owner_subject_id"] == actor:
payload["exception"] = _exception(conn, "element", element["id"], context)
return payload
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
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
ORDER BY a.display_name, g.id
""",
(kind, resource_id),
).fetchall()
return [
{
"id": str(row["id"]),
"grantee_subject_id": str(row["grantee_subject_id"]),
"email": row["email"],
"display_name": row["display_name"],
"can_read": row["can_read"],
"can_edit": row["can_edit"],
"can_share": row["can_share"],
}
for row in rows
]
def case_summary(case: dict, rights) -> dict:
return {
"id": str(case["id"]),
"title": case["title"],
"status": case["record_status"],
"version": case["version"],
"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"]),
"rights": rights.as_dict(),
}
def case_detail(conn, actor: UUID, case: dict, rights) -> dict:
payload = case_summary(case, rights)
payload["home_scope_name"] = room_name(conn, case["home_scope_id"])
payload["is_owner"] = case["owner_subject_id"] == actor
if case["parent_case_id"]:
parent = get_case(conn, case["parent_case_id"])
if parent is not None and case_rights(conn, actor, parent).read:
payload["parent_title"] = parent["title"]
payload["chapters"] = _chapters(conn, "case", case["id"])
subcases = []
for row in conn.execute(
"""
SELECT * FROM cases
WHERE parent_case_id = %s AND deleted_at IS NULL
ORDER BY title, id
""",
(case["id"],),
).fetchall():
child_rights = case_rights(conn, actor, row)
if child_rights.read:
subcases.append(case_summary(row, child_rights))
payload["subcases"] = subcases
matters = []
for link in conn.execute(
"""
SELECT l.id AS link_id, m.*
FROM matter_case_links l
JOIN matters m ON m.id = l.matter_id
WHERE l.case_id = %s AND m.deleted_at IS NULL
ORDER BY m.title, m.id
""",
(case["id"],),
).fetchall():
matter_right = matter_rights(conn, actor, link, Ctx("case", case["id"]))
if not matter_right.read:
continue
matters.append(
{
"id": str(link["id"]),
"link_id": str(link["link_id"]),
"title": link["title"],
"status": link["record_status"],
}
)
payload["matters"] = matters
context = Ctx("case", case["id"])
bindings = []
for binding in conn.execute(
"""
SELECT * FROM bindings
WHERE context_kind = 'case' AND context_id = %s
ORDER BY position, created_at
""",
(case["id"],),
).fetchall():
item = binding_payload(conn, actor, binding, context)
if item is not None:
bindings.append(item)
payload["bindings"] = bindings
if rights.share or case["owner_subject_id"] == actor:
payload["grants"] = _grants(conn, "case", case["id"])
return payload
def matter_contexts(conn, actor: UUID, matter: dict) -> list[dict]:
contexts = []
for item in readable_matter_contexts(conn, actor, matter):
kind = "direct" if item["kind"] == "matter" and item["id"] == str(matter["id"]) else item["kind"]
contexts.append({"kind": kind, "id": item["id"], "title": item["title"]})
return contexts
def matter_summary(conn, actor: UUID, matter: dict) -> dict:
return {
"id": str(matter["id"]),
"title": matter["title"],
"status": matter["record_status"],
"version": matter["version"],
"parent_matter_id": str(matter["parent_matter_id"]) if matter["parent_matter_id"] else None,
"home_scope_id": str(matter["home_scope_id"]),
"home_scope_name": room_name(conn, matter["home_scope_id"]),
"contexts": matter_contexts(conn, actor, matter),
}
def _page_context(matter_id: UUID, context: Ctx | None) -> Ctx:
if context is None:
return Ctx("matter", matter_id)
return context
def matter_detail(conn, actor: UUID, matter: dict, rights, context: Ctx | None) -> dict:
page = _page_context(matter["id"], context)
payload = {
"id": str(matter["id"]),
"title": matter["title"],
"status": matter["record_status"],
"version": matter["version"],
"parent_matter_id": str(matter["parent_matter_id"]) if matter["parent_matter_id"] else 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"]),
"is_owner": matter["owner_subject_id"] == actor,
"rights": rights.as_dict(),
"context": None if context is None else context.as_dict(),
"chapters": _chapters(conn, "matter", matter["id"]),
}
submatters = []
for child in conn.execute(
"SELECT * FROM matters WHERE parent_matter_id = %s AND deleted_at IS NULL ORDER BY title, id",
(matter["id"],),
).fetchall():
child_rights = matter_rights(conn, actor, child, page)
if child_rights.read:
submatters.append({"id": str(child["id"]), "title": child["title"], "status": child["record_status"]})
payload["submatters"] = submatters
case_links = []
for link in conn.execute(
"""
SELECT l.id, l.case_id, c.title
FROM matter_case_links l
JOIN cases c ON c.id = l.case_id AND c.deleted_at IS NULL
WHERE l.matter_id = %s
ORDER BY c.title, c.id
""",
(matter["id"],),
).fetchall():
linked_case = get_case(conn, link["case_id"])
if linked_case is not None and case_rights(conn, actor, linked_case).read:
case_links.append({"id": str(link["id"]), "case_id": str(link["case_id"]), "title": link["title"]})
payload["case_links"] = case_links
crosses = []
for link in conn.execute(
"""
SELECT l.id, l.to_matter_id
FROM matter_cross_links l
WHERE l.from_matter_id = %s
""",
(matter["id"],),
).fetchall():
title = matter_title_if_readable(conn, actor, link["to_matter_id"])
if title is not None:
crosses.append({"id": str(link["id"]), "matter_id": str(link["to_matter_id"]), "title": title})
payload["cross_links"] = crosses
bindings = []
for binding in conn.execute(
"""
SELECT * FROM bindings
WHERE context_kind = 'matter' AND context_id = %s
ORDER BY position, created_at
""",
(matter["id"],),
).fetchall():
item = binding_payload(conn, actor, binding, page)
if item is not None:
bindings.append(item)
payload["bindings"] = bindings
payload["tasks"] = []
for task in conn.execute(
"""
SELECT * FROM tasks
WHERE matter_id = %s AND deleted_at IS NULL
ORDER BY due_on NULLS LAST, created_at
""",
(matter["id"],),
).fetchall():
task_right = task_rights(conn, actor, task, context)
if task_right.read:
payload["tasks"].append(task_payload(conn, actor, task, task_right))
payload["deadlines"] = []
visible_deadlines = set()
for deadline in conn.execute(
"""
SELECT * FROM deadlines
WHERE matter_id = %s AND deleted_at IS NULL
ORDER BY due_on, created_at
""",
(matter["id"],),
).fetchall():
deadline_right = deadline_rights(conn, actor, deadline, context)
if deadline_right.read:
payload["deadlines"].append(deadline_payload(conn, actor, deadline))
visible_deadlines.add(deadline["id"])
visible_tasks = {UUID(item["id"]) for item in payload["tasks"]}
links = []
if visible_tasks and visible_deadlines:
for link in conn.execute(
"SELECT task_id, deadline_id FROM task_deadline_links WHERE task_id = ANY(%s::uuid[])",
(list(visible_tasks),),
).fetchall():
if link["deadline_id"] in visible_deadlines:
links.append({"task_id": str(link["task_id"]), "deadline_id": str(link["deadline_id"])})
payload["task_deadline_links"] = links
if rights.share or matter["owner_subject_id"] == actor:
payload["grants"] = _grants(conn, "matter", matter["id"])
if matter["owner_subject_id"] == actor:
payload["exception"] = _exception(conn, "matter", matter["id"], context)
return payload
def task_payload(conn, actor: UUID, task: dict, rights=None) -> dict:
payload = {
"id": str(task["id"]),
"title": task["title"],
"status": task["task_status"],
"version": task["version"],
"due_on": dump_date(task["due_on"]),
"assignee_display_name": display_name(conn, task["assignee_subject_id"]),
}
if rights is not None:
payload["rights"] = rights.as_dict()
title = matter_title_if_readable(conn, actor, task["matter_id"])
if title is not None and task["matter_id"] is not None:
payload["matter_id"] = str(task["matter_id"])
payload["matter_title"] = title
action = _task_action_context(conn, actor, task)
if action is not None:
payload["action_context"] = action
return payload
def _task_action_context(conn, actor: UUID, task: dict) -> dict | None:
direct = task_rights(conn, actor, task, None)
if direct.read and (direct.edit or task["owner_subject_id"] == actor or task["assignee_subject_id"] == actor):
return None
if task["matter_id"] is None:
return None
matter = get_matter(conn, task["matter_id"])
if matter is None:
return None
for item in readable_matter_contexts(conn, actor, matter):
if item["kind"] != "case":
continue
rights = task_rights(conn, actor, task, Ctx("case", UUID(item["id"])))
if rights.edit or (rights.read and task["assignee_subject_id"] == actor):
return {"kind": "case", "id": item["id"]}
return None
def deadline_payload(conn, actor: UUID, deadline: dict) -> dict:
payload = {
"id": str(deadline["id"]),
"title": deadline["title"],
"status": deadline["deadline_status"],
"version": deadline["version"],
"due_on": dump_date(deadline["due_on"]),
"fulfilled_at": dump_dt(deadline["fulfilled_at"]),
"assignee_display_name": display_name(conn, deadline["assignee_subject_id"]),
}
title = matter_title_if_readable(conn, actor, deadline["matter_id"])
if title is not None and deadline["matter_id"] is not None:
payload["matter_id"] = str(deadline["matter_id"])
payload["matter_title"] = title
direct = deadline_rights(conn, actor, deadline, None)
if not (direct.read and (direct.edit or deadline["owner_subject_id"] == actor or deadline["assignee_subject_id"] == actor)):
if deadline["matter_id"] is not None:
matter = get_matter(conn, deadline["matter_id"])
if matter is not None:
for item in readable_matter_contexts(conn, actor, matter):
if item["kind"] != "case":
continue
rights = deadline_rights(conn, actor, deadline, Ctx("case", UUID(item["id"])))
if rights.edit or (rights.read and deadline["assignee_subject_id"] == actor):
payload["action_context"] = {"kind": "case", "id": item["id"]}
break
return payload
def note_update_payload(conn, actor: UUID, element: dict, document: dict) -> dict:
return {
"id": str(element["id"]),
"title": element["title"],
"version": element["version"],
"document": document,
"visible_bindings": visible_bindings_for_element(conn, actor, element),
"notice": SHARED_NOTICE,
}
LABELS = {
"case_created": "Akte angelegt",
"matter_created": "Vorgang angelegt",
"matter_linked": "Vorgang einer Akte zugeordnet",
"matter_unlinked": "Aktenzuordnung gelöst",
"cross_linked": "Querverweis erfasst",
"note_created": "Notiz angelegt",
"note_updated": "Gemeinsamer Notizinhalt geändert",
"annotation_created": "Kontextbezogene Anmerkung erfasst",
"file_added": "Datei hinzugefügt",
"external_ref_added": "Externe Referenz erfasst",
"binding_created": "Einbindung ergänzt",
"binding_removed": "Einbindung entfernt",
"element_deleted": "Element gelöscht",
"task_created": "Aufgabe angelegt",
"task_done": "Aufgabe erledigt",
"task_reopened": "Aufgabe wieder geöffnet",
"deadline_created": "Frist erfasst",
"deadline_fulfilled": "Frist erfüllt",
"grant_created": "Freigabe erteilt",
"grant_revoked": "Freigabe entzogen",
"correspondence_document": "Dokumentdatum",
"correspondence_sent": "Versand",
"correspondence_received": "Zugang",
"correspondence_recorded": "Erfassung",
"chapter_created": "Kapitel angelegt",
}