"""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", }