Files
tsumugu/backend/app/exporting.py
T
LarsandCursor 2b23992a1a
Deploy Development / deploy (push) Successful in 28s
Test Suite / pytest-backend (push) Failing after 1m38s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 9s
Ordne Anlagen und Belege im Übergabepaket pro Hauptschriftstück zu.
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>
2026-10-18 14:32:05 +02:00

1015 lines
38 KiB
Python

"""Hierarchical export of one matter into a self-contained handover package."""
from __future__ import annotations
import html
import io
import zipfile
from dataclasses import dataclass, field
from datetime import datetime, timezone
from pathlib import PurePosixPath
from urllib.parse import quote
from uuid import UUID
from app.access.policy import (
Ctx,
audit,
element_rights,
get_element,
get_matter,
matter_rights,
)
from app.core.errors import not_found, unprocessable
from app.core.timeutil import dump_dt, utcnow
from app.correspondence import GapNote, export_children, load_snapshot_file
from app.mailpack import parse_mail
from app.present import _chapters, _ordered_bindings
from app.retrieval import (
FilePayload,
MailPayload,
RetrievalFailure,
load_external,
load_file,
)
_NODE_KINDS = {"binding", "annotation", "attachment", "dispatch_item", "evidence"}
_DIRECTION = {"in": "Eingang", "out": "Ausgang"}
_KIND_LABEL = {
"note": "Notiz",
"file": "Datei",
"email": "E-Mail",
"paperless": "Paperless",
"url": "Webadresse",
"annotation": "Anmerkung",
"chapter": "Kapitel",
"matter": "Teilvorgang",
"root": "Vorgang",
}
@dataclass
class ExportNode:
id: str
kind: str
title: str
exportable: bool
reason: str | None
content_kind: str | None
children: list[ExportNode] = field(default_factory=list)
element_id: str | None = None
summary: str | None = None
direction: str | None = None
dates: dict | None = None
annotation_body: str | None = None
annotation_author: str | None = None
annotation_at: str | None = None
label: str = ""
relation: str | None = None
edition: str | None = None
gap_reason: str | None = None
snapshot_id: str | None = None
def public(self) -> dict:
return {
"id": self.id,
"kind": self.kind,
"title": self.title,
"label": self.label or _KIND_LABEL.get(self.kind, ""),
"exportable": self.exportable,
"reason": self.reason,
"content_kind": self.content_kind,
"children": [child.public() for child in self.children],
}
@dataclass
class Issue:
node_id: str
title: str
code: str
message: str
choices: list[dict] = field(default_factory=list)
def public(self) -> dict:
body = {
"node_id": self.node_id,
"title": self.title,
"code": self.code,
"message": self.message,
}
if self.choices:
body["choices"] = self.choices
return body
@dataclass
class Notice:
node_id: str
message: str
def public(self) -> dict:
return {"node_id": self.node_id, "message": self.message}
@dataclass
class Entry:
node_id: str
title: str
kind_label: str
path: str | None
links: list[tuple[str, str]]
dates: dict
direction: str | None
summary: str | None
notice: str | None
replies: list[tuple[str, str]]
recorded_at: str | None
notes: tuple[str, ...] = ()
def public(self) -> dict:
return {
"node_id": self.node_id,
"title": self.title,
"kind_label": self.kind_label,
"path": self.path,
"links": [{"label": label, "path": path} for label, path in self.links],
}
@dataclass
class ExportPlan:
matter_title: str
generated_at: str
ready: bool
issues: list[Issue]
notices: list[Notice]
entries: list[Entry]
files: list[tuple[str, bytes]]
tree: ExportNode
def review(self) -> dict:
return {
"ready": self.ready,
"matter_title": self.matter_title,
"issues": [item.public() for item in self.issues],
"notices": [item.public() for item in self.notices],
"entries": [item.public() for item in self.entries],
}
def export_tree(conn, actor: UUID, matter_id: UUID, context: Ctx | None) -> dict:
matter, page = _require_matter(conn, actor, matter_id, context)
root = _matter_node(conn, actor, matter, page, root=True)
return {"matter_id": str(matter["id"]), "context": None if context is None else context.as_dict(), "tree": root.public()}
def review_export(
conn,
actor: UUID,
matter_id: UUID,
context: Ctx | None,
selected: list[str],
assignments: dict[str, UUID],
media_root: str,
) -> ExportPlan:
return _plan(conn, actor, matter_id, context, selected, assignments, media_root)
def build_export(
conn,
actor: UUID,
matter_id: UUID,
context: Ctx | None,
selected: list[str],
assignments: dict[str, UUID],
media_root: str,
) -> tuple[str, bytes]:
plan = _plan(conn, actor, matter_id, context, selected, assignments, media_root)
if not plan.ready:
detail = " ".join(f"{item.title}: {item.message}" for item in plan.issues[:8])
raise unprocessable(detail or "Das Paket ist nicht vollständig.")
matter = get_matter(conn, matter_id)
audit(conn, actor, matter["home_scope_id"], "export_created", "matter", matter_id, context)
return _zip_name(plan.matter_title), _zip_bytes(plan.files)
def _plan(conn, actor, matter_id, context, selected, assignments, media_root) -> ExportPlan:
matter, page = _require_matter(conn, actor, matter_id, context)
root = _matter_node(conn, actor, matter, page, root=True)
chosen = _chosen(root, selected)
leaves = [node for node in _walk(root) if node.id in chosen and node.kind in _NODE_KINDS]
issues: list[Issue] = []
notices: list[Notice] = []
loaded: dict[str, FilePayload | MailPayload | str] = {}
hashes = _local_hashes(conn, root, chosen)
for node in leaves:
if not node.exportable:
issues.append(Issue(node.id, node.title, "rights", node.reason or "Für die Übergabe fehlt die Freigabebefugnis."))
continue
if node.kind == "annotation":
loaded[node.id] = node.annotation_body or ""
continue
if node.gap_reason and node.kind in {"dispatch_item", "evidence"}:
loaded[node.id] = GapNote(node.gap_reason)
continue
if node.snapshot_id and node.kind in {"dispatch_item", "evidence"}:
result = load_snapshot_file(conn, UUID(node.snapshot_id), media_root)
if isinstance(result, RetrievalFailure):
issues.append(Issue(node.id, node.title, result.code, result.message, [dict(item) for item in result.choices]))
continue
loaded[node.id] = result
continue
if node.content_kind == "note":
loaded[node.id] = _note_text(conn, UUID(node.element_id))
continue
if node.content_kind == "file":
result = load_file(conn, UUID(node.element_id), media_root)
elif node.content_kind in {"email", "paperless", "url"}:
result = load_external(conn, actor, UUID(node.element_id), assignments.get(node.id))
else:
result = RetrievalFailure("capability", "Für diesen Inhalt ist kein Originalabruf vorgesehen.")
if isinstance(result, RetrievalFailure):
issues.append(Issue(node.id, node.title, result.code, result.message, [dict(item) for item in result.choices]))
continue
loaded[node.id] = result
if isinstance(result, MailPayload):
notices.extend(_retention_notices(node, result, hashes))
notices.extend(_bundle_notices(root, chosen))
issues.extend(_reference_issues(conn, actor, page, leaves))
generated = dump_dt(utcnow()) or ""
if issues:
entries = [
Entry(node.id, node.title, _label(node), None, [], node.dates or {}, node.direction, node.summary, None, [], _recorded(node))
for node in leaves
]
return ExportPlan(matter["title"], generated, False, issues, notices, entries, [], root)
files, entries = _layout(root, chosen, loaded, notices, generated)
_attach_replies(conn, actor, page, entries, leaves)
_stitch_replies(files, entries)
files = _with_overview(matter["title"], generated, entries, files)
return ExportPlan(matter["title"], generated, True, [], notices, entries, files, root)
def _require_matter(conn, actor: UUID, matter_id: UUID, context: Ctx | None):
matter = get_matter(conn, matter_id)
if matter is None:
raise not_found()
# A matter context that names the matter itself is the direct view, as with notes.
access = None if context is not None and context.kind == "matter" and context.id == matter["id"] else context
if not matter_rights(conn, actor, matter, access).read:
raise not_found()
return matter, context or Ctx("matter", matter_id)
def _matter_node(conn, actor, matter, page: Ctx, root: bool) -> ExportNode:
mode = matter.get("content_order") or "position"
direction = matter.get("content_order_dir") or "asc"
chapters = _chapters(conn, "matter", matter["id"], mode, direction)
bindings = _ordered_bindings(conn, actor, "matter", matter["id"], page, mode, direction)
grouped: dict[str | None, list] = {}
for binding in bindings:
grouped.setdefault(binding.get("chapter_id"), []).append(binding)
children: list[ExportNode] = []
children.extend(_chapter_nodes(conn, actor, page, chapters, grouped))
for binding in grouped.get(None, []):
if not _stands_in_chapter(binding):
continue
children.append(_binding_node(conn, actor, binding, page))
rows = conn.execute(
"SELECT * FROM matters WHERE parent_matter_id = %s AND deleted_at IS NULL ORDER BY title, id",
(matter["id"],),
).fetchall()
for child in rows:
if not matter_rights(conn, actor, child, page).read:
continue
children.append(_matter_node(conn, actor, child, page, root=False))
return ExportNode(
id=f"matter:{matter['id']}",
kind="matter",
title=matter["title"],
exportable=True,
reason=None,
content_kind=None,
children=children,
label="Vorgang" if root else "Teilvorgang",
)
def _stands_in_chapter(binding: dict) -> bool:
"""A folded attachment or receipt stays under its letter, not as another chapter row."""
pack = binding.get("correspondence") or {}
if pack.get("fold") in {"attachment", "evidence"}:
return False
if pack.get("hosts"):
return False
return True
def _chapter_nodes(conn, actor, page, chapters: list[dict], grouped: dict[str | None, list]) -> list[ExportNode]:
by_parent: dict[str | None, list[dict]] = {}
for chapter in chapters:
by_parent.setdefault(chapter.get("parent_chapter_id"), []).append(chapter)
def build(parent_id: str | None, path: str) -> list[ExportNode]:
nodes: list[ExportNode] = []
for chapter in by_parent.get(parent_id, []):
chapter_path = f"{path} / {chapter['title']}" if path else chapter["title"]
nested = build(chapter["id"], chapter_path)
items = []
for item in grouped.get(chapter["id"], []):
if not _stands_in_chapter(item):
continue
node = _binding_node(conn, actor, item, page)
node.relation = f"Kapitel: {chapter_path}"
items.append(node)
if not items and not nested:
continue
nodes.append(
ExportNode(
id=f"chapter:{chapter['id']}",
kind="chapter",
title=chapter["title"],
exportable=True,
reason=None,
content_kind=None,
children=[*items, *nested],
label="Unterkapitel" if parent_id else "Kapitel",
)
)
return nodes
return build(None, "")
def _binding_node(conn, actor, binding: dict, page) -> ExportNode:
element = binding["element"]
rights = binding["rights"]
content_kind = _content_kind(element)
exportable = bool(rights.get("read") and rights.get("share"))
reason = None if exportable else "Für die Übergabe fehlt die Freigabebefugnis."
dates = element.get("dates") or {}
node = ExportNode(
id=f"binding:{binding['id']}",
kind="binding",
title=element["title"],
exportable=exportable,
reason=reason,
content_kind=content_kind,
element_id=element["id"],
summary=element.get("summary"),
direction=(binding.get("communication") or {}).get("direction"),
dates=dates,
label=_KIND_LABEL.get(content_kind, "Inhalt"),
)
for note in binding.get("annotations") or []:
node.children.append(
ExportNode(
id=f"annotation:{note['id']}",
kind="annotation",
title=f"Anmerkung zu {element['title']}",
exportable=exportable,
reason=reason,
content_kind="annotation",
element_id=element["id"],
annotation_body=note.get("body") or "",
annotation_author=note.get("author_display_name") or "",
annotation_at=note.get("created_at"),
label="Anmerkung",
)
)
for spec in export_children(conn, actor, binding, page):
node.children.append(_spec_node(spec))
return node
def _spec_node(spec: dict) -> ExportNode:
if spec["kind"] == "dispatch":
return ExportNode(
id=spec["id"],
kind="dispatch",
title=spec["title"],
exportable=True,
reason=None,
content_kind=None,
children=[_spec_node(child) for child in spec["children"]],
label=spec.get("label") or "Versand",
)
element = spec.get("element")
if spec["kind"] == "dispatch_item":
content_kind = _item_content_kind(spec)
else:
content_kind = _content_kind(element) if element else "file"
rights = spec.get("rights") or {}
exportable = bool(rights.get("read") and rights.get("share"))
return ExportNode(
id=spec["id"],
kind=spec["kind"],
title=spec["title"],
exportable=exportable,
reason=None if exportable else "Für die Übergabe fehlt die Freigabebefugnis.",
content_kind=content_kind,
element_id=(element or {}).get("id") or spec.get("element_id"),
dates=spec.get("dates"),
label={"attachment": "Anlage", "dispatch_item": "Versandfassung", "evidence": "Nachweis"}.get(spec["kind"], "Inhalt"),
relation=spec.get("relation"),
edition=spec.get("edition"),
gap_reason=spec.get("gap_reason"),
snapshot_id=spec.get("snapshot_id"),
)
def _item_content_kind(spec: dict) -> str:
if spec.get("gap_reason"):
return "gap"
media = spec.get("content_type") or ""
if media == "message/rfc822":
return "email"
if media == "application/json":
return "note"
return "file"
def _content_kind(element: dict) -> str:
if element["kind"] == "note":
return "note"
if element["kind"] == "file":
return "file"
source = (element.get("external") or {}).get("source")
if source == "imap":
return "email"
if source == "paperless":
return "paperless"
if source == "url":
return "url"
return element["kind"]
def _chosen(root: ExportNode, selected: list[str]) -> set[str]:
known = {node.id for node in _walk(root) if node.kind in _NODE_KINDS}
unknown = [item for item in selected if item not in known]
if unknown:
raise unprocessable("Die Auswahl enthält einen unbekannten oder nicht sichtbaren Inhalt.")
if not selected:
raise unprocessable("Die Auswahl enthält keinen Inhalt.")
return set(selected)
def _walk(node: ExportNode):
yield node
for child in node.children:
yield from _walk(child)
def _note_text(conn, element_id: UUID) -> str:
row = conn.execute("SELECT document_json FROM note_bodies WHERE element_id = %s", (element_id,)).fetchone()
document = row["document_json"] if row else {}
parts = []
for block in document.get("blocks") or []:
if isinstance(block, dict):
text = str(block.get("text") or "").strip()
if text:
parts.append(text)
return "\n\n".join(parts)
def _local_hashes(conn, root: ExportNode, chosen: set[str]) -> list[tuple[str, str, bool]]:
found = []
for node in _walk(root):
if node.kind != "binding" or node.content_kind != "file" or not node.element_id:
continue
asset = conn.execute(
"SELECT sha256, status FROM media_assets WHERE element_id = %s",
(UUID(node.element_id),),
).fetchone()
if asset is None or asset["status"] != "active" or not asset["sha256"]:
continue
found.append((node.id, asset["sha256"], node.id in chosen))
return found
def _retention_notices(node: ExportNode, mail: MailPayload, hashes: list[tuple[str, str, bool]]) -> list[Notice]:
notices = []
seen: set[str] = set()
for attachment in mail.parsed.attachments:
if any(digest == attachment.sha256 and not selected for _node_id, digest, selected in hashes):
if attachment.sha256 in seen:
continue
seen.add(attachment.sha256)
notices.append(
Notice(
node.id,
f"Die Anlage „{attachment.filename}“ bleibt Bestandteil dieser E-Mail. "
"Ein separates Vorkommen derselben Datei ist nicht ausgewählt.",
)
)
return notices
def _reference_issues(conn, actor, page: Ctx, leaves: list[ExportNode]) -> list[Issue]:
issues = []
selected_elements = {node.element_id for node in leaves if node.kind == "binding" and node.element_id}
for node in leaves:
if node.kind != "binding" or not node.element_id:
continue
rows = conn.execute(
"""
SELECT refers_to_element_id
FROM element_references
WHERE element_id = %s
ORDER BY created_at, refers_to_element_id
""",
(UUID(node.element_id),),
).fetchall()
for row in rows:
target = get_element(conn, row["refers_to_element_id"])
if target is None or not element_rights(conn, actor, target, page).read:
issues.append(Issue(node.id, node.title, "reference", "Ein Antwortbezug lässt sich nicht auflösen."))
continue
if str(target["id"]) not in selected_elements and str(target["id"]) != node.element_id:
continue
return issues
def _layout(root, chosen, loaded, notices, generated: str):
used: set[str] = {"index.html", "inhalt.md"}
files: list[tuple[str, bytes]] = []
entries: list[Entry] = []
notice_for = {}
for notice in notices:
notice_for.setdefault(notice.node_id, []).append(notice.message)
def add(parts: list[str], data: bytes) -> str:
path = _unique_path(parts, used)
files.append((path, data))
return path
def rewrite(path: str, data: bytes) -> None:
for index, (existing, _data) in enumerate(files):
if existing == path:
files[index] = (path, data)
return
def emit(node: ExportNode, prefix: list[str]) -> None:
folders = [child for child in node.children if _is_folder(child) and _included(child, chosen)]
numbers = {child.id: index + 1 for index, child in enumerate(folders)}
for child in node.children:
if child.id in numbers:
folder = prefix + [_folder_name(child.title, numbers[child.id], prefix)]
if child.kind == "binding" and child.content_kind == "email":
_emit_email(child, folder, add, rewrite, entries, loaded, notice_for, generated, chosen)
else:
emit(child, folder)
else:
_emit_loose(child, prefix, add, entries, loaded, notice_for, generated, chosen)
emit(root, [])
return files, entries
def _emit_email(node, folder, add, rewrite, entries, loaded, notice_for, generated: str, chosen: set[str]) -> None:
mail = loaded.get(node.id)
if isinstance(mail, MailPayload):
eml = add(folder + ["nachricht.eml"], mail.raw)
attachments = []
for attachment in mail.parsed.attachments:
path = add(folder + ["anlagen", attachment.filename], attachment.data)
attachments.append((attachment.filename, path))
notice = "\n".join(notice_for.get(node.id, []))
text_path = add(folder + ["lesefassung.md"], b"")
readable = _mail_markdown(node, mail, text_path, eml, attachments, notice, generated)
rewrite(text_path, readable.encode("utf-8"))
links = [("EML-Original", eml), ("Lesefassung", text_path), *attachments]
entries.append(_entry(node, eml, links, notice or None))
for child in node.children:
if child.kind == "annotation" and child.id in loaded:
path = add(folder + [_annotation_filename(child, folder)], _annotation_markdown(child).encode("utf-8"))
entries.append(_entry(child, path, [], None))
_emit_related(node, folder, add, entries, loaded, notice_for, chosen, generated)
def _emit_loose(node, prefix, add, entries, loaded, notice_for, generated: str, chosen: set[str]) -> None:
if node.kind == "binding" and node.id in loaded and node.content_kind != "email":
payload = loaded[node.id]
if node.content_kind == "note":
path = add(prefix + [f"{_segment(node.title)}.md"], _note_markdown(node, str(payload), generated).encode("utf-8"))
entries.append(_entry(node, path, [], None))
elif isinstance(payload, FilePayload):
path = add(prefix + [payload.filename], payload.data)
entries.append(_entry(node, path, [(payload.filename, path)], None))
if node.kind == "binding":
for child in node.children:
if child.kind == "annotation" and child.id in loaded and not (node.content_kind == "email" and node.id in loaded):
path = add(prefix + [_annotation_filename(child, prefix)], _annotation_markdown(child).encode("utf-8"))
entries.append(_entry(child, path, [], None))
elif node.kind == "annotation" and node.id in loaded:
path = add(prefix + [_annotation_filename(node, prefix)], _annotation_markdown(node).encode("utf-8"))
entries.append(_entry(node, path, [], None))
if node.kind == "binding":
_emit_related(node, prefix, add, entries, loaded, notice_for, chosen, generated)
def _host_bundle(prefix: list[str], host: ExportNode) -> list[str]:
"""Correspondence files stay under the host title, not a shared chapter folder."""
return prefix + [_segment(host.title)]
def _related_bucket(node: ExportNode) -> str:
if node.kind == "attachment":
return "Anlagen"
if node.kind == "evidence":
return "Belege"
if node.kind == "dispatch_item":
relation = node.relation or ""
if "Anlage → Versand" in relation:
return "Anlagen"
return "Belege"
return "Belege"
def _emit_related(node, prefix, add, entries, loaded, notice_for, chosen, generated: str) -> None:
bundle = _host_bundle(prefix, node)
for child in node.children:
if child.kind == "attachment" and child.id in chosen and child.id in loaded:
_emit_one(child, bundle + ["Anlagen"], add, entries, loaded, notice_for, generated)
if child.kind != "dispatch":
continue
picked = [item for item in child.children if item.id in chosen and item.id in loaded]
for item in picked:
_emit_one(item, bundle + [_related_bucket(item)], add, entries, loaded, notice_for, generated)
def _emit_one(node, prefix, add, entries, loaded, notice_for, generated: str) -> None:
payload = loaded[node.id]
notice = "\n".join(notice_for.get(node.id, []))
if isinstance(payload, GapNote):
path = add(prefix + [f"{_segment(node.title)}-luecke.txt"], payload.reason.encode("utf-8"))
entries.append(_entry(node, path, [( "Lücke", path)], notice or payload.reason))
return
if isinstance(payload, MailPayload) or (isinstance(payload, FilePayload) and payload.media_type == "message/rfc822"):
raw = payload.raw if isinstance(payload, MailPayload) else payload.data
eml = add(prefix + ["nachricht.eml"], raw)
links = [("EML-Original", eml)]
try:
parsed = payload.parsed if isinstance(payload, MailPayload) else parse_mail(raw)
for attachment in parsed.attachments:
path = add(prefix + ["anlagen", attachment.filename], attachment.data)
links.append((attachment.filename, path))
except Exception:
links.append(("Hinweis", eml))
entries.append(_entry(node, eml, links, notice or None))
return
if isinstance(payload, str):
path = add(prefix + [f"{_segment(node.title)}.md"], _note_markdown(node, payload, generated).encode("utf-8"))
entries.append(_entry(node, path, [], notice or None))
return
if isinstance(payload, FilePayload) and payload.media_type == "application/json":
path = add(prefix + [f"{_segment(node.title)}.stand.json"], payload.data)
text = _json_note(payload.data)
reading = add(prefix + [f"{_segment(node.title)}.md"], _note_markdown(node, text, generated).encode("utf-8"))
entries.append(_entry(node, reading, [("Gesicherter Text", path), ("Lesefassung", reading)], notice or None))
return
if isinstance(payload, FilePayload):
path = add(prefix + [payload.filename], payload.data)
entries.append(_entry(node, path, [(payload.filename, path)], notice or None))
def _json_note(data: bytes) -> str:
import json
try:
document = json.loads(data.decode("utf-8"))
except (UnicodeDecodeError, json.JSONDecodeError):
return ""
parts = []
for block in document.get("blocks") or []:
if isinstance(block, dict):
text = str(block.get("text") or "").strip()
if text:
parts.append(text)
return "\n\n".join(parts)
def _bundle_notices(root: ExportNode, chosen: set[str]) -> list[Notice]:
found = []
for node in _walk(root):
if node.kind != "dispatch":
continue
parts = [child for child in node.children if child.kind in {"dispatch_item", "evidence"}]
picked = [child for child in parts if child.id in chosen]
if not picked:
continue
if len(picked) < len(parts):
found.append(
Notice(
picked[0].id,
"Auszug dieses Versands. Die Ausgabe ist nicht der vollständige Versandstand.",
)
)
gaps = [child.gap_reason for child in picked if child.gap_reason]
if gaps:
found.append(Notice(picked[0].id, "Fehlende Fassung: " + " ".join(gaps)))
return found
def _entry(node: ExportNode, path: str | None, links, notice: str | None) -> Entry:
notes = tuple(part for part in (node.relation, node.edition, node.gap_reason) if part)
return Entry(
node.id,
node.title,
_label(node),
path,
links,
node.dates or {},
node.direction,
node.summary,
notice,
[],
_recorded(node),
notes,
)
def _attach_replies(conn, actor, page, entries: list[Entry], leaves: list[ExportNode]) -> None:
by_element: dict[str, str] = {}
nodes = {node.id: node for node in leaves}
for entry in entries:
node = nodes.get(entry.node_id)
if node and node.kind == "binding" and node.element_id and entry.path and node.element_id not in by_element:
by_element[node.element_id] = entry.path
for entry in entries:
node = nodes.get(entry.node_id)
if node is None or node.kind != "binding" or not node.element_id:
continue
rows = conn.execute(
"""
SELECT refers_to_element_id
FROM element_references
WHERE element_id = %s
ORDER BY created_at, refers_to_element_id
""",
(UUID(node.element_id),),
).fetchall()
for row in rows:
target_id = str(row["refers_to_element_id"])
target = get_element(conn, row["refers_to_element_id"])
if target is None or not element_rights(conn, actor, target, page).read:
continue
path = by_element.get(target_id)
if path is None:
continue
entry.replies.append((target["title"], path))
def _with_overview(title: str, generated: str, entries: list[Entry], files: list[tuple[str, bytes]]):
html_doc = _html_overview(title, generated, entries)
markdown = _markdown_overview(title, generated, entries)
return [("index.html", html_doc.encode("utf-8")), ("inhalt.md", markdown.encode("utf-8")), *files]
def _html_overview(title: str, generated: str, entries: list[Entry]) -> str:
items = []
for entry in entries:
bits = [f"<h2>{html.escape(entry.title)}</h2>", f"<p>{html.escape(entry.kind_label)}</p>"]
facts = _fact_lines(entry, generated)
if facts:
bits.append("<ul>" + "".join(f"<li>{html.escape(line)}</li>" for line in facts) + "</ul>")
if entry.summary:
bits.append(f"<p>Kurzfassung: {html.escape(entry.summary)}</p>")
for label, path in _entry_links(entry):
bits.append(f'<p><a href="{_href(path)}">{html.escape(label)}</a></p>')
for reply_title, path in entry.replies:
bits.append(
f'<p>Antwort auf <a href="{_href(path)}">{html.escape(reply_title)}</a></p>'
)
if entry.notice:
bits.append(f"<p>{html.escape(entry.notice)}</p>")
items.append(f"<article>{''.join(bits)}</article>")
body = "".join(items) or "<p>Die bestätigte Auswahl enthält keinen ausgebbaren Inhalt.</p>"
return (
"<!DOCTYPE html><html lang=\"de\"><head><meta charset=\"utf-8\">"
f"<title>Übergabe {html.escape(title)}</title>"
"<style>body{font-family:Segoe UI,sans-serif;line-height:1.45;max-width:46rem;margin:2rem auto;padding:0 1rem;color:#1c1b18}"
"a{color:#085041}article{border-top:1px solid #ddd;padding:1rem 0}</style></head><body>"
f"<h1>Übergabe {html.escape(title)}</h1>"
f"<p>Erzeugt am {html.escape(generated)}. Fachliche Daten stehen bei den einzelnen Inhalten und sind kein Erzeugungszeitpunkt.</p>"
f"{body}</body></html>"
)
def _markdown_overview(title: str, generated: str, entries: list[Entry]) -> str:
lines = [
f"# Übergabe {title}",
"",
f"Erzeugt am {generated}. Fachliche Daten stehen bei den einzelnen Inhalten und sind kein Erzeugungszeitpunkt.",
"",
]
for entry in entries:
lines.append(f"## {entry.title}")
lines.append("")
lines.append(entry.kind_label)
lines.append("")
for fact in _fact_lines(entry, generated):
lines.append(f"- {fact}")
if entry.summary:
lines.append(f"- Kurzfassung: {entry.summary}")
for label, path in _entry_links(entry):
lines.append(f"- [{label}]({_href(path)})")
for reply_title, path in entry.replies:
lines.append(f"- Antwort auf [{reply_title}]({_href(path)})")
if entry.notice:
lines.append("")
lines.append(entry.notice)
lines.append("")
return "\n".join(lines).rstrip() + "\n"
def _entry_links(entry: Entry) -> list[tuple[str, str]]:
if entry.links:
return entry.links
if entry.path:
return [(entry.kind_label, entry.path)]
return []
def _fact_lines(entry: Entry, generated: str) -> list[str]:
dates = entry.dates or {}
lines = []
if dates.get("document_on"):
lines.append(f"Fachdatum: {dates['document_on']}")
if dates.get("sent_on"):
lines.append(f"Gesendet: {dates['sent_on']}")
if dates.get("received_on"):
lines.append(f"Empfangen: {dates['received_on']}")
if entry.recorded_at:
lines.append(f"Erfasst am: {entry.recorded_at}")
if entry.direction in _DIRECTION:
lines.append(_DIRECTION[entry.direction])
lines.extend(entry.notes)
lines.append(f"Stand der Ausgabe: {generated}")
return lines
def _note_markdown(node: ExportNode, body: str, generated: str) -> str:
lines = [f"# {node.title}", ""]
lines.extend(f"- {fact}" for fact in _fact_lines(_entry(node, None, [], None), generated))
if node.summary:
lines.extend(["", f"Kurzfassung: {node.summary}"])
lines.extend(["", body, ""])
return "\n".join(lines)
def _mail_markdown(node, mail: MailPayload, text_path: str, eml_path: str, attachments, notice: str, generated: str) -> str:
parsed = mail.parsed
lines = [f"# {node.title}", "", "Lesefassung. Das unveränderte Original ist die EML-Datei.", ""]
lines.extend(f"- {fact}" for fact in _fact_lines(_entry(node, None, [], None), generated))
if parsed.sender:
lines.append(f"- Von: {parsed.sender}")
if parsed.recipient:
lines.append(f"- An: {parsed.recipient}")
if parsed.copy:
lines.append(f"- Kopie: {parsed.copy}")
lines.append(f"- [EML-Original]({_href(_relative(text_path, eml_path))})")
lines.extend(["", parsed.text or "Der Text steht im EML-Original.", ""])
if attachments:
lines.append("## Anlagen")
lines.append("")
for label, path in attachments:
lines.append(f"- [{label}]({_href(_relative(text_path, path))})")
lines.append("")
if notice:
lines.extend([notice, ""])
return "\n".join(lines)
def _stitch_replies(files: list[tuple[str, bytes]], entries: list[Entry]) -> None:
positions = {path: index for index, (path, _data) in enumerate(files)}
for entry in entries:
if not entry.replies:
continue
target = entry.path if entry.path and entry.path.endswith(".md") else None
if target is None:
target = next((path for label, path in entry.links if label == "Lesefassung"), None)
if target is None or target not in positions:
continue
extra = ["", "## Antwortbezug", ""]
for title, path in entry.replies:
extra.append(f"- [{title}]({_href(_relative(target, path))})")
extra.append("")
index = positions[target]
files[index] = (target, files[index][1] + ("\n".join(extra)).encode("utf-8"))
def _annotation_markdown(node: ExportNode) -> str:
lines = [f"# {node.title}", ""]
if node.annotation_author or node.annotation_at:
who = node.annotation_author or "Unbekannt"
when = node.annotation_at or ""
lines.append(f"Verfasst von {who}" + (f", {when}" if when else "") + ".")
lines.append("")
lines.append(node.annotation_body or "")
lines.append("")
return "\n".join(lines)
def _annotation_filename(node: ExportNode, _prefix) -> str:
return f"{_segment(node.title)}.md"
def _is_folder(node: ExportNode) -> bool:
return node.kind in {"chapter", "matter"} or (node.kind == "binding" and node.content_kind == "email")
def _included(node: ExportNode, chosen: set[str]) -> bool:
if node.kind == "binding" and node.content_kind == "email":
return any(child.id in chosen for child in _walk(node) if child.kind in _NODE_KINDS)
return any(child.id in chosen for child in _walk(node) if child.kind in _NODE_KINDS)
def _label(node: ExportNode) -> str:
return node.label or _KIND_LABEL.get(node.content_kind or node.kind, "Inhalt")
def _recorded(node: ExportNode) -> str | None:
if not node.dates:
return None
return node.dates.get("recorded_at")
def _segment(value: str, limit: int = 80) -> str:
cleaned = []
for char in value or "":
if char in '\\/:*?"<>|' or ord(char) < 32:
cleaned.append(" ")
else:
cleaned.append(char)
text = " ".join("".join(cleaned).split()).strip(" .")
if text in {"", ".", ".."}:
text = "Inhalt"
return text[:limit]
def _folder_name(title: str, number: int, prefix: list[str]) -> str:
"""Keep a readable directory name inside a bounded path. The overview keeps the full title."""
limit = 80
while True:
name = f"{number:02d} {_segment(title, limit)}"
if len("/".join([*prefix, name])) <= 180 or limit <= 24:
return name
limit -= 8
def _file_segment(value: str) -> str:
name = (value or "datei").replace("\\", "/").split("/")[-1]
return _segment(name) or "datei"
def _unique_path(parts: list[str], used: set[str]) -> str:
folder = [_segment(part) for part in parts[:-1]]
filename = _file_segment(parts[-1])
path = "/".join([*folder, filename])
if path not in used:
used.add(path)
return path
stem, dot, ext = filename.rpartition(".")
if not dot:
stem, extension = filename, ""
else:
extension = f".{ext}"
number = 2
while True:
candidate = "/".join([*folder, f"{stem} ({number}){extension}"])
if candidate not in used:
used.add(candidate)
return candidate
number += 1
def _href(path: str) -> str:
return "/".join(quote(part) for part in PurePosixPath(path).parts)
def _relative(from_path: str, to_path: str) -> str:
source = PurePosixPath(from_path).parent.parts
target = PurePosixPath(to_path).parts
shared = 0
while shared < len(source) and shared < len(target) and source[shared] == target[shared]:
shared += 1
hops = [".."] * (len(source) - shared)
return "/".join([*hops, *target[shared:]]) or "."
def _zip_bytes(files: list[tuple[str, bytes]]) -> bytes:
buffer = io.BytesIO()
with zipfile.ZipFile(buffer, "w", compression=zipfile.ZIP_DEFLATED) as archive:
for path, data in files:
info = zipfile.ZipInfo(path)
info.flag_bits |= 0x800
info.compress_type = zipfile.ZIP_DEFLATED
info.date_time = datetime.now(timezone.utc).timetuple()[:6]
archive.writestr(info, data)
return buffer.getvalue()
def _zip_name(title: str) -> str:
return f"Übergabe {_segment(title)}.zip"