Files
tsumugu/backend/app/present.py
T
LarsandClaude Sonnet 5.5 6d7b7c5f85
Deploy Development / deploy (push) Successful in 45s
Test Suite / pytest-backend (push) Successful in 5m20s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Führe Hauptnutzer und Mitarbeiter ein, damit der Betreiber Kunden und Hauptnutzer ihre Teams verwalten.
Eine Einladung erzeugt jetzt ein Mitarbeiter-Konto mit dem Eigentümer des Raums als Förderer. Mitarbeiter arbeiten nur in den eingeladenen Räumen nach ihrer Rolle, legen keine Räume und im persönlichen Raum nichts an und starten ihre Sitzung im Team-Raum. Einladen darf nur der Eigentümer als Hauptnutzer; nur ein Hauptnutzer kann Raum-Eigentümer sein. Hauptnutzer sehen unter Mein Team die Personen in ihren Räumen und verwalten ihre Mitarbeiter (deaktivieren, Einmal-Passwort, aus Räumen entfernen). Der Betreiber sieht die Team-Übersicht mit CSV-Export und macht einen Mitarbeiter zum Hauptnutzer.

Eine zentrale Prüfstelle für Grenzen (access/limits.py) wird beim Anlegen von Räumen und beim Aufnehmen und Einladen von Mitgliedern aufgerufen; Tarife folgen später.

Die lokale Suite läuft mit 143 Tests grün, der Frontend-Build und 24 Node-Tests ebenfalls. Die Oberfläche wurde noch nicht im Browser bedient.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 09:03:40 +02:00

