Statt gemeinsamem anlagen-arbeitsstand und Datumsordnern auf Kapitel-Ebene liegen zugeordnete Dateien unter Dokumentname/Anlagen bzw. Belege, damit mehrere Schreiben im gleichen Kapitel vollständig und eindeutig exportiert werden. Co-authored-by: Cursor <cursoragent@cursor.com>
637 lines
25 KiB
Python
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("/Anlagen/lage.pdf"))
|
|
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("/Anlagen/lage.pdf"))
|
|
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,
|
|
)
|