From 3c190c87b414ba01ffcfb2d7744eafe56bd6e999 Mon Sep 17 00:00:00 2001 From: Lars Date: Sun, 18 Oct 2026 09:57:59 +0200 Subject: [PATCH 01/24] Halte Anlagen und Versand als eigene Verwendung fest, damit die uebermittelte Fassung und ihre Nachweise spaeter nicht still mit der Arbeitsfassung verschmelzen. Co-authored-by: Cursor --- backend/app/api/correspondence.py | 247 +++ backend/app/api/routes.py | 15 +- backend/app/api/schemas.py | 67 + backend/app/correspondence.py | 1337 +++++++++++++++++ backend/app/exporting.py | 227 ++- backend/app/main.py | 2 + backend/app/ops.py | 18 +- backend/app/present.py | 12 +- .../20261018T090000Z_correspondence.sql | 147 ++ backend/tests/test_correspondence.py | 620 ++++++++ docs/architecture/API_REFERENZ.md | 195 +++ docs/architecture/DATENMODELL_IST.md | 114 ++ docs/architecture/TSUMUGU_TECHNICAL_SPEC.md | 8 +- ...GU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md | 2 + .../TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md | 2 + docs/product/TSUMUGU_PRODUCT_SPEC.md | 20 +- ...IBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md | 134 ++ ...TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md | 2 + docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md | 6 +- ...MUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md | 2 + frontend/src/chapters.test.mjs | 15 + frontend/src/pages/ExportPackage.jsx | 4 +- frontend/src/pages/ReadingPane.jsx | 9 + frontend/src/pages/chapters.js | 17 + frontend/src/pages/content.jsx | 227 ++- frontend/src/pages/correspondence.jsx | 547 +++++++ frontend/src/styles.css | 28 +- 27 files changed, 3953 insertions(+), 71 deletions(-) create mode 100644 backend/app/api/correspondence.py create mode 100644 backend/app/correspondence.py create mode 100644 backend/migrations/20261018T090000Z_correspondence.sql create mode 100644 backend/tests/test_correspondence.py create mode 100644 docs/architecture/API_REFERENZ.md create mode 100644 docs/architecture/DATENMODELL_IST.md create mode 100644 docs/product/TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md create mode 100644 frontend/src/chapters.test.mjs create mode 100644 frontend/src/pages/correspondence.jsx diff --git a/backend/app/api/correspondence.py b/backend/app/api/correspondence.py new file mode 100644 index 0000000..6d79b22 --- /dev/null +++ b/backend/app/api/correspondence.py @@ -0,0 +1,247 @@ +"""HTTP for attachment roles, documented dispatches and secured editions.""" + +from __future__ import annotations + +from uuid import UUID + +from fastapi import APIRouter, Depends, Request, Response +from psycopg import Connection + +from app.access.policy import Ctx +from app.api.deps import Principal, get_conn, get_principal +from app.api.schemas import ( + AttachmentAssignIn, + AttachmentDetachIn, + AttachmentOrderIn, + DispatchCorrectIn, + DispatchEvidenceIn, + DispatchIn, + FoldIn, +) +from app.correspondence import ( + GapNote, + add_dispatch_evidence, + assign_attachments, + correct_dispatch, + detach_attachment, + dispatch_view, + open_container, + order_attachments, + read_snapshot, + record_dispatch, + set_fold, +) +from app.core.errors import not_found +from app.media.storage import content_disposition + +router = APIRouter() + + +def _ctx(value) -> Ctx: + return Ctx(value.kind, value.id) + + +def _placement(value) -> Ctx | None: + if value is None: + return None + return Ctx(value.kind, value.id) + + +@router.post("/api/v1/elements/{element_id}/attachments", status_code=201) +def post_attachments( + element_id: UUID, + body: AttachmentAssignIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + return assign_attachments( + conn, + principal.account_id, + element_id, + body.expected_version, + _ctx(body.context), + _placement(body.placement), + body.attachment_element_ids, + body.fold, + [], + ) + + +@router.post("/api/v1/elements/{element_id}/attachments/order") +def post_attachment_order( + element_id: UUID, + body: AttachmentOrderIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + return order_attachments( + conn, + principal.account_id, + element_id, + body.expected_version, + _ctx(body.context), + _placement(body.placement), + body.attachment_element_ids, + ) + + +@router.post("/api/v1/elements/{element_id}/attachments/{attachment_id}/detach", status_code=204) +def post_detach( + element_id: UUID, + attachment_id: UUID, + body: AttachmentDetachIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + detach_attachment( + conn, + principal.account_id, + element_id, + attachment_id, + body.expected_version, + _ctx(body.context), + _placement(body.placement), + ) + + +@router.patch("/api/v1/bindings/{binding_id}/fold") +def patch_fold( + binding_id: UUID, + body: FoldIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + return set_fold( + conn, + principal.account_id, + binding_id, + body.expected_version, + _ctx(body.context), + _placement(body.placement), + body.fold, + ) + + +@router.post("/api/v1/elements/{element_id}/dispatches", status_code=201) +def post_dispatch( + element_id: UUID, + body: DispatchIn, + request: Request, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + request.state.cleanup_files = [] + return record_dispatch( + conn, + principal.account_id, + element_id, + body.expected_version, + _ctx(body.context), + _placement(body.placement), + body.channel, + body.sent_on, + body.counterpart, + body.attachment_element_ids, + [item.model_dump() for item in body.evidence], + body.historical_gap, + request.app.state.settings.media_root, + request.state.cleanup_files, + ) + + +@router.post("/api/v1/dispatches/{dispatch_id}/evidence", status_code=201) +def post_evidence( + dispatch_id: UUID, + body: DispatchEvidenceIn, + request: Request, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + request.state.cleanup_files = [] + return add_dispatch_evidence( + conn, + principal.account_id, + dispatch_id, + body.expected_version, + _ctx(body.context), + _placement(body.placement), + body.element_id, + body.role, + body.fold, + request.app.state.settings.media_root, + request.state.cleanup_files, + ) + + +@router.post("/api/v1/dispatches/{dispatch_id}/correct") +def post_correct( + dispatch_id: UUID, + body: DispatchCorrectIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + return correct_dispatch( + conn, + principal.account_id, + dispatch_id, + body.expected_version, + _ctx(body.context), + _placement(body.placement), + body.channel, + body.sent_on, + body.clear_sent_on, + body.counterpart, + body.clear_counterpart, + ) + + +@router.get("/api/v1/dispatches/{dispatch_id}") +def get_dispatch( + dispatch_id: UUID, + context_kind: str, + context_id: UUID, + placement_kind: str | None = None, + placement_id: UUID | None = None, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + context = Ctx(context_kind, context_id) + placement = Ctx(placement_kind, placement_id) if placement_kind and placement_id else None + _row, page, scope = open_container(conn, principal.account_id, context, placement, "read") + return dispatch_view(conn, principal.account_id, dispatch_id, page, scope) + + +@router.get("/api/v1/dispatches/{dispatch_id}/items/{item_id}/content") +def get_dispatch_item( + dispatch_id: UUID, + item_id: UUID, + context_kind: str, + context_id: UUID, + request: Request, + placement_kind: str | None = None, + placement_id: UUID | None = None, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + context = Ctx(context_kind, context_id) + placement = Ctx(placement_kind, placement_id) if placement_kind and placement_id else None + result = read_snapshot( + conn, + principal.account_id, + dispatch_id, + item_id, + context, + placement, + request.app.state.settings.media_root, + ) + if isinstance(result, GapNote): + raise not_found() + return Response( + content=result.data, + media_type=result.media_type or "application/octet-stream", + headers={ + "Content-Disposition": content_disposition(result.filename), + "X-Content-Type-Options": "nosniff", + "Cache-Control": "private, no-store", + }, + ) diff --git a/backend/app/api/routes.py b/backend/app/api/routes.py index 9df0e11..e4aacd3 100644 --- a/backend/app/api/routes.py +++ b/backend/app/api/routes.py @@ -1460,9 +1460,17 @@ def patch_case_order( conn: Connection = Depends(get_conn), ): version = set_content_order( - conn, principal.account_id, "case", case_id, body.expected_version, body.mode, body.direction, None + conn, + principal.account_id, + "case", + case_id, + body.expected_version, + body.mode, + body.direction, + None, + body.view, ) - return {"version": version, "mode": body.mode, "direction": body.direction} + return {"version": version, "mode": body.mode, "direction": body.direction, "view": body.view} @router.post("/api/v1/cases/{case_id}/bindings/order") @@ -1514,8 +1522,9 @@ def patch_matter_order( body.mode, body.direction, _ctx_model(body.context), + body.view, ) - return {"version": version, "mode": body.mode, "direction": body.direction} + return {"version": version, "mode": body.mode, "direction": body.direction, "view": body.view} @router.post("/api/v1/matters/{matter_id}/bindings/order") diff --git a/backend/app/api/schemas.py b/backend/app/api/schemas.py index 0d0022e..2ede6b0 100644 --- a/backend/app/api/schemas.py +++ b/backend/app/api/schemas.py @@ -197,6 +197,7 @@ class ContentOrderIn(APIModel): expected_version: int = Field(ge=1) mode: Literal["date", "position"] direction: Literal["asc", "desc"] = "asc" + view: Literal["structure", "chronology"] | None = None context: ContextIn | None = None @@ -366,3 +367,69 @@ class ExportIn(APIModel): context: ContextIn | None = None selected: list[str] = Field(default_factory=list, max_length=2000) assignments: dict[str, UUID] = Field(default_factory=dict) + + +class EvidenceIn(APIModel): + element_id: UUID + role: Literal["email", "submission", "delivery", "other"] + fold: Literal["keep", "evidence"] = "keep" + + +class AttachmentAssignIn(APIModel): + expected_version: int = Field(ge=1) + context: ContextIn + placement: ContextIn | None = None + attachment_element_ids: list[UUID] = Field(min_length=1, max_length=100) + fold: Literal["keep", "attachment"] = "keep" + + +class AttachmentOrderIn(APIModel): + expected_version: int = Field(ge=1) + context: ContextIn + placement: ContextIn | None = None + attachment_element_ids: list[UUID] = Field(min_length=1, max_length=100) + + +class AttachmentDetachIn(APIModel): + expected_version: int = Field(ge=1) + context: ContextIn + placement: ContextIn | None = None + + +class FoldIn(APIModel): + expected_version: int = Field(ge=1) + context: ContextIn + placement: ContextIn | None = None + fold: Literal["attachment", "evidence"] | None = None + + +class DispatchIn(APIModel): + expected_version: int = Field(ge=1) + context: ContextIn + placement: ContextIn | None = None + channel: Literal["email", "post", "other"] + sent_on: date | None = None + counterpart: str | None = Field(default=None, max_length=200) + attachment_element_ids: list[UUID] = Field(default_factory=list, max_length=100) + evidence: list[EvidenceIn] = Field(default_factory=list, max_length=20) + historical_gap: bool = False + + +class DispatchEvidenceIn(APIModel): + expected_version: int = Field(ge=1) + context: ContextIn + placement: ContextIn | None = None + element_id: UUID + role: Literal["email", "submission", "delivery", "other"] + fold: Literal["keep", "evidence"] = "keep" + + +class DispatchCorrectIn(APIModel): + expected_version: int = Field(ge=1) + context: ContextIn + placement: ContextIn | None = None + channel: Literal["email", "post", "other"] | None = None + sent_on: date | None = None + clear_sent_on: bool = False + counterpart: str | None = Field(default=None, max_length=200) + clear_counterpart: bool = False diff --git a/backend/app/correspondence.py b/backend/app/correspondence.py new file mode 100644 index 0000000..654abb2 --- /dev/null +++ b/backend/app/correspondence.py @@ -0,0 +1,1337 @@ +"""Anlagenverwendung, dokumentierter Versand und gesicherte Fassung. + +An attachment use is a role in one container. It does not copy the file and +does not grant access. A dispatch freezes the transmitted stand. Later edits +of the working papers do not rewrite that stand. A missing historical original +stays a gap and is never filled with today's file. +""" + +from __future__ import annotations + +import json +import re +from dataclasses import dataclass +from datetime import date +from pathlib import Path +from uuid import UUID, uuid4 + +from psycopg.types.json import Json + +from app.access.policy import ( + Ctx, + audit, + bump_version, + element_rights, + get_element, + require_case, + require_matter, +) +from app.core.errors import conflict, not_found, unprocessable +from app.core.timeutil import dump_date, dump_dt +from app.media.storage import asset_path, display_filename, read_bytes, sha256, write_bytes +from app.retrieval import FilePayload, MailPayload, RetrievalFailure, load_external, load_file + +CHANNELS = {"email": "per E-Mail", "post": "per Post", "other": "sonstiger Weg"} +EVIDENCE_ROLES = { + "email": "E-Mail/Versanddokumentation", + "submission": "Einlieferung", + "delivery": "Zustellung", + "other": "sonstiger Nachweis", +} +_HISTORICAL_GAP = ( + "Historische Fassung liegt nicht vor. " + "Die aktuelle Arbeitsfassung wurde nicht als Versandstand übernommen." +) + + +@dataclass(frozen=True) +class GapNote: + reason: str + + +def open_container(conn, actor: UUID, context: Ctx, placement: Ctx | None, need: str) -> tuple[dict, Ctx, Ctx]: + """Rights follow the checked context. The relationship lives on the container.""" + container = placement or context + if container.kind == "case": + if placement is not None and (context.kind != "case" or context.id != placement.id): + raise not_found() + row, _rights = require_case(conn, actor, container.id, need) + page = Ctx("case", container.id) + return row, page, page + if container.kind != "matter": + raise unprocessable("Der Zusammenhang fehlt.") + if context.kind == "matter" and context.id != container.id: + raise not_found() + rights_context = context if context.kind == "case" else None + row, _rights = require_matter(conn, actor, container.id, rights_context, need) + page = rights_context or Ctx("matter", container.id) + return row, page, Ctx("matter", container.id) + + +def assign_attachments( + conn, + actor: UUID, + host_id: UUID, + expected: int, + context: Ctx, + placement: Ctx | None, + attachment_ids: list[UUID], + fold: str, + cleanup: list[Path], +) -> dict: + del cleanup + if fold not in {"keep", "attachment"}: + raise unprocessable("Die Darstellung der Vorkommen ist nicht festgelegt.") + if not attachment_ids: + raise unprocessable("Es ist keine Anlage ausgewählt.") + if len(attachment_ids) != len(set(attachment_ids)): + raise unprocessable("Dieselbe Anlage ist mehrfach ausgewählt.") + container_row, page, scope = open_container(conn, actor, context, placement, "edit") + host = _bound_element(conn, actor, host_id, page, scope) + bump_version(conn, "elements", host_id, expected) + created = [] + for attachment_id in attachment_ids: + created.append(_assign_one(conn, actor, container_row, page, scope, host, attachment_id, fold)) + audit(conn, actor, container_row["home_scope_id"], "attachments_assigned", "element", host_id, page) + return {"attachments": created} + + +def order_attachments( + conn, + actor: UUID, + host_id: UUID, + expected: int, + context: Ctx, + placement: Ctx | None, + attachment_ids: list[UUID], +) -> dict: + if len(attachment_ids) != len(set(attachment_ids)): + raise unprocessable("Dieselbe Anlage steht mehrfach in der Reihenfolge.") + container_row, page, scope = open_container(conn, actor, context, placement, "edit") + _bound_element(conn, actor, host_id, page, scope) + bump_version(conn, "elements", host_id, expected) + rows = _uses(conn, scope, host_id) + current = [row["attachment_element_id"] for row in rows] + if set(attachment_ids) != set(current) or len(attachment_ids) != len(current): + raise unprocessable("Die Anlagenreihenfolge ist unvollständig. Bitte neu laden.") + for position, attachment_id in enumerate(attachment_ids): + conn.execute( + """ + UPDATE attachment_uses + SET position = %s + WHERE context_kind = %s AND context_id = %s + AND host_element_id = %s AND attachment_element_id = %s + """, + (position, scope.kind, scope.id, host_id, attachment_id), + ) + audit(conn, actor, container_row["home_scope_id"], "attachments_ordered", "element", host_id, page) + return {"attachment_element_ids": [str(item) for item in attachment_ids]} + + +def detach_attachment( + conn, + actor: UUID, + host_id: UUID, + attachment_id: UUID, + expected: int, + context: Ctx, + placement: Ctx | None, +) -> None: + container_row, page, scope = open_container(conn, actor, context, placement, "edit") + _bound_element(conn, actor, host_id, page, scope) + bump_version(conn, "elements", host_id, expected) + deleted = conn.execute( + """ + DELETE FROM attachment_uses + WHERE context_kind = %s AND context_id = %s + AND host_element_id = %s AND attachment_element_id = %s + RETURNING id + """, + (scope.kind, scope.id, host_id, attachment_id), + ).fetchone() + if deleted is None: + raise not_found() + _clear_attachment_fold(conn, scope, attachment_id) + audit(conn, actor, container_row["home_scope_id"], "attachment_detached", "element", host_id, page) + + +def set_fold( + conn, + actor: UUID, + binding_id: UUID, + expected: int, + context: Ctx, + placement: Ctx | None, + fold: str | None, +) -> dict: + if fold not in {None, "attachment", "evidence"}: + raise unprocessable("Diese Darstellung ist nicht vorgesehen.") + container_row, page, scope = open_container(conn, actor, context, placement, "edit") + binding = conn.execute("SELECT * FROM bindings WHERE id = %s", (binding_id,)).fetchone() + if binding is None or binding["context_kind"] != scope.kind or binding["context_id"] != scope.id: + raise not_found() + element = _readable(conn, actor, binding["element_id"], page) + if element is None: + raise not_found() + bump_version(conn, "elements", element["id"], expected) + if fold == "attachment" and not _is_attachment(conn, scope, element["id"]): + raise unprocessable("Nur eine zugeordnete Anlage kann so dargestellt werden.") + if fold == "evidence" and not _is_evidence(conn, scope, element["id"]): + raise unprocessable("Nur ein zugeordneter Nachweis kann so dargestellt werden.") + conn.execute("UPDATE bindings SET list_fold = %s WHERE id = %s", (fold, binding_id)) + audit(conn, actor, container_row["home_scope_id"], "binding_folded", "element", element["id"], page) + return {"id": str(binding_id), "fold": fold} + + +def record_dispatch( + conn, + actor: UUID, + host_id: UUID, + expected: int, + context: Ctx, + placement: Ctx | None, + channel: str, + sent_on: date | None, + counterpart: str | None, + attachment_ids: list[UUID], + evidence: list[dict], + historical_gap: bool, + media_root: str, + cleanup: list[Path], +) -> dict: + if channel not in CHANNELS: + raise unprocessable("Der Versandweg ist nicht vorgesehen.") + if len(attachment_ids) != len(set(attachment_ids)): + raise unprocessable("Dieselbe Anlage ist mehrfach im Versand genannt.") + container_row, page, scope = open_container(conn, actor, context, placement, "edit") + host = _bound_element(conn, actor, host_id, page, scope) + bump_version(conn, "elements", host_id, expected) + known = {row["attachment_element_id"] for row in _uses(conn, scope, host_id)} + if any(item not in known for item in attachment_ids): + raise unprocessable("Mitversendet werden nur Anlagen dieses Schreibens.") + counterpart_text = _counterpart(counterpart) + dispatch = conn.execute( + """ + INSERT INTO dispatches ( + home_scope_id, context_kind, context_id, host_element_id, channel, + sent_on, counterpart, completeness, provenance, recorded_by + ) + VALUES (%s, %s, %s, %s, %s, %s, %s, 'gap', %s, %s) + RETURNING * + """, + ( + container_row["home_scope_id"], + scope.kind, + scope.id, + host_id, + channel, + sent_on, + counterpart_text, + "reconstructed" if historical_gap else "captured", + actor, + ), + ).fetchone() + states = [_capture_item(conn, actor, dispatch, host, "host", 0, page, historical_gap, media_root, cleanup)] + ordered = [row for row in _uses(conn, scope, host_id) if row["attachment_element_id"] in set(attachment_ids)] + position_of = {item: index for index, item in enumerate(attachment_ids)} + ordered.sort(key=lambda row: position_of[row["attachment_element_id"]]) + for index, row in enumerate(ordered, start=1): + element = _readable(conn, actor, row["attachment_element_id"], page) + if element is None: + raise not_found() + states.append( + _capture_item(conn, actor, dispatch, element, "attachment", index, page, historical_gap, media_root, cleanup) + ) + evidence_rows = [] + for item in evidence: + evidence_rows.append( + _add_evidence( + conn, + actor, + container_row, + page, + scope, + dispatch, + item["element_id"], + item["role"], + item.get("fold") or "keep", + media_root, + cleanup, + log=False, + ) + ) + completeness = _completeness(states) + conn.execute( + "UPDATE dispatches SET completeness = %s, updated_at = now() WHERE id = %s", + (completeness, dispatch["id"]), + ) + audit(conn, actor, container_row["home_scope_id"], "dispatch_recorded", "element", host_id, page) + return dispatch_view(conn, actor, dispatch["id"], page, scope) + + +def add_dispatch_evidence( + conn, + actor: UUID, + dispatch_id: UUID, + expected: int, + context: Ctx, + placement: Ctx | None, + element_id: UUID, + role: str, + fold: str, + media_root: str, + cleanup: list[Path], +) -> dict: + container_row, page, scope = open_container(conn, actor, context, placement, "edit") + dispatch = _dispatch_in(conn, dispatch_id, scope) + _bump_dispatch(conn, dispatch_id, expected) + row = _add_evidence( + conn, actor, container_row, page, scope, dispatch, element_id, role, fold, media_root, cleanup, log=True + ) + return row + + +def correct_dispatch( + conn, + actor: UUID, + dispatch_id: UUID, + expected: int, + context: Ctx, + placement: Ctx | None, + channel: str | None, + sent_on: date | None, + clear_sent_on: bool, + counterpart: str | None, + clear_counterpart: bool, +) -> dict: + container_row, page, scope = open_container(conn, actor, context, placement, "edit") + dispatch = _dispatch_in(conn, dispatch_id, scope) + if channel is None and sent_on is None and not clear_sent_on and counterpart is None and not clear_counterpart: + raise unprocessable("Es fehlt eine Berichtigung.") + if channel is not None and channel not in CHANNELS: + raise unprocessable("Der Versandweg ist nicht vorgesehen.") + _bump_dispatch(conn, dispatch_id, expected) + changes = [] + if channel is not None and channel != dispatch["channel"]: + conn.execute("UPDATE dispatches SET channel = %s WHERE id = %s", (channel, dispatch_id)) + changes.append(f"Weg: {CHANNELS[channel]}") + if clear_sent_on: + conn.execute("UPDATE dispatches SET sent_on = NULL WHERE id = %s", (dispatch_id,)) + changes.append("Versanddatum: undatiert") + elif sent_on is not None and sent_on != dispatch["sent_on"]: + conn.execute("UPDATE dispatches SET sent_on = %s WHERE id = %s", (sent_on, dispatch_id)) + changes.append(f"Versanddatum: {sent_on.isoformat()}") + if clear_counterpart: + conn.execute("UPDATE dispatches SET counterpart = NULL WHERE id = %s", (dispatch_id,)) + changes.append("Gegenüber: unbekannt") + elif counterpart is not None: + text = _counterpart(counterpart) + conn.execute("UPDATE dispatches SET counterpart = %s WHERE id = %s", (text, dispatch_id)) + changes.append("Gegenüber berichtigt") + if not changes: + raise unprocessable("Die Angaben sind unverändert.") + conn.execute("UPDATE dispatches SET updated_at = now() WHERE id = %s", (dispatch_id,)) + _log(conn, dispatch_id, actor, "Berichtigung: " + "; ".join(changes)) + audit(conn, actor, container_row["home_scope_id"], "dispatch_corrected", "element", dispatch["host_element_id"], page) + return dispatch_view(conn, actor, dispatch_id, page, scope) + + +def dispatch_view(conn, actor: UUID, dispatch_id: UUID, page: Ctx, scope: Ctx) -> dict: + dispatch = _dispatch_in(conn, dispatch_id, scope) + host = _readable(conn, actor, dispatch["host_element_id"], page) + if host is None: + raise not_found() + return _public_dispatch(conn, actor, dispatch, page) + + +def read_snapshot( + conn, + actor: UUID, + dispatch_id: UUID, + item_id: UUID, + context: Ctx, + placement: Ctx | None, + media_root: str, +) -> FilePayload | GapNote: + _container, page, scope = open_container(conn, actor, context, placement, "read") + dispatch = _dispatch_in(conn, dispatch_id, scope) + if _readable(conn, actor, dispatch["host_element_id"], page) is None: + raise not_found() + item = conn.execute( + "SELECT * FROM dispatch_items WHERE id = %s AND dispatch_id = %s", + (item_id, dispatch_id), + ).fetchone() + if item is None or _readable(conn, actor, item["element_id"], page) is None: + raise not_found() + if item["source_state"] != "snapshot": + return GapNote(item["gap_reason"] or "Für diesen Bestandteil liegt keine gesicherte Fassung vor.") + return _snapshot_file(conn, media_root, dispatch_item_id=item["id"]) + + +def load_snapshot_file(conn, snapshot_id: UUID, media_root: str) -> FilePayload | RetrievalFailure: + row = conn.execute("SELECT * FROM dispatch_snapshots WHERE id = %s", (snapshot_id,)).fetchone() + if row is None: + return RetrievalFailure("missing", "Die gesicherte Fassung ist nicht mehr vorhanden.") + try: + data = read_bytes(_snapshot_path(media_root, row["id"])) + except Exception: + return RetrievalFailure("missing", "Die gesicherte Fassung ist nicht mehr vorhanden.") + if sha256(data) != row["sha256"]: + return RetrievalFailure("missing", "Die gesicherte Fassung lässt sich nicht unverändert lesen.") + return FilePayload(row["original_filename"], row["content_type"], data, row["sha256"]) + + +def export_children(conn, actor: UUID, binding: dict, page: Ctx) -> list[dict]: + """Selectable export nodes for one visible binding. Unreadable parts are omitted.""" + element_id = UUID(binding["element"]["id"]) + scope = Ctx(binding_context_kind(binding), UUID(binding_context_id(binding))) + nodes = [] + host_title = binding["element"]["title"] + for use in _readable_uses(conn, actor, scope, element_id, page): + element = use["element"] + nodes.append( + { + "id": f"attachment:{use['id']}", + "kind": "attachment", + "title": element["title"], + "element": element, + "rights": element["rights"], + "relation": f"Schreiben → Anlage · {host_title}", + "edition": "Aktuelle Arbeitsfassung", + "dates": element.get("dates") or {}, + } + ) + for dispatch in _dispatch_rows(conn, scope, element_id): + if _readable(conn, actor, dispatch["host_element_id"], page) is None: + continue + children = [] + for item in _item_rows(conn, dispatch["id"]): + element = _readable(conn, actor, item["element_id"], page) + if element is None: + continue + rights = element_rights(conn, actor, element, page) + label = "Schreiben → Versand" if item["role"] == "host" else "Schreiben → Anlage → Versand" + sent = dump_date(dispatch["sent_on"]) or "undatiert" + edition = ( + f"Gesicherte Versandfassung · Versanddatum {sent}" + if item["source_state"] == "snapshot" + else "Lücke, keine gesicherte historische Fassung" + ) + children.append( + { + "id": f"dispatch-item:{item['id']}", + "kind": "dispatch_item", + "title": item["title"], + "element_id": str(item["element_id"]), + "rights": rights.as_dict(), + "relation": label, + "edition": edition, + "gap_reason": item["gap_reason"] if item["source_state"] == "gap" else None, + "snapshot_id": _snapshot_id(conn, dispatch_item_id=item["id"]), + "dates": {"document_on": dump_date(item["document_on"]), "sent_on": sent if dispatch["sent_on"] else None}, + "filename": item["filename"], + "content_type": item["content_type"], + } + ) + for proof in _evidence_rows(conn, dispatch["id"]): + element = _readable(conn, actor, proof["element_id"], page) + if element is None: + continue + body = _element_public(conn, element, page) + rights = element_rights(conn, actor, element, page) + children.append( + { + "id": f"evidence:{proof['id']}", + "kind": "evidence", + "title": element["title"], + "element": body, + "rights": rights.as_dict(), + "relation": f"Schreiben → Versand → Nachweis · {EVIDENCE_ROLES[proof['role']]}", + "edition": ( + "Identifiziertes Nachweisoriginal" + if proof["source_state"] == "identified" + else "Nachweis ohne gesicherte Originalfassung" + ), + "gap_reason": proof["gap_reason"] if proof["source_state"] == "gap" else None, + "snapshot_id": _snapshot_id(conn, evidence_id=proof["id"]), + "dates": body.get("dates") or {}, + "role": proof["role"], + } + ) + if not children: + continue + sent = dump_date(dispatch["sent_on"]) or "undatiert" + nodes.append( + { + "id": f"dispatch:{dispatch['id']}", + "kind": "dispatch", + "title": f"Versand {sent} · {CHANNELS[dispatch['channel']]}", + "children": children, + "completeness": dispatch["completeness"], + "provenance": dispatch["provenance"], + } + ) + return nodes + + +def attach_correspondence(conn, actor: UUID, bindings: list[dict], page: Ctx) -> None: + if not bindings: + return + scopes: dict[tuple[str, str], list[dict]] = {} + for binding in bindings: + key = (binding_context_kind(binding), binding_context_id(binding)) + scopes.setdefault(key, []).append(binding) + for (kind, raw_id), group in scopes.items(): + scope = Ctx(kind, UUID(raw_id)) + _attach_scope(conn, actor, group, page, scope) + + +def binding_context_kind(binding: dict) -> str: + container = binding.get("container") or {} + return container.get("kind") or binding.get("_context_kind") or "matter" + + +def binding_context_id(binding: dict) -> str: + container = binding.get("container") or {} + return container.get("id") or binding.get("_context_id") or "" + + +def purge_element_dispatch_files(conn, element_id: UUID, media_root: str) -> list[Path]: + """Drop stored bytes for a deleted element. The manifest of a remaining dispatch shows the gap.""" + paths: list[Path] = [] + host_dispatches = conn.execute( + "SELECT id FROM dispatches WHERE host_element_id = %s", + (element_id,), + ).fetchall() + for dispatch in host_dispatches: + paths.extend(_delete_dispatch_files(conn, dispatch["id"], media_root)) + conn.execute("DELETE FROM dispatches WHERE id = %s", (dispatch["id"],)) + item_ids = [ + row["id"] + for row in conn.execute("SELECT id FROM dispatch_items WHERE element_id = %s", (element_id,)).fetchall() + ] + for item_id in item_ids: + snap = conn.execute( + "SELECT id FROM dispatch_snapshots WHERE dispatch_item_id = %s", + (item_id,), + ).fetchone() + if snap is not None: + paths.append(_snapshot_path(media_root, snap["id"])) + conn.execute("DELETE FROM dispatch_snapshots WHERE id = %s", (snap["id"],)) + conn.execute( + """ + UPDATE dispatch_items + SET source_state = 'gap', + gap_reason = 'Die Fassung wurde mit der Unterlage gelöscht.', + note_document = NULL, + content_sha256 = NULL + WHERE id = %s + """, + (item_id,), + ) + evidence_ids = [ + row["id"] + for row in conn.execute("SELECT id FROM dispatch_evidence WHERE element_id = %s", (element_id,)).fetchall() + ] + for evidence_id in evidence_ids: + snap = conn.execute( + "SELECT id FROM dispatch_snapshots WHERE evidence_id = %s", + (evidence_id,), + ).fetchone() + if snap is not None: + paths.append(_snapshot_path(media_root, snap["id"])) + conn.execute("DELETE FROM dispatch_snapshots WHERE id = %s", (snap["id"],)) + conn.execute( + """ + UPDATE dispatch_evidence + SET source_state = 'gap', gap_reason = 'Der Nachweis wurde mit der Unterlage gelöscht.', + identity_sha256 = NULL + WHERE id = %s + """, + (evidence_id,), + ) + affected = conn.execute( + """ + SELECT DISTINCT dispatch_id FROM dispatch_items + WHERE element_id = %s + """, + (element_id,), + ).fetchall() + for row in affected: + states = [ + item["source_state"] + for item in conn.execute( + "SELECT source_state FROM dispatch_items WHERE dispatch_id = %s", + (row["dispatch_id"],), + ).fetchall() + ] + conn.execute( + "UPDATE dispatches SET completeness = %s, updated_at = now() WHERE id = %s", + (_completeness(states), row["dispatch_id"]), + ) + return paths + + +def _assign_one(conn, actor, container_row, page: Ctx, scope: Ctx, host: dict, attachment_id: UUID, fold: str) -> dict: + if attachment_id == host["id"]: + raise unprocessable("Ein Schriftstück kann nicht Anlage seiner selbst sein.") + element = _readable(conn, actor, attachment_id, page) + if element is None: + raise not_found() + existing = conn.execute( + """ + SELECT id FROM attachment_uses + WHERE context_kind = %s AND context_id = %s + AND host_element_id = %s AND attachment_element_id = %s + """, + (scope.kind, scope.id, host["id"], attachment_id), + ).fetchone() + if existing is not None: + raise unprocessable("Diese Anlage ist dem Schreiben bereits zugeordnet.") + if _reaches(conn, scope, attachment_id, host["id"]): + raise unprocessable("Diese Zuordnung würde einen Anlagenkreislauf erzeugen.") + position = conn.execute( + """ + SELECT COALESCE(MAX(position) + 1, 0) AS next_position + FROM attachment_uses + WHERE context_kind = %s AND context_id = %s AND host_element_id = %s + """, + (scope.kind, scope.id, host["id"]), + ).fetchone()["next_position"] + row = conn.execute( + """ + INSERT INTO attachment_uses ( + home_scope_id, context_kind, context_id, host_element_id, + attachment_element_id, position, created_by + ) + VALUES (%s, %s, %s, %s, %s, %s, %s) + RETURNING id, position + """, + (container_row["home_scope_id"], scope.kind, scope.id, host["id"], attachment_id, position, actor), + ).fetchone() + if fold == "attachment": + _set_binding_fold(conn, scope, attachment_id, "attachment") + return {"id": str(row["id"]), "element_id": str(attachment_id), "position": row["position"]} + + +def _add_evidence(conn, actor, container_row, page, scope, dispatch, element_id, role, fold, media_root, cleanup, log: bool) -> dict: + if role not in EVIDENCE_ROLES: + raise unprocessable("Die Rolle des Nachweises ist nicht vorgesehen.") + if fold not in {"keep", "evidence"}: + raise unprocessable("Die Darstellung des Nachweises ist nicht festgelegt.") + element = _readable(conn, actor, element_id, page) + if element is None: + raise not_found() + if conn.execute( + "SELECT id FROM dispatch_evidence WHERE dispatch_id = %s AND element_id = %s", + (dispatch["id"], element_id), + ).fetchone(): + raise unprocessable("Dieser Nachweis ist dem Versand bereits zugeordnet.") + identified, gap_reason, message_id, digest, comparisons, snapshot = _identify_evidence( + conn, actor, dispatch, element, page, media_root, cleanup, container_row["home_scope_id"] + ) + proof = conn.execute( + """ + INSERT INTO dispatch_evidence ( + dispatch_id, element_id, role, source_state, gap_reason, message_id, + identity_sha256, comparisons, manual, created_by + ) + VALUES (%s, %s, %s, %s, %s, %s, %s, %s, true, %s) + RETURNING * + """, + ( + dispatch["id"], + element_id, + role, + "identified" if identified else "gap", + gap_reason, + message_id, + digest, + Json(comparisons), + actor, + ), + ).fetchone() + if snapshot is not None: + _store_snapshot( + conn, + container_row["home_scope_id"], + actor, + snapshot, + media_root, + cleanup, + evidence_id=proof["id"], + ) + if fold == "evidence": + _set_binding_fold(conn, scope, element_id, "evidence") + if log: + _log(conn, dispatch["id"], actor, f"Nachweis ergänzt: {EVIDENCE_ROLES[role]}") + audit(conn, actor, container_row["home_scope_id"], "dispatch_evidence", "element", element_id, page) + return { + "id": str(proof["id"]), + "element_id": str(element_id), + "role": role, + "role_label": EVIDENCE_ROLES[role], + "source_state": proof["source_state"], + "gap_reason": gap_reason, + "manual": True, + "comparisons": comparisons, + } + + +def _identify_evidence(conn, actor, dispatch, element, page, media_root, cleanup, scope_id): + del cleanup, scope_id + comparisons = [] + if element["kind"] == "external_ref": + loaded = load_external(conn, actor, element["id"], None) + if isinstance(loaded, RetrievalFailure): + return False, loaded.message, None, None, [], None + if isinstance(loaded, MailPayload): + comparisons = _compare_mail(conn, actor, dispatch["id"], page, loaded) + payload = FilePayload("nachweis.eml", "message/rfc822", loaded.raw, sha256(loaded.raw)) + return True, None, loaded.parsed.message_id or None, payload.sha256, comparisons, payload + payload = FilePayload(loaded.filename, loaded.media_type, loaded.data, sha256(loaded.data)) + return True, None, None, payload.sha256, [], payload + if element["kind"] == "file": + loaded = load_file(conn, element["id"], media_root) + if isinstance(loaded, RetrievalFailure): + return False, loaded.message, None, None, [], None + payload = FilePayload(loaded.filename, loaded.media_type, loaded.data, sha256(loaded.data)) + return True, None, None, payload.sha256, [], payload + if element["kind"] == "note": + text = _note_bytes(conn, element["id"]) + if text is None: + return False, "Der Nachweistext liegt nicht vor.", None, None, [], None + payload = FilePayload(display_filename(element["title"] + ".json"), "application/json", text, sha256(text)) + return True, None, None, payload.sha256, [], payload + return False, "Für diesen Nachweis liegt kein sicherbares Original vor.", None, None, [], None + + +def _compare_mail(conn, actor: UUID, dispatch_id: UUID, page: Ctx, mail: MailPayload) -> list[dict]: + known = [] + for item in _item_rows(conn, dispatch_id): + element = _readable(conn, actor, item["element_id"], page) + if element is None or not item["content_sha256"]: + continue + known.append( + { + "element_id": str(item["element_id"]), + "title": item["title"], + "sha256": item["content_sha256"], + "filename": item["filename"] or item["title"], + } + ) + return _comparison_rows(mail, known) + + +def _base_filename(filename: str) -> str: + return re.sub(r" \(\d+\)(\.[^.]+)$", r"\1", filename) + + +def _comparison_rows(mail: MailPayload, known: list[dict]) -> list[dict]: + rows = [] + for attachment in mail.parsed.attachments: + base = _base_filename(attachment.filename) + same_bytes = [item for item in known if item["sha256"] == attachment.sha256] + same_name = [ + item + for item in known + if item["sha256"] != attachment.sha256 and (item["filename"] == attachment.filename or item["filename"] == base) + ] + if same_bytes: + disposition = "same_bytes" + matches = same_bytes + elif same_name: + disposition = "same_name_different_bytes" + matches = same_name + else: + disposition = "distinct" + matches = [] + rows.append( + { + "filename": attachment.filename, + "sha256": attachment.sha256, + "disposition": disposition, + "manual": True, + "matches": [{"element_id": item["element_id"], "title": item["title"]} for item in matches], + } + ) + return rows + + +def _capture_item(conn, actor, dispatch, element, role: str, position: int, page: Ctx, historical_gap: bool, media_root: str, cleanup: list[Path]) -> str: + dates = _dates(conn, element["id"]) + title = element["title"] + filename = None + content_type = None + digest = None + byte_size = None + note_document = None + external_source = None + external_id = None + gap_reason = None + payload = None + if historical_gap: + state = "gap" + gap_reason = _HISTORICAL_GAP + else: + payload, gap_reason, note_document, external_source, external_id = _working_bytes( + conn, actor, element, media_root + ) + if payload is None: + state = "gap" + else: + state = "snapshot" + filename = payload.filename + content_type = payload.media_type + digest = sha256(payload.data) + byte_size = len(payload.data) + item = conn.execute( + """ + INSERT INTO dispatch_items ( + dispatch_id, role, position, element_id, title, document_on, filename, + content_type, byte_size, content_sha256, source_state, gap_reason, + note_document, external_source, external_id + ) + VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) + RETURNING id + """, + ( + dispatch["id"], + role, + position, + element["id"], + title, + dates["document_on"], + filename, + content_type, + byte_size, + digest, + state, + gap_reason, + Json(note_document) if note_document is not None else None, + external_source, + external_id, + ), + ).fetchone() + if payload is not None: + _store_snapshot( + conn, + dispatch["home_scope_id"], + actor, + payload, + media_root, + cleanup, + dispatch_item_id=item["id"], + ) + del page + return state + + +def _working_bytes(conn, actor, element, media_root: str): + if element["kind"] == "note": + raw = _note_bytes(conn, element["id"]) + if raw is None: + return None, "Der Text des Schreibens liegt nicht vor.", None, None, None + document = json.loads(raw.decode("utf-8")) + payload = FilePayload(display_filename(element["title"] + ".json"), "application/json", raw, sha256(raw)) + return payload, None, document, None, None + if element["kind"] == "file": + loaded = load_file(conn, element["id"], media_root) + if isinstance(loaded, RetrievalFailure): + return None, loaded.message, None, None, None + return loaded, None, None, None, None + if element["kind"] == "external_ref": + ref = conn.execute( + "SELECT source, external_id FROM external_references WHERE element_id = %s", + (element["id"],), + ).fetchone() + loaded = load_external(conn, actor, element["id"], None) + source = ref["source"] if ref else None + external_id = ref["external_id"] if ref else None + if isinstance(loaded, RetrievalFailure): + return None, loaded.message, None, source, external_id + if isinstance(loaded, MailPayload): + payload = FilePayload("nachricht.eml", "message/rfc822", loaded.raw, sha256(loaded.raw)) + return payload, None, None, source, external_id + return loaded, None, None, source, external_id + return None, "Für diesen Inhalt ist keine sicherbare Fassung vorgesehen.", None, None, None + + +def _store_snapshot(conn, scope_id, actor, payload: FilePayload, media_root: str, cleanup: list[Path], dispatch_item_id: UUID | None = None, evidence_id: UUID | None = None) -> UUID: + snapshot_id = uuid4() + path = _snapshot_path(media_root, snapshot_id) + write_bytes(path, payload.data) + cleanup.append(path) + digest = sha256(payload.data) + conn.execute( + """ + INSERT INTO dispatch_snapshots ( + id, dispatch_item_id, evidence_id, home_scope_id, owner_subject_id, + original_filename, content_type, byte_size, sha256 + ) + VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s) + """, + ( + snapshot_id, + dispatch_item_id, + evidence_id, + scope_id, + actor, + display_filename(payload.filename), + payload.media_type or "application/octet-stream", + len(payload.data), + digest, + ), + ) + return snapshot_id + + +def _snapshot_file(conn, media_root: str, dispatch_item_id: UUID | None = None, evidence_id: UUID | None = None) -> FilePayload: + if dispatch_item_id is not None: + row = conn.execute( + "SELECT * FROM dispatch_snapshots WHERE dispatch_item_id = %s", + (dispatch_item_id,), + ).fetchone() + else: + row = conn.execute( + "SELECT * FROM dispatch_snapshots WHERE evidence_id = %s", + (evidence_id,), + ).fetchone() + if row is None: + raise not_found() + data = read_bytes(_snapshot_path(media_root, row["id"])) + if sha256(data) != row["sha256"]: + raise not_found() + return FilePayload(row["original_filename"], row["content_type"], data, row["sha256"]) + + +def _snapshot_path(media_root: str, snapshot_id: UUID) -> Path: + root = Path(media_root).resolve() + folder = (root / "dispatch").resolve() + folder.mkdir(parents=True, exist_ok=True) + target = (folder / str(snapshot_id)).resolve() + if target.parent != folder: + raise unprocessable("Ungültiger Speicherpfad.") + return target + + +def _snapshot_id(conn, dispatch_item_id: UUID | None = None, evidence_id: UUID | None = None) -> str | None: + if dispatch_item_id is not None: + row = conn.execute( + "SELECT id FROM dispatch_snapshots WHERE dispatch_item_id = %s", + (dispatch_item_id,), + ).fetchone() + else: + row = conn.execute( + "SELECT id FROM dispatch_snapshots WHERE evidence_id = %s", + (evidence_id,), + ).fetchone() + return None if row is None else str(row["id"]) + + +def _public_dispatch(conn, actor: UUID, dispatch, page: Ctx) -> dict: + items = [] + for item in _item_rows(conn, dispatch["id"]): + if _readable(conn, actor, item["element_id"], page) is None: + continue + items.append( + { + "id": str(item["id"]), + "role": item["role"], + "position": item["position"], + "element_id": str(item["element_id"]), + "title": item["title"], + "document_on": dump_date(item["document_on"]), + "filename": item["filename"], + "source_state": item["source_state"], + "gap_reason": item["gap_reason"], + "content_sha256": item["content_sha256"], + } + ) + evidence = [] + for proof in _evidence_rows(conn, dispatch["id"]): + element = _readable(conn, actor, proof["element_id"], page) + if element is None: + continue + evidence.append(_public_evidence(conn, proof, element, page)) + return { + "id": str(dispatch["id"]), + "host_element_id": str(dispatch["host_element_id"]), + "channel": dispatch["channel"], + "channel_label": CHANNELS[dispatch["channel"]], + "sent_on": dump_date(dispatch["sent_on"]), + "undated": dispatch["sent_on"] is None, + "counterpart": dispatch["counterpart"], + "completeness": dispatch["completeness"], + "provenance": dispatch["provenance"], + "recorded_at": dump_dt(dispatch["recorded_at"]), + "version": dispatch["version"], + "items": items, + "evidence": evidence, + "corrections": [ + { + "id": str(row["id"]), + "corrected_at": dump_dt(row["corrected_at"]), + "summary": row["summary"], + } + for row in conn.execute( + """ + SELECT id, corrected_at, summary + FROM dispatch_corrections + WHERE dispatch_id = %s + ORDER BY corrected_at, id + """, + (dispatch["id"],), + ).fetchall() + ], + } + + +def _public_evidence(conn, proof, element, page: Ctx) -> dict: + del page + return { + "id": str(proof["id"]), + "element_id": str(element["id"]), + "title": element["title"], + "role": proof["role"], + "role_label": EVIDENCE_ROLES[proof["role"]], + "source_state": proof["source_state"], + "gap_reason": proof["gap_reason"], + "manual": proof["manual"], + "comparisons": proof["comparisons"] or [], + "document_on": dump_date(_dates(conn, element["id"])["document_on"]), + } + + +def _attach_scope(conn, actor, bindings: list[dict], page: Ctx, scope: Ctx) -> None: + element_ids = [UUID(item["element"]["id"]) for item in bindings] + folds = { + str(row["id"]): row["list_fold"] + for row in conn.execute( + "SELECT id, list_fold FROM bindings WHERE context_kind = %s AND context_id = %s", + (scope.kind, scope.id), + ).fetchall() + } + uses = conn.execute( + """ + SELECT * FROM attachment_uses + WHERE context_kind = %s AND context_id = %s + ORDER BY position, id + """, + (scope.kind, scope.id), + ).fetchall() + by_host: dict[UUID, list] = {} + hosts_of: dict[UUID, list] = {} + for use in uses: + by_host.setdefault(use["host_element_id"], []).append(use) + hosts_of.setdefault(use["attachment_element_id"], []).append(use) + dispatch_rows = conn.execute( + """ + SELECT * FROM dispatches + WHERE context_kind = %s AND context_id = %s + ORDER BY sent_on NULLS LAST, recorded_at, id + """, + (scope.kind, scope.id), + ).fetchall() + by_dispatch_host: dict[UUID, list] = {} + for row in dispatch_rows: + by_dispatch_host.setdefault(row["host_element_id"], []).append(row) + visible = set(element_ids) + for binding in bindings: + element_id = UUID(binding["element"]["id"]) + attachments = [] + for use in by_host.get(element_id, []): + if use["attachment_element_id"] not in visible and _readable(conn, actor, use["attachment_element_id"], page) is None: + continue + if _readable(conn, actor, use["attachment_element_id"], page) is None: + continue + target = next((item for item in bindings if UUID(item["element"]["id"]) == use["attachment_element_id"]), None) + element = target["element"] if target else _element_public(conn, get_element(conn, use["attachment_element_id"]), page) + attachments.append( + { + "id": str(use["id"]), + "element_id": str(use["attachment_element_id"]), + "binding_id": target["id"] if target else _binding_id(conn, scope, use["attachment_element_id"]), + "title": element["title"], + "kind": element["kind"], + "position": use["position"], + "document_on": (element.get("dates") or {}).get("document_on"), + "label": use["label"], + } + ) + hosts = [] + for use in hosts_of.get(element_id, []): + if _readable(conn, actor, use["host_element_id"], page) is None: + continue + host_binding = next((item for item in bindings if UUID(item["element"]["id"]) == use["host_element_id"]), None) + host_element = host_binding["element"] if host_binding else _element_public(conn, get_element(conn, use["host_element_id"]), page) + hosts.append({"element_id": str(use["host_element_id"]), "title": host_element["title"]}) + dispatches = [] + for dispatch in by_dispatch_host.get(element_id, []): + public = _public_dispatch(conn, actor, dispatch, page) + for proof in public["evidence"]: + match = next((item for item in bindings if item["element"]["id"] == proof["element_id"]), None) + proof["listed_fold"] = folds.get(match["id"]) if match else None + dispatches.append(public) + binding["correspondence"] = { + "fold": folds.get(binding["id"]), + "attachments": attachments, + "hosts": hosts, + "dispatches": dispatches, + } + + +def _element_public(conn, element, page: Ctx) -> dict: + del page + if element is None: + return {"title": "", "kind": "", "dates": {}} + dates = _dates(conn, element["id"]) + return { + "id": str(element["id"]), + "title": element["title"], + "kind": element["kind"], + "dates": { + "document_on": dump_date(dates["document_on"]), + "sent_on": dump_date(dates["sent_on"]), + "received_on": dump_date(dates["received_on"]), + }, + } + + +def _readable_uses(conn, actor, scope: Ctx, host_id: UUID, page: Ctx) -> list[dict]: + found = [] + for use in _uses(conn, scope, host_id): + element = _readable(conn, actor, use["attachment_element_id"], page) + if element is None: + continue + rights = element_rights(conn, actor, element, page) + body = _element_public(conn, element, page) + body["rights"] = rights.as_dict() + found.append({"id": use["id"], "element": body}) + return found + + +def _bound_element(conn, actor, element_id: UUID, page: Ctx, scope: Ctx) -> dict: + element = _readable(conn, actor, element_id, page) + if element is None: + raise not_found() + binding = conn.execute( + """ + SELECT id FROM bindings + WHERE element_id = %s AND context_kind = %s AND context_id = %s + """, + (element_id, scope.kind, scope.id), + ).fetchone() + if binding is None: + raise unprocessable("Das Schriftstück ist in diesem Zusammenhang nicht eingebunden.") + return element + + +def _readable(conn, actor: UUID, element_id: UUID, page: Ctx): + element = get_element(conn, element_id) + if element is None or not element_rights(conn, actor, element, page).read: + return None + return element + + +def _uses(conn, scope: Ctx, host_id: UUID): + return conn.execute( + """ + SELECT * FROM attachment_uses + WHERE context_kind = %s AND context_id = %s AND host_element_id = %s + ORDER BY position, id + """, + (scope.kind, scope.id, host_id), + ).fetchall() + + +def _dispatch_rows(conn, scope: Ctx, host_id: UUID): + return conn.execute( + """ + SELECT * FROM dispatches + WHERE context_kind = %s AND context_id = %s AND host_element_id = %s + ORDER BY sent_on NULLS LAST, recorded_at, id + """, + (scope.kind, scope.id, host_id), + ).fetchall() + + +def _item_rows(conn, dispatch_id: UUID): + return conn.execute( + "SELECT * FROM dispatch_items WHERE dispatch_id = %s ORDER BY position, id", + (dispatch_id,), + ).fetchall() + + +def _evidence_rows(conn, dispatch_id: UUID): + return conn.execute( + "SELECT * FROM dispatch_evidence WHERE dispatch_id = %s ORDER BY created_at, id", + (dispatch_id,), + ).fetchall() + + +def _dispatch_in(conn, dispatch_id: UUID, scope: Ctx): + row = conn.execute("SELECT * FROM dispatches WHERE id = %s", (dispatch_id,)).fetchone() + if row is None or row["context_kind"] != scope.kind or row["context_id"] != scope.id: + raise not_found() + return row + + +def _bump_dispatch(conn, dispatch_id: UUID, expected: int) -> int: + row = conn.execute( + """ + UPDATE dispatches + SET version = version + 1, updated_at = now() + WHERE id = %s AND version = %s + RETURNING version + """, + (dispatch_id, expected), + ).fetchone() + if row is None: + current = conn.execute("SELECT id FROM dispatches WHERE id = %s", (dispatch_id,)).fetchone() + if current is None: + raise not_found() + raise conflict() + return int(row["version"]) + + +def _reaches(conn, scope: Ctx, start: UUID, target: UUID) -> bool: + seen = set() + stack = [start] + while stack: + current = stack.pop() + if current == target: + return True + if current in seen: + continue + seen.add(current) + rows = conn.execute( + """ + SELECT attachment_element_id FROM attachment_uses + WHERE context_kind = %s AND context_id = %s AND host_element_id = %s + """, + (scope.kind, scope.id, current), + ).fetchall() + stack.extend(row["attachment_element_id"] for row in rows) + return False + + +def _is_attachment(conn, scope: Ctx, element_id: UUID) -> bool: + return ( + conn.execute( + """ + SELECT id FROM attachment_uses + WHERE context_kind = %s AND context_id = %s AND attachment_element_id = %s + """, + (scope.kind, scope.id, element_id), + ).fetchone() + is not None + ) + + +def _is_evidence(conn, scope: Ctx, element_id: UUID) -> bool: + return ( + conn.execute( + """ + SELECT e.id + FROM dispatch_evidence e + JOIN dispatches d ON d.id = e.dispatch_id + WHERE d.context_kind = %s AND d.context_id = %s AND e.element_id = %s + """, + (scope.kind, scope.id, element_id), + ).fetchone() + is not None + ) + + +def _set_binding_fold(conn, scope: Ctx, element_id: UUID, fold: str) -> None: + conn.execute( + """ + UPDATE bindings SET list_fold = %s + WHERE element_id = %s AND context_kind = %s AND context_id = %s + """, + (fold, element_id, scope.kind, scope.id), + ) + + +def _clear_attachment_fold(conn, scope: Ctx, element_id: UUID) -> None: + if _is_attachment(conn, scope, element_id): + return + conn.execute( + """ + UPDATE bindings SET list_fold = NULL + WHERE element_id = %s AND context_kind = %s AND context_id = %s AND list_fold = 'attachment' + """, + (element_id, scope.kind, scope.id), + ) + + +def _binding_id(conn, scope: Ctx, element_id: UUID) -> str | None: + row = conn.execute( + """ + SELECT id FROM bindings + WHERE element_id = %s AND context_kind = %s AND context_id = %s + """, + (element_id, scope.kind, scope.id), + ).fetchone() + return None if row is None else str(row["id"]) + + +def _dates(conn, element_id: UUID) -> dict: + row = conn.execute("SELECT document_on, sent_on, received_on FROM correspondence_dates WHERE element_id = %s", (element_id,)).fetchone() + if row is None: + return {"document_on": None, "sent_on": None, "received_on": None} + return row + + +def _note_bytes(conn, element_id: UUID) -> bytes | None: + row = conn.execute("SELECT document_json FROM note_bodies WHERE element_id = %s", (element_id,)).fetchone() + if row is None: + return None + return json.dumps(row["document_json"], ensure_ascii=False, sort_keys=True).encode("utf-8") + + +def _counterpart(value: str | None) -> str | None: + if value is None: + return None + text = value.strip() + if not text: + return None + if len(text) > 200: + raise unprocessable("Das Gegenüber ist zu lang.") + return text + + +def _completeness(states: list[str]) -> str: + if states and all(item == "snapshot" for item in states): + return "secured" + if any(item == "snapshot" for item in states): + return "partial" + return "gap" + + +def _log(conn, dispatch_id: UUID, actor: UUID, summary: str) -> None: + conn.execute( + """ + INSERT INTO dispatch_corrections (dispatch_id, corrected_by, summary) + VALUES (%s, %s, %s) + """, + (dispatch_id, actor, summary[:500]), + ) + + +def _delete_dispatch_files(conn, dispatch_id: UUID, media_root: str) -> list[Path]: + paths = [] + rows = conn.execute( + """ + SELECT s.id + FROM dispatch_snapshots s + LEFT JOIN dispatch_items i ON i.id = s.dispatch_item_id + LEFT JOIN dispatch_evidence e ON e.id = s.evidence_id + WHERE i.dispatch_id = %s OR e.dispatch_id = %s + """, + (dispatch_id, dispatch_id), + ).fetchall() + for row in rows: + paths.append(_snapshot_path(media_root, row["id"])) + return paths diff --git a/backend/app/exporting.py b/backend/app/exporting.py index 9686872..34a1aeb 100644 --- a/backend/app/exporting.py +++ b/backend/app/exporting.py @@ -21,6 +21,8 @@ from app.access.policy import ( ) 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, @@ -30,7 +32,7 @@ from app.retrieval import ( load_file, ) -_NODE_KINDS = {"binding", "annotation"} +_NODE_KINDS = {"binding", "annotation", "attachment", "dispatch_item", "evidence"} _DIRECTION = {"in": "Eingang", "out": "Ausgang"} _KIND_LABEL = { "note": "Notiz", @@ -62,6 +64,10 @@ class ExportNode: 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 { @@ -118,6 +124,7 @@ class Entry: notice: str | None replies: list[tuple[str, str]] recorded_at: str | None + notes: tuple[str, ...] = () def public(self) -> dict: return { @@ -202,6 +209,16 @@ def _plan(conn, actor, matter_id, context, selected, assignments, media_root) -> 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 @@ -217,6 +234,7 @@ def _plan(conn, actor, matter_id, context, selected, assignments, media_root) -> 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: @@ -252,9 +270,9 @@ def _matter_node(conn, actor, matter, page: Ctx, root: bool) -> ExportNode: for binding in bindings: grouped.setdefault(binding.get("chapter_id"), []).append(binding) children: list[ExportNode] = [] - children.extend(_chapter_nodes(chapters, grouped)) + children.extend(_chapter_nodes(conn, actor, page, chapters, grouped)) for binding in grouped.get(None, []): - children.append(_binding_node(binding)) + 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"],), @@ -275,16 +293,21 @@ def _matter_node(conn, actor, matter, page: Ctx, root: bool) -> ExportNode: ) -def _chapter_nodes(chapters: list[dict], grouped: dict[str | None, list]) -> list[ExportNode]: +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) -> list[ExportNode]: + def build(parent_id: str | None, path: str) -> list[ExportNode]: nodes: list[ExportNode] = [] for chapter in by_parent.get(parent_id, []): - nested = build(chapter["id"]) - items = [_binding_node(item) for item in grouped.get(chapter["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"], []): + 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( @@ -301,10 +324,10 @@ def _chapter_nodes(chapters: list[dict], grouped: dict[str | None, list]) -> lis ) return nodes - return build(None) + return build(None, "") -def _binding_node(binding: dict) -> ExportNode: +def _binding_node(conn, actor, binding: dict, page) -> ExportNode: element = binding["element"] rights = binding["rights"] content_kind = _content_kind(element) @@ -340,9 +363,58 @@ def _binding_node(binding: dict) -> ExportNode: 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="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" @@ -470,37 +542,38 @@ def _layout(root, chosen, loaded, notices, generated: str): 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) + _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) + _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) -> None: - mail = loaded[node.id] - assert 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)) +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) -> None: +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": @@ -517,9 +590,99 @@ def _emit_loose(node, prefix, add, entries, loaded, notice_for, generated: str) 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 _emit_related(node, prefix, add, entries, loaded, notice_for, chosen, generated: str) -> None: + for child in node.children: + if child.kind == "attachment" and child.id in chosen and child.id in loaded: + _emit_one(child, prefix + ["anlagen-arbeitsstand"], 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] + if not picked: + continue + folder = prefix + [_segment(child.title)] + for item in picked: + _emit_one(item, folder, 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, @@ -532,6 +695,7 @@ def _entry(node: ExportNode, path: str | None, links, notice: str | None) -> Ent notice, [], _recorded(node), + notes, ) @@ -650,6 +814,7 @@ def _fact_lines(entry: Entry, generated: str) -> list[str]: 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 @@ -726,7 +891,7 @@ def _is_folder(node: ExportNode) -> bool: def _included(node: ExportNode, chosen: set[str]) -> bool: if node.kind == "binding" and node.content_kind == "email": - return node.id in chosen + 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) diff --git a/backend/app/main.py b/backend/app/main.py index f748a18..f69218f 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -9,6 +9,7 @@ from fastapi import FastAPI, Request from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse +from app.api.correspondence import router as correspondence_router from app.api.export import router as export_router from app.api.routes import router from app.api.sources import router as sources_router @@ -117,6 +118,7 @@ def create_app() -> FastAPI: app.include_router(router) app.include_router(sources_router) app.include_router(export_router) + app.include_router(correspondence_router) return app diff --git a/backend/app/ops.py b/backend/app/ops.py index dc109fe..1f57328 100644 --- a/backend/app/ops.py +++ b/backend/app/ops.py @@ -1046,6 +1046,9 @@ def delete_element(conn, actor: UUID, element_id: UUID, expected: int, media_roo if element is None or element["owner_subject_id"] != actor: raise not_found() bump_version(conn, "elements", element_id, expected) + from app.correspondence import purge_element_dispatch_files + + delete_after.extend(purge_element_dispatch_files(conn, element_id, media_root)) asset = conn.execute("SELECT * FROM media_assets WHERE element_id = %s", (element_id,)).fetchone() conn.execute("DELETE FROM bindings WHERE element_id = %s", (element_id,)) conn.execute( @@ -1394,6 +1397,7 @@ def set_content_order( mode: str, direction: str, context: Ctx | None, + view: str | None = None, ) -> int: if kind == "case": container, rights = require_case(conn, actor, container_id, "edit") @@ -1404,10 +1408,16 @@ def set_content_order( if not rights.edit: raise forbidden() version = bump_version(conn, table, container_id, expected) - conn.execute( - f"UPDATE {table} SET content_order = %s, content_order_dir = %s WHERE id = %s", - (mode, direction, container_id), - ) + if view is None: + conn.execute( + f"UPDATE {table} SET content_order = %s, content_order_dir = %s WHERE id = %s", + (mode, direction, container_id), + ) + else: + conn.execute( + f"UPDATE {table} SET content_order = %s, content_order_dir = %s, content_view = %s WHERE id = %s", + (mode, direction, view, container_id), + ) audit(conn, actor, container["home_scope_id"], "content_order", kind, container_id, context) return version diff --git a/backend/app/present.py b/backend/app/present.py index 5b93321..8805422 100644 --- a/backend/app/present.py +++ b/backend/app/present.py @@ -338,8 +338,16 @@ def _ordered_bindings(conn, actor: UUID, kind: str, container_id: UUID, context: continue item["_raw_position"] = binding["position"] item["_document_on"] = item["element"]["dates"]["document_on"] + item["container"] = {"kind": kind, "id": str(container_id)} + item["_fold"] = binding.get("list_fold") visible.append(item) - return arrange(visible, mode or "position", direction or "asc") + arranged = arrange(visible, mode or "position", direction or "asc") + from app.correspondence import attach_correspondence + + attach_correspondence(conn, actor, arranged, context) + for item in arranged: + item.pop("_fold", None) + return arranged def course_items(bindings: list[dict]) -> list[dict]: @@ -575,6 +583,7 @@ def case_detail(conn, actor: UUID, case: dict, rights) -> dict: payload = case_summary(case, rights) payload["content_order"] = case.get("content_order") or "position" payload["content_order_dir"] = case.get("content_order_dir") or "asc" + payload["content_view"] = case.get("content_view") or "structure" payload["trail"] = case_trail(conn, actor, case) payload["kind_label"] = "Unterakte" if case["parent_case_id"] else "Akte" payload["home_scope_name"] = room_name(conn, case["home_scope_id"]) @@ -714,6 +723,7 @@ def matter_detail(conn, actor: UUID, matter: dict, rights, context: Ctx | None) "is_owner": matter["owner_subject_id"] == actor, "content_order": matter.get("content_order") or "position", "content_order_dir": matter.get("content_order_dir") or "asc", + "content_view": matter.get("content_view") or "structure", "trail": matter_trail(conn, actor, matter, context), "placements": matter_placements(conn, actor, matter["id"], context), "kind_label": "Teilvorgang" if matter["parent_matter_id"] else "Vorgang", diff --git a/backend/migrations/20261018T090000Z_correspondence.sql b/backend/migrations/20261018T090000Z_correspondence.sql new file mode 100644 index 0000000..bff96fe --- /dev/null +++ b/backend/migrations/20261018T090000Z_correspondence.sql @@ -0,0 +1,147 @@ +-- Anlagenverwendung, dokumentierter Versand und Arbeitsansicht. +-- Bestehende Kapitel, Einbindungen und Dateien bleiben unverändert. + +ALTER TABLE cases + ADD COLUMN content_view text NOT NULL DEFAULT 'structure'; + +ALTER TABLE cases + ADD CONSTRAINT cases_content_view + CHECK (content_view IN ('structure', 'chronology')); + +ALTER TABLE matters + ADD COLUMN content_view text NOT NULL DEFAULT 'structure'; + +ALTER TABLE matters + ADD CONSTRAINT matters_content_view + CHECK (content_view IN ('structure', 'chronology')); + +ALTER TABLE bindings + ADD COLUMN list_fold text; + +ALTER TABLE bindings + ADD CONSTRAINT bindings_list_fold + CHECK (list_fold IS NULL OR list_fold IN ('attachment', 'evidence')); + +CREATE TABLE attachment_uses ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + home_scope_id uuid NOT NULL REFERENCES data_rooms (id), + context_kind text NOT NULL, + context_id uuid NOT NULL, + host_element_id uuid NOT NULL REFERENCES elements (id) ON DELETE CASCADE, + attachment_element_id uuid NOT NULL REFERENCES elements (id) ON DELETE CASCADE, + position integer NOT NULL, + label text, + created_by uuid NOT NULL REFERENCES auth_accounts (id), + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT attachment_uses_kind CHECK (context_kind IN ('case', 'matter')), + CONSTRAINT attachment_uses_not_self CHECK (host_element_id <> attachment_element_id), + CONSTRAINT attachment_uses_position CHECK (position >= 0), + CONSTRAINT attachment_uses_label CHECK (label IS NULL OR char_length(label) BETWEEN 1 AND 200), + CONSTRAINT attachment_uses_once UNIQUE (context_kind, context_id, host_element_id, attachment_element_id) +); + +CREATE INDEX attachment_uses_host + ON attachment_uses (context_kind, context_id, host_element_id, position); + +CREATE TABLE dispatches ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + home_scope_id uuid NOT NULL REFERENCES data_rooms (id), + context_kind text NOT NULL, + context_id uuid NOT NULL, + host_element_id uuid NOT NULL REFERENCES elements (id) ON DELETE CASCADE, + channel text NOT NULL, + sent_on date, + counterpart text, + completeness text NOT NULL, + provenance text NOT NULL, + recorded_by uuid NOT NULL REFERENCES auth_accounts (id), + recorded_at timestamptz NOT NULL DEFAULT now(), + version integer NOT NULL DEFAULT 1, + created_at timestamptz NOT NULL DEFAULT now(), + updated_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT dispatches_kind CHECK (context_kind IN ('case', 'matter')), + CONSTRAINT dispatches_channel CHECK (channel IN ('email', 'post', 'other')), + CONSTRAINT dispatches_completeness CHECK (completeness IN ('secured', 'partial', 'gap')), + CONSTRAINT dispatches_provenance CHECK (provenance IN ('captured', 'reconstructed')), + CONSTRAINT dispatches_counterpart CHECK (counterpart IS NULL OR char_length(counterpart) BETWEEN 1 AND 200), + CONSTRAINT dispatches_version CHECK (version >= 1) +); + +CREATE INDEX dispatches_host + ON dispatches (context_kind, context_id, host_element_id, recorded_at); + +CREATE TABLE dispatch_items ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + dispatch_id uuid NOT NULL REFERENCES dispatches (id) ON DELETE CASCADE, + role text NOT NULL, + position integer NOT NULL, + element_id uuid NOT NULL REFERENCES elements (id) ON DELETE CASCADE, + title text NOT NULL, + document_on date, + filename text, + content_type text, + byte_size bigint, + content_sha256 text, + source_state text NOT NULL, + gap_reason text, + note_document jsonb, + external_source text, + external_id text, + CONSTRAINT dispatch_items_role CHECK (role IN ('host', 'attachment')), + CONSTRAINT dispatch_items_position CHECK (position >= 0), + CONSTRAINT dispatch_items_state CHECK (source_state IN ('snapshot', 'gap')), + CONSTRAINT dispatch_items_once UNIQUE (dispatch_id, element_id) +); + +CREATE INDEX dispatch_items_dispatch ON dispatch_items (dispatch_id, position); + +CREATE TABLE dispatch_snapshots ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + dispatch_item_id uuid UNIQUE REFERENCES dispatch_items (id) ON DELETE CASCADE, + evidence_id uuid, + home_scope_id uuid NOT NULL REFERENCES data_rooms (id), + owner_subject_id uuid NOT NULL REFERENCES auth_accounts (id), + original_filename text NOT NULL, + content_type text NOT NULL, + byte_size bigint NOT NULL, + sha256 text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT dispatch_snapshots_filename CHECK (char_length(original_filename) BETWEEN 1 AND 240), + CONSTRAINT dispatch_snapshots_target CHECK ( + (dispatch_item_id IS NOT NULL AND evidence_id IS NULL) + OR (dispatch_item_id IS NULL AND evidence_id IS NOT NULL) + ) +); + +CREATE TABLE dispatch_evidence ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + dispatch_id uuid NOT NULL REFERENCES dispatches (id) ON DELETE CASCADE, + element_id uuid NOT NULL REFERENCES elements (id) ON DELETE CASCADE, + role text NOT NULL, + source_state text NOT NULL, + gap_reason text, + message_id text, + identity_sha256 text, + comparisons jsonb NOT NULL DEFAULT '[]'::jsonb, + manual boolean NOT NULL DEFAULT true, + created_by uuid NOT NULL REFERENCES auth_accounts (id), + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT dispatch_evidence_role CHECK (role IN ('email', 'submission', 'delivery', 'other')), + CONSTRAINT dispatch_evidence_state CHECK (source_state IN ('identified', 'gap')), + CONSTRAINT dispatch_evidence_once UNIQUE (dispatch_id, element_id) +); + +ALTER TABLE dispatch_snapshots + ADD CONSTRAINT dispatch_snapshots_evidence_fk + FOREIGN KEY (evidence_id) REFERENCES dispatch_evidence (id) ON DELETE CASCADE; + +CREATE TABLE dispatch_corrections ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + dispatch_id uuid NOT NULL REFERENCES dispatches (id) ON DELETE CASCADE, + corrected_at timestamptz NOT NULL DEFAULT now(), + corrected_by uuid NOT NULL REFERENCES auth_accounts (id), + summary text NOT NULL, + CONSTRAINT dispatch_corrections_summary CHECK (char_length(summary) BETWEEN 1 AND 500) +); + +CREATE INDEX dispatch_corrections_dispatch ON dispatch_corrections (dispatch_id, corrected_at); diff --git a/backend/tests/test_correspondence.py b/backend/tests/test_correspondence.py new file mode 100644 index 0000000..a7ea527 --- /dev/null +++ b/backend/tests/test_correspondence.py @@ -0,0 +1,620 @@ +"""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( + "", + "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": "", + "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" + 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"} + 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, + ) diff --git a/docs/architecture/API_REFERENZ.md b/docs/architecture/API_REFERENZ.md new file mode 100644 index 0000000..dbc7c10 --- /dev/null +++ b/docs/architecture/API_REFERENZ.md @@ -0,0 +1,195 @@ +# Tsumugu – API-Referenz (Ist-Stand) + +**Stand:** 18.10.2026. Erstellt im Code-Review aus `backend/app/main.py`, `api/routes.py`, `api/sources.py`, `api/export.py` und `api/correspondence.py`. + +Diese Datei beschreibt die tatsächlich registrierten Endpunkte. Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 6.2](TSUMUGU_TECHNICAL_SPEC.md). OpenAPI ist in allen Umgebungen abgeschaltet (`docs_url=None`, `openapi_url=None`). Diese Datei ist deshalb die einzige Übersicht. Sie wird bei jeder Routenänderung mitgepflegt. + +## Gemeinsame Regeln + +| Thema | Regel im Code | +|---|---| +| Sitzung | Cookie `__Host-jinkendo-session` (Produktion, HTTPS) bzw. `jinkendo-session` (Development über HTTP). Gültigkeit `SESSION_TTL_HOURS`, Default 336 h | +| Schreibschutz | Alle Methoden außer GET/HEAD/OPTIONS unter `/api/` verlangen einen `Origin` aus `ALLOWED_ORIGINS` (Middleware) und den Header `X-CSRF-Token` der Session | +| Datenraum | Fachrouten verlangen `X-Scope-Kind` (`personal` oder `organization`) und `X-Scope-Id`. Beide müssen mit dem in der Session bestätigten Raum übereinstimmen, die Mitgliedschaft wird je Request geprüft | +| Handlungskontext | Lesend als Query `context_kind` und `context_id` (`case`/`matter` + UUID), schreibend als `context: {kind, id}` im JSON. Ohne Kontext gelten nur Owner und direkte Grants | +| Eingaben | JSON ohne unbekannte Felder (`extra="forbid"`); Upload als Multipart | +| Fehler | `application/problem+json` mit `type`, `title`, `status`, `detail`, `instance`, `code`. 401 keine Session, 403 fehlendes Recht bei sichtbarem Objekt, 404 unsichtbar oder nicht vorhanden, 409 Versionskonflikt, 422 ungültige Eingabe, 429 Login-Begrenzung, 503 Speicher nicht verfügbar | +| Versionen | Ändernde Aufrufe tragen `expected_version` des geänderten Ankers (Akte, Vorgang, Element, Aufgabe, Frist). Kapitel- und Ordnungsänderungen erhöhen die Version des Behälters | +| Listen | Antwort `{items, next_cursor}`. `next_cursor` ist außer in der Chronologie immer `null` | + +Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R** Session und Datenraum-Header, **B** Betreiber (`is_superadmin`), **M** Verwalter des Raums. Alle Tabellen ohne Spalte „Auth“ verlangen **S+R**; die Objektrechte prüft danach die Rechteauswertung ([RECHTEMODELL_IST.md](RECHTEMODELL_IST.md)). + +## Betrieb + +| Methode | Pfad | Auth | Zweck | +|---|---|---|---| +| GET | `/api/health` | – | `{status, app}`; 503 bei DB-Fehler | +| GET | `/health/live` | – | Prozess lebt | +| GET | `/health/ready` | – | DB antwortet | + +## Anmeldung, Session, Konten + +| Methode | Pfad | Auth | Zweck | +|---|---|---|---| +| POST | `/api/v1/auth/login` | – | E-Mail, Passwort → Session-Sicht und Cookie. 8 Versuche je IP+E-Mail in 10 min (Prozessspeicher) | +| POST | `/api/v1/auth/logout` | S | Session widerrufen, Cookie löschen, 204 | +| GET | `/api/v1/auth/session` | S | Konto, bestätigter Datenraum, Räume, CSRF-Token, Epoche | +| POST | `/api/v1/auth/session/scope` | S | Datenraum wechseln (`kind`, `id`); erhöht die Epoche | +| GET | `/api/v1/auth/bootstrap` | – | `{available: true}`, solange kein Betreiber existiert, sonst 404 | +| POST | `/api/v1/auth/bootstrap` | – | erstes Konto als Betreiber anlegen, nur ohne vorhandenen Betreiber | +| GET | `/api/v1/auth/demo` | – | Beispielkonten; nur Development mit Datenbank `*_test` und `SEED_DEMO=true`, sonst 404 | +| GET | `/api/v1/accounts` | S+R, B | aktive Betreiberkonten (`origin='operator'`) | +| POST | `/api/v1/accounts` | S+R, B | Konto mit Passwort anlegen, erhält persönlichen Raum | +| GET | `/api/v1/principals?email=` | S+R | aktives Konto per E-Mail auflösen (ID, Anzeigename) | +| POST | `/api/v1/invitations` | S+R, M | Einladung in einen gemeinsamen Raum; Antwort enthält das Token einmalig. Keine Oberfläche | +| POST | `/api/v1/invitations/{id}/accept` | – | Token, Anzeigename, Passwort → Konto, Mitgliedschaft, Session | + +## Datenräume + +| Methode | Pfad | Auth | Zweck | +|---|---|---|---| +| GET | `/api/v1/rooms` | S+R | wählbare Räume | +| POST | `/api/v1/rooms` | S+R | gemeinsamen Raum anlegen, Anlegende Person wird Verwalter | +| GET | `/api/v1/rooms/{id}/members` | S+R, M | Mitglieder | +| POST | `/api/v1/rooms/{id}/members` | S+R, M | bestehendes Konto als `member` oder `manager` aufnehmen | +| DELETE | `/api/v1/rooms/{id}/members/{subject_id}` | S+R, M | Mitgliedschaft beenden; letzter Verwalter bleibt. Keine Oberfläche | + +## Akten + +| Methode | Pfad | Zweck | +|---|---|---| +| GET | `/api/v1/cases` | lesbare Akten und Unterakten | +| POST | `/api/v1/cases` | Akte anlegen (`title`, optional `parent_case_id`, `rights_mode`, `home_scope_id`) | +| GET | `/api/v1/cases/{id}` | Akte mit Trail, Kapiteln, Unterakten, Vorgangsbaum, direkten Einbindungen, `contained` (Inhalte zugeordneter Vorgänge), Aufgaben, Fristen, Grants (für Freigebende) | +| PATCH | `/api/v1/cases/{id}` | Titel, Status `open`/`closed` | +| POST | `/api/v1/cases/{id}/delete` | Akte löschen (`deleted_at`); nur ohne Unterakten und Vorgangszuordnungen. Verlangt `edit` (siehe Review R-01) | +| POST | `/api/v1/cases/{id}/grants` | Grant per E-Mail (`can_read`, `can_edit`, `can_share`) | +| POST | `/api/v1/cases/{id}/chapters` | Kapitel anlegen, optional `parent_chapter_id`, `document_on` | +| POST | `/api/v1/cases/{id}/chapters/order` | Geschwisterreihenfolge | +| PATCH | `/api/v1/cases/{id}/content-order` | Ordnungsart `date`/`position`, Richtung | +| POST | `/api/v1/cases/{id}/bindings/order` | eigene Reihenfolge der sichtbaren Einbindungen | +| POST | `/api/v1/cases/{id}/bindings/chapters` | mehrere Einbindungen in ein Kapitel | +| GET | `/api/v1/cases/{id}/course` | fachlicher Verlauf | +| GET | `/api/v1/cases/{id}/chronology?cursor=` | Änderungsprotokoll, 40 Einträge je Seite | + +## Vorgänge + +| Methode | Pfad | Zweck | +|---|---|---| +| GET | `/api/v1/matters` | lesbare Vorgänge mit lesbaren Kontexten | +| POST | `/api/v1/matters` | Vorgang oder Teilvorgang (`parent_matter_id`, `context`) | +| GET | `/api/v1/matters/{id}` | Vorgang mit Trail, Zuordnungen (`placements`, `case_links`), Teilvorgängen, Querverweisen, Einbindungen, Aufgaben, Fristen | +| PATCH | `/api/v1/matters/{id}` | Titel, Status | +| POST | `/api/v1/matters/{id}/delete` | Vorgang löschen; nur ohne Teilvorgänge. Verlangt `edit` (Review R-01) | +| POST | `/api/v1/matters/{id}/move` | Akte wechseln (`case_id`), Elternvorgang setzen oder lösen | +| POST | `/api/v1/matters/{id}/case-links` | Akte zuordnen; Freigaberecht am Vorgang und Bearbeitungsrecht an der Akte | +| DELETE | `/api/v1/matter-case-links/{id}` | Zuordnung lösen | +| POST | `/api/v1/matters/{id}/cross-links` | Querverweis (`target_matter_id`, `target_context`) | +| DELETE | `/api/v1/matter-cross-links/{id}` | Querverweis lösen | +| POST | `/api/v1/matters/{id}/grants` | Grant am Vorgang | +| POST | `/api/v1/matters/{id}/chapters` | Kapitel (Kontext als Query) | +| POST | `/api/v1/matters/{id}/chapters/order` | Geschwisterreihenfolge | +| PATCH | `/api/v1/matters/{id}/content-order` | Ordnungsart | +| POST | `/api/v1/matters/{id}/bindings/order` | eigene Reihenfolge | +| POST | `/api/v1/matters/{id}/bindings/chapters` | mehrere Einbindungen in ein Kapitel | +| GET | `/api/v1/matters/{id}/course` | fachlicher Verlauf | +| GET | `/api/v1/matters/{id}/chronology?cursor=` | Änderungsprotokoll | + +## Kapitel + +| Methode | Pfad | Zweck | +|---|---|---| +| PATCH | `/api/v1/chapters/{id}` | Kapiteldatum | +| PATCH | `/api/v1/chapters/{id}/title` | umbenennen | +| POST | `/api/v1/chapters/{id}/parent` | umhängen, `parent_chapter_id: null` = oberste Ebene | +| POST | `/api/v1/chapters/{id}/delete` | auflösen; Inhalte und Kinder rücken eine Ebene nach oben | + +## Inhalte und Einbindungen + +| Methode | Pfad | Zweck | +|---|---|---| +| POST | `/api/v1/notes` | Notiz mit Einbindung (`context`, optional `placement`, `chapter_id`, `dates`, `communication_direction`) | +| PATCH | `/api/v1/notes/{id}` | gemeinsamen Text ändern; Antwort mit `visible_bindings` und `notice` | +| POST | `/api/v1/files` | Datei hochladen (Multipart: `title`, `context_kind`, `context_id`, `upload`, optional Platzierung, Kapitel, Daten, Richtung); PDF, PNG, JPEG, WebP bis 20 MiB | +| GET | `/api/v1/files/{id}/content` | Datei als `attachment`, `no-store` | +| POST | `/api/v1/external-refs` | externe Referenz (`paperless`, `imap`, `url`) mit `detail` | +| POST | `/api/v1/sources/link` | wie oben, nur `paperless`/`imap` (doppelter Weg, siehe Connectoren-Befund) | +| GET | `/api/v1/elements` | eigene, nicht eingebundene Elemente (max. 100) | +| POST | `/api/v1/elements/{id}/delete` | überall löschen; nur Element-Owner | +| PATCH | `/api/v1/elements/{id}/title` | Titel | +| PATCH | `/api/v1/elements/{id}/summary` | Kurzbeschreibung (≤ 400 Zeichen) | +| PATCH | `/api/v1/elements/{id}/dates` | Dokument-, Versand-, Zugangsdatum | +| POST | `/api/v1/elements/{id}/references` | Bezug auf eine andere Unterlage (zyklusfrei) | +| DELETE | `/api/v1/elements/{id}/references/{target}` | Bezug lösen | +| POST | `/api/v1/bindings` | Element in weiteren Kontext einbinden (`share` an der Quelle, `edit` am Ziel) | +| DELETE | `/api/v1/bindings/{id}` | Einbindung lösen | +| PATCH | `/api/v1/bindings/{id}/chapter` | Kapitel einer Einbindung | +| PATCH | `/api/v1/bindings/{id}/communication` | Richtung `in`/`out`/`local`/`null` | +| POST | `/api/v1/bindings/{id}/annotations` | kontextbezogene Anmerkung | +| PUT | `/api/v1/exceptions` | Kontextausnahme am Element, Vorgang, Aufgabe oder Frist setzen bzw. löschen; nur Owner | +| DELETE | `/api/v1/grants/{id}` | Grant entziehen | + +## Aufgaben, Fristen, Übersichten, Suche + +| Methode | Pfad | Zweck | +|---|---|---| +| POST | `/api/v1/tasks` | Aufgabe, optional mit Vorgang und Kontext | +| PATCH | `/api/v1/tasks/{id}` | Titel, Arbeitstermin, Status `open`/`done` | +| POST | `/api/v1/tasks/{id}/assignee` | zuweisen (E-Mail) oder lösen; legt begrenztes Grant an. Keine Oberfläche | +| POST | `/api/v1/tasks/{id}/deadline-links` | Frist verknüpfen | +| PUT | `/api/v1/tasks/{id}/elements` | verknüpfte Inhalte ersetzen (max. 40) | +| POST | `/api/v1/tasks/{id}/dependencies` | Abhängigkeit von anderer Aufgabe (zyklusfrei) | +| DELETE | `/api/v1/tasks/{id}/dependencies/{other}` | Abhängigkeit lösen | +| POST | `/api/v1/deadlines` | Frist | +| PATCH | `/api/v1/deadlines/{id}` | Titel, Datum | +| POST | `/api/v1/deadlines/{id}/fulfill` | als erfüllt kennzeichnen | +| GET | `/api/v1/views/open-tasks` | offene sichtbare Aufgaben (siehe Review R-11) | +| GET | `/api/v1/views/open-deadlines` | offene sichtbare Fristen (siehe Review R-11) | +| GET | `/api/v1/views/recent-matters` | acht zuletzt geänderte sichtbare Vorgänge | +| GET | `/api/v1/placement-targets` | bearbeitbare Akten und Vorgänge als Ziele | +| GET | `/api/v1/search?q=` | Akten, Vorgänge, Elemente (Titel und Notiztext), max. 50 | + +## Quellen + +| Methode | Pfad | Zweck | +|---|---|---| +| GET | `/api/v1/connectors` | eigene Zugänge ohne Secret | +| POST | `/api/v1/connectors` | Paperless (überschreibt den vorhandenen) oder IMAP anlegen | +| DELETE | `/api/v1/connectors/{id}` | Zugang löschen | +| POST | `/api/v1/connectors/{id}/probe` | Zugang prüfen | +| GET | `/api/v1/sources/paperless/documents?q=` | Paperless-Suche (letzter eigener Zugang) | +| GET | `/api/v1/sources/imap/mailboxes?connector_id=` | IMAP-Fächer | +| GET | `/api/v1/sources/imap/messages?connector_id=&mailbox=&q=&before=` | Nachrichtenliste, 30 je Seite | +| GET | `/api/v1/sources/imap/message?connector_id=&mailbox=&uid=` | Vorschau vor dem Übernehmen | +| GET | `/api/v1/external-refs/{id}/content` | Paperless-Datei zum Ansehen (`inline`) | +| GET | `/api/v1/external-refs/{id}/mail` | vollständige E-Mail als JSON, Identität per Message-ID geprüft | +| GET | `/api/v1/external-refs/{id}/mail/original` | EML | +| GET | `/api/v1/external-refs/{id}/mail/attachments/{index}` | Anlage (`inline`, siehe Review R-03) | + +Quelleninhalte werden mit den Zugängen der **anfragenden** Person geladen (Review R-10). + +## Übergabepaket + +| Methode | Pfad | Zweck | +|---|---|---| +| GET | `/api/v1/matters/{id}/export-tree` | Auswahlbaum mit `exportable` und Grund | +| POST | `/api/v1/matters/{id}/export/review` | Prüfung: `ready`, `issues`, `notices`, `entries` mit Paketpfaden | +| POST | `/api/v1/matters/{id}/export` | ZIP nur bei `ready`; Audit `export_created`. Knoten `attachment`, `dispatch-item` und `evidence` gehören zur Auswahl | + +## Anlagen und Versand + +Alle schreibenden Aufrufe prüfen den Handlungskontext, `expected_version` und den Behälter (`placement`, sonst der Kontext). Fremde oder unlesbare IDs antworten mit 404. Ohne Bearbeitungsrecht mit 403. + +| Methode | Pfad | Zweck | +|---|---|---| +| POST | `/api/v1/elements/{id}/attachments` | Anlagen zuordnen, optional nur als Anlagenansicht | +| POST | `/api/v1/elements/{id}/attachments/order` | Reihenfolge | +| POST | `/api/v1/elements/{id}/attachments/{attachment_id}/detach` | nur diese Zuordnung lösen | +| PATCH | `/api/v1/bindings/{id}/fold` | Vorkommen als Anlage, Nachweis oder wieder eigenständig | +| POST | `/api/v1/elements/{id}/dispatches` | Versand dokumentieren und Fassung sichern oder als Lücke kennzeichnen | +| POST | `/api/v1/dispatches/{id}/evidence` | Nachweis ergänzen | +| POST | `/api/v1/dispatches/{id}/correct` | Weg, Datum oder Gegenüber berichtigen | +| GET | `/api/v1/dispatches/{id}` | Manifest, Nachweise, Berichtigungen | +| GET | `/api/v1/dispatches/{id}/items/{item_id}/content` | gesicherte Bytes; eine Lücke liefert 404 und nicht die aktuelle Datei | + +Eingabe für beide POST-Aufrufe: `{context, selected: [Knoten-IDs], assignments: {Knoten-ID: connector_id}}`. diff --git a/docs/architecture/DATENMODELL_IST.md b/docs/architecture/DATENMODELL_IST.md new file mode 100644 index 0000000..31ec7f8 --- /dev/null +++ b/docs/architecture/DATENMODELL_IST.md @@ -0,0 +1,114 @@ +# Tsumugu – Datenmodell (Ist-Stand) + +**Stand:** 18.10.2026, nach den Migrationen in `backend/migrations/` (letzte: `20261018T090000Z_correspondence.sql`). Erstellt im Code-Review. + +Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TECHNICAL_SPEC.md). Diese Datei beschreibt, was tatsächlich angelegt ist. Bei jeder neuen Migration nachziehen. + +## Migrationsverfahren + +- Dateien `YYYYMMDDTHHMMSSZ_name.sql`, lexikalisch sortiert. +- Ledger `schema_migrations(version, checksum, applied_at)`; eine geänderte angewandte Datei bricht den Start ab. +- Jede Datei läuft mit ihrem Ledger-Eintrag in einer Transaktion. +- Danach legt `migrate` die Rolle `tsumugu_runtime` an bzw. aktualisiert sie: `LOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT`, DML auf alle Tabellen, kein `CREATE` im Schema, kein Zugriff auf `schema_migrations`. Das Passwort ist das des Owners (siehe Review R-09). +- Aufruf beim Containerstart (`app.entrypoint`) und über `python -m app.cli migrate`. + +## Identität und Räume + +| Tabelle | Wesentliche Spalten | Regeln | +|---|---|---| +| `auth_accounts` | `id`, `email` (unique), `display_name`, `password_hash` (bcrypt), `status` (`active`/`disabled`), `is_superadmin`, `origin` (`operator`/`fixture`) | Konten mit `origin='fixture'` entfernt der Start in jeder Umgebung | +| `auth_sessions` | `id`, `account_id`, `secret_hash` (SHA-256, unique), `csrf_token`, `scope_kind`, `scope_id`, `epoch`, `expires_at`, `revoked_at` | der bestätigte Datenraum steht in der Session | +| `auth_invitations` | `email`, `room_id`, `token_hash`, `invited_by`, `expires_at`, `accepted_at` | 7 Tage gültig | +| `data_rooms` | `id`, `kind` (`personal`/`organization`), `name`, `status` (`active`/`archived`), `created_by` | persönlicher Raum: `id = account_id` | +| `room_memberships` | PK (`room_id`, `subject_id`), `role` (`member`/`manager`), `status` (`active`/`removed`) | – | + +## Struktur + +| Tabelle | Wesentliche Spalten | Regeln | +|---|---|---| +| `cases` | Anker¹, `title`, `parent_case_id`, `rights_mode` (`inherit_parent`/`explicit`), `record_status` (`open`/`closed`), `content_order` (`date`/`position`), `content_order_dir`, `content_view` (`structure`/`chronology`) | Wurzelakte immer `explicit`; Composite-FK (`parent_case_id`, `home_scope_id`); Anwendung erlaubt eine Unteraktenebene. `content_view` ist nur die Arbeitsansicht | +| `matters` | Anker¹, `title`, `parent_matter_id`, `record_status`, `content_order`, `content_order_dir`, `content_view` | Composite-FK für den Elternvorgang im selben Raum; Anwendung erlaubt beim Anlegen eine Teilvorgangsebene | +| `matter_case_links` | `matter_id`, `case_id`, `created_by` | unique (`matter_id`, `case_id`); Vererbungskontext | +| `case_link_blocks` | PK (`link_id`, `element_id`) | Inhalte, die die zuordnende Person nicht freigeben durfte; im Aktenkontext unsichtbar. Kaskade beim Lösen der Zuordnung | +| `matter_cross_links` | `from_matter_id`, `to_matter_id` | kein Selbstverweis, unique | +| `chapters` | `home_scope_id`, genau eines von `case_id`/`matter_id`, `title`, `position`, `document_on`, `parent_chapter_id` | Composite-FKs zum Behälter; Trigger `chapters_parent_guard`: gleiches Objekt, gleicher Raum, kein Zyklus, höchstens 32 Ebenen | + +¹ Anker: `id`, `home_scope_id`, `owner_subject_id`, `created_by`, `version`, `created_at`, `updated_at`, `deleted_at`. + +## Inhalte + +| Tabelle | Wesentliche Spalten | Regeln | +|---|---|---| +| `elements` | Anker¹, `title`, `kind` (`note`/`file`/`external_ref`), `summary` (≤ 400) | gemeinsamer Inhaltsträger | +| `note_bodies` | `element_id`, `document_json`, `version` | ein Text je Notiz; Format `{version: 1, blocks: [...]}` mit Absatz- oder einem Markdown-Block | +| `correspondence_dates` | `element_id`, `document_on`, `sent_on`, `received_on` | getrennte Datumssachen; Erfassung = `elements.created_at` | +| `external_references` | `element_id`, `source` (`paperless`/`url`/`imap`), `external_id`, `detail` (JSON) | IMAP: Message-ID als `external_id`, `connector_id`, `mailbox`, `uid` im JSON; kein Eindeutigkeitsindex | +| `bindings` | `element_id`, `context_kind` (`case`/`matter`), `context_id`, `chapter_id`, `position`, `communication_direction` (`in`/`out`/`local`/NULL), `direction_explicit`, `list_fold` (`attachment`/`evidence`/NULL) | unique (`element_id`, `context_kind`, `context_id`); kein FK auf den Kontext (polymorph). `list_fold` gilt nur für dieses Vorkommen | +| `attachment_uses` | Behälter, `host_element_id`, `attachment_element_id`, `position`, optionales `label` | flache Zuordnung je Hauptschriftstück und Behälter; keine Dateikopie; kein Selbstbezug | +| `dispatches` | Behälter, `host_element_id`, `channel`, `sent_on`, `counterpart`, `completeness`, `provenance`, `version` | mehrere Versände je Schreiben; `sent_on` leer bleibt undatiert | +| `dispatch_items` | Rolle `host`/`attachment`, Titel, Dokumentdatum, `source_state` `snapshot`/`gap`, Hash, optionales Notiz-JSON | Manifest der übermittelten Fassung; Lücke ersetzt nicht die Arbeitsdatei | +| `dispatch_snapshots` | Bytes, Hash, Dateiname | Datei unter `MEDIA_ROOT/dispatch/`; fällt in den Löschpfad des Elements | +| `dispatch_evidence` | `element_id`, Rolle `email`/`submission`/`delivery`/`other`, Identitätsprüfung, `comparisons` | manuelle Zuordnung; Einlieferung ist keine Zustellung | +| `dispatch_corrections` | Zeitpunkt, Zusammenfassung | Berichtigung ohne stilles Umschreiben der Bytes | +| `context_annotations` | `binding_id`, `body` (≤ 4 000), `author_subject_id` | Kaskade mit der Einbindung | +| `element_references` | PK (`element_id`, `refers_to_element_id`) | kein Selbstbezug; Zyklusprüfung in der Anwendung; FK-Kaskade greift nur bei physischem Löschen, Elemente werden aber nur markiert (Review R-13) | +| `media_assets` | `id`, `element_id` (unique), Owner, Heimatraum, `original_filename`, `content_type`, `byte_size`, `sha256`, `revision`, `status` (`active`/`purging`/`purged`) | Bytes unter `MEDIA_ROOT/` | +| `media_operations` | `element_id`, `asset_id`, `phase`, `status` | derzeit reines Protokoll | + +## Rechte + +| Tabelle | Wesentliche Spalten | Regeln | +|---|---|---| +| `access_grants` | `grantee_subject_id` (NULL bei Kontextausnahme), `resource_kind` (`case`/`matter`/`element`/`task`/`deadline`), `resource_id`, `context_kind`/`context_id`, `can_read/edit/share/delete`, `is_exception` | Grant: `is_exception=false`, ohne Kontext. Ausnahme: `is_exception=true`, Kontext gesetzt, die Flags bedeuten „entfernt“. Eindeutigkeitsindex über Ressource, Empfänger, Kontext und Art | + +## Nachverfolgung + +| Tabelle | Wesentliche Spalten | Regeln | +|---|---|---| +| `tasks` | Anker¹, `title`, `matter_id`, `assignee_subject_id`, `due_on`, `task_status` (`open`/`done`) | ohne Vorgang ist die Aufgabe selbst der Rechteanker | +| `deadlines` | Anker¹, `title`, `matter_id`, `element_id` (ungenutzt), `assignee_subject_id`, `due_on`, `deadline_status` (`open`/`fulfilled`), `fulfilled_at` | – | +| `task_deadline_links` | PK (`task_id`, `deadline_id`) | keine Statuskopplung | +| `task_element_links` | PK (`task_id`, `element_id`) | nicht in der Spezifikation | +| `task_dependencies` | PK (`task_id`, `depends_on_task_id`) | kein Selbstbezug, Zyklusprüfung in der Anwendung; nicht in der Spezifikation | + +## Quellen und Audit + +| Tabelle | Wesentliche Spalten | Regeln | +|---|---|---| +| `connectors` | `owner_id`, `kind` (`paperless`/`imap`), `name`, `settings` (JSON), `secret` (Klartext, Review R-05) | Paperless höchstens einmal je Konto (in der Anwendung) | +| `domain_events` | `actor_subject_id`, `scope_id`, `action`, `resource_kind`, `resource_id`, `context_kind/id`, `occurred_on`, `occurred_at`, `result` | append-only; Grundlage von Chronologie und fachlichem Verlauf | + +## Nicht angelegt (bewusst) + +`compilations`, `release_state`, Finanztabellen (`invoices`, `payments`, …), `external_field_states`, `retain_until`, Auth-Tabellen für Flows, MFA, Recovery-Codes und Rate-Limits. Sie gehören zu späteren Paketen bzw. zu offenen Befunden. + +## Beziehungen + +```mermaid +erDiagram + auth_accounts ||--|| data_rooms : "persoenlicher Raum" + auth_accounts }o--o{ data_rooms : "room_memberships" + data_rooms ||--o{ cases : "Heimat" + data_rooms ||--o{ matters : "Heimat" + data_rooms ||--o{ elements : "Heimat" + cases ||--o{ cases : "Unterakte" + matters ||--o{ matters : "Teilvorgang" + matters }o--o{ cases : "matter_case_links" + matters }o--o{ matters : "matter_cross_links" + cases ||--o{ chapters : "Gliederung" + matters ||--o{ chapters : "Gliederung" + chapters ||--o{ chapters : "Unterkapitel" + elements ||--o{ bindings : "Einbindung" + bindings ||--o{ context_annotations : "Anmerkung" + elements ||--o| note_bodies : "Text" + elements ||--o| correspondence_dates : "Daten" + elements ||--o| external_references : "Referenz" + elements ||--o| media_assets : "Datei" + elements }o--o{ elements : "element_references" + matters ||--o{ tasks : "optional" + matters ||--o{ deadlines : "optional" + tasks }o--o{ deadlines : "task_deadline_links" + tasks }o--o{ elements : "task_element_links" + tasks }o--o{ tasks : "task_dependencies" + auth_accounts ||--o{ connectors : "Zugang" +``` diff --git a/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md b/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md index 9606f46..ff24d4b 100644 --- a/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md +++ b/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md @@ -6,6 +6,10 @@ **Technische Grundlagen:** Jinkendo-Referenzarchitektur A/B/C v0.3 vom 16.10.2026 sowie die Blueprints Auth/Session/Scope, Release/Betrieb/Recovery und Medien/Dateien. KI-Gateway, Prompt-/Workflow-Laufzeit und Entitlements gelten nur als Grenze, nicht als MVP-Pflicht. +### Hinweis zum Ist-Stand (Code-Review 18.10.2026) + +Diese Fassung ist der Entwurf vom 16.10.2026 mit späteren punktuellen Ergänzungen (Ordnung, Richtung, Unterkapitel). Abschnitt 1.3 („keine Fachanwendung“) und der Satz in Abschnitt 8, der erste Auftrag solle nur P0 umfassen, beschreiben den damaligen Ausgangspunkt. Die Anwendung umfasst inzwischen P0–P3, P4a und P5a sowie die Folgeaufträge F-06 bis F-08. P7 fehlt. Den tatsächlichen Stand beschreiben [API_REFERENZ.md](API_REFERENZ.md), [DATENMODELL_IST.md](DATENMODELL_IST.md) und [RECHTEMODELL_IST.md](RECHTEMODELL_IST.md). Abweichungen zwischen dieser Spezifikation und dem Code stehen im [Code-Review](../review/04_TECHNISCHE_SPEZIFIKATION.md). + ### Änderungsnotiz 0.3 F-05a bestätigt die erste benutzbare Lieferung „Organisieren und Nachverfolgen“. Finanzfunktionen und bidirektionaler Paperless-Abgleich folgen anschließend, ohne gestrichen zu werden. Die zuvor kombinierten Pakete P4 und P5 sind dafür in unabhängig lieferbare Teile aufgeteilt; P7 sichert schon den ersten echten Betrieb ab. Die technische Präzisierung des Akten-Handlungskontexts ist in Abschnitt 6.2 ergänzt. Diese Angleichung ist keine pauschale Freigabe der offenen Rechte-/Löschvorschläge und kein Implementierungsauftrag. @@ -217,7 +221,9 @@ Gemeinsame Spalten der fachlichen Ankerobjekte `cases`, `matters`, `elements`, ` Auth-Tabellen `auth_accounts` und `auth_sessions` folgen dem Auth-Blueprint. Ein Anzeigename ist kein Identitätsbeweis. -Akten und Vorgänge speichern `content_order` (`date` oder `position`) und `content_order_dir` (`asc` oder `desc`). Bestehende Zeilen bleiben auf `position`, damit eine schon gesetzte Einbindungsreihenfolge nicht ersetzt wird. Neue Akten und Vorgänge beginnen mit fachlichem Datum aufsteigend. `bindings.position` gehört zur Einbindung. Die Datumssortierung schreibt sie nicht um. `PATCH /api/v1/cases/{id}/content-order` und `POST /api/v1/cases/{id}/bindings/order` sowie die gleichen Pfade unter `matters` prüfen das Bearbeitungsrecht im Handlungskontext und `expected_version`. Der fachliche Verlauf liest die Datumsfelder der sichtbaren Unterlagen einmal je Element. Das Änderungsprotokoll bleibt `GET .../chronology`, seitenweise über `cursor`. Der Breadcrumb eines Vorgangs ist der Objektpfad `Vorgänge` und gegebenenfalls der lesbare Elternvorgang; lesbare Aktenzuordnungen stehen separat in `placements` und wechseln den Handlungskontext nur bei bewusster Auswahl. `elements.summary` ist eine optionale gemeinsame Kurzbeschreibung. Ein Textauszug entsteht nur aus vorhandenem Notiztext. Bild- und PDF-Vorschauen verwenden denselben berechtigten Dateiabruf wie das Öffnen. +Akten und Vorgänge speichern `content_order` (`date` oder `position`) und `content_order_dir` (`asc` oder `desc`). Bestehende Zeilen bleiben auf `position`, damit eine schon gesetzte Einbindungsreihenfolge nicht ersetzt wird. Neue Akten und Vorgänge beginnen mit fachlichem Datum aufsteigend. `bindings.position` gehört zur Einbindung. Die Datumssortierung schreibt sie nicht um. `PATCH /api/v1/cases/{id}/content-order` und `POST /api/v1/cases/{id}/bindings/order` sowie die gleichen Pfade unter `matters` prüfen das Bearbeitungsrecht im Handlungskontext und `expected_version`. Der fachliche Verlauf liest die Datumsfelder der sichtbaren Unterlagen einmal je Element. Das Änderungsprotokoll bleibt `GET .../chronology`, seitenweise über `cursor`. `content_view` ist `structure` oder `chronology` und nur eine Darstellung. Sie schreibt Kapitel, Positionen und Datumssortierung nicht um. Der Breadcrumb eines Vorgangs ist der Objektpfad `Vorgänge` und gegebenenfalls der lesbare Elternvorgang; lesbare Aktenzuordnungen stehen separat in `placements` und wechseln den Handlungskontext nur bei bewusster Auswahl. `elements.summary` ist eine optionale gemeinsame Kurzbeschreibung. Ein Textauszug entsteht nur aus vorhandenem Notiztext. Bild- und PDF-Vorschauen verwenden denselben berechtigten Dateiabruf wie das Öffnen. + +Anlagen, Versand und Nachweise sind eigene Verwendungen im Behälter der Einbindung, nicht im geerbten Aktenkontext. `attachment_uses` ordnet ein vorhandenes Element einem Hauptschriftstück zu, mit eigener Reihenfolge je Behälter und ohne Dateikopie. `bindings.list_fold` blendet nur dieses Vorkommen als Anlage oder Nachweis aus; andere Einbindungen bleiben. `dispatches` hält Weg, Versanddatum, Gegenüber, Vollständigkeit und Herkunft (`captured` oder `reconstructed`). `dispatch_items` ist das Manifest. Eine sicherbare Fassung liegt als Bytes unter `MEDIA_ROOT/dispatch/` in `dispatch_snapshots`, bei Notizen zusätzlich als JSON im Manifest. Eine fehlende historische Fassung bleibt `gap` und wird nicht durch die aktuelle Arbeitsdatei ersetzt. `dispatch_evidence` verknüpft einen vorhandenen Beleg in der Rolle E-Mail, Einlieferung, Zustellung oder sonstiger Nachweis. Einlieferung setzt keinen Zustellstatus. Berichtigungen stehen in `dispatch_corrections` und ändern die gesicherten Bytes nicht. Löschen eines Elements entfernt die Bytes seiner Versandfassungen über denselben Löschpfad wie die Arbeitsdatei. Lesen des Hauptschriftstücks öffnet keine gesperrte Anlage. Exportknoten `attachment`, `dispatch_item` und `evidence` unterscheiden Arbeitsstand, gesicherte Fassung und Nachweis. Eine unvollständige Auswahl ist ein Auszug. Eine ausgewählte E-Mail bleibt das vollständige Original. ### 4.3 Überblick diff --git a/docs/product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md b/docs/product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md index bc0d2ba..616ab5f 100644 --- a/docs/product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md +++ b/docs/product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md @@ -1,5 +1,7 @@ # Tsumugu – Erste Lieferung: vollständiges Übergabepaket +**Erweiterung vom 18.10.2026:** [Schreiben/Anlagen/Versand/Nachweise](TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md) erweitert den vorhandenen Export um Rollen, Ereignisse und konkrete übermittelte Fassungen. Die vollständige EML-Anlagenregel und die Auswahl nach Vorkommen bleiben erhalten; bewusste Auszüge eines Versandstands werden als solche bezeichnet. Die unten beschriebene erste Liefergrenze ist historisch. + Stand: 17.10.2026. Fachliches Lieferpaket und vorbereiteter Cursor-Auftrag. Führend für die bestätigten Entscheidungen ist die Produktspezifikation 0.32, F-07a–c. Neue Bestandsänderungen sind vor Umsetzung erneut abzugleichen. Dieser Dokumentationsauftrag beginnt keine Umsetzung. ## Ziel diff --git a/docs/product/TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md b/docs/product/TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md index 8ff94e8..34fa654 100644 --- a/docs/product/TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md +++ b/docs/product/TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md @@ -1,5 +1,7 @@ # Tsumugu – kompakte Inhaltsliste und Bezüge +**Spätere Erweiterung, 18.10.2026:** [Schreiben mit Anlagen, Versand und Nachweisen](TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md) ergänzt ausdrückliche Inhaltsrollen und Chronologie. Die kompakte Darstellung bleibt; Anlagen dürfen am Hauptschriftstück gezielt geöffnet werden, allgemeine Bezüge bleiben ohne Umordnung. Der neue Auftrag präzisiert zusätzlich Kapitelgrenzen und Nachweisdarstellung. + **Stand:** 17.10.2026 · **Fassung:** 1.0 · **Ziel:** deutlich mehr Vorgangsinhalt auf einen Blick, direkt bedienbare Kommunikationszeichen und kompakte Beziehungen. ## 1. Geltung und Befund diff --git a/docs/product/TSUMUGU_PRODUCT_SPEC.md b/docs/product/TSUMUGU_PRODUCT_SPEC.md index dd3ebb3..49be26c 100644 --- a/docs/product/TSUMUGU_PRODUCT_SPEC.md +++ b/docs/product/TSUMUGU_PRODUCT_SPEC.md @@ -1,6 +1,6 @@ # Tsumugu – Fachliche Produktspezifikation -**Stand:** 17.10.2026 · **Arbeitsstand:** 0.37, Unterkapitel als reine verschachtelte Gliederung; kompakte Inhaltsliste und Exportlieferung bleiben erhalten. +**Stand:** 18.10.2026 · **Arbeitsstand:** 0.38, Anforderungen zu Schreiben mit Anlagen, Versand/Nachweisen, Chronologie und Kapitelgrenzen zusammengestellt. **Status:** Führende fachliche Arbeitsdatei; noch keine freigegebene Gesamtspezifikation. **Aktuelle Ergänzung:** [Bedienung, Orientierung und Aktenordnung im MVP](TSUMUGU_UX_MVP_ERGAENZUNG.md). Sie sichert den Nutzerbedarf aus der Prüfung der inzwischen bestehenden Anwendung und konkrete Umsetzungsvorgaben für deren Überarbeitung. Bestätigter Bedarf und empfohlene Ausgestaltung sind dort getrennt; die historischen Etappenbeschreibungen dieser Datei bleiben als solche erhalten. @@ -418,6 +418,20 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G **Auswirkungen auf Fachmodell und MVP:** Jedes Kapitel hat höchstens ein Elternkapitel im selben Objekt. Direkte Inhalte eines Kapitels bleiben von den Inhalten seiner Unterkapitel unterscheidbar. Geschwister haben eine eigene Reihenfolge; die Eintragsreihenfolge bleibt die des jeweiligen Kapitels. Umhängen bleibt im selben Objekt und gibt nichts frei. Auflösen einer Kapitelgliederung löscht keine Inhalte oder Originaldateien: direkte Einbindungen und direkte Unterkapitel rücken unter das bisherige Elternkapitel, bei einem Wurzelkapitel auf die oberste Ebene. Der vorhandene Export stellt die Struktur als Verzeichnisse dar. F-07c bleibt unverändert. Eine technische Schutzgrenze von 32 Ebenen verhindert Zyklen und unbegrenzte Tiefe; sie ist keine fachliche Produktgrenze. Auftrag und Abnahme: [Unterkapitel](TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md). +### F-08b – Schreiben mit Anlagen und erkennbare Kapitelgrenzen: 18.10.2026 + +**Nutzerbedarf und Auftrag:** Unterkapitel werden ersatzweise verwendet, um ein Schriftstück mit seinen Anlagen zusammenzuhalten. Die Abgrenzung von Vorgang, Kapitel und Unterkapitel ist in der Oberfläche zu schwach; chronologische Einordnung und konkrete Anlagenzuordnung werden nicht ausreichend ausgedrückt. Der Nutzer benennt Anlagen ausdrücklich als neue fachliche Funktion und beauftragt Anforderungen und Cursor-Prompt für den besprochenen Ausbau. + +**Konkrete Ausgestaltung:** Vorhandenes Hauptschriftstück mit ausdrücklicher, geordneter Anlagenverwendung ergänzen. Kapitel bleiben thematische Gliederung ohne eigene Rechte; allgemeine Antwort-/Belegbezüge bleiben eigenständig. Ein Inhalt kann Anlage mehrerer Schreiben sein, ohne Kopie zur bloßen Organisation und ohne neue Zugriffsrechte. Anlagen als kompakte, bei Bedarf öffnende Einheit darstellen. Klare Kapitelgrenzen, keine unmittelbare doppelte Überschrift und verständliche direkte/Gesamtzähler. Bestandsunterkapitel nicht automatisch umdeuten; vorhandene Belege gesammelt bewusst zuordnen. Gliederung und durchgehende Chronologie als verständliche Arbeitsansichten erhalten; Dokumentdaten nicht durch Versanddaten überschreiben. + +### F-08c – Versand, Nachweise und übermittelte Fassung: 18.10.2026 + +**Nutzerbedarf:** Selbst erstellte Schreiben wurden per Post oder E-Mail verschickt. Einlieferungsbeleg oder E-Mail sollen als Nachweis dienen. Eine eigenständige Nachweis-E-Mail in der Struktur führt durch ihre Anhänge zu redundanten Informationen und erschwert die Übersicht. Der Nutzer beauftragt die Zusammenstellung des besprochenen fachlichen Lösungsansatzes. + +**Konkrete Ausgestaltung:** Versandereignis mit Zeitpunkt, Kanal, Gegenüber, konkretem Inhaltsstand und zugeordneten Nachweisen dokumentieren; mehrere Versände desselben Schreibens bleiben möglich. Die tatsächliche übermittelte Fassung bleibt abrufbar und verändert sich nicht still durch spätere Bearbeitung. Fehlende historische Originale als Lücke/Rekonstruktion ausweisen. E-Mail als Nachweis vollständig erhalten, auf Wunsch im aktiven Kontext kompakt am Versand darstellen statt eine zweite sichtbare Anlagenzusammenstellung zu erzeugen. Fachlich eigenständige E-Mails bleiben weiterhin eigenständige Kommunikation. Eine Einlieferung ist keine automatisch bestätigte Zustellung. Keine echte Versandfunktion, automatische Nachweisbewertung oder neue allgemeine Versionsplattform erforderlich. + +**Lieferung und Grenzen zu F-08b/c:** Der gemeinsame [Anforderungs- und Cursor-Auftrag vom 18.10.2026](TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md) konkretisiert Anlage-/Nachweisrollen, gesicherte Fassungen, Listen-/Chronologiedarstellung, Bestandsübergang, Kontextrechte und Export einschließlich vollständiger EML gemäß F-07c. Er ersetzt die historische Zurückstellung eines Hauptdokuments/Dokumentpakets für diese neue Lieferung; F-08a bleibt als Kapitelmodell erhalten. Detailregeln des Auftrags sind die aktuelle Umsetzungsausgestaltung, keine Behauptung bereits implementierter oder früher einzeln bestätigter Funktionen. Dieses Dokumentationspaket ändert keine Anwendung, Datenbank oder Bereitstellung. + ## 6. Fortschreibung 16.10.2026, Arbeitsstand 0.1: Recovery vollständig gelesen, Repository-Unterlagen gezielt abgeglichen, ursprüngliche Nutzernachrichten geprüft und Ergänzungen gesichert. Historische Baseline unverändert übernommen. @@ -494,4 +508,8 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G 17.10.2026, Arbeitsstand 0.37: F-08a bestätigt Unterkapitel als verschachtelte Gliederung ohne eigene Rechte, Ownership oder Status. Die frühere Zurückstellung ist historisch. Kein Sammler und keine Freigabezusammenstellung. Der Auftrag liegt unter [TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md](TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md). Prüfergebnis und Grenzen: [TSUMUGU_UNTERKAPITEL_PRUEFBERICHT_2026-10-17.md](TSUMUGU_UNTERKAPITEL_PRUEFBERICHT_2026-10-17.md). +18.10.2026, Arbeitsstand 0.38: F-08b/c aus der aktuellen Besprechung gesichert und gemeinsamen Auftrag erstellt: Schreiben mit Anlagen, Versandereignisse mit vollständigen Nachweisen/konkreten Fassungen, klare Kapitelgrenzen und getrennte Gliederungs-/Chronologieansicht. Bestand und vollständiger E-Mail-Export bleiben berücksichtigt. Historische Beschränkung der Unterkapitellieferung wird gezielt erweitert. Keine Änderungen an Anwendungscode, Datenbanken, Commit/Push oder Deployment durch diesen Anforderungsauftrag. + +18.10.2026, Arbeitsstand 0.39: F-08b/c lokal umgesetzt. Anlagenverwendung, dokumentierte Versände mit gesicherter oder ausdrücklich fehlender Fassung, Nachweisrollen und die getrennte Gliederungs-/Chronologieansicht sind in der Anwendung. Bestehende Unterkapitel werden nicht umgedeutet. Der Export unterscheidet Arbeitsstand, Versandfassung und vollständige E-Mail. + Nach jeder Entscheidung diese Datei mit kurzer Begründung und Auswirkungen auf Fachmodell/MVP aktualisieren. Die historische Baseline bleibt unverändert. Keine Implementierung ohne ausdrückliche Freigabe; technische Umsetzung später anhand der dann freigegebenen Jinkendo-Blueprints. diff --git a/docs/product/TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md b/docs/product/TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md new file mode 100644 index 0000000..6d9e767 --- /dev/null +++ b/docs/product/TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md @@ -0,0 +1,134 @@ +# Tsumugu – Schreiben, Anlagen, Versand und klare Kapitelgrenzen + +**Stand:** 18.10.2026 · **Fassung:** 1.0 · **Ergebnis:** zusammenhängender Ausbau des vorhandenen MVP bis zur lokal prüfbaren Umsetzung. + +## 1. Ziel, Herkunft und Vorrang + +Der Nutzer verwendet Unterkapitel bislang ersatzweise, um ein Schriftstück mit seinen Anlagen zusammenzuhalten. Kapitelgrenzen sind in der Vorgangsseite zu wenig erkennbar. Die zeitliche Einordnung sowie die Zuordnung von Belegen zu einem konkreten Schriftstück werden dadurch nicht ausreichend ausgedrückt. Eine versendete E-Mail oder ein Einlieferungsbeleg soll außerdem als Nachweis zum Schreiben gehören, ohne durch die E-Mail-Anhänge eine zweite sichtbare Dokumentzusammenstellung aufzubauen. Der Nutzer beauftragt die Zusammenstellung dieser Anforderungen und eines Cursor-Prompts. + +Die folgenden Regeln sind die konkrete Ausgestaltung dieses Ausbaus. Sie sind keine Behauptung, die Funktion sei bereits vorhanden. **Anlagenzuordnung und Versand mit Nachweisen sind neue fachliche Funktionen**, kein bloßer CSS-Umbau. Bestehende Originale, Kapitel, Unterkapitel, Bezüge, Kontextrechte und der vollständige Export sind weiterzuverwenden. + +Führend: [Produktspezifikation](TSUMUGU_PRODUCT_SPEC.md), F-08a–c. Ergänzend: [kompakte Liste](TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md), [Unterkapitel](TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md) und [Export](TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md). Historische Beschränkungen „kein Hauptdokument/kein Dokumentpaket“ gelten für die frühere Unterkapitellieferung; sie verhindern den jetzt beauftragten Ausbau nicht. Virtuelle Freigabezusammenstellungen und dynamische Sichten bleiben eigenständige Begriffe. + +## 2. Fachliche Trennung und minimaler Umfang + +| Begriff | Bedeutung und Grenze | +|---|---| +| Kapitel / Unterkapitel | Thematische Gliederung des aktiven Fachobjekts, weiterhin ohne eigene Rechte oder Status. | +| Schreiben mit Anlagen | Vorhandenes Hauptschriftstück mit ausdrücklich zugeordneten, geordneten Anlagen. Keine zusätzliche Vorgangsebene und kein künstliches Kapitel erforderlich. | +| Versand | Konkrete Übermittlung eines bestimmten Stands an ein Gegenüber, zu einem Datum und über einen Kanal. Mehrere Versände desselben Schreibens sind möglich. | +| Nachweis | Vorhandene E-Mail, Einlieferungsbeleg, Zustellbestätigung oder anderes geeignetes Element, gezielt einem Versand zugeordnet. | +| Allgemeiner Bezug | Antwort, spätere Bestätigung oder sonstiger Zusammenhang zwischen eigenständigen Einträgen. Er macht einen Beleg nicht automatisch zur versendeten Anlage. | + +Minimal liefern: Anlagen zuordnen/ordnen/lösen, Versand manuell dokumentieren, bestehende Nachweise zuordnen, redundant eingebundene Nachweise bewusst kompakt darstellen, konkrete übermittelte Fassungen erhalten, Gliederung und Chronologie verständlich anzeigen und den vorhandenen Export erweitern. E-Mail-Versand, Postversand, Tracking-Automatik, juristische Nachweisbewertung, OCR/KI-Klassifizierung, allgemeines Versionsverwaltungssystem und Connector-Gesamtumbau sind nicht erforderlich. + +## 3. Schreiben mit Anlagen + +- Ein bestehendes lesbares Dokument bzw. eine geeignete vorhandene E-Mail kann Hauptschriftstück sein. Die Zuordnung ergänzt das vorhandene Inhaltsmodell; sie kopiert nicht zur bloßen Organisation die ganze Datei und ersetzt keine Akten-/Vorgangshierarchie. +- Über „Anlagen zuordnen“ vorhandene zugängliche Elemente einzeln oder gesammelt auswählen. Zieldokument, aktiver Vorgang/Teilvorgang und geprüfter Handlungskontext sind klar. Bei Quellenübernahme den vorhandenen Auswahlweg mit eindeutigem Ziel wiederverwenden. +- Anlagen erhalten eine eigene Reihenfolge innerhalb des Schreibens. Dokumenttitel und ursprüngliche fachliche Daten bleiben erhalten. Optional vorhandene Anlagenbezeichnungen nutzen; kein Pflichtformular je Anlage. +- Dasselbe Element darf Anlage mehrerer Schreiben sein. Reihenfolge, Rolle und Zuordnung gehören zur jeweiligen Verwendung. Eine Änderung im Vorgang A darf keine Zuordnung in B überschreiben. Keine Kopie des gemeinsamen Inhalts zur bloßen Mehrfachverwendung. +- „Anlage lösen“ entfernt nur diese Zuordnung. Original, andere Einbindungen und dokumentierte frühere Versände werden nicht still geändert. Kein globales Löschen über eine Anlagenaktion. +- Keine Selbstzuordnung, Zyklen oder versehentliche doppelte Zuordnung desselben Vorkommens. Für diesen Ausbau genügt eine flache Anlagenliste pro Hauptschriftstück. Keine rekursiven Anlagenbäume oder neue allgemeine Beziehungssprache als Voraussetzung. +- Ein Zustellvermerk, der später erstellt wurde, ist zunächst ein eigenständiger Nachweis/Bezug; er wird nicht nachträglich zur ursprünglich versendeten Anlage erklärt. Ebenso ist ein unterstützender Beleg nicht automatisch tatsächlich mitgesendet worden. Die Rolle wird bewusst gewählt. + +## 4. Versand und Nachweise + +### 4.1 Benutzbarer Ablauf + +1. Beim Hauptschriftstück „Versand dokumentieren“ öffnen. +2. Kanal „E-Mail“, „Post“ oder „Sonstiger Weg“, tatsächliches Versanddatum und Gegenüber erfassen. Bestehende Kontaktdaten wiederverwenden; ein lesbarer Freitext ist ausreichend, kein neues Parteienregister bauen. Fehlende Einzelangaben als unbekannt belassen statt erfinden. Ein unbekannter Versandtag bleibt als undatiert kenntlich; der Erfassungszeitpunkt ersetzt ihn nicht. +3. Hauptschriftstück und tatsächlich mitversendete Anlagen einschließlich Reihenfolge prüfen. Die aktuelle Anlagenliste ist ein Vorschlag, keine automatische Behauptung über einen früheren Versand. +4. Vorhandene E-Mail bzw. Belege als Nachweise auswählen, alternativ zunächst ohne Nachweis dokumentieren. „Vom Nutzer dokumentiert“ und „Nachweis vorhanden“ bleiben unterscheidbar. Speichern führt keinen echten Versand aus und behauptet keinen automatisch geprüften Erfolg. +5. Einen späteren Versand desselben Schreibens, etwa nach E-Mail zusätzlich per Post, als weiteres Ereignis dokumentieren. Eigener Zeitpunkt, Kanal, Gegenüber, Inhaltsstand und Nachweise; kein Überschreiben des ersten Versands. + +Ein Versand kann mehrere Nachweise haben, etwa Einlieferungsbeleg und spätere Zustellbestätigung. Die Rolle des Nachweises ist verständlich benannt: E-Mail/Versanddokumentation, Einlieferung, Zustellung oder sonstiger Nachweis. Eine Einlieferung wird nicht automatisch als Zustellung angezeigt. Neue Aufgaben, Fristen oder Erledigungsstände werden daraus nicht automatisch abgeleitet. + +### 4.2 E-Mail als Nachweis ohne doppelte sichtbare Inhalte + +- Gezielte Aktion „Als Versandnachweis zuordnen …“ an einem vorhandenen Element oder im vorhandenen Quellen-Auswahldialog. Hauptschriftstück und konkreten vorhandenen Versand auswählen oder den Versand in demselben Ablauf anlegen. +- Die vollständige E-Mail mit Nachrichtentext, Headern und ursprünglichen Anhängen erhalten. Ein unverändertes Original bleibt direkt erreichbar. Keine Anhänge aus der EML entfernen, keine Originale umschreiben und keine Dateien allein wegen gleicher Namen zusammenführen. +- Im Standard der Liste zeigt das Schreiben eine kompakte Angabe, etwa „8 Anlagen · per E-Mail · Nachweis“. Die E-Mail-Anhänge erscheinen hier nicht nochmals als zweite vollständig aufgeklappte Anlagenliste. Im Nachweis-Leser bleibt die vollständige Nachricht einschließlich Anhängen zugänglich. +- Ist die E-Mail bereits eigenständig im selben Kontext eingebunden, ausdrücklich anbieten: „Hier als Nachweis darstellen“ oder „Zusätzlich als eigenständigen Eintrag behalten“. Keine automatische Entfernung, kein globales Verstecken und kein Löschen. Andere Einbindungen bleiben unverändert. Eine reine Nachweisdarstellung muss in den Details erkennbar und wieder als eigenständiges Vorkommen darstellbar sein. +- Enthält die E-Mail zusätzliche fachliche Aussagen, muss sie als eigenständige Kommunikation erhalten bleiben können und trotzdem Nachweis sein. Nicht nach Betreff, Dateityp oder Vorhandensein von Anhängen automatisch als bloßes Transportmittel einstufen. +- Anhänge dürfen auf bereits bekannte Unterlagen verweisen. Zuverlässiger Inhaltsvergleich, etwa vollständiger Hash mit exakter Quellenidentität, kann einen Vorschlag liefern; gleiches Dateimaterial beweist nicht allein dieselbe fachliche Rolle oder denselben Versand. Eine manuelle Zuordnung ist möglich und als solche unterscheidbar. Abweichende Fassungen sichtbar belassen. +- Keine vorgetäuschte Speicher-Deduplizierung: Original-EML enthält ihre Anhänge weiterhin. Ziel ist eine verständliche Darstellung und explizite Identitäts-/Verwendungszuordnung. + +## 5. Übermittelten Stand nachvollziehbar erhalten + +- Ein dokumentierter Versand hält Hauptschriftstück, Anlagenbestand, Reihenfolge und konkrete Fassungen fest. Spätere Bearbeitung der Arbeitsunterlagen, neue Paperless-Fassungen, geänderte Titel oder gelöste Anlagenzuordnungen ändern diesen Stand nicht still. +- Minimal eine unveränderliche Versandfassung mit Manifest und tatsächlich wieder abrufbaren Inhalten sichern. Eine vorhandene nachweislich unveränderliche Quellen-/Dateiversion darf referenziert werden; bei veränderlicher Quelle ist ein geschützter Stand der übermittelten Daten erforderlich. Ein Hash oder eine unversionierte Paperless-ID allein erhält den Inhalt nicht. Für unveränderliche Originaldateien vorhandene Speicherung wiederverwenden. +- Nachricht und Anhänge eines Nachweis-Originals ebenso konkret identifizieren. Beim Zuordnen einer bestehenden E-Mail bekannte Quelle und Nachricht eindeutig prüfen; keinen beliebigen Zugang oder ähnlich benannten Anhang verwenden. +- Nicht vorhandene historische Fassungen nicht nachträglich erfinden. Ein später rekonstruierter Versand bleibt als rekonstruierter/manuell zugeordneter Stand erkennbar. Dokumentation ohne verfügbare Originalfassung darf gespeichert werden, aber keinen vollständigen gesicherten Inhaltsstand vortäuschen. Lücken klar anzeigen; vollständiger Export meldet sie. +- Nachträgliche Korrekturen als nachvollziehbare Berichtigung mit Zeitpunkt festhalten. Bestehende Rechte-/Löschregeln gelten weiter, auch für gespeicherte Versandfassungen; daraus keine neue unbegrenzte Aufbewahrung oder undeletbare Parallelablage ableiten. Der technische Entwurf muss Schutz, Speicherung und vorhandenen Löschpfad konkret beschreiben. +- Keine starre Kopie zu jedem UI-Klick. Sichern beim bewussten Dokumentieren des Versands, atomar bzw. mit eindeutigem unvollständigem Zustand bei Abruffehlern. Bestehende Arbeitsunterlagen bleiben normal bearbeitbar. + +## 6. Darstellung: Kapitel, Einheit und Chronologie + +### 6.1 Kapitelgrenzen + +- Kapitelköpfe durch zurückhaltend abgesetzte Fläche und eindeutige Typografie von Dokumentzeilen unterscheiden. Unterkapitel mit konsistenter Einrückung und erkennbarem Ende des jeweiligen Bereichs. Keine breiten Karten und großen Leerflächen als Ersatz für Struktur. +- Im ausgewählten Kapitel dessen Überschrift nicht unmittelbar darunter identisch wiederholen. Vorgangstitel und ausgewähltes Kapitel eindeutig benennen; Breadcrumbs und tatsächlicher Handlungskontext bleiben erhalten. +- Zähler verständlich machen: etwa „2 direkt · 8 in Unterkapiteln“ oder nachvollziehbare Gesamtzahl. Nie eine unbeschriftete direkte Anzahl neben einer sichtbar größeren Gesamtmenge. Sichtbare Zählwerte berücksichtigen Rechte, Filter und die gewählte Darstellung; ausgeblendete Original-/Nachweisvorkommen nicht als vermeintlich sichtbare Zeilen zählen. +- Kapitel und Unterkapitel bleiben reine Gliederung. „Einzelbelege“ darf weiterhin ein thematisches Unterkapitel sein, belegt aber keine Anlagen- oder Versandzuordnung. + +### 6.2 Schreiben als kompakte Einheit + +- Hauptschriftstück in einer kompakten Zeile mit Kennzeichnungen „Anlagen n“, „Versand n“ bzw. passendem Kanal und „Nachweise n“. Nur vorhandene Angaben zeigen. Keine dauerhaft aufgeklappten Anlagen-, Versand- und Nachweislisten pro Eintrag. +- „Anlagen“ öffnet die geordnete Liste bzw. den bestehenden Leserbereich. Eintrag, Dateityp und ursprüngliches Datum bleiben erkennbar; mobile Navigation nutzt dieselbe Einheit ohne verkleinerte Mehrspaltenansicht. Anlagen sind ausdrücklich als solche benannt und sehen nicht wie Unterkapitel aus. +- Derselbe Inhalt wird innerhalb einer gewählten Ansicht nicht ungefragt mehrfach als scheinbar unabhängige Zeile dargestellt. Ein ausdrücklich gewünschtes eigenständiges Vorkommen bleibt möglich und wird als dieselbe Unterlage kenntlich gemacht. Suche, Filter und Direktöffnung können den Inhalt weiterhin auffinden; benötigte Herkunft bleibt erreichbar. +- Das Zusammenfassen erfolgt durch die neue ausdrückliche Anlagen-/Nachweisrolle. Allgemeine Antwortbezüge bleiben beim kompakten Bezugsauslöser und verschieben keine Zwischenstücke. Keine verbindenden Klammern über die Chronologie. + +### 6.3 Zwei verständliche Arbeitsansichten + +- **Gliederung:** Kapitel/Unterkapitel und ihre gespeicherte eigene oder fachliche Ordnung bleiben. Schreiben mit Anlagen erscheinen als Einheit. Die bestehende Ordnung nicht beim Erfassen eines Versands umschreiben. +- **Chronologie:** Datierte Kommunikation, dokumentierte Versände und eigenständige Notizen/Ereignisse innerhalb des gewählten Vorgangs-/Kapitelbereichs bilden eine durchgehende zeitliche Folge. Datumsgruppen sind möglich, thematische Kapitel unterbrechen die Folge nicht. Kein gleichzeitig daneben angezeigter zweiter Verlauf. Auf-/absteigende Sortierung anbieten und undatierte Einträge kenntlich behandeln. +- Ein dokumentierter Versand erscheint am tatsächlichen Versanddatum und verweist auf die gesicherte Fassung des Schreibens mit Anlagen. Er erscheint einmal pro Versand; Hauptschriftstück und reine Nachweis-E-Mail erzeugen dafür nicht zusätzlich identische Ausgangsereignisse. Ein weiterer echter Versand bleibt ein eigenes Ereignis. Eigenständige fachliche E-Mails/Notizen bleiben eigene Ereignisse. +- Vorhandene Unterlagen ohne Versand behalten ihre fachliche Datierung. Dokumentdatum, Versanddatum, Zugangsdatum, Nachweisdatum und Erfassungszeitpunkt nicht gleichsetzen. Eine beigefügte Rechnung aus 2023 verschiebt das 2026 versendete Schreiben nicht nach 2023; das Rechnungsdatum bleibt am Inhalt sichtbar. +- Ein späterer Zustellvermerk bleibt mit seinem eigenen Datum nachvollziehbar. Ein Nachweis kann aus dem Versand erreichbar sein und zugleich ein eigenständiges Ereignis dokumentieren. Doppelte Darstellung desselben Ereignisses vermeiden; Informationsrolle bewusst erhalten. +- Wechsel der Arbeitsansicht ist eine Darstellungswahl, keine Migration der Einträge. Kapitelzuordnung, manuelle Reihenfolge, gewählter Kontext und Rückkehr aus dem Leser bleiben erhalten. Vorhandene geeignete Auswahl-/Sortierbedienung erweitern statt neue verstreute Schalter zu bauen. + +## 7. Kontext, Bestand und bestehende Quellen + +- Alle neuen Beziehungen und Versandverwendungen im geprüften Akten-/Vorgangskontext führen. Kapitel erzeugen keine Rechte; Anlage oder Nachweis sein erzeugt ebenso keine neue Freigabe, Ownership oder Einsicht in Herkunftsvorgänge. +- Hauptschriftstück allein lesen zu dürfen verleiht keinen Zugriff auf gesperrte Anlagen/Nachweise. Titel, Vorschau, Parteien, Zähler und gespeicherte Versandfassungen dürfen keine Inhaltsausnahmen umgehen. Lesen, Bearbeiten und Weitergeben/Exportieren weiterhin unterscheiden. +- Richtung je Einbindung bleibt erhalten. Das Zuordnen eines lokalen Belegs als Anlage ändert nicht seine eigene Richtung oder die Richtung anderer Dokumente. Der konkrete Ausgangsversand ist ein zusätzliches fachliches Ereignis. +- Bestandsmigration additiv und rückwärtskompatibel. Keine vorhandenen Kapitel anhand von Namen automatisch in Schreiben/Anlagen umwandeln und keine Anlage allein wegen Reihenfolge/Unterkapitelposition erkennen. +- Für den bestehenden Umgehungsfall einen manuellen Sammelablauf anbieten: im Unterkapitel Unterlagen auswählen, Hauptschriftstück wählen, Anlagen zuordnen und Reihenfolge prüfen. Danach ausdrücklich wählen, ob die zusätzlichen Vorkommen dort bestehen bleiben oder nur die Anlagenansicht verwendet werden soll. Keine stillen Löschungen. Ein überflüssiges Kapitel kann anschließend separat mit der vorhandenen, erklärten Funktion aufgelöst werden. +- Paperless bleibt Quelle/Archiv. Neue Manifest-/Versanddaten sind Tsumugu-Fachdaten; kein bidirektionaler Metadatenabgleich als Vorbedingung. Den bestehenden vollständigen E-Mail-/Dateiabruf wiederverwenden und gezielt erweitern. + +## 8. Export als Teil derselben Lieferung + +- Bestehendes Übergabepaket um Anlagenrollen, Versandereignisse, Nachweise und gesicherte Fassungen ergänzen. HTML-/Markdown-Übersicht erklärt Kapitelzugehörigkeit und „Schreiben → Anlagen → Versand → Nachweise“ mit relativen Links, Datumsarten und Herkunft der Fassung. Dateinamen dürfen sich nicht überschreiben. +- Die Auswahl zeigt, welche Anlagen/Nachweise beim gewählten Schreiben bzw. Versand enthalten sind. Für einen vollständigen Versandstand müssen die tatsächlich dazugehörenden Bestandteile mitgegeben werden. Bewusstes Abwählen bleibt nach der bisherigen Auswahl nach Vorkommen möglich, kennzeichnet die Ausgabe aber als Auszug dieses Versands; Vollständigkeit nicht behaupten. +- Die bestehende Regel F-07c bleibt: Eine ausgewählte E-Mail enthält das vollständige Original mit sämtlichen ursprünglichen Anhängen. Ein separat abgewähltes Anlage-Vorkommen entfernt den Anhang nicht aus der EML. Die Auswahl/Prüfübersicht weist darauf hin. Eine ausgeblendete Nachweiszeile darf den Nachweis nicht versehentlich vom Export ausschließen; der Nutzer muss seine Aufnahme erkennen und wählen können. +- Zugriffs- und bestehende Weitergabebefugnisse auch für Nachweise, Anlagen und gespeicherte Fassungen prüfen. Kein Export einer unveränderten vollständigen EML, wenn dessen vollständiger Inhalt im Exportkontext nicht freigegeben ist; verständlich melden statt ungeprüft redigieren oder heimlich auslassen. +- Quellenlücken, fehlende historische Fassungen und fehlgeschlagene Abrufe ausdrücklich in der Vollständigkeitsprüfung behandeln. Gesicherte alte Fassungen und aktuelle Arbeitsstände unterscheidbar exportieren; keine aktuelle Datei als historische Versandfassung ausgeben. + +## 9. Technische Umsetzung und Liefergrenze + +Vor Änderungen `AGENTS.md`, aktuellen technischen Entwurf und vorhandene Dokumentation zum Ist-Datenmodell/API/Rechten lesen. Aktuelle Änderungen erhalten. Bestehende Elemente, Einbindungen, Quellidentitäten, Media-Speicherung, Audit/Versionskonflikte, Leser und Export nutzen. Die konkrete Speicherung entscheidet der Coder im Bestand; keine Tabellenstruktur aus diesem Fachauftrag blind übernehmen. + +Zuerst knapp festhalten, welche vorhandenen Modelle erweitert werden und wie Anlagenverwendung, Versandmanifest, wiederabrufbare Fassung und Nachweisrolle voneinander getrennt werden. Technischen Entwurf/API-Dokumentation gezielt aktualisieren und anschließend den gesamten Ablauf implementieren. Nicht nach Spezifikation, leeren Tabellen oder bloßen UI-Attrappen aufhören. Kleine umsetzbare Schritte sind sinnvoll, das Ergebnis muss alle hier beschriebenen Hauptabläufe abdecken. + +Neue API-Mutationen müssen Kontextrechte, fremde IDs, Zyklus-/Doppelzuordnung, Validierung und gleichzeitige Änderungen behandeln. Abruffehler dürfen keinen als vollständig markierten halben Versand erzeugen. Dateien und vertrauliche Daten nicht in öffentlichen Assets oder Logs ablegen. Betrieb, Backup und bestehende Löschpfade müssen die neuen gespeicherten Fassungen einschließen. + +Die kompakte Gestaltung einschließlich vorhandener Symbole, Punkt/Kasten, Aktion über das Richtungszeichen und mobiler Auszüge beibehalten. Keine neue Symbolfamilie oder frei erfundene Logos. Bestehende Funktionsicons verwenden. + +## 10. Abnahme mit synthetischen Daten + +1. Ein Schreiben, drei Anlagen mit verschiedenen Dokumentdaten und ein thematisches Unterkapitel. Anlagen gesammelt zuordnen, ordnen und eine lösen. Nach Neuladen stimmt alles; andere Einbindungen bleiben unverändert. +2. Dasselbe Dokument ist Anlage eines zweiten Schreibens in anderem Kontext. Rollen/Reihenfolgen bleiben unabhängig; keine zusätzlichen Rechte und keine Dateikopie zur bloßen Organisation. +3. Schreiben per E-Mail dokumentieren, vorhandene vollständige E-Mail als Nachweis zuordnen. Das Original hat dieselben drei Anhänge sowie einen weiteren, abweichenden Anhang. Gleiche Namen und unterschiedliche Inhalte gesondert prüfen. Kein automatisches falsches Zusammenführen, Original vollständig erreichbar und Abweichung sichtbar. +4. Bereits eigenständige E-Mail bewusst in reine Nachweisdarstellung überführen und zurück. Andere Einbindung und Original bleiben erhalten. E-Mail mit fachlichem Zusatzinhalt eigenständig belassen und dennoch zuordnen. +5. Nach dokumentiertem Versand Arbeitsdokument ändern, Anlagenliste ändern und externe aktuelle Fassung austauschen. Erster Versand bleibt in ursprünglicher Fassung lesbar/exportierbar. Fehlende alte Originale werden als Lücke behandelt, nicht durch aktuelle Dateien ersetzt. +6. Zweiten Versand per Post mit anderem Datum, anderer Anlagenzusammenstellung und Einlieferungsbeleg dokumentieren. Spätere Zustellbestätigung ergänzen. Beide Versände und alle Nachweisrollen sind eindeutig; kein automatischer Status „zugestellt“ allein durch Einlieferung. +7. Gliederung/Chronologie wechseln. 2023er Anlage in 2026er Versand verschiebt diesen nicht. Späterer Nachweis und eigenständige Rückfrage bleiben datiert. Mehrere unabhängige Zwischenstücke bleiben in Reihenfolge, keine Klammern und keine doppelten Ausgangsereignisse. Filter, Kontext, Rückkehr und eigene Ordnung erhalten. +8. In einem Kapitel mit zwei direkten Einträgen und acht Unterkapitel-Inhalten Grenzen und Zähler prüfen. Keine doppelte Kapitelüberschrift. Auf 1280px, 390px und kurz 360px prüfen: klare Hierarchie, kompakte geschlossene Einheiten, Leser/Anlagen/Nachweise per Touch und Tastatur erreichbar. Größere Schrift darf umbrechen. +9. Gesperrte Anlage und Nachweis in fremdem Kontext prüfen: weder Inhalt noch Metadaten/Zähler werden offengelegt, neue Fassungen umgehen die Einschränkung nicht. Lesender Nutzer kann keine Zuordnung oder Versanddaten ändern. Fremde IDs serverseitig abweisen. +10. Vollständigen historischen Versand und einen bewussten Auszug exportieren. Manifest/Fassungen/Nachweise stimmen, vollständige EML bleibt einschließlich aller Anhänge erhalten; separat abgewählte Vorkommen ändern dies nicht. Fehlende Quellen/Fassungen/Rechte führen zu erklärten Lücken oder gezieltem Abbruch. +11. Bestehende Bestandseinträge und Unterkapitel bleiben ohne automatische Umwandlung erhalten. Sammelzuordnung als Anlagen funktioniert; selbst erstellte Schriftstücke ohne Versand sind weiter nutzbar. Allgemeine Bezüge und vorhandenes Exportpaket regressionsprüfen. + +Relevante Backend-/Interaktionsprüfungen für Rollen, gesicherte Fassungen, Kontexte, Export und Fehlerfälle sowie den vorhandenen Frontend-Build ausführen. Vorhandene Tests wiederverwenden und gezielt ergänzen; keine bloßen CSS-/Implementierungs-Abbildtests. Tatsächliche Bedienung und Screenshots synthetischer Beispiele liefern. Geplante, bestandene und blockierte Prüfungen trennen; alte Prüfberichte belegen keinen aktuellen Stand. + +**Übergabepunkt:** lokal prüfbar implementiert, Migration und relevante Doku aktualisiert, Hauptabläufe getestet, Einschränkungen benannt. Kein Commit, Push oder Deployment durch diesen Auftrag. Ein Push auf `develop` startet Development; Production bleibt separat. Keine Nachricht an andere Chats oder externe Empfänger versenden. diff --git a/docs/product/TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md b/docs/product/TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md index e64c125..fad6817 100644 --- a/docs/product/TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md +++ b/docs/product/TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md @@ -1,5 +1,7 @@ # Auftrag an Cursor: Unterkapitel in Tsumugu +**Spätere fachliche Erweiterung, 18.10.2026:** [Schreiben mit Anlagen und Versand/Nachweisen](TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md), Produkt F-08b/c. Der folgende Ausschluss eines Hauptdokuments/Dokumentpakets bezeichnet die damalige Liefergrenze. Der neue Auftrag ergänzt diese Funktion gezielt; die Kapitel bleiben unabhängig davon reine Gliederung. Keine automatische Umwandlung bestehender Unterkapitel. + Stand: 17.10.2026. Vorbereiteter Umsetzungsauftrag nach fachlicher Abstimmung. Dieser Chat hat keine Anwendung implementiert. Der Auftrag wird durch die Übergabe an Cursor erteilt. ## 1. Ziel und bestätigte Fachentscheidung diff --git a/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md b/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md index 0790d55..7973c6a 100644 --- a/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md +++ b/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md @@ -1,6 +1,8 @@ # Tsumugu – Ergänzung zur Bedienung, Orientierung und Aktenordnung im MVP -**Stand:** 17.10.2026 · **Fassung:** 0.8, Unterkapitel in der bestehenden Gliederung; Fassung 0.7 zur kompakten Liste bleibt erhalten. +**Stand:** 18.10.2026 · **Fassung:** 0.9, klare Kapitelgrenzen, Schreiben mit Anlagen und Versand/Nachweise. + +**Aktueller Ausbau F-08b/c:** [Schreiben, Anlagen, Versand und Kapitelgrenzen – gemeinsamer Auftrag](TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md). Anlagen sind eine neue ausdrückliche Inhaltsverwendung; Unterkapitel bleiben thematische Gliederung. Schreiben werden mit ihren Anlagen kompakt dargestellt, Versand mit konkretem übermitteltem Stand und vollständigen Nachweisen dokumentiert. E-Mails bleiben vollständig erhalten, ihre reine Nachweisdarstellung kann redundante Einträge im aktiven Kontext vermeiden. Gliederung und durchgehende Chronologie unterscheiden; keine stillen Datumsänderungen oder Umdeutung allgemeiner Bezüge. Kapitel/Unterkapitel durch Flächen/Typografie/Einrückung abgrenzen, doppelte Überschrift und unklare Zählwerte korrigieren. Kompakte Liste, bestehende Symbole und Kontextrechte bleiben erhalten. Der Auftrag legt die neue Darstellung gegenüber widersprechenden älteren Vorgaben fest; keine Umsetzung wird hiermit als bereits fertig behauptet. **Neuester Auftrag F-06f:** [Kompakte Inhaltsliste – vollständige Anforderungen und Cursor-Auftrag](TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md). Diese spätere Präzisierung ersetzt widersprechende ältere Darstellungsvorgaben in diesem Dokument: dauerhaftes Richtungs-Dropdown, nicht anklickbare Richtungsgrafik, fehlendes Zeichen für bewusst Lokal, Kapitelwiederholung und aufgeklappte Bezugskarten/Beziehungsleisten. Richtung direkt über das Zeichen wählen, Lokal als Punkt, Keine Angabe als leerer umrandeter Kasten ohne Checkbox-Semantik, Bezüge nur als kompakter Auslöser. Kapitel-/Vorgangsköpfe und mobile Auszüge verkürzen, Inhaltstypen, Reihenfolge, Rechte und ausführlichen Leser erhalten. @@ -309,6 +311,8 @@ Ein Push auf `develop` löst laut Repository einen Development-Deploy aus. Der r ## 15. Fortschreibung +- **0.9:** F-08b/c: Hauptschriftstück und Anlagen ausdrücklich zuordnen; Versand mit Nachweisen und abrufbarem übermitteltem Stand. Redundante Nachweis-E-Mails bewusst kompakt darstellen; Original vollständig bewahren. Klare Kapitelgrenzen/Zähler und durchgehende Chronologie präzisiert. Gemeinsamer Auftrag und Abnahmefälle verlinkt. + - **0.8:** F-08a: verschachtelte Kapitel ohne eigene Rechte. Pfad, Mehrfachauswahl, Umhängen und Auflösen in der bestehenden Navigation und im vorhandenen Export. Teilvorgänge bleiben eigene Objekte. - **0.7:** F-06f: konsolidierter Auftrag zur Reduktion der Eintrags- und Kopfhöhe; Richtungszeichen als direkte Bedienung und Punkt für Lokal. Bezugsdetails erst bei Bedarf, keine Klammern/Leisten oder zusätzliche Reihenfolgeänderung. Abnahme mit mehreren unabhängigen Zwischenstücken und vergleichbaren Zeilenhöhen. diff --git a/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md b/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md index 858c38b..91fa6f7 100644 --- a/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md +++ b/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md @@ -10,6 +10,8 @@ Die ausgewählte Tsumugu-Oberfläche wird im vorhandenen Produkt umgesetzt. Dara ## 2. Führende Quellen und gezielte Lesereihenfolge +**Aktueller Auftrag vom 18.10.2026, Produkt 0.38 / UX 0.9:** [Schreiben mit Anlagen, Versand/Nachweise und Kapitelgrenzen](TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md). Der Nutzer beauftragt die Anforderungen und den Cursor-Prompt nach Besprechung der fachlichen Lücke. Anlagenzuordnung und Versand/Nachweise sind neue Funktionen. Hauptschriftstück mit geordneten Anlagen, konkrete übermittelte Fassung, E-Mail/Einlieferungsbeleg als Nachweis, bewusste kompakte Nachweisdarstellung, verständliche Gliederung/Chronologie und bestehender vollständiger Export bilden den nächsten zusammenhängenden Ausbau. Historische Beschränkung „kein Hauptdokument/kein Sammler“ der Unterkapitellieferung ist keine Blockade dieses neuen Auftrags. Unterkapitel, Kontextrechte und ursprüngliche E-Mails bleiben erhalten. Keine Umsetzung, Migration oder Bereitstellung durch diesen Dokumentationsauftrag. + **Unterkapitel, Produkt 0.37:** [Auftrag Unterkapitel](TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md) und F-08a. Unterkapitel sind reine verschachtelte Gliederung ohne eigene Rechte. Die frühere Zurückstellung ist historisch. Kein zusätzlicher Sammler und keine Freigabezusammenstellung. **Neueste Präzisierung, Produkt 0.36 / UX 0.7:** [Kompakte Inhaltsliste und Bezüge](TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md) ist der aktuelle UI-Auftrag. Richtung direkt am Zeichen ändern, Lokal als Punkt, Keine Angabe als leerer Kasten. Keine permanenten Dropdowns, Kapitelwiederholungen oder aufgeklappten Bezugskarten. Bezüge bleiben an ihren Listenpositionen und werden erst auf Anforderung aufgefächert; keine Verbindungsklammern/Beziehungsleisten über unabhängige Zwischenstücke. Symbolpaket 1.4 liefert die neuen Einzeldateien. Frühere Versionsangaben und Live-Befunde unten beschreiben den vorherigen Stand; zuletzt war das Notizmotiv korrekt eingebunden. Die fachliche Exportplanung bleibt erhalten. diff --git a/frontend/src/chapters.test.mjs b/frontend/src/chapters.test.mjs new file mode 100644 index 0000000..9485822 --- /dev/null +++ b/frontend/src/chapters.test.mjs @@ -0,0 +1,15 @@ +import assert from "node:assert/strict"; +import test from "node:test"; +import { countLabel, sectionCounts } from "./pages/chapters.js"; + +test("chapter counts name direct rows and rows in subchapters", () => { + assert.equal(countLabel(2, 8), "2 direkt · 8 in Unterkapiteln"); + assert.equal(countLabel(0, 8), "8 in Unterkapiteln"); + assert.equal(countLabel(2, 0), "2"); + const section = { + items: [{ id: "a" }, { id: "b" }], + children: [{ items: [{ id: "c" }, { id: "d" }, { id: "e" }, { id: "f" }, { id: "g" }, { id: "h" }, { id: "i" }, { id: "j" }], children: [] }], + }; + const counts = sectionCounts(section); + assert.equal(countLabel(counts.direct, counts.nested), "2 direkt · 8 in Unterkapiteln"); +}); diff --git a/frontend/src/pages/ExportPackage.jsx b/frontend/src/pages/ExportPackage.jsx index 4dc1b23..fb5a57f 100644 --- a/frontend/src/pages/ExportPackage.jsx +++ b/frontend/src/pages/ExportPackage.jsx @@ -4,7 +4,7 @@ import { symbolUrl } from "../content-symbol.mjs"; function leafIds(node, into = []) { if (!node) return into; - if (node.kind === "binding" || node.kind === "annotation") into.push(node.id); + if (node.kind === "binding" || node.kind === "annotation" || node.kind === "attachment" || node.kind === "dispatch_item" || node.kind === "evidence") into.push(node.id); (node.children || []).forEach((child) => leafIds(child, into)); return into; } @@ -30,7 +30,7 @@ function withNode(node, selected, on) { function initialSelection(node) { const next = new Set(); function visit(current) { - if ((current.kind === "binding" || current.kind === "annotation") && current.exportable) { + if ((current.kind === "binding" || current.kind === "annotation" || current.kind === "attachment" || current.kind === "dispatch_item" || current.kind === "evidence") && current.exportable) { next.add(current.id); } (current.children || []).forEach(visit); diff --git a/frontend/src/pages/ReadingPane.jsx b/frontend/src/pages/ReadingPane.jsx index 527b0c5..9c836c7 100644 --- a/frontend/src/pages/ReadingPane.jsx +++ b/frontend/src/pages/ReadingPane.jsx @@ -1,6 +1,7 @@ import { useEffect, useRef, useState } from "react"; import { documentToText, downloadMailPart, fetchFile, fetchMailPart, fetchPaperless, markDirty, textToDocument, api } from "../api.js"; import { ErrorNote } from "./widgets.jsx"; +import { UnitDetail } from "./correspondence.jsx"; import { dateCaption, DateField, DirectionChoice, DirectionColumn, directionValue, directionWord, formatDate, mailFacts, MarkdownEditor, sourceLabel } from "./content.jsx"; import { NavIcon } from "./icons.jsx"; import workerSrc from "pdfjs-dist/build/pdf.worker.min.mjs?url"; @@ -505,6 +506,14 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
+ onOpenRelated?.(elementId)} + onDetach={() => {}} + onUnfold={() => {}} + /> {isMail ? (

{directionWord(shownDirection) ? {directionWord(shownDirection)} : null}

diff --git a/frontend/src/pages/chapters.js b/frontend/src/pages/chapters.js index 3bd0fcf..b059975 100644 --- a/frontend/src/pages/chapters.js +++ b/frontend/src/pages/chapters.js @@ -72,6 +72,23 @@ export function trailWithChapter(items, chapters, chapterId, backHref) { return [...base, { label: path.join(" / "), href: null }]; } +export function countLabel(direct, nested) { + const here = Number(direct) || 0; + const below = Number(nested) || 0; + if (here && below) return `${here} direkt · ${below} in Unterkapiteln`; + if (!here && below) return `${below} in Unterkapiteln`; + return String(here); +} + +export function sectionCounts(section) { + const direct = (section?.items || []).length; + const nested = (section?.children || []).reduce((sum, child) => { + const inner = sectionCounts(child); + return sum + inner.direct + inner.nested; + }, 0); + return { direct, nested }; +} + export function findSection(nodes, id) { for (const node of nodes || []) { if (node.id === id) return node; diff --git a/frontend/src/pages/content.jsx b/frontend/src/pages/content.jsx index 7fb4096..7c52f9b 100644 --- a/frontend/src/pages/content.jsx +++ b/frontend/src/pages/content.jsx @@ -11,10 +11,23 @@ import { ErrorNote } from "./widgets.jsx"; import { buildChapterSections, chapterPathLabel, + countLabel, descendantChapterIds, findSection, + sectionCounts, siblingChapterIds, } from "./chapters.js"; +import { + AttachDialog, + Chronology, + DispatchDialog, + EvidenceDialog, + hostMark, + restoreFold, + scopeBody, + unitMarks, + UnitDetail, +} from "./correspondence.jsx"; export function formatDate(value) { if (!value) return "Ohne Datum"; @@ -756,6 +769,9 @@ function EntryActions({ onRemove, onMove, onPlaceChapter, + onAttach, + onDispatch, + onEvidence, }) { const anchorRef = useRef(null); const [open, setOpen] = useState(false); @@ -823,6 +839,9 @@ function EntryActions({ ) : null} {canSort && custom ? : null} {canSort && custom ? : null} + {canEdit && onAttach ? : null} + {canEdit && onDispatch ? : null} + {canEdit && onEvidence ? : null} {canEdit ? : null} {canEdit && canDestroy ? : null} @@ -919,6 +938,8 @@ export function ContentBoard({ const chapters = record?.chapters || []; const [error, setError] = useState(""); const [pending, setPending] = useState(false); + const [dialog, setDialog] = useState(null); + const [openUnits, setOpenUnits] = useState(() => new Set()); const [draggingId, setDraggingId] = useState(""); const [indicator, setIndicator] = useState(null); const [folded, setFolded] = useState(() => new Set()); @@ -930,11 +951,17 @@ export function ContentBoard({ const savingDirection = useRef(false); const custom = record?.content_order === "position"; const direction = record?.content_order_dir === "desc" ? "desc" : "asc"; - const forest = buildChapterSections(chapters, source); + const viewMode = record?.content_view === "chronology" ? "chronology" : "structure"; + const listed = source.filter((item) => !item.correspondence?.fold); + const forest = buildChapterSections(chapters, listed); const loose = looseSection(forest.loose, chapters); const selectedSection = onlyChapter ? findSection(forest.roots, onlyChapter) : null; const visibleRoots = onlyChapter ? (selectedSection ? [selectedSection] : []) : forest.roots; - const shownCount = onlyChapter ? (selectedSection?.items.length || 0) : source.length; + const shownCount = viewMode === "chronology" + ? "" + : onlyChapter + ? countLabel(sectionCounts(selectedSection).direct, sectionCounts(selectedSection).nested) + : String(listed.length); const activePath = onlyChapter ? chapterPathLabel(chapters, onlyChapter) : ""; const canSort = sortable && record?.rights?.edit; const canEdit = Boolean(record?.rights?.edit); @@ -1081,13 +1108,13 @@ export function ContentBoard({ }; }, []); - async function saveMode(mode, nextDirection) { + async function saveMode(mode, nextDirection, nextView = viewMode) { setError(""); setPending(true); try { await api(`${orderPath}/content-order`, { method: "PATCH", - body: { expected_version: record.version, mode, direction: nextDirection, ...orderContext }, + body: { expected_version: record.version, mode, direction: nextDirection, view: nextView, ...orderContext }, }); onChange(); } catch (err) { @@ -1097,6 +1124,30 @@ export function ContentBoard({ } } + function orderedIds(sections) { + const hidden = source.filter((item) => item.correspondence?.fold); + const used = new Set(); + const ids = []; + for (const section of sections) { + for (const item of section.items) { + ids.push(item.id); + used.add(item.id); + } + const chapterId = section.id === "loose" ? null : section.id; + for (const item of hidden) { + const itemChapter = item.chapter_id || null; + if ((chapterId ? itemChapter === chapterId : !itemChapter) && !used.has(item.id)) { + ids.push(item.id); + used.add(item.id); + } + } + } + for (const item of source) { + if (!used.has(item.id)) ids.push(item.id); + } + return ids; + } + async function persist(next, version = record.version) { setError(""); setPending(true); @@ -1105,7 +1156,7 @@ export function ContentBoard({ method: "POST", body: { expected_version: version, - binding_ids: next.flatMap((section) => section.items.map((item) => item.id)), + binding_ids: orderedIds(next), ...orderContext, }, }); @@ -1423,7 +1474,7 @@ export function ContentBoard({ return (
-

{activePath || listTitle || "Inhalte"} {shownCount}

+

{viewMode === "chronology" ? "Chronologie" : (activePath || listTitle || "Inhalte")} {shownCount}

{canSort && chapters.length && !picking ? ( @@ -1432,8 +1483,10 @@ export function ContentBoard({ ) : sortable ? ( @@ -1456,21 +1509,78 @@ export function ContentBoard({ +
) : null} - {source.length || chapters.length ? ( + {viewMode === "chronology" ? ( + + ) : source.length || chapters.length ? ( renderBlockList() ) : (

Noch keine Unterlage und keine Notiz.

)} + setDialog(null)}> + {dialog?.type === "bulk" && !dialog.host ? ( +
{ + event.preventDefault(); + const host = listed.find((item) => item.id === new FormData(event.currentTarget).get("host")); + if (!host) return; + const candidates = listed.filter((item) => picked.has(item.id) && item.id !== host.id); + setDialog({ type: "attach", host, candidates }); + }}> +

Hauptschriftstück für die ausgewählten Unterlagen wählen. Die Kapitel bleiben bestehen, bis sie separat aufgelöst werden.

+ + +
+ ) : null} + {dialog?.type === "attach" && dialog.host ? ( + setDialog(null)} + onDone={() => { setDialog(null); setPicked(new Set()); setPicking(false); onChange(); }} + /> + ) : null} +
+ setDialog(null)}> + {dialog?.type === "dispatch" ? ( + setDialog(null)} + onDone={() => { setDialog(null); onChange(); }} + /> + ) : null} + + setDialog(null)}> + {dialog?.type === "evidence" ? ( + item.element.id !== dialog.binding.element.id)} + scope={scopeBody(actionContext(), containerKind, containerId)} + pending={pending} + onClose={() => setDialog(null)} + onDone={() => onChange()} + /> + ) : null} +
); function renderBlockList() { const blocks = [...visibleRoots]; if (!onlyChapter && loose) blocks.push(loose); - return blocks.map((section) => renderBlock(section, 0, false)); + return blocks.map((section) => renderBlock(section, 0, Boolean(onlyChapter && section.id === onlyChapter))); } function renderBlock(section, depth, hideHead) { @@ -1526,7 +1636,7 @@ export function ContentBoard({ ) : null} {text} ) : null} + {samePiece ? {samePiece} : null} {originText ? {originText} : null} + {(binding.correspondence?.attachments?.length || binding.correspondence?.dispatches?.length) ? ( + + ) : null} + {openUnits.has(binding.id) ? ( + { + const found = source.find((item) => item.element?.id === elementId); + if (found) onOpen?.(found); + }} + onDetach={async (elementId) => { + setPending(true); + setError(""); + try { + await api(`/api/v1/elements/${element.id}/attachments/${elementId}/detach`, { + method: "POST", + body: { + expected_version: element.version, + ...scopeBody(actionContext(), containerKind, containerId), + }, + }); + onChange(); + } catch (err) { + setError(err.message); + } finally { + setPending(false); + } + }} + onUnfold={async (elementId) => { + const found = source.find((item) => item.element?.id === elementId); + if (!found) return; + setPending(true); + setError(""); + try { + await restoreFold(found.id, found.element.version, scopeBody(actionContext(), containerKind, containerId)); + onChange(); + } catch (err) { + setError(err.message); + } finally { + setPending(false); + } + }} + /> + ) : null}
setDialog({ + type: "attach", + host: row, + candidates: listed.filter((item) => item.element.id !== row.element.id && !(row.correspondence?.attachments || []).some((entry) => entry.element_id === item.element.id)), + })} + onDispatch={(row) => setDialog({ type: "dispatch", host: row })} + onEvidence={(row) => setDialog({ type: "evidence", binding: row })} /> ); @@ -1698,24 +1880,31 @@ export function ContentBoard({ } } -export function OrderChoice({ mode, direction, disabled, allowPosition = false, onChange }) { - const value = mode === "position" ? "position" : direction === "desc" ? "date-desc" : "date-asc"; +export function OrderChoice({ mode, direction, view = "structure", disabled, allowPosition = false, allowChronology = false, onChange }) { + const value = view === "chronology" + ? (direction === "desc" ? "chrono-desc" : "chrono-asc") + : mode === "position" ? "position" : direction === "desc" ? "date-desc" : "date-asc"; return ( ); diff --git a/frontend/src/pages/correspondence.jsx b/frontend/src/pages/correspondence.jsx new file mode 100644 index 0000000..d32c5a1 --- /dev/null +++ b/frontend/src/pages/correspondence.jsx @@ -0,0 +1,547 @@ +import { useState } from "react"; +import { Link } from "react-router-dom"; +import { api } from "../api.js"; + +function formatDate(value) { + if (!value) return "Ohne Datum"; + const [year, month, day] = String(value).slice(0, 10).split("-"); + if (!year || !month || !day) return String(value); + return `${day}.${month}.${year}`; +} + +export function scopeBody(context, containerKind, containerId) { + const rights = context || { kind: containerKind, id: containerId }; + const same = rights.kind === containerKind && rights.id === containerId; + return { context: rights, placement: same ? null : { kind: containerKind, id: containerId } }; +} + +export function channelWord(channel) { + if (channel === "email") return "per E-Mail"; + if (channel === "post") return "per Post"; + if (channel === "other") return "sonstiger Weg"; + return ""; +} + +export function unitMarks(binding) { + const pack = binding?.correspondence; + if (!pack) return ""; + const parts = []; + const attachments = pack.attachments || []; + if (attachments.length === 1) parts.push("1 Anlage"); + else if (attachments.length > 1) parts.push(`${attachments.length} Anlagen`); + const dispatches = pack.dispatches || []; + if (dispatches.length === 1) parts.push(channelWord(dispatches[0].channel)); + else if (dispatches.length > 1) parts.push(`${dispatches.length} Versände`); + const evidence = dispatches.reduce((sum, item) => sum + (item.evidence || []).length, 0); + if (evidence === 1) parts.push("Nachweis"); + else if (evidence > 1) parts.push(`${evidence} Nachweise`); + return parts.join(" · "); +} + +export function hostMark(binding) { + const hosts = binding?.correspondence?.hosts || []; + if (!hosts.length) return ""; + return `Dieselbe Unterlage · Anlage zu ${hosts.map((item) => item.title).join(", ")}`; +} + +function snapshotHref(dispatchId, itemId, scope) { + const search = new URLSearchParams({ + context_kind: scope.context.kind, + context_id: scope.context.id, + }); + if (scope.placement) { + search.set("placement_kind", scope.placement.kind); + search.set("placement_id", scope.placement.id); + } + return `/api/v1/dispatches/${dispatchId}/items/${itemId}/content?${search}`; +} + +function fieldBody(scope, extra) { + const body = { ...extra, context: scope.context }; + if (scope.placement) body.placement = scope.placement; + return body; +} + +export function AttachDialog({ host, candidates, scope, pending, onClose, onDone }) { + const initial = candidates.map((item) => item.element.id); + const [order, setOrder] = useState(initial); + const [chosen, setChosen] = useState(() => new Set(initial)); + const [fold, setFold] = useState("attachment"); + const [error, setError] = useState(""); + + function move(id, delta) { + setOrder((current) => { + const index = current.indexOf(id); + const target = index + delta; + if (index < 0 || target < 0 || target >= current.length) return current; + const next = [...current]; + const [item] = next.splice(index, 1); + next.splice(target, 0, item); + return next; + }); + } + + async function save(event) { + event.preventDefault(); + const ids = order.filter((id) => chosen.has(id)); + if (!ids.length) { + setError("Es ist keine Anlage ausgewählt."); + return; + } + setError(""); + try { + await api(`/api/v1/elements/${host.element.id}/attachments`, { + method: "POST", + body: fieldBody(scope, { + expected_version: host.element.version, + attachment_element_ids: ids, + fold, + }), + }); + onDone(); + } catch (err) { + setError(err.message); + } + } + + return ( +
+

Anlagen von {host.element.title}. Die Dateien bleiben an ihrem Ort. Die aktuelle Liste ist nur die Zuordnung in diesem Zusammenhang.

+
    + {order.map((id, index) => { + const item = candidates.find((entry) => entry.element.id === id); + if (!item) return null; + return ( +
  1. + + + + + +
  2. + ); + })} +
+
+ Vorkommen in der Liste + + +
+ {error ?

{error}

: null} + + +
+ ); +} + +export function DispatchDialog({ host, scope, pending, onClose, onDone }) { + const proposal = host.correspondence?.attachments || []; + const [order, setOrder] = useState(proposal.map((item) => item.element_id)); + const [chosen, setChosen] = useState(() => new Set(proposal.map((item) => item.element_id))); + const [channel, setChannel] = useState("email"); + const [sentOn, setSentOn] = useState(""); + const [counterpart, setCounterpart] = useState(""); + const [historical, setHistorical] = useState(false); + const [error, setError] = useState(""); + + function move(id, delta) { + setOrder((current) => { + const index = current.indexOf(id); + const target = index + delta; + if (index < 0 || target < 0 || target >= current.length) return current; + const next = [...current]; + const [item] = next.splice(index, 1); + next.splice(target, 0, item); + return next; + }); + } + + async function save(event) { + event.preventDefault(); + setError(""); + try { + await api(`/api/v1/elements/${host.element.id}/dispatches`, { + method: "POST", + body: fieldBody(scope, { + expected_version: host.element.version, + channel, + sent_on: sentOn || null, + counterpart: counterpart.trim() || null, + attachment_element_ids: order.filter((id) => chosen.has(id)), + evidence: [], + historical_gap: historical, + }), + }); + onDone(); + } catch (err) { + setError(err.message); + } + } + + return ( +
+

Versand von {host.element.title} dokumentieren. Dabei wird nichts verschickt. Die Anlagenliste ist ein Vorschlag für diesen Versand.

+ + +

Leer lassen, wenn der Versandtag unbekannt ist. Der Erfassungszeitpunkt ersetzt ihn nicht.

+ +

Leer lassen, wenn das Gegenüber unbekannt ist.

+
+ Tatsächlich mitversendet +
    + {order.map((id, index) => { + const item = proposal.find((entry) => entry.element_id === id); + if (!item) return null; + return ( +
  1. + + + + + +
  2. + ); + })} +
+ {!proposal.length ?

Keine zugeordnete Anlage. Das Schreiben kann allein dokumentiert werden.

: null} +
+ + {error ?

{error}

: null} + + +
+ ); +} + +export function EvidenceDialog({ element, hosts, scope, pending, onClose, onDone }) { + const [hostId, setHostId] = useState(hosts[0]?.element.id || ""); + const host = hosts.find((item) => item.element.id === hostId) || null; + const [dispatchId, setDispatchId] = useState(host?.correspondence?.dispatches?.[0]?.id || ""); + const [role, setRole] = useState("email"); + const [fold, setFold] = useState("keep"); + const [channel, setChannel] = useState("email"); + const [sentOn, setSentOn] = useState(""); + const [counterpart, setCounterpart] = useState(""); + const [result, setResult] = useState(null); + const [error, setError] = useState(""); + + async function save(event) { + event.preventDefault(); + if (!host) return; + setError(""); + try { + let target = dispatchId; + if (!target) { + const created = await api(`/api/v1/elements/${host.element.id}/dispatches`, { + method: "POST", + body: fieldBody(scope, { + expected_version: host.element.version, + channel, + sent_on: sentOn || null, + counterpart: counterpart.trim() || null, + attachment_element_ids: (host.correspondence?.attachments || []).map((item) => item.element_id), + evidence: [{ element_id: element.id, role, fold }], + historical_gap: false, + }), + }); + const proof = (created.evidence || []).find((item) => item.element_id === element.id); + setResult(proof || created); + onDone(false); + return; + } + const dispatch = (host.correspondence?.dispatches || []).find((item) => item.id === target); + const proof = await api(`/api/v1/dispatches/${target}/evidence`, { + method: "POST", + body: fieldBody(scope, { + expected_version: dispatch?.version || 1, + element_id: element.id, + role, + fold, + }), + }); + setResult(proof); + onDone(false); + } catch (err) { + setError(err.message); + } + } + + return ( +
+

{element.title} als Nachweis zuordnen. Das Original bleibt vollständig erhalten.

+ + + {!dispatchId ? ( + <> + + + + + ) : null} + +
+ Darstellung hier + + +
+ {result ? : null} + {error ?

{error}

: null} + + + + ); +} + +export function ComparisonList({ comparisons = [], state, reason }) { + if (!comparisons.length && state !== "gap") return null; + return ( +
+ {state === "gap" ?

Originalfassung nicht gesichert: {reason}

: null} + {state === "identified" ?

Nachweis manuell zugeordnet. Gleiche Dateinamen werden nicht automatisch zusammengeführt.

: null} +
    + {comparisons.map((item) => ( +
  • + {item.filename} + {item.disposition === "same_bytes" ? ` · gleicher Dateiinhalt wie ${item.matches.map((match) => match.title).join(", ")} · Vorschlag, nicht automatisch zugeordnet` : null} + {item.disposition === "same_name_different_bytes" ? ` · gleicher Name, anderer Inhalt als ${item.matches.map((match) => match.title).join(", ")}` : null} + {item.disposition === "distinct" ? " · eigener Inhalt" : null} +
  • + ))} +
+
+ ); +} + +export function UnitDetail({ binding, canEdit, pending, scope, onOpen, onDetach, onUnfold }) { + const pack = binding.correspondence || {}; + const attachments = pack.attachments || []; + const dispatches = pack.dispatches || []; + if (!attachments.length && !dispatches.length && !(pack.hosts || []).length) return null; + return ( +
+ {attachments.length ? ( +
+

Anlagen

+
    + {attachments.map((item, index) => ( +
  1. + {index + 1}. {item.title} + {formatDate(item.document_on)} + {item.binding_id ? ( + + ) : null} + {canEdit ? ( + + ) : null} +
  2. + ))} +
+
+ ) : null} + {dispatches.map((item) => ( +
+

+ Versand {item.undated ? "undatiert" : formatDate(item.sent_on)} · {item.channel_label} + {item.counterpart ? ` · ${item.counterpart}` : " · Gegenüber unbekannt"} +

+

+ {item.provenance === "reconstructed" ? "Rekonstruierte Dokumentation. " : "Beim Dokumentieren gesichert. "} + {item.completeness === "secured" ? "Inhaltsstand gesichert." : null} + {item.completeness === "partial" ? "Inhaltsstand nur teilweise gesichert." : null} + {item.completeness === "gap" ? "Kein vollständiger gesicherter Inhaltsstand." : null} + {item.recorded_at ? ` Erfasst ${formatDate(item.recorded_at.slice(0, 10))}.` : ""} +

+
    + {item.items.map((part) => ( +
  1. + {part.role === "host" ? "Schreiben" : "Anlage"}: {part.title} + Dokumentdatum {formatDate(part.document_on)} + {part.source_state === "gap" ? Lücke: {part.gap_reason} : scope ? ( + Gesicherte Fassung + ) : Gesicherte Fassung} +
  2. + ))} +
+ {item.evidence?.length ? ( +
    + {item.evidence.map((proof) => ( +
  • + + {formatDate(proof.document_on)} + {proof.source_state === "gap" ? Lücke: {proof.gap_reason} : null} + + {canEdit && proof.listed_fold === "evidence" ? ( + + ) : null} +
  • + ))} +
+ ) :

Vom Nutzer dokumentiert, noch ohne Nachweis.

} +
+ ))} +
+ ); +} + +export function Chronology({ bindings, direction, itemHref, selectedId, onOpen }) { + const events = []; + for (const binding of bindings || []) { + if (binding.correspondence?.fold !== "evidence") { + events.push({ + key: `doc-${binding.id}`, + date: binding.element?.dates?.document_on || "", + label: "Unterlage", + title: binding.element?.title || "", + detail: `Dokumentdatum ${formatDate(binding.element?.dates?.document_on)}`, + binding, + }); + } + for (const dispatch of binding.correspondence?.dispatches || []) { + events.push({ + key: `send-${dispatch.id}`, + date: dispatch.sent_on || "", + label: "Versand", + title: binding.element?.title || "", + detail: [ + dispatch.undated ? "Versand undatiert" : `Versanddatum ${formatDate(dispatch.sent_on)}`, + dispatch.channel_label, + (dispatch.evidence || []).length === 1 + ? "1 Nachweis" + : (dispatch.evidence || []).length + ? `${dispatch.evidence.length} Nachweise` + : "ohne Nachweis", + ].join(" · "), + binding, + dispatch, + }); + } + } + events.sort((left, right) => { + if (!left.date && !right.date) return left.key.localeCompare(right.key); + if (!left.date) return 1; + if (!right.date) return -1; + const compared = left.date.localeCompare(right.date); + if (compared) return direction === "desc" ? -compared : compared; + return left.key.localeCompare(right.key); + }); + const undated = events.filter((item) => !item.date); + const dated = events.filter((item) => item.date); + const ordered = direction === "desc" ? [...undated, ...dated] : [...dated, ...undated]; + const groups = []; + for (const event of ordered) { + const name = event.date ? formatDate(event.date) : "Ohne Datum"; + const last = groups[groups.length - 1]; + if (!last || last.name !== name) groups.push({ name, events: [event] }); + else last.events.push(event); + } + if (!groups.length) return

In dieser Ansicht ist noch nichts zu sehen.

; + return ( +
+ {groups.map((group) => ( +
+

{group.name}

+
    + {group.events.map((event) => ( +
  1. +
    + { + if (click.metaKey || click.ctrlKey || click.shiftKey || click.altKey || click.button !== 0) return; + click.preventDefault(); + onOpen(event.binding); + }}> + {event.label}: {event.title} + + {event.detail} +
    +
  2. + ))} +
+
+ ))} +
+ ); +} + +export async function restoreFold(bindingId, version, scope) { + await api(`/api/v1/bindings/${bindingId}/fold`, { + method: "PATCH", + body: fieldBody(scope, { expected_version: version, fold: null }), + }); +} diff --git a/frontend/src/styles.css b/frontend/src/styles.css index d4e7afc..68ec1d3 100644 --- a/frontend/src/styles.css +++ b/frontend/src/styles.css @@ -546,7 +546,7 @@ button.nav-item:active { transform: none; } .content-row__title { font-weight: 650; } .content-row__kind { color: var(--text3); font-size: 13px; } .content-row__move { display: flex; gap: 4px; } -.chapter-head { display: flex; flex-wrap: wrap; gap: 4px 8px; align-items: center; margin: 0 0 2px; padding: 0; border: 0; border-radius: 0; background: transparent; min-height: 32px; } +.chapter-head { display: flex; flex-wrap: wrap; gap: 4px 8px; align-items: center; margin: 10px 0 4px; padding: 4px 8px; border: 0; border-radius: 8px; background: color-mix(in srgb, var(--brand) 8%, transparent); min-height: 32px; } .chapter-head.is-movable { cursor: grab; touch-action: none; user-select: none; } .chapter-head.is-movable:active { cursor: grabbing; } .chapter-head.is-movable .chapter-date, @@ -556,13 +556,13 @@ button.nav-item:active { transform: none; } align-items: center; gap: 8px; margin: 0; - font-size: 20px; - letter-spacing: 0; + font-size: 15px; + letter-spacing: 0.01em; text-transform: none; color: var(--brand); font-weight: 700; } -.chapter-title.is-nested { font-size: 17px; } +.chapter-title.is-nested { font-size: 14px; font-weight: 650; } .chapter-title svg { width: 18px; height: 18px; flex: 0 0 18px; } .chapter-title span { min-width: 0; } .chapter-plus { @@ -1032,7 +1032,8 @@ button.hierarchy__row { width: 100%; min-height: 34px; padding: 6px 8px; border: .order-choice { align-items: center; flex-direction: row; max-width: none; } .order-choice select { width: auto; min-width: 0; flex: 1; } .preview-row__text { -webkit-line-clamp: 1; } - .preview-row__facts { white-space: normal; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; } + .preview-row__facts { white-space: normal; display: -webkit-box; -webkit-line-clamp: 4; -webkit-box-orient: vertical; } + .chapter-nest { margin-left: 8px; padding-left: 8px; } .entry-mark, .entry-mark--photo { width: 36px; height: 36px; flex-basis: 36px; } } @@ -1319,10 +1320,21 @@ button.hierarchy__row { width: 100%; min-height: 34px; padding: 6px 8px; border: font-weight: 700; } .chapter-nest { - margin-left: 12px; - padding-left: 10px; - border-left: 1px solid var(--border); + margin: 4px 0 8px 16px; + padding: 2px 0 8px 12px; + border-left: 2px solid color-mix(in srgb, var(--brand) 35%, var(--border)); + border-bottom: 1px solid var(--border2); } +.choice-list { list-style: none; margin: 0; padding: 0; display: grid; gap: 6px; } +.choice-list li, .choice-list label { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; } +.choice-list__move { display: inline-flex; gap: 4px; margin-left: auto; } +.unit-detail, .comparison, .chrono { display: grid; gap: 6px; margin-top: 4px; } +.unit-detail h4, .chrono h3 { margin: 6px 0 0; font-size: 13px; } +.unit-detail ol, .unit-detail ul, .comparison ul { margin: 0; padding-left: 1.1rem; display: grid; gap: 4px; } +.unit-detail li { display: flex; flex-wrap: wrap; gap: 2px 10px; align-items: center; min-width: 0; max-width: 100%; } +.unit-detail li .muted { white-space: nowrap; } +.unit-toggle { min-height: 32px; } +.count { white-space: normal; } .chapter-children { display: grid; gap: 8px; margin-top: 8px; } .pick-bar { display: flex; -- 2.43.0 From c138df5e688dd5ab34bc02856d9c6df375f5f03c Mon Sep 17 00:00:00 2001 From: Lars Date: Sun, 18 Oct 2026 10:03:14 +0200 Subject: [PATCH 02/24] Halte lokale Testdateien und Medien aus dem Repository, damit sie bei einem spaeteren Commit nicht auf das Development-System gelangen. Co-authored-by: Cursor --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index da64b01..d27b169 100644 --- a/.gitignore +++ b/.gitignore @@ -43,3 +43,6 @@ tmp/ temp/ data/local/ *.db +backend/data/ +backend/.pytest-tmp/ +backend/.pytest-export-tmp/ -- 2.43.0 From c774fb720640c043d8af50935e28da7e67bcc7db Mon Sep 17 00:00:00 2001 From: Lars Date: Sun, 18 Oct 2026 10:35:32 +0200 Subject: [PATCH 03/24] Lege Anlagen und Versandbelege direkt am Schriftstueck ab, damit die Zuordnung aus dem Vorgang gezogen werden kann und mehrere Belege an einem Versand bleiben. Co-authored-by: Cursor --- backend/app/api/correspondence.py | 21 ++ backend/app/api/schemas.py | 6 + backend/app/correspondence.py | 39 ++ backend/tests/test_correspondence.py | 11 + docs/architecture/API_REFERENZ.md | 1 + docs/architecture/TSUMUGU_TECHNICAL_SPEC.md | 2 +- frontend/src/pages/content.jsx | 373 ++++++++++++++----- frontend/src/pages/correspondence.jsx | 382 ++++++++++++++------ frontend/src/styles.css | 28 +- 9 files changed, 663 insertions(+), 200 deletions(-) diff --git a/backend/app/api/correspondence.py b/backend/app/api/correspondence.py index 6d79b22..1ee8bfa 100644 --- a/backend/app/api/correspondence.py +++ b/backend/app/api/correspondence.py @@ -14,6 +14,7 @@ from app.api.schemas import ( AttachmentDetachIn, AttachmentOrderIn, DispatchCorrectIn, + DispatchEvidenceDetachIn, DispatchEvidenceIn, DispatchIn, FoldIn, @@ -22,6 +23,7 @@ from app.correspondence import ( GapNote, add_dispatch_evidence, assign_attachments, + detach_dispatch_evidence, correct_dispatch, detach_attachment, dispatch_view, @@ -173,6 +175,25 @@ def post_evidence( ) +@router.post("/api/v1/dispatches/{dispatch_id}/evidence/{element_id}/detach", status_code=204) +def post_detach_evidence( + dispatch_id: UUID, + element_id: UUID, + body: DispatchEvidenceDetachIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + detach_dispatch_evidence( + conn, + principal.account_id, + dispatch_id, + element_id, + body.expected_version, + _ctx(body.context), + _placement(body.placement), + ) + + @router.post("/api/v1/dispatches/{dispatch_id}/correct") def post_correct( dispatch_id: UUID, diff --git a/backend/app/api/schemas.py b/backend/app/api/schemas.py index 2ede6b0..7fa123d 100644 --- a/backend/app/api/schemas.py +++ b/backend/app/api/schemas.py @@ -424,6 +424,12 @@ class DispatchEvidenceIn(APIModel): fold: Literal["keep", "evidence"] = "keep" +class DispatchEvidenceDetachIn(APIModel): + expected_version: int = Field(ge=1) + context: ContextIn + placement: ContextIn | None = None + + class DispatchCorrectIn(APIModel): expected_version: int = Field(ge=1) context: ContextIn diff --git a/backend/app/correspondence.py b/backend/app/correspondence.py index 654abb2..25274e5 100644 --- a/backend/app/correspondence.py +++ b/backend/app/correspondence.py @@ -291,6 +291,33 @@ def add_dispatch_evidence( return row +def detach_dispatch_evidence( + conn, + actor: UUID, + dispatch_id: UUID, + element_id: UUID, + expected: int, + context: Ctx, + placement: Ctx | None, +) -> None: + container_row, page, scope = open_container(conn, actor, context, placement, "edit") + dispatch = _dispatch_in(conn, dispatch_id, scope) + _bump_dispatch(conn, dispatch_id, expected) + deleted = conn.execute( + """ + DELETE FROM dispatch_evidence + WHERE dispatch_id = %s AND element_id = %s + RETURNING id + """, + (dispatch_id, element_id), + ).fetchone() + if deleted is None: + raise not_found() + _clear_evidence_fold(conn, scope, element_id) + _log(conn, dispatch_id, actor, "Nachweis aus diesem Versand gelöst") + audit(conn, actor, container_row["home_scope_id"], "dispatch_evidence_detached", "element", dispatch["host_element_id"], page) + + def correct_dispatch( conn, actor: UUID, @@ -1254,6 +1281,18 @@ def _set_binding_fold(conn, scope: Ctx, element_id: UUID, fold: str) -> None: ) +def _clear_evidence_fold(conn, scope: Ctx, element_id: UUID) -> None: + if _is_evidence(conn, scope, element_id): + return + conn.execute( + """ + UPDATE bindings SET list_fold = NULL + WHERE element_id = %s AND context_kind = %s AND context_id = %s AND list_fold = 'evidence' + """, + (element_id, scope.kind, scope.id), + ) + + def _clear_attachment_fold(conn, scope: Ctx, element_id: UUID) -> None: if _is_attachment(conn, scope, element_id): return diff --git a/backend/tests/test_correspondence.py b/backend/tests/test_correspondence.py index a7ea527..6c9f056 100644 --- a/backend/tests/test_correspondence.py +++ b/backend/tests/test_correspondence.py @@ -470,6 +470,17 @@ def test_dispatch_keeps_the_secured_stand_and_distinct_mail_parts(client, db, mo 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", diff --git a/docs/architecture/API_REFERENZ.md b/docs/architecture/API_REFERENZ.md index dbc7c10..73db9d2 100644 --- a/docs/architecture/API_REFERENZ.md +++ b/docs/architecture/API_REFERENZ.md @@ -188,6 +188,7 @@ Alle schreibenden Aufrufe prüfen den Handlungskontext, `expected_version` und d | PATCH | `/api/v1/bindings/{id}/fold` | Vorkommen als Anlage, Nachweis oder wieder eigenständig | | POST | `/api/v1/elements/{id}/dispatches` | Versand dokumentieren und Fassung sichern oder als Lücke kennzeichnen | | POST | `/api/v1/dispatches/{id}/evidence` | Nachweis ergänzen | +| POST | `/api/v1/dispatches/{id}/evidence/{element_id}/detach` | nur diesen Beleg vom Versand lösen | | POST | `/api/v1/dispatches/{id}/correct` | Weg, Datum oder Gegenüber berichtigen | | GET | `/api/v1/dispatches/{id}` | Manifest, Nachweise, Berichtigungen | | GET | `/api/v1/dispatches/{id}/items/{item_id}/content` | gesicherte Bytes; eine Lücke liefert 404 und nicht die aktuelle Datei | diff --git a/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md b/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md index ff24d4b..9a4f528 100644 --- a/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md +++ b/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md @@ -223,7 +223,7 @@ Auth-Tabellen `auth_accounts` und `auth_sessions` folgen dem Auth-Blueprint. Ein Akten und Vorgänge speichern `content_order` (`date` oder `position`) und `content_order_dir` (`asc` oder `desc`). Bestehende Zeilen bleiben auf `position`, damit eine schon gesetzte Einbindungsreihenfolge nicht ersetzt wird. Neue Akten und Vorgänge beginnen mit fachlichem Datum aufsteigend. `bindings.position` gehört zur Einbindung. Die Datumssortierung schreibt sie nicht um. `PATCH /api/v1/cases/{id}/content-order` und `POST /api/v1/cases/{id}/bindings/order` sowie die gleichen Pfade unter `matters` prüfen das Bearbeitungsrecht im Handlungskontext und `expected_version`. Der fachliche Verlauf liest die Datumsfelder der sichtbaren Unterlagen einmal je Element. Das Änderungsprotokoll bleibt `GET .../chronology`, seitenweise über `cursor`. `content_view` ist `structure` oder `chronology` und nur eine Darstellung. Sie schreibt Kapitel, Positionen und Datumssortierung nicht um. Der Breadcrumb eines Vorgangs ist der Objektpfad `Vorgänge` und gegebenenfalls der lesbare Elternvorgang; lesbare Aktenzuordnungen stehen separat in `placements` und wechseln den Handlungskontext nur bei bewusster Auswahl. `elements.summary` ist eine optionale gemeinsame Kurzbeschreibung. Ein Textauszug entsteht nur aus vorhandenem Notiztext. Bild- und PDF-Vorschauen verwenden denselben berechtigten Dateiabruf wie das Öffnen. -Anlagen, Versand und Nachweise sind eigene Verwendungen im Behälter der Einbindung, nicht im geerbten Aktenkontext. `attachment_uses` ordnet ein vorhandenes Element einem Hauptschriftstück zu, mit eigener Reihenfolge je Behälter und ohne Dateikopie. `bindings.list_fold` blendet nur dieses Vorkommen als Anlage oder Nachweis aus; andere Einbindungen bleiben. `dispatches` hält Weg, Versanddatum, Gegenüber, Vollständigkeit und Herkunft (`captured` oder `reconstructed`). `dispatch_items` ist das Manifest. Eine sicherbare Fassung liegt als Bytes unter `MEDIA_ROOT/dispatch/` in `dispatch_snapshots`, bei Notizen zusätzlich als JSON im Manifest. Eine fehlende historische Fassung bleibt `gap` und wird nicht durch die aktuelle Arbeitsdatei ersetzt. `dispatch_evidence` verknüpft einen vorhandenen Beleg in der Rolle E-Mail, Einlieferung, Zustellung oder sonstiger Nachweis. Einlieferung setzt keinen Zustellstatus. Berichtigungen stehen in `dispatch_corrections` und ändern die gesicherten Bytes nicht. Löschen eines Elements entfernt die Bytes seiner Versandfassungen über denselben Löschpfad wie die Arbeitsdatei. Lesen des Hauptschriftstücks öffnet keine gesperrte Anlage. Exportknoten `attachment`, `dispatch_item` und `evidence` unterscheiden Arbeitsstand, gesicherte Fassung und Nachweis. Eine unvollständige Auswahl ist ein Auszug. Eine ausgewählte E-Mail bleibt das vollständige Original. +Anlagen, Versand und Nachweise sind eigene Verwendungen im Behälter der Einbindung, nicht im geerbten Aktenkontext. `attachment_uses` ordnet ein vorhandenes Element einem Hauptschriftstück zu, mit eigener Reihenfolge je Behälter und ohne Dateikopie. `bindings.list_fold` blendet nur dieses Vorkommen als Anlage oder Nachweis aus; andere Einbindungen bleiben. `dispatches` hält Weg, Versanddatum, Gegenüber, Vollständigkeit und Herkunft (`captured` oder `reconstructed`). `dispatch_items` ist das Manifest. Eine sicherbare Fassung liegt als Bytes unter `MEDIA_ROOT/dispatch/` in `dispatch_snapshots`, bei Notizen zusätzlich als JSON im Manifest. Eine fehlende historische Fassung bleibt `gap` und wird nicht durch die aktuelle Arbeitsdatei ersetzt. `dispatch_evidence` verknüpft einen vorhandenen Beleg in der Rolle E-Mail, Einlieferung, Zustellung oder sonstiger Nachweis. Am Schriftstück liegt dafür ein eigenes Ablagefeld; mehrere Belege eines Versands bleiben nebeneinander. Ziehen aus der Liste ordnet zu, Ziehen zurück in die Liste löst nur diese Verwendung. Einlieferung setzt keinen Zustellstatus. Berichtigungen stehen in `dispatch_corrections` und ändern die gesicherten Bytes nicht. Löschen eines Elements entfernt die Bytes seiner Versandfassungen über denselben Löschpfad wie die Arbeitsdatei. Lesen des Hauptschriftstücks öffnet keine gesperrte Anlage. Exportknoten `attachment`, `dispatch_item` und `evidence` unterscheiden Arbeitsstand, gesicherte Fassung und Nachweis. Eine unvollständige Auswahl ist ein Auszug. Eine ausgewählte E-Mail bleibt das vollständige Original. ### 4.3 Überblick diff --git a/frontend/src/pages/content.jsx b/frontend/src/pages/content.jsx index 7c52f9b..54740b8 100644 --- a/frontend/src/pages/content.jsx +++ b/frontend/src/pages/content.jsx @@ -27,6 +27,7 @@ import { scopeBody, unitMarks, UnitDetail, + writeAssign, } from "./correspondence.jsx"; export function formatDate(value) { @@ -839,9 +840,9 @@ function EntryActions({ ) : null} {canSort && custom ? : null} {canSort && custom ? : null} - {canEdit && onAttach ? : null} + {canEdit && onAttach ? : null} {canEdit && onDispatch ? : null} - {canEdit && onEvidence ? : null} + {canEdit && onEvidence ? : null} {canEdit ? : null} {canEdit && canDestroy ? : null} @@ -857,11 +858,12 @@ function TypeGlyph({ name, tone, size = 28 }) { width={size} height={size} alt="" + draggable={false} /> ); } -function EntryMark({ element, context }) { +function EntryMark({ element, context, assignable = false, onAssignStart, onAssignEnd }) { const symbol = elementSymbol(element); const photo = symbol === "image" && Boolean(element.preview?.available); const [url, setUrl] = useState(""); @@ -883,8 +885,16 @@ function EntryMark({ element, context }) { }; }, [photo, element.id, element.preview?.source, context?.kind, context?.id]); return ( - - {url ? : ( + + {url ? : ( <> @@ -939,14 +949,16 @@ export function ContentBoard({ const [error, setError] = useState(""); const [pending, setPending] = useState(false); const [dialog, setDialog] = useState(null); - const [openUnits, setOpenUnits] = useState(() => new Set()); const [draggingId, setDraggingId] = useState(""); + const [carry, setCarry] = useState(null); const [indicator, setIndicator] = useState(null); const [folded, setFolded] = useState(() => new Set()); const [picking, setPicking] = useState(false); const [picked, setPicked] = useState(() => new Set()); const [pickTarget, setPickTarget] = useState(""); const dragRef = useRef(null); + const carryRef = useRef(null); + const releaseRef = useRef(null); const rootRef = useRef(null); const savingDirection = useRef(false); const custom = record?.content_order === "position"; @@ -1081,6 +1093,10 @@ export function ContentBoard({ const node = rootRef.current; if (!node) return undefined; function place(event) { + if (carryRef.current) { + event.preventDefault(); + return; + } const drag = dragRef.current; if (!drag?.html5) return; event.preventDefault(); @@ -1096,6 +1112,17 @@ export function ContentBoard({ setIndicator({ sectionId, index: drag.index }); } function drop(event) { + const carried = carryRef.current; + if (carried) { + if (event.target?.closest?.(".drop-well")) return; + if (carried.source === "attachment" || carried.source === "evidence") { + event.preventDefault(); + releaseRef.current?.(carried); + } + carryRef.current = null; + setCarry(null); + return; + } if (!dragRef.current?.html5) return; place(event); finishDragRef.current(dragRef.current); @@ -1456,6 +1483,125 @@ export function ContentBoard({ }, 0); } + function beginCarry(payload) { + carryRef.current = payload; + setCarry(payload); + } + + function endCarry() { + carryRef.current = null; + setCarry(null); + } + + function bindingByElement(elementId) { + return source.find((item) => item.element?.id === elementId) || null; + } + + function dispatchOf(dispatchId) { + for (const item of source) { + const found = (item.correspondence?.dispatches || []).find((entry) => entry.id === dispatchId); + if (found) return { host: item, dispatch: found }; + } + return null; + } + + const correspondenceScope = () => scopeBody(actionContext(), containerKind, containerId); + + async function releaseToList(payload) { + setPending(true); + setError(""); + try { + const scope = correspondenceScope(); + if (payload.source === "attachment") { + const host = bindingByElement(payload.hostElementId); + if (!host) return; + await api(`/api/v1/elements/${host.element.id}/attachments/${payload.elementId}/detach`, { + method: "POST", + body: { expected_version: host.element.version, ...scope }, + }); + } else if (payload.source === "evidence") { + const found = dispatchOf(payload.dispatchId); + if (!found) return; + await api(`/api/v1/dispatches/${found.dispatch.id}/evidence/${payload.elementId}/detach`, { + method: "POST", + body: { expected_version: found.dispatch.version, ...scope }, + }); + } + const item = bindingByElement(payload.elementId); + if (item?.correspondence?.fold) { + await restoreFold(item.id, item.element.version, scope); + } + onChange(); + } catch (err) { + setError(err.message); + } finally { + setPending(false); + } + } + + releaseRef.current = releaseToList; + + async function dropAttachment(hostBinding, payload) { + if (!payload || payload.elementId === hostBinding.element.id) return; + const already = (hostBinding.correspondence?.attachments || []).some((item) => item.element_id === payload.elementId); + if (payload.source === "attachment" && payload.hostElementId === hostBinding.element.id) return; + if (already) { + setError("Diese Anlage ist dem Schreiben bereits zugeordnet."); + return; + } + setPending(true); + setError(""); + try { + const scope = correspondenceScope(); + if (payload.source === "attachment") { + const from = bindingByElement(payload.hostElementId); + if (!from) return; + await api(`/api/v1/elements/${from.element.id}/attachments/${payload.elementId}/detach`, { + method: "POST", + body: { expected_version: from.element.version, ...scope }, + }); + } + if (payload.source === "evidence") { + const found = dispatchOf(payload.dispatchId); + if (!found) return; + await api(`/api/v1/dispatches/${found.dispatch.id}/evidence/${payload.elementId}/detach`, { + method: "POST", + body: { expected_version: found.dispatch.version, ...scope }, + }); + } + await api(`/api/v1/elements/${hostBinding.element.id}/attachments`, { + method: "POST", + body: { + expected_version: hostBinding.element.version, + attachment_element_ids: [payload.elementId], + fold: "attachment", + ...scope, + }, + }); + onChange(); + } catch (err) { + setError(err.message); + } finally { + setPending(false); + } + } + + function dropReceipt(hostBinding, payload, dispatch) { + if (!payload || payload.elementId === hostBinding.element.id) return; + if (payload.source === "evidence" && dispatch && payload.dispatchId === dispatch.id) return; + const item = bindingByElement(payload.elementId); + const found = payload.source === "evidence" ? dispatchOf(payload.dispatchId) : null; + setDialog({ + type: "evidence", + binding: item || { element: { id: payload.elementId, title: payload.title || "Unterlage", version: 1 } }, + hosts: [hostBinding], + dispatchId: dispatch ? dispatch.id : "", + replace: found && (!dispatch || found.dispatch.id !== dispatch.id) + ? { dispatchId: found.dispatch.id, version: found.dispatch.version } + : null, + }); + } + function beginDrag(event, drag) { if (pending || (event.button != null && event.button !== 0)) return; event.preventDefault(); @@ -1509,7 +1655,7 @@ export function ContentBoard({ - +
) : null} @@ -1520,34 +1666,54 @@ export function ContentBoard({ ) : (

Noch keine Unterlage und keine Notiz.

)} - setDialog(null)}> + setDialog(null)}> {dialog?.type === "bulk" && !dialog.host ? ( -
{ + { event.preventDefault(); - const host = listed.find((item) => item.id === new FormData(event.currentTarget).get("host")); - if (!host) return; - const candidates = listed.filter((item) => picked.has(item.id) && item.id !== host.id); - setDialog({ type: "attach", host, candidates }); + const host = source.find((item) => item.id === new FormData(event.currentTarget).get("host")); + const ids = [...picked].map((id) => source.find((item) => item.id === id)).filter((item) => item && item.id !== host?.id).map((item) => item.element.id); + if (!host || !ids.length) return; + setPending(true); + setError(""); + try { + await api(`/api/v1/elements/${host.element.id}/attachments`, { + method: "POST", + body: { + expected_version: host.element.version, + attachment_element_ids: ids, + fold: "attachment", + ...scopeBody(actionContext(), containerKind, containerId), + }, + }); + setDialog(null); + setPicked(new Set()); + setPicking(false); + onChange(); + } catch (err) { + setError(err.message); + } finally { + setPending(false); + } }}> -

Hauptschriftstück für die ausgewählten Unterlagen wählen. Die Kapitel bleiben bestehen, bis sie separat aufgelöst werden.

+

Die ausgewählten Unterlagen werden Anlagen dieses Schriftstücks und verschwinden aus der normalen Liste. Zurückziehen legt sie wieder dorthin.

- +
) : null} {dialog?.type === "attach" && dialog.host ? ( item.id === dialog.host.id) || dialog.host} + candidates={source.filter((item) => item.element.id !== (source.find((entry) => entry.id === dialog.host.id) || dialog.host).element.id)} scope={scopeBody(actionContext(), containerKind, containerId)} pending={pending} onClose={() => setDialog(null)} - onDone={() => { setDialog(null); setPicked(new Set()); setPicking(false); onChange(); }} + onDone={() => onChange()} /> ) : null}
@@ -1562,11 +1728,34 @@ export function ContentBoard({ /> ) : null}
- setDialog(null)}> + setDialog(null)}> + {dialog?.type === "receipt-source" ? ( +
+

Unterlage aus diesem Vorgang als Beleg von {dialog.host.element.title}.

+
    + {source.filter((item) => item.element.id !== dialog.host.element.id).map((item) => ( +
  • + {item.element.title} + +
  • + ))} +
+ {!source.filter((item) => item.element.id !== dialog.host.element.id).length ?

Keine weitere Unterlage.

: null} +
+ ) : null} +
+ setDialog(null)}> {dialog?.type === "evidence" ? ( item.element.id !== dialog.binding.element.id)} + hosts={dialog.hosts || source.filter((item) => item.element.id !== dialog.binding.element.id)} + presetDispatchId={dialog.dispatchId} + replace={dialog.replace || null} scope={scopeBody(actionContext(), containerKind, containerId)} pending={pending} onClose={() => setDialog(null)} @@ -1749,11 +1938,32 @@ export function ContentBoard({