Files
tsumugu/backend/tests/test_correspondence.py
T
LarsandCursor 9f5327f3be
Deploy Development / deploy (push) Successful in 27s
Test Suite / pytest-backend (push) Successful in 1m41s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 8s
Schliesse das Ablegen an der Markierung ab und halte Anlagen und Belege getrennt, damit der Dialog erscheint und zugeordnete Unterlagen im Uebergabepaket nur beim Schreiben stehen.
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-18 11:35:03 +02:00

637 lines
25 KiB
Python

"""Schreiben, Anlagen, Versandfassungen, Nachweise, Rechte und Export."""
from __future__ import annotations
import io
import json
import os
import zipfile
from email.message import EmailMessage
from pathlib import Path
from tests.support import ORIGIN, Actor, document, grant, register
PDF_A = b"%PDF-1.4\n1 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nA\n"
PDF_B = b"%PDF-1.4\n2 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nB\n"
PDF_C = b"%PDF-1.4\n3 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nC\n"
PDF_D = b"%PDF-1.4\n4 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nD\n"
def _detail(actor: Actor, matter_id: str, context: dict | None = None) -> dict:
params = None
if context is not None:
params = {"context_kind": context["kind"], "context_id": context["id"]}
return actor.request("GET", f"/api/v1/matters/{matter_id}", params=params)
def _binding(detail: dict, title: str) -> dict:
for item in detail["bindings"]:
if item["element"]["title"] == title:
return item
raise AssertionError(title)
def _file(actor: Actor, matter_id: str, title: str, name: str, data: bytes, document_on: str, chapter_id: str | None = None) -> dict:
form = {"title": title, "context_kind": "matter", "context_id": matter_id, "document_on": document_on}
if chapter_id:
form["chapter_id"] = chapter_id
return actor.request(
"POST",
"/api/v1/files",
data=form,
files={"upload": (name, data, "application/pdf")},
status=201,
)
def _ctx(matter_id: str) -> dict:
return {"kind": "matter", "id": matter_id}
def _eml(message_id: str, body: str, attachments: list[tuple[str, bytes]]) -> bytes:
message = EmailMessage()
message["Subject"] = "Versandnachweis"
message["From"] = "kanzlei@example.test"
message["To"] = "gegenueber@example.test"
message["Message-ID"] = message_id
message["Date"] = "Thu, 12 Mar 2026 10:00:00 +0100"
message.set_content(body)
for name, data in attachments:
message.add_attachment(data, maintype="application", subtype="pdf", filename=name)
return message.as_bytes()
def _zip(actor: Actor, matter_id: str, selected: list[str]) -> zipfile.ZipFile:
headers = {
"Origin": ORIGIN,
"X-CSRF-Token": actor.csrf,
"Content-Type": "application/json",
"X-Scope-Kind": actor.scope["kind"],
"X-Scope-Id": actor.scope["id"],
}
response = actor.client.post(
f"/api/v1/matters/{matter_id}/export",
json={"selected": selected},
headers=headers,
)
assert response.status_code == 200, response.text
return zipfile.ZipFile(io.BytesIO(response.content))
def _walk(node):
yield node
for child in node.get("children") or []:
yield from _walk(child)
def test_attachments_keep_other_uses_and_do_not_copy_files(client, db):
ada = Actor(client, "ada-anlage@example.test", "Ada Anlage")
register(db, ada.email, ada.name)
ada.login()
matter = ada.request("POST", "/api/v1/matters", json={"title": "Schreiben A"}, status=201)
other = ada.request("POST", "/api/v1/matters", json={"title": "Schreiben B"}, status=201)
chapter = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Korrespondenz"}, status=201)
sub = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/chapters",
json={"title": "Einzelbelege", "parent_chapter_id": chapter["id"]},
status=201,
)
letter = ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Anschreiben",
"document": document("Bitte um Stellungnahme"),
"context": _ctx(matter["id"]),
"chapter_id": chapter["id"],
"dates": {"document_on": "2026-03-01"},
},
status=201,
)
first = _file(ada, matter["id"], "Rechnung 2023", "rechnung.pdf", PDF_A, "2023-05-01", sub["id"])
second = _file(ada, matter["id"], "Lageplan", "lage.pdf", PDF_B, "2024-01-15", sub["id"])
third = _file(ada, matter["id"], "Kontoauszug", "konto.pdf", PDF_C, "2025-11-02", sub["id"])
before = db.execute("SELECT count(*) AS n FROM media_assets").fetchone()["n"]
detail = _detail(ada, matter["id"])
host = _binding(detail, "Anschreiben")
ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/attachments",
json={
"expected_version": host["element"]["version"],
"context": _ctx(matter["id"]),
"attachment_element_ids": [first["id"], second["id"], third["id"]],
"fold": "keep",
},
status=201,
)
ordered = _detail(ada, matter["id"])
host = _binding(ordered, "Anschreiben")
assert [item["title"] for item in host["correspondence"]["attachments"]] == [
"Rechnung 2023",
"Lageplan",
"Kontoauszug",
]
assert [item["document_on"] for item in host["correspondence"]["attachments"]] == [
"2023-05-01",
"2024-01-15",
"2025-11-02",
]
ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/attachments/order",
json={
"expected_version": host["element"]["version"],
"context": _ctx(matter["id"]),
"attachment_element_ids": [third["id"], first["id"], second["id"]],
},
)
moved = _detail(ada, matter["id"])
host = _binding(moved, "Anschreiben")
assert [item["element_id"] for item in host["correspondence"]["attachments"]] == [third["id"], first["id"], second["id"]]
ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/attachments/{second['id']}/detach",
json={"expected_version": host["element"]["version"], "context": _ctx(matter["id"])},
status=204,
)
kept = _detail(ada, matter["id"])
assert _binding(kept, "Lageplan")["chapter_id"] == sub["id"]
assert [item["title"] for item in _binding(kept, "Anschreiben")["correspondence"]["attachments"]] == [
"Kontoauszug",
"Rechnung 2023",
]
assert any(item["title"] == "Einzelbelege" and item["parent_chapter_id"] == chapter["id"] for item in kept["chapters"])
after = db.execute("SELECT count(*) AS n FROM media_assets").fetchone()["n"]
assert after == before
ada.request(
"POST",
"/api/v1/bindings",
json={"element_id": first["id"], "source_context": _ctx(matter["id"]), "target": _ctx(other["id"])},
status=201,
)
other_letter = ada.request(
"POST",
"/api/v1/notes",
json={"title": "Zweites Schreiben", "document": document("Andere Sache"), "context": _ctx(other["id"])},
status=201,
)
other_detail = _detail(ada, other["id"])
ada.request(
"POST",
f"/api/v1/elements/{other_letter['id']}/attachments",
json={
"expected_version": _binding(other_detail, "Zweites Schreiben")["element"]["version"],
"context": _ctx(other["id"]),
"attachment_element_ids": [first["id"]],
"fold": "keep",
},
status=201,
)
again = _detail(ada, matter["id"])
elsewhere = _detail(ada, other["id"])
assert [item["element_id"] for item in _binding(again, "Anschreiben")["correspondence"]["attachments"]] == [
third["id"],
first["id"],
]
assert [item["element_id"] for item in _binding(elsewhere, "Zweites Schreiben")["correspondence"]["attachments"]] == [
first["id"],
]
grants = db.execute("SELECT count(*) AS n FROM access_grants").fetchone()["n"]
assert grants == 0
ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/attachments",
json={
"expected_version": _binding(again, "Anschreiben")["element"]["version"],
"context": _ctx(matter["id"]),
"attachment_element_ids": [letter["id"]],
"fold": "keep",
},
status=422,
)
ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/attachments",
json={
"expected_version": _binding(again, "Anschreiben")["element"]["version"],
"context": _ctx(other["id"]),
"attachment_element_ids": [first["id"]],
"fold": "keep",
},
status=404,
)
def test_dispatch_keeps_the_secured_stand_and_distinct_mail_parts(client, db, monkeypatch):
raw = _eml(
"<versand@example.test>",
"Fachlicher Zusatz: die Frist bleibt der 1. Juni.",
[("rechnung.pdf", PDF_A), ("lage.pdf", PDF_B), ("konto.pdf", PDF_C), ("lage.pdf", PDF_D)],
)
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
ada = Actor(client, "ada-versand@example.test", "Ada Versand")
register(db, ada.email, ada.name)
ada.login()
matter = ada.request("POST", "/api/v1/matters", json={"title": "Versandakte"}, status=201)
letter = ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Anschreiben",
"document": document("Ursprünglicher Text"),
"context": _ctx(matter["id"]),
"dates": {"document_on": "2026-02-01"},
},
status=201,
)
invoice = _file(ada, matter["id"], "Rechnung 2023", "rechnung.pdf", PDF_A, "2023-05-01")
plan = _file(ada, matter["id"], "Lageplan", "lage.pdf", PDF_B, "2024-01-15")
account = _file(ada, matter["id"], "Kontoauszug", "konto.pdf", PDF_C, "2025-11-02")
mailbox = ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "imap", "name": "Postfach", "host": "mail.example.test", "username": "ada", "password": "secret-pass"},
status=201,
)
mail = ada.request(
"POST",
"/api/v1/external-refs",
json={
"title": "Gesendete Nachricht",
"source": "imap",
"external_id": "<versand@example.test>",
"context": _ctx(matter["id"]),
"detail": {"connector_id": mailbox["id"], "mailbox": "INBOX", "uid": 4},
},
status=201,
)
detail = _detail(ada, matter["id"])
ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/attachments",
json={
"expected_version": _binding(detail, "Anschreiben")["element"]["version"],
"context": _ctx(matter["id"]),
"attachment_element_ids": [invoice["id"], plan["id"], account["id"]],
"fold": "attachment",
},
status=201,
)
folded = _detail(ada, matter["id"])
assert _binding(folded, "Rechnung 2023")["correspondence"]["fold"] == "attachment"
host = _binding(folded, "Anschreiben")
dispatch = ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/dispatches",
json={
"expected_version": host["element"]["version"],
"context": _ctx(matter["id"]),
"channel": "email",
"sent_on": "2026-03-12",
"counterpart": "Gegenüber Beispiel",
"attachment_element_ids": [invoice["id"], plan["id"], account["id"]],
"evidence": [{"element_id": mail["id"], "role": "email", "fold": "evidence"}],
},
status=201,
)
assert dispatch["completeness"] == "secured"
assert dispatch["provenance"] == "captured"
assert dispatch["sent_on"] == "2026-03-12"
proof = dispatch["evidence"][0]
assert proof["source_state"] == "identified"
assert proof["manual"] is True
by_name = {item["filename"]: item["disposition"] for item in proof["comparisons"]}
assert by_name["rechnung.pdf"] == "same_bytes"
assert by_name["lage.pdf"] == "same_bytes"
assert by_name["konto.pdf"] == "same_bytes"
assert by_name["lage (2).pdf"] == "same_name_different_bytes"
uses = db.execute("SELECT count(*) AS n FROM attachment_uses").fetchone()["n"]
assert uses == 3
hidden = _detail(ada, matter["id"])
assert _binding(hidden, "Gesendete Nachricht")["correspondence"]["fold"] == "evidence"
placed = list(_walk(ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]))
assert not any(node["kind"] == "binding" and node["title"] in {"Rechnung 2023", "Gesendete Nachricht"} for node in placed)
assert sum(1 for node in placed if node["kind"] == "attachment" and node["title"] == "Rechnung 2023") == 1
assert any(node["kind"] == "dispatch_item" and node["title"] == "Rechnung 2023" for node in placed)
assert any(node["kind"] == "evidence" and node["title"] == "Gesendete Nachricht" for node in placed)
ada.request(
"PATCH",
f"/api/v1/bindings/{_binding(hidden, 'Gesendete Nachricht')['id']}/fold",
json={
"expected_version": _binding(hidden, "Gesendete Nachricht")["element"]["version"],
"context": _ctx(matter["id"]),
"fold": None,
},
)
restored = _detail(ada, matter["id"])
assert _binding(restored, "Gesendete Nachricht")["correspondence"]["fold"] is None
ada.request(
"PATCH",
f"/api/v1/bindings/{_binding(restored, 'Gesendete Nachricht')['id']}/fold",
json={
"expected_version": _binding(restored, "Gesendete Nachricht")["element"]["version"],
"context": _ctx(matter["id"]),
"fold": "evidence",
},
)
ada.request(
"PATCH",
f"/api/v1/notes/{letter['id']}",
json={
"expected_version": _binding(restored, "Anschreiben")["element"]["version"],
"document": document("Später geänderter Text"),
"context": _ctx(matter["id"]),
},
)
changed = _detail(ada, matter["id"])
assert "Später geänderter Text" in _binding(changed, "Anschreiben")["element"]["excerpt"]
asset = db.execute("SELECT id FROM media_assets WHERE element_id = %s", (plan["id"],)).fetchone()
Path(os.environ["MEDIA_ROOT"], str(asset["id"])).write_bytes(PDF_D)
fresh = _detail(ada, matter["id"])
host = _binding(fresh, "Anschreiben")
ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/attachments/{account['id']}/detach",
json={"expected_version": host["element"]["version"], "context": _ctx(matter["id"])},
status=204,
)
current = _detail(ada, matter["id"])
recorded = _binding(current, "Anschreiben")["correspondence"]["dispatches"][0]
assert [item["title"] for item in recorded["items"] if item["role"] == "attachment"] == [
"Rechnung 2023",
"Lageplan",
"Kontoauszug",
]
assert recorded["sent_on"] == "2026-03-12"
assert _binding(current, "Anschreiben")["element"]["dates"]["document_on"] == "2026-02-01"
plan_item = next(item for item in recorded["items"] if item["title"] == "Lageplan")
content = ada.client.get(
f"/api/v1/dispatches/{recorded['id']}/items/{plan_item['id']}/content",
params={"context_kind": "matter", "context_id": matter["id"]},
headers={
"Origin": ORIGIN,
"X-CSRF-Token": ada.csrf,
"X-Scope-Kind": ada.scope["kind"],
"X-Scope-Id": ada.scope["id"],
},
)
assert content.status_code == 200
assert content.content == PDF_B
tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")
nodes = list(_walk(tree["tree"]))
selected = [node["id"] for node in nodes if node["kind"] in {"dispatch_item", "evidence"}]
archive = _zip(ada, matter["id"], selected)
names = archive.namelist()
snapshot = next(name for name in names if name.endswith("/lage.pdf") and "/anlagen/" not in name)
assert archive.read(snapshot) == PDF_B
eml_name = next(name for name in names if name.endswith("nachricht.eml"))
assert b"Fachlicher Zusatz" in archive.read(eml_name)
assert archive.read(eml_name).count(b"lage.pdf") >= 2
overview = archive.read("inhalt.md").decode("utf-8")
assert "Gesicherte Versandfassung" in overview
assert "Schreiben → Versand → Nachweis" in overview
first_text = "\n".join(
archive.read(name).decode("utf-8", errors="replace")
for name in names
if name.endswith((".md", ".txt", ".eml", ".json"))
)
assert "Ursprünglicher Text" in first_text
assert "Später geänderter Text" not in first_text
gap = ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/dispatches",
json={
"expected_version": _binding(current, "Anschreiben")["element"]["version"],
"context": _ctx(matter["id"]),
"channel": "post",
"sent_on": None,
"counterpart": None,
"attachment_element_ids": [invoice["id"]],
"historical_gap": True,
},
status=201,
)
assert gap["provenance"] == "reconstructed"
assert gap["completeness"] == "gap"
assert gap["undated"] is True
assert gap["sent_on"] is None
assert all(item["source_state"] == "gap" for item in gap["items"])
receipt = ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Einlieferungsbeleg",
"document": document("Eingeliefert am Schalter"),
"context": _ctx(matter["id"]),
"dates": {"document_on": "2026-03-20"},
},
status=201,
)
delivery = ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Zustellbestätigung",
"document": document("Zugestellt"),
"context": _ctx(matter["id"]),
"dates": {"document_on": "2026-03-28"},
},
status=201,
)
posted = ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/dispatches",
json={
"expected_version": _binding(_detail(ada, matter["id"]), "Anschreiben")["element"]["version"],
"context": _ctx(matter["id"]),
"channel": "post",
"sent_on": "2026-03-18",
"counterpart": "Poststelle",
"attachment_element_ids": [invoice["id"]],
"evidence": [{"element_id": receipt["id"], "role": "submission", "fold": "keep"}],
},
status=201,
)
assert posted["evidence"][0]["role"] == "submission"
assert "zugestellt" not in json.dumps(posted).lower()
added = ada.request(
"POST",
f"/api/v1/dispatches/{posted['id']}/evidence",
json={
"expected_version": posted["version"],
"context": _ctx(matter["id"]),
"element_id": delivery["id"],
"role": "delivery",
"fold": "keep",
},
status=201,
)
assert added["role"] == "delivery"
final = _detail(ada, matter["id"])
sends = _binding(final, "Anschreiben")["correspondence"]["dispatches"]
assert len(sends) == 3
assert {item["channel"] for item in sends} == {"email", "post"}
post_send = next(item for item in sends if item["sent_on"] == "2026-03-18")
assert {item["role"] for item in post_send["evidence"]} == {"submission", "delivery"}
ada.request(
"POST",
f"/api/v1/dispatches/{post_send['id']}/evidence/{delivery['id']}/detach",
json={"expected_version": post_send["version"], "context": _ctx(matter["id"])},
status=204,
)
final = _detail(ada, matter["id"])
sends = _binding(final, "Anschreiben")["correspondence"]["dispatches"]
post_send = next(item for item in sends if item["sent_on"] == "2026-03-18")
assert {item["role"] for item in post_send["evidence"]} == {"submission"}
assert _binding(final, "Zustellbestätigung")["correspondence"]["fold"] is None
assert _binding(final, "Zustellbestätigung")["element"]["dates"]["document_on"] == "2026-03-28"
ada.request(
"PATCH",
f"/api/v1/matters/{matter['id']}/content-order",
json={"expected_version": final["version"], "mode": "date", "direction": "asc", "view": "chronology"},
)
viewed = _detail(ada, matter["id"])
assert viewed["content_view"] == "chronology"
assert viewed["content_order"] == "date"
assert _binding(viewed, "Anschreiben")["chapter_id"] is None
excerpt_tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")
host_item = next(
node["id"]
for node in _walk(excerpt_tree["tree"])
if node["kind"] == "dispatch_item" and node["title"] == "Anschreiben"
)
review = ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/export/review",
json={"selected": [host_item]},
)
assert any("Auszug dieses Versands" in item["message"] for item in review["notices"])
whole = [node["id"] for node in _walk(excerpt_tree["tree"]) if node["id"].startswith("dispatch-item:") or node["id"].startswith("evidence:")]
full = _zip(ada, matter["id"], whole)
joined = "\n".join(full.read(name).decode("utf-8", errors="replace") for name in full.namelist() if name.endswith((".md", ".txt", ".eml", ".json")))
assert "Ursprünglicher Text" in joined
assert "Historische Fassung liegt nicht vor" in joined
gaps = [name for name in full.namelist() if name.endswith("-luecke.txt")]
assert gaps
assert all("Später geänderter Text" not in full.read(name).decode("utf-8") for name in gaps)
assert all(b"%PDF" not in full.read(name) for name in gaps)
secured = next(name for name in full.namelist() if name.endswith("/lage.pdf") and "/anlagen/" not in name)
assert full.read(secured) == PDF_B
def test_locked_parts_and_readers_stay_outside(client, db):
ada = Actor(client, "ada-sperre@example.test", "Ada Sperre")
ben = Actor(client, "ben-sperre@example.test", "Ben Sperre")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
ada.login()
case = ada.request("POST", "/api/v1/cases", json={"title": "Geteilte Akte"}, status=201)
matter = ada.request("POST", "/api/v1/matters", json={"title": "Geteilter Vorgang"}, status=201)
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
letter = ada.request(
"POST",
"/api/v1/notes",
json={"title": "Sichtbares Schreiben", "document": document("Sichtbar"), "context": _ctx(matter["id"])},
status=201,
)
secret = ada.request(
"POST",
"/api/v1/notes",
json={"title": "Geheime AnlageXQ", "document": document("Nicht zeigen"), "context": _ctx(matter["id"])},
status=201,
)
proof = ada.request(
"POST",
"/api/v1/notes",
json={"title": "Geheimer NachweisXQ", "document": document("Auch nicht"), "context": _ctx(matter["id"])},
status=201,
)
detail = _detail(ada, matter["id"])
ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/attachments",
json={
"expected_version": _binding(detail, "Sichtbares Schreiben")["element"]["version"],
"context": _ctx(matter["id"]),
"attachment_element_ids": [secret["id"]],
"fold": "keep",
},
status=201,
)
sent = ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/dispatches",
json={
"expected_version": _binding(_detail(ada, matter["id"]), "Sichtbares Schreiben")["element"]["version"],
"context": _ctx(matter["id"]),
"channel": "other",
"sent_on": "2026-04-01",
"attachment_element_ids": [secret["id"]],
"evidence": [{"element_id": proof["id"], "role": "other", "fold": "keep"}],
},
status=201,
)
grant(ada, case["id"], ben.email, edit=False, share=False)
ada.request(
"PUT",
"/api/v1/exceptions",
json={
"resource_kind": "element",
"resource_id": secret["id"],
"context": {"kind": "case", "id": case["id"]},
"remove_read": True,
},
)
ada.request(
"PUT",
"/api/v1/exceptions",
json={
"resource_kind": "element",
"resource_id": proof["id"],
"context": {"kind": "case", "id": case["id"]},
"remove_read": True,
},
)
ben.login()
page = {"kind": "case", "id": case["id"]}
visible = _detail(ben, matter["id"], page)
blob = json.dumps(visible)
assert "Geheime AnlageXQ" not in blob
assert "Geheimer NachweisXQ" not in blob
assert "Nicht zeigen" not in blob
host = _binding(visible, "Sichtbares Schreiben")
assert host["correspondence"]["attachments"] == []
assert host["correspondence"]["dispatches"][0]["evidence"] == []
ben.request(
"POST",
f"/api/v1/elements/{letter['id']}/attachments",
json={
"expected_version": host["element"]["version"],
"context": page,
"placement": _ctx(matter["id"]),
"attachment_element_ids": [letter["id"]],
"fold": "keep",
},
status=403,
)
ben.request(
"POST",
f"/api/v1/dispatches/{sent['id']}/correct",
json={"expected_version": sent["version"], "context": page, "placement": _ctx(matter["id"]), "counterpart": "Fremd"},
status=403,
)
ada.login()
ada.request(
"POST",
f"/api/v1/elements/{letter['id']}/attachments",
json={
"expected_version": _binding(_detail(ada, matter["id"]), "Sichtbares Schreiben")["element"]["version"],
"context": _ctx(matter["id"]),
"attachment_element_ids": ["00000000-0000-4000-8000-000000000099"],
"fold": "keep",
},
status=404,
)