Deploy Development / deploy (push) Successful in 23s
Anmeldung, Datenraeume, Akten, Vorgaenge, gemeinsame Notizen, Dateien, manuelle Paperless-Referenzen, Aufgaben und unabhaengige Fristen laufen damit in der Entwicklungsumgebung. Co-authored-by: Cursor <cursoragent@cursor.com>
491 lines
18 KiB
Python
491 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 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"]}
|
|
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
|
|
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"]),
|
|
"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,
|
|
"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",
|
|
}
|