1084 lines
41 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,
get_task,
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
from app.order import arrange
def rights_dict(rights) -> dict:
return rights.as_dict()
def _chapters(conn, kind: str, container_id: UUID, mode: str = "position", direction: str = "asc") -> list[dict]:
column = "case_id" if kind == "case" else "matter_id"
rows = conn.execute(
f"SELECT id, title, position, document_on, parent_chapter_id FROM chapters WHERE {column} = %s",
(container_id,),
).fetchall()
items = [
{
"id": str(row["id"]),
"title": row["title"],
"position": row["position"],
"document_on": dump_date(row["document_on"]),
"parent_chapter_id": str(row["parent_chapter_id"]) if row["parent_chapter_id"] else None,
}
for row in rows
]
if mode == "date":
dated = [item for item in items if item["document_on"]]
undated = [item for item in items if not item["document_on"]]
dated.sort(key=lambda item: (item["document_on"], item["position"], item["id"]))
undated.sort(key=lambda item: (item["position"], item["id"]))
if direction == "desc":
dated.reverse()
return dated + undated
items.sort(key=lambda item: (item["position"], item["id"]))
return items
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 _plain_excerpt(document: dict | None) -> str | None:
if not isinstance(document, dict):
return None
parts = []
for block in document.get("blocks") or []:
if not isinstance(block, dict):
continue
text = str(block.get("text") or "").strip()
if text:
parts.append(text)
raw = " ".join(parts).strip()
if not raw:
return None
return raw[:180]
def _preview_meta(kind: str, content_type: str | None, source: str | None) -> dict:
if kind == "note":
return {"available": False, "media": "note", "source": "note"}
media = (content_type or "").split(";")[0].strip().lower()
if kind == "file" and media.startswith("image/"):
return {"available": True, "media": "image", "source": "file"}
if kind == "file" and media == "application/pdf":
return {"available": True, "media": "pdf", "source": "file"}
if kind == "external_ref" and source:
from app.sourceregistry import get_source
module = get_source(source)
if module is not None:
return {
"available": bool(module.capabilities.get("read_preview")),
"media": module.representation,
"source": source,
}
if kind == "file":
return {"available": False, "media": "file", "source": "file"}
return {"available": False, "media": "none", "source": source}
_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"],
"title": element["title"],
"summary": element.get("summary") or None,
"excerpt": None,
"version": element["version"],
"owner_subject_id": str(element["owner_subject_id"]),
"dates": _dates(conn, element),
"preview": _preview_meta(element["kind"], None, None),
}
if element["kind"] == "note":
body = conn.execute(
"SELECT document_json FROM note_bodies WHERE element_id = %s",
(element["id"],),
).fetchone()
document = body["document_json"] if body else {"version": 1, "blocks": []}
payload["document"] = document
payload["excerpt"] = _plain_excerpt(document)
payload["preview"] = _preview_meta("note", None, "note")
elif element["kind"] == "file":
asset = conn.execute(
"""
SELECT original_filename, content_type, byte_size, status, protection_profile
FROM media_assets WHERE element_id = %s
""",
(element["id"],),
).fetchone()
if asset is not None:
profile = asset["protection_profile"] or "legacy-plaintext"
payload["file"] = {
"filename": asset["original_filename"],
"content_type": asset["content_type"],
"byte_size": asset["byte_size"],
"status": asset["status"],
"protection_profile": profile,
}
if profile != "legacy-plaintext":
payload["preview"] = {"available": False, "media": "locked", "source": "file"}
else:
payload["preview"] = _preview_meta("file", asset["content_type"], "file")
elif element["kind"] == "external_ref":
ref = conn.execute(
"""
SELECT source, external_id, detail, connector_id, resolution
FROM external_references WHERE element_id = %s
""",
(element["id"],),
).fetchone()
if ref is not None:
detail = dict(ref["detail"] or {})
connector_owner = _connector_owner(conn, ref["connector_id"] or 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}
resolution = ref["resolution"] or "unresolved"
external = {"source": ref["source"], "detail": detail, "resolution": resolution}
if revealed:
external["external_id"] = ref["external_id"]
payload["external"] = external
from app.sourcebind import resolve_for_read
from app.sourceregistry import get_source
module = get_source(ref["source"])
if module is None:
payload["preview"] = _preview_meta("external_ref", None, ref["source"])
else:
resolved = resolve_for_read(conn, element["owner_subject_id"], ref["source"], ref, None)
if resolved.code == "ok":
payload["preview"] = _preview_meta("external_ref", None, ref["source"])
elif actor == element["owner_subject_id"]:
payload["preview"] = {"available": False, "media": "unassigned", "source": ref["source"]}
else:
payload["preview"] = {"available": False, "media": "none", "source": ref["source"]}
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 communication_from_row(conn, binding: dict, element: dict) -> dict:
"""Explicit binding direction wins. An adopted mailbox direction may prefill. Dates never do."""
stored = binding.get("communication_direction")
stored = stored if stored in ("in", "out", "local") else None
if binding.get("direction_explicit"):
return {"direction": stored, "explicit": True}
source = None
if element["kind"] == "external_ref":
ref = conn.execute(
"SELECT source, detail FROM external_references WHERE element_id = %s",
(element["id"],),
).fetchone()
detail = (ref["detail"] or {}) if ref is not None else {}
if detail.get("direction") in ("in", "out"):
source = detail["direction"]
return {"direction": source, "explicit": False}
def _reference_view(conn, actor: UUID, element_id: UUID, context: Ctx, container: Ctx) -> dict | None:
element = get_element(conn, element_id)
if element is None or not element_rights(conn, actor, element, context).read:
return None
dates = _dates(conn, element)
row = conn.execute(
"""
SELECT communication_direction, direction_explicit
FROM bindings
WHERE element_id = %s AND context_kind = %s AND context_id = %s
""",
(element["id"], container.kind, container.id),
).fetchone()
direction = communication_from_row(
conn,
row or {"communication_direction": None, "direction_explicit": False},
element,
)["direction"]
return {
"id": str(element["id"]),
"title": element["title"],
"document_on": dates["document_on"],
"direction": direction,
}
def _attach_references(conn, actor: UUID, element: dict, context: Ctx, container: Ctx, body: dict) -> None:
refers = []
for row in conn.execute(
"""
SELECT refers_to_element_id
FROM element_references
WHERE element_id = %s
ORDER BY created_at, refers_to_element_id
""",
(element["id"],),
).fetchall():
view = _reference_view(conn, actor, row["refers_to_element_id"], context, container)
if view is not None:
refers.append(view)
replies = []
for row in conn.execute(
"""
SELECT element_id
FROM element_references
WHERE refers_to_element_id = %s
ORDER BY created_at, element_id
""",
(element["id"],),
).fetchall():
view = _reference_view(conn, actor, row["element_id"], context, container)
if view is not None:
replies.append(view)
if refers:
body["refers_to"] = refers
if replies:
body["referred_by"] = replies
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
body = _element_body(conn, actor, element)
container = Ctx(binding["context_kind"], binding["context_id"])
_attach_references(conn, actor, element, context, container, body)
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"]),
"communication": communication_from_row(conn, binding, element),
"element": body,
}
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, 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
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"],
"use_owner_sources": row["use_owner_sources"],
}
for row in rows
]
def _ordered_bindings(conn, actor: UUID, kind: str, container_id: UUID, context: Ctx, mode: str, direction: str) -> list[dict]:
rows = conn.execute(
"""
SELECT * FROM bindings
WHERE context_kind = %s AND context_id = %s
ORDER BY position, id
""",
(kind, container_id),
).fetchall()
visible = []
for binding in rows:
item = binding_payload(conn, actor, binding, context)
if item is None:
continue
item["_raw_position"] = binding["position"]
item["_document_on"] = item["element"]["dates"]["document_on"]
item["container"] = {"kind": kind, "id": str(container_id)}
item["_fold"] = binding.get("list_fold")
visible.append(item)
arranged = arrange(visible, mode or "position", direction or "asc")
from app.correspondence import attach_correspondence
attach_correspondence(conn, actor, arranged, context)
for item in arranged:
item.pop("_fold", None)
return arranged
def course_items(bindings: list[dict]) -> list[dict]:
"""One fachlicher Eintrag je Unterlage. Das Erfassungsdatum ist kein Belegdatum."""
items = []
for binding in bindings:
dates = binding["element"]["dates"]
items.append(
{
"id": binding["element"]["id"],
"binding_id": binding["id"],
"title": binding["element"]["title"],
"kind": binding["element"]["kind"],
"document_on": dates["document_on"],
"sent_on": dates["sent_on"],
"received_on": dates["received_on"],
"dated": dates["document_on"] is not None,
}
)
dated = [item for item in items if item["dated"]]
undated = [item for item in items if not item["dated"]]
dated.sort(key=lambda item: (item["document_on"], item["id"]))
undated.sort(key=lambda item: item["id"])
return dated + undated
def _matter_href(matter_id: UUID, context: Ctx | None) -> str:
href = f"/matters/{matter_id}"
if context is not None and context.kind == "case":
href += f"?context_kind=case&context_id={context.id}"
return href
def _append_matter_steps(conn, actor: UUID, trail: list[dict], matter: dict, context: Ctx | None) -> None:
"""Object path only. The same labels apply from a case, a list or a direct link."""
page = context if context is not None and context.kind == "case" else None
if matter["parent_matter_id"]:
parent = get_matter(conn, matter["parent_matter_id"])
if parent is not None and matter_title_if_readable(conn, actor, parent["id"]):
trail.append({"label": f"Vorgang {parent['title']}", "href": _matter_href(parent["id"], page if _parent_keeps_context(conn, actor, parent, page) else None)})
kind = "Teilvorgang" if matter["parent_matter_id"] else "Vorgang"
trail.append({"label": f"{kind} {matter['title']}", "href": None})
def _parent_keeps_context(conn, actor: UUID, parent: dict, page: Ctx | None) -> bool:
return page is not None and matter_rights(conn, actor, parent, page).read
def case_trail(conn, actor: UUID, case: dict) -> list[dict]:
trail = [{"label": "Akten", "href": "/cases"}]
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:
trail.append({"label": f"Akte {parent['title']}", "href": f"/cases/{parent['id']}"})
kind = "Unterakte" if case["parent_case_id"] else "Akte"
trail.append({"label": f"{kind} {case['title']}", "href": None})
return trail
def _structural_case(conn, actor: UUID, matter: dict, context: Ctx | None) -> dict | None:
"""The case that places this matter in the structure. Several placements do not invent a main case."""
if context is not None and context.kind == "case":
case = get_case(conn, context.id)
if case is not None and case_rights(conn, actor, case).read:
return case
return None
placements = matter_placements(conn, actor, matter["id"], None)
if len(placements) != 1:
return None
case = get_case(conn, UUID(placements[0]["case_id"]))
if case is None or not case_rights(conn, actor, case).read:
return None
return case
def matter_trail(conn, actor: UUID, matter: dict, context: Ctx | None) -> list[dict]:
case = _structural_case(conn, actor, matter, context)
if case is None:
trail = [{"label": "Vorgänge", "href": "/matters"}]
_append_matter_steps(conn, actor, trail, matter, None)
return trail
trail = case_trail(conn, actor, case)
trail[-1]["href"] = f"/cases/{case['id']}"
_append_matter_steps(conn, actor, trail, matter, Ctx("case", case["id"]))
return trail
def _case_chain_label(conn, actor: UUID, case: dict) -> str:
parts = []
current = case
guard = 0
while current is not None and guard < 4:
if not case_rights(conn, actor, current).read:
break
kind = "Unterakte" if current["parent_case_id"] else "Akte"
parts.append(f"{kind} {current['title']}")
parent_id = current["parent_case_id"]
current = get_case(conn, parent_id) if parent_id else None
guard += 1
parts.reverse()
return " → ".join(parts)
def _placement_rows(conn, matter_id: UUID) -> list[dict]:
return conn.execute(
"""
SELECT c.*
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()
def matter_placements(conn, actor: UUID, matter_id: UUID, context: Ctx | None) -> list[dict]:
"""Readable case assignments of this matter and its readable parent chain."""
items = []
seen: set[UUID] = set()
matter = get_matter(conn, matter_id)
guard = 0
while matter is not None and guard < 4:
for link in _placement_rows(conn, matter["id"]):
if link["id"] in seen or not case_rights(conn, actor, link).read:
continue
seen.add(link["id"])
items.append(
{
"case_id": str(link["id"]),
"label": _case_chain_label(conn, actor, link),
"href": f"/cases/{link['id']}",
"current": context is not None and context.kind == "case" and context.id == link["id"],
}
)
parent_id = matter["parent_matter_id"]
if parent_id is None or matter_title_if_readable(conn, actor, parent_id) is None:
break
matter = get_matter(conn, parent_id)
guard += 1
return items
def _contained_group(conn, actor: UUID, matter: dict, context: Ctx) -> dict | None:
matter_right = matter_rights(conn, actor, matter, context)
if not matter_right.read:
return None
return {
"matter_id": str(matter["id"]),
"title": matter["title"],
"kind_label": "Teilvorgang" if matter["parent_matter_id"] else "Vorgang",
"parent_title": matter_title_if_readable(conn, actor, matter["parent_matter_id"]),
"version": matter["version"],
"rights": matter_right.as_dict(),
"chapters": _chapters(
conn,
"matter",
matter["id"],
matter.get("content_order") or "position",
matter.get("content_order_dir") or "asc",
),
"content_order": matter.get("content_order") or "position",
"content_order_dir": matter.get("content_order_dir") or "asc",
"bindings": _ordered_bindings(
conn,
actor,
"matter",
matter["id"],
context,
matter.get("content_order") or "position",
matter.get("content_order_dir") or "asc",
),
}
def _matter_node(row: dict) -> dict:
return {
"id": str(row["id"]),
"title": row["title"],
"status": row["record_status"],
"kind_label": "Teilvorgang" if row["parent_matter_id"] else "Vorgang",
"parent_matter_id": str(row["parent_matter_id"]) if row["parent_matter_id"] else None,
"children": [],
}
def _matter_tree(conn, actor: UUID, case_id: UUID, linked: list[dict]) -> list[dict]:
"""One level: a Teilvorgang sits under its Vorgang, not beside it."""
context = Ctx("case", case_id)
rows = list(linked)
seen = {row["id"] for row in rows}
for row in list(rows):
children = conn.execute(
"""
SELECT * FROM matters
WHERE parent_matter_id = %s AND deleted_at IS NULL
ORDER BY title, id
""",
(row["id"],),
).fetchall()
for child in children:
if child["id"] in seen:
continue
if matter_rights(conn, actor, child, context).read:
rows.append(child)
seen.add(child["id"])
nodes = {row["id"]: _matter_node(row) for row in rows}
roots = []
for row in rows:
parent_id = row["parent_matter_id"]
node = nodes[row["id"]]
if parent_id and parent_id in nodes:
nodes[parent_id]["children"].append(node)
else:
roots.append(node)
return roots
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["content_order"] = case.get("content_order") or "position"
payload["content_order_dir"] = case.get("content_order_dir") or "asc"
payload["content_view"] = case.get("content_view") or "structure"
payload["trail"] = case_trail(conn, actor, case)
payload["kind_label"] = "Unterakte" if case["parent_case_id"] else "Akte"
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"], case.get("content_order") or "position", case.get("content_order_dir") or "asc"
)
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(link)
payload["matters"] = _matter_tree(conn, actor, case["id"], matters)
context = Ctx("case", case["id"])
payload["bindings"] = _ordered_bindings(
conn, actor, "case", case["id"], context, payload["content_order"], payload["content_order_dir"]
)
contained = []
seen_matters: set[UUID] = set()
linked_matters = conn.execute(
"""
SELECT 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()
for link in linked_matters:
block = [link]
if not link["parent_matter_id"]:
block.extend(
conn.execute(
"""
SELECT * FROM matters
WHERE parent_matter_id = %s AND deleted_at IS NULL
ORDER BY title, id
""",
(link["id"],),
).fetchall()
)
for matter in block:
if matter["id"] in seen_matters:
continue
seen_matters.add(matter["id"])
group = _contained_group(conn, actor, matter, context)
if group is not None:
contained.append(group)
payload["contained"] = contained
payload["tasks"] = []
payload["deadlines"] = []
payload["task_deadline_links"] = []
def _walk(nodes):
for node in nodes:
yield node
yield from _walk(node["children"])
for node in _walk(payload["matters"]):
tracked = _tracking(conn, actor, UUID(node["id"]), context)
payload["tasks"].extend(tracked["tasks"])
payload["deadlines"].extend(tracked["deadlines"])
payload["task_deadline_links"].extend(tracked["links"])
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 shared_room_names(conn, kind: str, resource_id: UUID) -> list[str]:
rows = conn.execute(
"""
SELECT r.name FROM room_shares s JOIN data_rooms r ON r.id = s.room_id
WHERE s.resource_kind = %s AND s.resource_id = %s
ORDER BY r.name, r.id
""",
(kind, resource_id),
).fetchall()
return [row["name"] for row in rows]
def matter_summary(conn, actor: UUID, matter: dict) -> dict:
owner = matter["owner_subject_id"] == actor
return {
"is_owner": owner,
"shared_with": shared_room_names(conn, "matter", matter["id"]) if owner else [],
"id": str(matter["id"]),
"title": matter["title"],
"status": matter["record_status"],
"version": matter["version"],
"kind_label": "Teilvorgang" if matter["parent_matter_id"] else "Vorgang",
"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"]),
"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,
"content_order": matter.get("content_order") or "position",
"content_order_dir": matter.get("content_order_dir") or "asc",
"content_view": matter.get("content_view") or "structure",
"trail": matter_trail(conn, actor, matter, context),
"placements": matter_placements(conn, actor, matter["id"], context),
"kind_label": "Teilvorgang" if matter["parent_matter_id"] else "Vorgang",
"rights": rights.as_dict(),
"context": None if context is None else context.as_dict(),
"chapters": _chapters(
conn,
"matter",
matter["id"],
matter.get("content_order") or "position",
matter.get("content_order_dir") or "asc",
),
}
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
payload["bindings"] = _ordered_bindings(
conn,
actor,
"matter",
matter["id"],
page,
payload["content_order"],
payload["content_order_dir"],
)
tracked = _tracking(conn, actor, matter["id"], context)
payload["tasks"] = tracked["tasks"]
payload["deadlines"] = tracked["deadlines"]
payload["task_deadline_links"] = tracked["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 _tracking(conn, actor: UUID, matter_id: UUID, context: Ctx | None) -> dict:
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:
tasks.append(task_payload(conn, actor, task, task_right))
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:
deadlines.append(deadline_payload(conn, actor, deadline))
visible_deadlines.add(deadline["id"])
links = []
visible_tasks = {UUID(item["id"]) for item in tasks}
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"])})
return {"tasks": tasks, "deadlines": deadlines, "links": links}
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
elements = []
for link in conn.execute(
"SELECT element_id FROM task_element_links WHERE task_id = %s ORDER BY created_at, element_id",
(task["id"],),
).fetchall():
element = get_element(conn, link["element_id"])
if element is None or element["deleted_at"] is not None:
continue
if not element_rights(conn, actor, element, None).read:
continue
elements.append({"id": str(element["id"]), "title": element["title"]})
if elements:
payload["elements"] = elements
depends_on = []
for link in conn.execute(
"SELECT depends_on_task_id FROM task_dependencies WHERE task_id = %s ORDER BY created_at, depends_on_task_id",
(task["id"],),
).fetchall():
earlier = get_task(conn, link["depends_on_task_id"])
if earlier is None or not task_rights(conn, actor, earlier, None).read:
continue
depends_on.append({"id": str(earlier["id"]), "title": earlier["title"], "status": earlier["task_status"]})
if depends_on:
payload["depends_on"] = depends_on
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",
"export_created": "Übergabepaket erzeugt",
"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",
"source_read_mediated": "Verknüpftes Original gelesen",
"correspondence_document": "Dokumentdatum",
"correspondence_sent": "Versand",
"correspondence_received": "Zugang",
"correspondence_recorded": "Erfassung",
"chapter_created": "Kapitel angelegt",
"summary_changed": "Kurzbeschreibung geändert",
"title_changed": "Titel geändert",
"binding_chapter": "In ein Kapitel eingeordnet",
"chapters_reordered": "Kapitelreihenfolge geändert",
"chapter_dated": "Kapiteldatum geändert",
"chapter_moved": "Kapitel umgehängt",
"content_order": "Ordnungsart geändert",
"content_reordered": "Eigene Reihenfolge geändert",
"account_created": "Konto angelegt",
"account_renamed": "Kontoname geändert",
"account_disabled": "Konto deaktiviert",
"account_enabled": "Konto aktiviert",
"operator_granted": "Betreiberrolle vergeben",
"operator_revoked": "Betreiberrolle entzogen",
"password_reset": "Passwort zurückgesetzt",
"password_changed": "Passwort geändert",
"sessions_revoked": "Sitzungen beendet",
"session_started": "Angemeldet",
"session_ended": "Abgemeldet",
"room_created": "Datenraum angelegt",
"room_renamed": "Datenraum umbenannt",
"room_archived": "Datenraum archiviert",
"room_restored": "Datenraum wieder aktiviert",
"membership_added": "Mitglied hinzugefügt",
"membership_role_changed": "Raumrolle geändert",
"membership_removed": "Mitglied entfernt",
"invitation_created": "Einladung erstellt",
"invitation_revoked": "Einladung widerrufen",
"invitation_accepted": "Einladung angenommen",
"visibility_changed": "Raumfreigabe geändert",
"employee_promoted": "Mitarbeiter zum Hauptnutzer gemacht",
"employee_disabled": "Mitarbeiter-Konto deaktiviert",
"employee_enabled": "Mitarbeiter-Konto aktiviert",
"employee_password_reset": "Passwort eines Mitarbeiters zurückgesetzt",
"employee_removed": "Mitarbeiter aus allen Räumen entfernt",
"room_shared": "Mit Datenraum geteilt",
"room_share_changed": "Freigabe an Datenraum geändert",
"room_unshared": "Freigabe an Datenraum beendet",
"person_excluded": "Person von der Raumfreigabe ausgenommen",
"person_included": "Person wieder in die Raumfreigabe aufgenommen",
"room_owner_changed": "Eigentümer des Datenraums gewechselt",
"room_default_changed": "Voreinstellung des Datenraums geändert",
}