"""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 from app.order import arrange 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 _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 == "paperless": return {"available": True, "media": "paperless", "source": "paperless"} if kind == "file": return {"available": False, "media": "file", "source": "file"} return {"available": False, "media": "none", "source": source} def _element_body(conn, 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 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"], } payload["preview"] = _preview_meta("file", asset["content_type"], "file") 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 {}, } payload["preview"] = _preview_meta("external_ref", None, 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 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 _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"] visible.append(item) return arrange(visible, mode or "position", direction or "asc") 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 matter_trail(conn, actor: UUID, matter: dict, context: Ctx | None) -> list[dict]: trail = [{"label": "Vorgänge", "href": "/matters"}] _append_matter_steps(conn, actor, trail, matter, context) 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"]), "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["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"]) 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 matter_summary(conn, actor: UUID, matter: dict) -> dict: return { "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", "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"]), } 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 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", "summary_changed": "Kurzbeschreibung geändert", "binding_chapter": "In ein Kapitel eingeordnet", "content_order": "Ordnungsart geändert", "content_reordered": "Eigene Reihenfolge geändert", }