780 lines
29 KiB
Python
780 lines
29 KiB
Python
"""Handover package: hierarchy, complete mail, source identity, rights, failures."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import io
|
|
import json
|
|
import zipfile
|
|
from email.message import EmailMessage
|
|
from urllib.parse import unquote, urljoin
|
|
|
|
import pytest
|
|
|
|
from app.core.errors import Problem
|
|
from app.mailpack import choose_message, parse_mail
|
|
from app.sources import pull_paperless_original
|
|
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"
|
|
|
|
|
|
def _eml(message_id: str, body: str, attachments: list[tuple[str, bytes]], subject: str = "Schreiben") -> bytes:
|
|
message = EmailMessage()
|
|
message["Subject"] = subject
|
|
message["From"] = "kanzlei@example.test"
|
|
message["To"] = "ada@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 _walk(node):
|
|
yield node
|
|
for child in node.get("children") or []:
|
|
yield from _walk(child)
|
|
|
|
|
|
def _parents(node, parent=None, found=None):
|
|
found = found if found is not None else {}
|
|
found[node["id"]] = parent
|
|
for child in node.get("children") or []:
|
|
_parents(child, node, found)
|
|
return found
|
|
|
|
|
|
def _under(node_id: str, title: str, parents: dict) -> bool:
|
|
current = parents.get(node_id)
|
|
while current is not None:
|
|
if current.get("title") == title:
|
|
return True
|
|
current = parents.get(current["id"])
|
|
return False
|
|
|
|
|
|
def _post_zip(actor: Actor, matter_id: str, body: dict):
|
|
headers = {
|
|
"Origin": ORIGIN,
|
|
"X-CSRF-Token": actor.csrf,
|
|
"Content-Type": "application/json",
|
|
"X-Scope-Kind": actor.scope["kind"],
|
|
"X-Scope-Id": actor.scope["id"],
|
|
}
|
|
return actor.client.post(f"/api/v1/matters/{matter_id}/export", json=body, headers=headers)
|
|
|
|
|
|
def _archive(blob: bytes) -> zipfile.ZipFile:
|
|
return zipfile.ZipFile(io.BytesIO(blob))
|
|
|
|
|
|
def _joined(archive: zipfile.ZipFile) -> str:
|
|
parts = []
|
|
for name in archive.namelist():
|
|
parts.append(name)
|
|
if name.endswith((".md", ".html", ".eml")):
|
|
parts.append(archive.read(name).decode("utf-8", errors="replace"))
|
|
return "\n".join(parts)
|
|
|
|
|
|
def _links_resolve(archive: zipfile.ZipFile) -> None:
|
|
html = archive.read("index.html").decode("utf-8")
|
|
names = set(archive.namelist())
|
|
for chunk in html.split('href="')[1:]:
|
|
href = unquote(chunk.split('"', 1)[0])
|
|
assert href in names, href
|
|
for name in archive.namelist():
|
|
if not name.endswith(".md"):
|
|
continue
|
|
text = archive.read(name).decode("utf-8")
|
|
base = name.rsplit("/", 1)[0] + "/" if "/" in name else ""
|
|
for chunk in text.split("](")[1:]:
|
|
href = unquote(chunk.split(")", 1)[0])
|
|
if href.startswith("http"):
|
|
continue
|
|
target = urljoin(base, href)
|
|
assert target in names, (name, href, target)
|
|
|
|
|
|
def test_duplicate_attachments_stay_distinct_and_identity_is_exact():
|
|
raw = _eml("<same@example.test>", "Volltext", [("lage.pdf", PDF_A), ("lage.pdf", PDF_B)])
|
|
parsed = parse_mail(raw)
|
|
assert [item.filename for item in parsed.attachments] == ["lage.pdf", "lage (2).pdf"]
|
|
assert parsed.attachments[0].data == PDF_A
|
|
assert parsed.attachments[1].data == PDF_B
|
|
assert parsed.text == "Volltext"
|
|
right = _eml("<right@example.test>", "richtig", [])
|
|
wrong = _eml("<wrong@example.test>", "falsch", [])
|
|
assert choose_message(right, [wrong], "<right@example.test>") == right
|
|
assert choose_message(wrong, [right], "<right@example.test>") == right
|
|
with pytest.raises(Exception, match="mehrdeutig"):
|
|
choose_message(wrong, [right, right], "<right@example.test>")
|
|
with pytest.raises(Exception, match="nicht eindeutig"):
|
|
choose_message(wrong, [], "uid:INBOX:4")
|
|
bare = _eml("", "ohne id", [])
|
|
# A message built without Message-ID still matches a stored uid fallback.
|
|
assert choose_message(bare, [], "uid:INBOX:4") == bare
|
|
|
|
|
|
def test_paperless_original_never_uses_preview(monkeypatch):
|
|
calls = []
|
|
|
|
def fake_file(base, token, path, max_bytes=40 * 1024 * 1024):
|
|
calls.append(path)
|
|
return None
|
|
|
|
monkeypatch.setattr("app.sources._paperless_file", fake_file)
|
|
monkeypatch.setattr("app.sources._paperless_metadata", lambda *args, **kwargs: None)
|
|
with pytest.raises(Problem, match="gibt es in Paperless nicht"):
|
|
pull_paperless_original("http://paper.example", "token", "15", 1000)
|
|
assert calls == ["/api/documents/15/download/"]
|
|
|
|
|
|
def test_handover_package_follows_the_confirmed_selection(client, db, monkeypatch):
|
|
raw = _eml(
|
|
"<export-brief@example.test>",
|
|
"Der vollständige Brieftext bleibt erhalten.",
|
|
[("lage.pdf", PDF_A), ("lage.pdf", PDF_B)],
|
|
)
|
|
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
|
|
monkeypatch.setattr(
|
|
"app.retrieval.pull_paperless_original",
|
|
lambda *args, **kwargs: (PDF_B, "application/pdf", "archiv.pdf"),
|
|
)
|
|
ada = Actor(client, "ada-export@example.test", "Ada Export")
|
|
register(db, ada.email, ada.name)
|
|
ada.login()
|
|
matter = ada.request("POST", "/api/v1/matters", json={"title": "Schaden"}, status=201)
|
|
vertrag = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Vertrag"}, status=201)
|
|
schrift = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Schrift"}, status=201)
|
|
note = ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={
|
|
"title": "Vertragnotiz",
|
|
"document": document("Nur der Vertrag"),
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"chapter_id": vertrag["id"],
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/files",
|
|
data={"title": "Einzeldatei", "context_kind": "matter", "context_id": matter["id"], "chapter_id": vertrag["id"]},
|
|
files={"upload": ("einzel.pdf", PDF_C, "application/pdf")},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/files",
|
|
data={"title": "Schreiben-Datei", "context_kind": "matter", "context_id": matter["id"], "chapter_id": schrift["id"]},
|
|
files={"upload": ("schreiben.pdf", PDF_C, "application/pdf")},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={
|
|
"title": "Randnotiz",
|
|
"document": document("Randwort bleibt draussen"),
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"chapter_id": schrift["id"],
|
|
},
|
|
status=201,
|
|
)
|
|
child = ada.request(
|
|
"POST",
|
|
"/api/v1/matters",
|
|
json={"title": "Nebenpunkt", "parent_matter_id": matter["id"]},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={
|
|
"title": "Teilnotiz",
|
|
"document": document("Im Teilvorgang"),
|
|
"context": {"kind": "matter", "id": child["id"]},
|
|
},
|
|
status=201,
|
|
)
|
|
mailbox = ada.request(
|
|
"POST",
|
|
"/api/v1/connectors",
|
|
json={
|
|
"kind": "imap",
|
|
"name": "Postfach",
|
|
"host": "mail.example.test",
|
|
"username": "ada",
|
|
"password": "secret-pass",
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/connectors",
|
|
json={
|
|
"kind": "paperless",
|
|
"name": "Archiv",
|
|
"base_url": "http://paper.example",
|
|
"token": "paperless-token",
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/external-refs",
|
|
json={
|
|
"title": "Schreiben mit Anlagen",
|
|
"source": "imap",
|
|
"external_id": "<export-brief@example.test>",
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"detail": {"connector_id": mailbox["id"], "mailbox": "INBOX", "uid": 9},
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/external-refs",
|
|
json={
|
|
"title": "Archivstück",
|
|
"source": "paperless",
|
|
"external_id": "15",
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"chapter_id": vertrag["id"],
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/files",
|
|
data={"title": "Gespiegelte Anlage", "context_kind": "matter", "context_id": matter["id"]},
|
|
files={"upload": ("lage.pdf", PDF_A, "application/pdf")},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/files",
|
|
data={"title": "Nur der Name", "context_kind": "matter", "context_id": matter["id"]},
|
|
files={"upload": ("lage.pdf", PDF_C, "application/pdf")},
|
|
status=201,
|
|
)
|
|
first = ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={
|
|
"title": "Anschreiben",
|
|
"document": document("Erstes Schreiben"),
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"communication_direction": "in",
|
|
"dates": {"document_on": "2026-03-12"},
|
|
},
|
|
status=201,
|
|
)
|
|
reply = ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={
|
|
"title": "Antwort",
|
|
"document": document("Spätere Antwort"),
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"communication_direction": "out",
|
|
"dates": {"document_on": "2026-05-18"},
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
f"/api/v1/elements/{reply['id']}/references",
|
|
json={"refers_to_element_id": first["id"], "context": {"kind": "matter", "id": matter["id"]}},
|
|
status=204,
|
|
)
|
|
foreign_parent = ada.request("POST", "/api/v1/matters", json={"title": "Fremder Rahmen"}, status=201)
|
|
foreign = ada.request(
|
|
"POST",
|
|
"/api/v1/matters",
|
|
json={"title": "Fremder Vorgang", "parent_matter_id": foreign_parent["id"]},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={
|
|
"title": "Fremdtext",
|
|
"document": document("Nicht mitnehmen"),
|
|
"context": {"kind": "matter", "id": foreign["id"]},
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
f"/api/v1/matters/{matter['id']}/cross-links",
|
|
json={
|
|
"target_matter_id": foreign["id"],
|
|
"target_context": {"kind": "matter", "id": foreign_parent["id"]},
|
|
},
|
|
status=201,
|
|
)
|
|
detail = ada.request("GET", f"/api/v1/matters/{matter['id']}")
|
|
note_binding = next(item["id"] for item in detail["bindings"] if item["element"]["title"] == "Vertragnotiz")
|
|
ada.request(
|
|
"POST",
|
|
f"/api/v1/bindings/{note_binding}/annotations",
|
|
json={"body": "Kontextvermerk speziell"},
|
|
status=201,
|
|
)
|
|
tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]
|
|
flat = list(_walk(tree))
|
|
parents = _parents(tree)
|
|
assert "Fremdtext" not in json.dumps(tree)
|
|
by_title = {}
|
|
for node in flat:
|
|
by_title.setdefault(node["title"], []).append(node)
|
|
schrift_ids = {
|
|
node["id"]
|
|
for node in flat
|
|
if node["kind"] in {"binding", "annotation"} and _under(node["id"], "Schrift", parents)
|
|
}
|
|
selected = {node["id"] for node in flat if node["kind"] in {"binding", "annotation"} and node["exportable"]}
|
|
selected -= schrift_ids
|
|
selected.add(next(node["id"] for node in by_title["Schreiben-Datei"]))
|
|
mirrored = next(node["id"] for node in by_title["Gespiegelte Anlage"])
|
|
name_only = next(node["id"] for node in by_title["Nur der Name"])
|
|
selected.discard(mirrored)
|
|
selected.discard(name_only)
|
|
body = {"context": {"kind": "matter", "id": matter["id"]}, "selected": sorted(selected)}
|
|
review = ada.request("POST", f"/api/v1/matters/{matter['id']}/export/review", json=body)
|
|
assert review["ready"] is True
|
|
assert any("bleibt Bestandteil" in item["message"] for item in review["notices"])
|
|
assert all("Nur der Name" not in item["message"] for item in review["notices"])
|
|
response = _post_zip(ada, matter["id"], body)
|
|
assert response.status_code == 200, response.text
|
|
archive = _archive(response.content)
|
|
names = archive.namelist()
|
|
assert "index.html" in names and "inhalt.md" in names
|
|
assert any(name.startswith("01 Vertrag/") for name in names)
|
|
schrift_names = [name for name in names if name.startswith("02 Schrift/")]
|
|
assert schrift_names == ["02 Schrift/schreiben.pdf"]
|
|
assert any("Nebenpunkt" in name and name.endswith("Teilnotiz.md") for name in names)
|
|
mail_names = [name for name in names if "Schreiben mit Anlagen" in name]
|
|
assert any(name.endswith("/nachricht.eml") for name in mail_names)
|
|
assert sorted(name.rsplit("/", 1)[-1] for name in mail_names if "/anlagen/" in name) == ["lage (2).pdf", "lage.pdf"]
|
|
assert archive.read(next(name for name in mail_names if name.endswith("/anlagen/lage.pdf"))) == PDF_A
|
|
assert archive.read(next(name for name in mail_names if name.endswith("/anlagen/lage (2).pdf"))) == PDF_B
|
|
whole = _joined(archive)
|
|
assert "Der vollständige Brieftext bleibt erhalten." in whole
|
|
assert "Randwort bleibt draussen" not in whole
|
|
assert "Gespiegelte Anlage" not in whole
|
|
assert "Fremdtext" not in whole
|
|
assert "bleibt Bestandteil" in whole
|
|
note_file = next(name for name in names if name.endswith("/Vertragnotiz.md"))
|
|
annotation_file = next(name for name in names if "Anmerkung zu Vertragnotiz" in name)
|
|
assert "Kontextvermerk speziell" not in archive.read(note_file).decode("utf-8")
|
|
assert "Kontextvermerk speziell" in archive.read(annotation_file).decode("utf-8")
|
|
assert "Anschreiben" in whole and "Antwort auf" in whole
|
|
assert "Erzeugt am" in archive.read("index.html").decode("utf-8")
|
|
assert "Fachdatum: 2026-03-12" in whole
|
|
assert "Nur der Vertrag" in whole
|
|
_links_resolve(archive)
|
|
reply_only = {
|
|
"context": body["context"],
|
|
"selected": [node["id"] for node in by_title["Antwort"]],
|
|
}
|
|
narrowed = _post_zip(ada, matter["id"], reply_only)
|
|
assert narrowed.status_code == 200, narrowed.text
|
|
assert "Anschreiben" not in _joined(_archive(narrowed.content))
|
|
changed = ada.request(
|
|
"PATCH",
|
|
f"/api/v1/notes/{note['id']}",
|
|
json={
|
|
"expected_version": note["version"],
|
|
"document": document("Neutext der Notiz"),
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
},
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={
|
|
"title": "Später ergänzt",
|
|
"document": document("Darf nicht still hinein"),
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
},
|
|
status=201,
|
|
)
|
|
assert "Neutext der Notiz" not in whole
|
|
assert "Später ergänzt" not in whole
|
|
again = _post_zip(ada, matter["id"], body)
|
|
assert again.status_code == 200, again.text
|
|
second = _joined(_archive(again.content))
|
|
assert "Neutext der Notiz" in second
|
|
assert "Später ergänzt" not in second
|
|
assert changed["version"] == note["version"] + 1
|
|
|
|
|
|
def test_export_names_gaps_and_hides_unreadable_counterparts(client, db, monkeypatch):
|
|
ada = Actor(client, "ada-gap@example.test", "Ada Gap")
|
|
ben = Actor(client, "ben-gap@example.test", "Ben Gap")
|
|
register(db, ada.email, ada.name)
|
|
register(db, ben.email, ben.name)
|
|
ada.login()
|
|
case = ada.request("POST", "/api/v1/cases", json={"title": "Freigabeakte"}, status=201)
|
|
matter = ada.request("POST", "/api/v1/matters", json={"title": "Geteilt"}, status=201)
|
|
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
|
|
visible = ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={"title": "Sichtbare Notiz", "document": document("Sichtbar"), "context": {"kind": "matter", "id": matter["id"]}},
|
|
status=201,
|
|
)
|
|
hidden = ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={"title": "GeheimtitelXQ", "document": document("Verborgen"), "context": {"kind": "matter", "id": matter["id"]}},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
f"/api/v1/elements/{visible['id']}/references",
|
|
json={"refers_to_element_id": hidden["id"], "context": {"kind": "matter", "id": matter["id"]}},
|
|
status=204,
|
|
)
|
|
ada.request(
|
|
"PUT",
|
|
"/api/v1/exceptions",
|
|
json={
|
|
"resource_kind": "element",
|
|
"resource_id": hidden["id"],
|
|
"context": {"kind": "case", "id": case["id"]},
|
|
"remove_read": True,
|
|
},
|
|
)
|
|
first = ada.request(
|
|
"POST",
|
|
"/api/v1/connectors",
|
|
json={"kind": "imap", "name": "Alt", "host": "mail.example.test", "username": "ada", "password": "secret-pass"},
|
|
status=201,
|
|
)
|
|
second = ada.request(
|
|
"POST",
|
|
"/api/v1/connectors",
|
|
json={"kind": "imap", "name": "Neu", "host": "mail.example.test", "username": "ada", "password": "secret-pass"},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/external-refs",
|
|
json={
|
|
"title": "Verwaiste Post",
|
|
"source": "imap",
|
|
"external_id": "<stored@example.test>",
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"detail": {"connector_id": first["id"], "mailbox": "INBOX", "uid": 3},
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request("DELETE", f"/api/v1/connectors/{first['id']}", status=204)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/connectors",
|
|
json={"kind": "imap", "name": "Weiter", "host": "mail.example.test", "username": "ada", "password": "secret-pass"},
|
|
status=201,
|
|
)
|
|
calls = []
|
|
|
|
def pull(*args, **kwargs):
|
|
calls.append(args)
|
|
return _eml("<stored@example.test>", "darf nicht ersatzweise kommen", [])
|
|
|
|
monkeypatch.setattr("app.retrieval.pull_rfc822", pull)
|
|
context = {"kind": "case", "id": case["id"]}
|
|
tree = ada.request(
|
|
"GET",
|
|
f"/api/v1/matters/{matter['id']}/export-tree",
|
|
params={"context_kind": "case", "context_id": case["id"]},
|
|
)["tree"]
|
|
assert "GeheimtitelXQ" not in json.dumps(tree)
|
|
leaves = [node for node in _walk(tree) if node["kind"] in {"binding", "annotation"}]
|
|
visible_node = next(node for node in leaves if node["title"] == "Sichtbare Notiz")
|
|
orphan = next(node for node in leaves if node["title"] == "Verwaiste Post")
|
|
review = ada.request(
|
|
"POST",
|
|
f"/api/v1/matters/{matter['id']}/export/review",
|
|
json={"context": context, "selected": [visible_node["id"], orphan["id"]]},
|
|
)
|
|
assert review["ready"] is False
|
|
assert any(item["code"] == "reference" for item in review["issues"])
|
|
assert any(item["code"] == "missing" for item in review["issues"])
|
|
blob = json.dumps(review)
|
|
assert "GeheimtitelXQ" not in blob
|
|
assert calls == []
|
|
assert second["id"] not in blob
|
|
failed = _post_zip(ada, matter["id"], {"context": context, "selected": [visible_node["id"], orphan["id"]]})
|
|
assert failed.status_code == 422
|
|
assert "GeheimtitelXQ" not in failed.text
|
|
assert failed.headers["content-type"].startswith("application/problem+json") or "problem" in failed.headers["content-type"]
|
|
|
|
ambiguous = ada.request(
|
|
"POST",
|
|
"/api/v1/external-refs",
|
|
json={
|
|
"title": "Ohne Zugang",
|
|
"source": "imap",
|
|
"external_id": "<offen@example.test>",
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"detail": {"mailbox": "INBOX", "uid": 8},
|
|
},
|
|
status=201,
|
|
)
|
|
del ambiguous
|
|
tree = ada.request(
|
|
"GET",
|
|
f"/api/v1/matters/{matter['id']}/export-tree",
|
|
params={"context_kind": "case", "context_id": case["id"]},
|
|
)["tree"]
|
|
open_mail = next(node for node in _walk(tree) if node["title"] == "Ohne Zugang")
|
|
pending = ada.request(
|
|
"POST",
|
|
f"/api/v1/matters/{matter['id']}/export/review",
|
|
json={"context": context, "selected": [open_mail["id"]]},
|
|
)
|
|
assert pending["issues"][0]["code"] == "ambiguous"
|
|
assert {item["name"] for item in pending["issues"][0]["choices"]} == {"Neu", "Weiter"}
|
|
monkeypatch.setattr("app.retrieval.EXPORT_BYTE_LIMIT", 40)
|
|
huge = _eml("<offen@example.test>", "GEKÜRZT-VERBOTEN " * 20, [])
|
|
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: huge)
|
|
assigned = ada.request(
|
|
"POST",
|
|
f"/api/v1/matters/{matter['id']}/export/review",
|
|
json={"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}},
|
|
)
|
|
assert assigned["issues"][0]["code"] == "too_large"
|
|
assert "GEKÜRZT-VERBOTEN" not in json.dumps(assigned)
|
|
wrong = _eml("<andere@example.test>", "FALSCHE-NACHRICHT", [])
|
|
monkeypatch.setattr("app.retrieval.EXPORT_BYTE_LIMIT", 80 * 1024 * 1024)
|
|
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: wrong)
|
|
identity = ada.request(
|
|
"POST",
|
|
f"/api/v1/matters/{matter['id']}/export/review",
|
|
json={"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}},
|
|
)
|
|
assert identity["issues"][0]["code"] == "identity"
|
|
assert "FALSCHE-NACHRICHT" not in json.dumps(identity)
|
|
blocked = _post_zip(
|
|
ada,
|
|
matter["id"],
|
|
{"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}},
|
|
)
|
|
assert blocked.status_code == 422
|
|
assert "FALSCHE-NACHRICHT" not in blocked.text
|
|
|
|
grant(ada, case["id"], ben.email, share=False)
|
|
ben.login()
|
|
ben_tree = ben.request(
|
|
"GET",
|
|
f"/api/v1/matters/{matter['id']}/export-tree",
|
|
params={"context_kind": "case", "context_id": case["id"]},
|
|
)["tree"]
|
|
assert "GeheimtitelXQ" not in json.dumps(ben_tree)
|
|
shared = next(node for node in _walk(ben_tree) if node["title"] == "Sichtbare Notiz")
|
|
assert shared["exportable"] is False
|
|
denied = ben.request(
|
|
"POST",
|
|
f"/api/v1/matters/{matter['id']}/export/review",
|
|
json={"context": context, "selected": [shared["id"]]},
|
|
)
|
|
assert denied["issues"][0]["code"] == "rights"
|
|
ada.login()
|
|
owner_direct = ada.request("GET", f"/api/v1/matters/{matter['id']}")
|
|
hidden_binding = next(item["id"] for item in owner_direct["bindings"] if item["element"]["title"] == "GeheimtitelXQ")
|
|
ben.login()
|
|
missing = ben.request(
|
|
"POST",
|
|
f"/api/v1/matters/{matter['id']}/export/review",
|
|
json={"context": context, "selected": [f"binding:{hidden_binding}"]},
|
|
status=422,
|
|
)
|
|
assert "GeheimtitelXQ" not in json.dumps(missing)
|
|
assert "unbekannten oder nicht sichtbaren" in missing["detail"]
|
|
|
|
|
|
def test_nested_chapter_export_keeps_path_and_complete_mail(client, db, monkeypatch):
|
|
raw = _eml(
|
|
"<nested-mail@example.test>",
|
|
"Die Antwort bleibt vollständig.",
|
|
[("lage.pdf", PDF_A), ("konto.pdf", PDF_B)],
|
|
)
|
|
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
|
|
ada = Actor(client, "ada-nested-export@example.test", "Ada Verschachtelt")
|
|
register(db, ada.email, ada.name)
|
|
ada.login()
|
|
matter = ada.request("POST", "/api/v1/matters", json={"title": "Nebenkosten"}, status=201)
|
|
root = ada.request(
|
|
"POST",
|
|
f"/api/v1/matters/{matter['id']}/chapters",
|
|
json={"title": "Nebenkostenabrechnung 2025"},
|
|
status=201,
|
|
)
|
|
sent = ada.request(
|
|
"POST",
|
|
f"/api/v1/matters/{matter['id']}/chapters",
|
|
json={"title": "Übermittelte Abrechnungsunterlagen", "parent_chapter_id": root["id"]},
|
|
status=201,
|
|
)
|
|
receipts = ada.request(
|
|
"POST",
|
|
f"/api/v1/matters/{matter['id']}/chapters",
|
|
json={"title": "Einzelbelege", "parent_chapter_id": sent["id"]},
|
|
status=201,
|
|
)
|
|
skipped = ada.request(
|
|
"POST",
|
|
f"/api/v1/matters/{matter['id']}/chapters",
|
|
json={"title": "../Nicht/mitnehmen", "parent_chapter_id": root["id"]},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={
|
|
"title": "Anschreiben",
|
|
"document": document("Anschreiben bleibt"),
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"chapter_id": sent["id"],
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/files",
|
|
data={
|
|
"title": "Heizkostenbeleg",
|
|
"context_kind": "matter",
|
|
"context_id": matter["id"],
|
|
"chapter_id": receipts["id"],
|
|
},
|
|
files={"upload": ("heiz.pdf", PDF_A, "application/pdf")},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/files",
|
|
data={
|
|
"title": "Hausmeisterbeleg",
|
|
"context_kind": "matter",
|
|
"context_id": matter["id"],
|
|
"chapter_id": receipts["id"],
|
|
},
|
|
files={"upload": ("haus.pdf", PDF_C, "application/pdf")},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={
|
|
"title": "Rückfrage",
|
|
"document": document("Direkt im Elternkapitel"),
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"chapter_id": root["id"],
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/notes",
|
|
json={
|
|
"title": "Ausgelassen",
|
|
"document": document("Geschwister bleibt draussen"),
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"chapter_id": skipped["id"],
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/files",
|
|
data={
|
|
"title": "Gespiegelte Anlage",
|
|
"context_kind": "matter",
|
|
"context_id": matter["id"],
|
|
"chapter_id": skipped["id"],
|
|
},
|
|
files={"upload": ("konto.pdf", PDF_B, "application/pdf")},
|
|
status=201,
|
|
)
|
|
mailbox = ada.request(
|
|
"POST",
|
|
"/api/v1/connectors",
|
|
json={
|
|
"kind": "imap",
|
|
"name": "Postfach",
|
|
"host": "mail.example.test",
|
|
"username": "ada",
|
|
"password": "secret-pass",
|
|
},
|
|
status=201,
|
|
)
|
|
ada.request(
|
|
"POST",
|
|
"/api/v1/external-refs",
|
|
json={
|
|
"title": "Antwort des Vermieters",
|
|
"source": "imap",
|
|
"external_id": "<nested-mail@example.test>",
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"chapter_id": root["id"],
|
|
"detail": {"connector_id": mailbox["id"], "mailbox": "INBOX", "uid": 4},
|
|
},
|
|
status=201,
|
|
)
|
|
tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]
|
|
flat = list(_walk(tree))
|
|
parents = _parents(tree)
|
|
einzel = next(node for node in flat if node["title"] == "Einzelbelege")
|
|
assert einzel["label"] == "Unterkapitel"
|
|
assert parents[einzel["id"]]["title"] == "Übermittelte Abrechnungsunterlagen"
|
|
leaves = [node["id"] for node in flat if node["kind"] in {"binding", "annotation"} and node["exportable"]]
|
|
hidden = {
|
|
node["id"]
|
|
for node in flat
|
|
if node["kind"] in {"binding", "annotation"}
|
|
and (
|
|
_under(node["id"], "Einzelbelege", parents)
|
|
or _under(node["id"], "../Nicht/mitnehmen", parents)
|
|
)
|
|
}
|
|
kept = next(node["id"] for node in flat if node["title"] == "Heizkostenbeleg")
|
|
selected = [item for item in leaves if item not in hidden or item == kept]
|
|
body = {"context": {"kind": "matter", "id": matter["id"]}, "selected": selected}
|
|
review = ada.request("POST", f"/api/v1/matters/{matter['id']}/export/review", json=body)
|
|
assert review["ready"] is True
|
|
reviewed = [item["title"] for item in review["entries"]]
|
|
assert "Heizkostenbeleg" in reviewed
|
|
assert "Hausmeisterbeleg" not in reviewed
|
|
assert "Ausgelassen" not in reviewed
|
|
assert "Anschreiben" in reviewed
|
|
assert any("bleibt Bestandteil" in item["message"] for item in review["notices"])
|
|
response = _post_zip(ada, matter["id"], body)
|
|
assert response.status_code == 200, response.text
|
|
names = _archive(response.content).namelist()
|
|
heating = next(name for name in names if name.endswith("/heiz.pdf"))
|
|
assert heating.startswith(
|
|
"01 Nebenkostenabrechnung 2025/02 Übermittelte Abrechnungsunterlagen/01 Einzelbelege/"
|
|
)
|
|
assert any(
|
|
name.startswith("01 Nebenkostenabrechnung 2025/01 ") and "Antwort des Vermieters" in name
|
|
for name in names
|
|
)
|
|
assert not any("Hausmeister" in name or name.endswith("/haus.pdf") for name in names)
|
|
assert not any(name.startswith("02 ") and "Nicht" in name for name in names)
|
|
assert any("Antwort des Vermieters" in name and name.endswith("/anlagen/lage.pdf") for name in names)
|
|
assert any("Antwort des Vermieters" in name and name.endswith("/anlagen/konto.pdf") for name in names)
|
|
overview = _archive(response.content).read("inhalt.md").decode("utf-8")
|
|
assert overview.index("Anschreiben") < overview.index("Heizkostenbeleg")
|
|
assert "Hausmeisterbeleg" not in overview
|
|
assert "Ausgelassen" not in overview
|