diff --git a/backend/app/api/export.py b/backend/app/api/export.py new file mode 100644 index 0000000..591a17f --- /dev/null +++ b/backend/app/api/export.py @@ -0,0 +1,99 @@ +"""Handover package: selection tree, completeness review, ZIP download.""" + +from __future__ import annotations + +from urllib.parse import quote +from uuid import UUID + +from fastapi import APIRouter, Depends, Request, Response +from psycopg import Connection + +from app.access.policy import Ctx, parse_query_context +from app.api.deps import Principal, get_conn, get_principal +from app.api.schemas import ExportIn +from app.core.errors import unprocessable +from app.exporting import build_export, export_tree, review_export + +router = APIRouter() + + +def _disposition(filename: str) -> str: + # Header values stay ASCII. The readable name travels in filename*. + encoded = quote(filename) + return f"attachment; filename=\"uebergabe.zip\"; filename*=UTF-8''{encoded}" + + +def _context(value) -> Ctx | None: + return None if value is None else Ctx(value.kind, value.id) + + +def _selection(body: ExportIn) -> tuple[list[str], dict[str, UUID]]: + if len(body.assignments) > 200: + raise unprocessable("Die Zuordnung der Zugänge ist zu umfangreich.") + return list(body.selected), dict(body.assignments) + + +@router.get("/api/v1/matters/{matter_id}/export-tree") +def get_export_tree( + matter_id: UUID, + context_kind: str | None = None, + context_id: str | None = None, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + return export_tree( + conn, + principal.account_id, + matter_id, + parse_query_context(context_kind, context_id), + ) + + +@router.post("/api/v1/matters/{matter_id}/export/review") +def post_export_review( + matter_id: UUID, + body: ExportIn, + request: Request, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + selected, assignments = _selection(body) + plan = review_export( + conn, + principal.account_id, + matter_id, + _context(body.context), + selected, + assignments, + request.app.state.settings.media_root, + ) + return plan.review() + + +@router.post("/api/v1/matters/{matter_id}/export") +def post_export( + matter_id: UUID, + body: ExportIn, + request: Request, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + selected, assignments = _selection(body) + filename, payload = build_export( + conn, + principal.account_id, + matter_id, + _context(body.context), + selected, + assignments, + request.app.state.settings.media_root, + ) + return Response( + content=payload, + media_type="application/zip", + headers={ + "Content-Disposition": _disposition(filename), + "X-Content-Type-Options": "nosniff", + "Cache-Control": "private, no-store", + }, + ) diff --git a/backend/app/api/schemas.py b/backend/app/api/schemas.py index 8390e50..d499741 100644 --- a/backend/app/api/schemas.py +++ b/backend/app/api/schemas.py @@ -340,3 +340,9 @@ class TaskDependencyIn(APIModel): class ElementReferenceIn(APIModel): refers_to_element_id: UUID context: ContextIn | None = None + + +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) diff --git a/backend/app/exporting.py b/backend/app/exporting.py new file mode 100644 index 0000000..a3b07d5 --- /dev/null +++ b/backend/app/exporting.py @@ -0,0 +1,793 @@ +"""Hierarchical export of one matter into a self-contained handover package.""" + +from __future__ import annotations + +import html +import io +import zipfile +from dataclasses import dataclass, field +from datetime import datetime, timezone +from pathlib import PurePosixPath +from urllib.parse import quote +from uuid import UUID + +from app.access.policy import ( + Ctx, + audit, + element_rights, + get_element, + get_matter, + matter_rights, +) +from app.core.errors import not_found, unprocessable +from app.core.timeutil import dump_dt, utcnow +from app.present import _chapters, _ordered_bindings +from app.retrieval import ( + FilePayload, + MailPayload, + RetrievalFailure, + load_external, + load_file, +) + +_NODE_KINDS = {"binding", "annotation"} +_DIRECTION = {"in": "Eingang", "out": "Ausgang"} +_KIND_LABEL = { + "note": "Notiz", + "file": "Datei", + "email": "E-Mail", + "paperless": "Paperless", + "url": "Webadresse", + "annotation": "Anmerkung", + "chapter": "Kapitel", + "matter": "Teilvorgang", + "root": "Vorgang", +} + + +@dataclass +class ExportNode: + id: str + kind: str + title: str + exportable: bool + reason: str | None + content_kind: str | None + children: list[ExportNode] = field(default_factory=list) + element_id: str | None = None + summary: str | None = None + direction: str | None = None + dates: dict | None = None + annotation_body: str | None = None + annotation_author: str | None = None + annotation_at: str | None = None + label: str = "" + + def public(self) -> dict: + return { + "id": self.id, + "kind": self.kind, + "title": self.title, + "label": self.label or _KIND_LABEL.get(self.kind, ""), + "exportable": self.exportable, + "reason": self.reason, + "content_kind": self.content_kind, + "children": [child.public() for child in self.children], + } + + +@dataclass +class Issue: + node_id: str + title: str + code: str + message: str + choices: list[dict] = field(default_factory=list) + + def public(self) -> dict: + body = { + "node_id": self.node_id, + "title": self.title, + "code": self.code, + "message": self.message, + } + if self.choices: + body["choices"] = self.choices + return body + + +@dataclass +class Notice: + node_id: str + message: str + + def public(self) -> dict: + return {"node_id": self.node_id, "message": self.message} + + +@dataclass +class Entry: + node_id: str + title: str + kind_label: str + path: str | None + links: list[tuple[str, str]] + dates: dict + direction: str | None + summary: str | None + notice: str | None + replies: list[tuple[str, str]] + recorded_at: str | None + + def public(self) -> dict: + return { + "node_id": self.node_id, + "title": self.title, + "kind_label": self.kind_label, + "path": self.path, + "links": [{"label": label, "path": path} for label, path in self.links], + } + + +@dataclass +class ExportPlan: + matter_title: str + generated_at: str + ready: bool + issues: list[Issue] + notices: list[Notice] + entries: list[Entry] + files: list[tuple[str, bytes]] + tree: ExportNode + + def review(self) -> dict: + return { + "ready": self.ready, + "matter_title": self.matter_title, + "issues": [item.public() for item in self.issues], + "notices": [item.public() for item in self.notices], + "entries": [item.public() for item in self.entries], + } + + +def export_tree(conn, actor: UUID, matter_id: UUID, context: Ctx | None) -> dict: + matter, page = _require_matter(conn, actor, matter_id, context) + root = _matter_node(conn, actor, matter, page, root=True) + return {"matter_id": str(matter["id"]), "context": None if context is None else context.as_dict(), "tree": root.public()} + + +def review_export( + conn, + actor: UUID, + matter_id: UUID, + context: Ctx | None, + selected: list[str], + assignments: dict[str, UUID], + media_root: str, +) -> ExportPlan: + return _plan(conn, actor, matter_id, context, selected, assignments, media_root) + + +def build_export( + conn, + actor: UUID, + matter_id: UUID, + context: Ctx | None, + selected: list[str], + assignments: dict[str, UUID], + media_root: str, +) -> tuple[str, bytes]: + plan = _plan(conn, actor, matter_id, context, selected, assignments, media_root) + if not plan.ready: + detail = " ".join(f"{item.title}: {item.message}" for item in plan.issues[:8]) + raise unprocessable(detail or "Das Paket ist nicht vollständig.") + matter = get_matter(conn, matter_id) + audit(conn, actor, matter["home_scope_id"], "export_created", "matter", matter_id, context) + return _zip_name(plan.matter_title), _zip_bytes(plan.files) + + +def _plan(conn, actor, matter_id, context, selected, assignments, media_root) -> ExportPlan: + matter, page = _require_matter(conn, actor, matter_id, context) + root = _matter_node(conn, actor, matter, page, root=True) + chosen = _chosen(root, selected) + leaves = [node for node in _walk(root) if node.id in chosen and node.kind in _NODE_KINDS] + issues: list[Issue] = [] + notices: list[Notice] = [] + loaded: dict[str, FilePayload | MailPayload | str] = {} + hashes = _local_hashes(conn, root, chosen) + for node in leaves: + if not node.exportable: + issues.append(Issue(node.id, node.title, "rights", node.reason or "Für die Übergabe fehlt die Freigabebefugnis.")) + continue + if node.kind == "annotation": + loaded[node.id] = node.annotation_body or "" + continue + if node.content_kind == "note": + loaded[node.id] = _note_text(conn, UUID(node.element_id)) + continue + if node.content_kind == "file": + result = load_file(conn, UUID(node.element_id), media_root) + elif node.content_kind in {"email", "paperless", "url"}: + result = load_external(conn, actor, UUID(node.element_id), assignments.get(node.id)) + else: + result = RetrievalFailure("capability", "Für diesen Inhalt ist kein Originalabruf vorgesehen.") + if isinstance(result, RetrievalFailure): + issues.append(Issue(node.id, node.title, result.code, result.message, [dict(item) for item in result.choices])) + continue + loaded[node.id] = result + if isinstance(result, MailPayload): + notices.extend(_retention_notices(node, result, hashes)) + issues.extend(_reference_issues(conn, actor, page, leaves)) + generated = dump_dt(utcnow()) or "" + if issues: + entries = [ + Entry(node.id, node.title, _label(node), None, [], node.dates or {}, node.direction, node.summary, None, [], _recorded(node)) + for node in leaves + ] + return ExportPlan(matter["title"], generated, False, issues, notices, entries, [], root) + files, entries = _layout(root, chosen, loaded, notices, generated) + _attach_replies(conn, actor, page, entries, leaves) + _stitch_replies(files, entries) + files = _with_overview(matter["title"], generated, entries, files) + return ExportPlan(matter["title"], generated, True, [], notices, entries, files, root) + + +def _require_matter(conn, actor: UUID, matter_id: UUID, context: Ctx | None): + matter = get_matter(conn, matter_id) + if matter is None: + raise not_found() + # A matter context that names the matter itself is the direct view, as with notes. + access = None if context is not None and context.kind == "matter" and context.id == matter["id"] else context + if not matter_rights(conn, actor, matter, access).read: + raise not_found() + return matter, context or Ctx("matter", matter_id) + + +def _matter_node(conn, actor, matter, page: Ctx, root: bool) -> ExportNode: + mode = matter.get("content_order") or "position" + direction = matter.get("content_order_dir") or "asc" + chapters = _chapters(conn, "matter", matter["id"], mode, direction) + bindings = _ordered_bindings(conn, actor, "matter", matter["id"], page, mode, direction) + grouped: dict[str | None, list] = {} + for binding in bindings: + grouped.setdefault(binding.get("chapter_id"), []).append(binding) + children: list[ExportNode] = [] + for chapter in chapters: + items = grouped.get(chapter["id"], []) + if not items: + continue + children.append( + ExportNode( + id=f"chapter:{chapter['id']}", + kind="chapter", + title=chapter["title"], + exportable=True, + reason=None, + content_kind=None, + children=[_binding_node(item) for item in items], + label="Kapitel", + ) + ) + for binding in grouped.get(None, []): + children.append(_binding_node(binding)) + rows = conn.execute( + "SELECT * FROM matters WHERE parent_matter_id = %s AND deleted_at IS NULL ORDER BY title, id", + (matter["id"],), + ).fetchall() + for child in rows: + if not matter_rights(conn, actor, child, page).read: + continue + children.append(_matter_node(conn, actor, child, page, root=False)) + return ExportNode( + id=f"matter:{matter['id']}", + kind="matter", + title=matter["title"], + exportable=True, + reason=None, + content_kind=None, + children=children, + label="Vorgang" if root else "Teilvorgang", + ) + + +def _binding_node(binding: dict) -> ExportNode: + element = binding["element"] + rights = binding["rights"] + content_kind = _content_kind(element) + exportable = bool(rights.get("read") and rights.get("share")) + reason = None if exportable else "Für die Übergabe fehlt die Freigabebefugnis." + dates = element.get("dates") or {} + node = ExportNode( + id=f"binding:{binding['id']}", + kind="binding", + title=element["title"], + exportable=exportable, + reason=reason, + content_kind=content_kind, + element_id=element["id"], + summary=element.get("summary"), + direction=(binding.get("communication") or {}).get("direction"), + dates=dates, + label=_KIND_LABEL.get(content_kind, "Inhalt"), + ) + for note in binding.get("annotations") or []: + node.children.append( + ExportNode( + id=f"annotation:{note['id']}", + kind="annotation", + title=f"Anmerkung zu {element['title']}", + exportable=exportable, + reason=reason, + content_kind="annotation", + element_id=element["id"], + annotation_body=note.get("body") or "", + annotation_author=note.get("author_display_name") or "", + annotation_at=note.get("created_at"), + label="Anmerkung", + ) + ) + return node + + +def _content_kind(element: dict) -> str: + if element["kind"] == "note": + return "note" + if element["kind"] == "file": + return "file" + source = (element.get("external") or {}).get("source") + if source == "imap": + return "email" + if source == "paperless": + return "paperless" + if source == "url": + return "url" + return element["kind"] + + +def _chosen(root: ExportNode, selected: list[str]) -> set[str]: + known = {node.id for node in _walk(root) if node.kind in _NODE_KINDS} + unknown = [item for item in selected if item not in known] + if unknown: + raise unprocessable("Die Auswahl enthält einen unbekannten oder nicht sichtbaren Inhalt.") + if not selected: + raise unprocessable("Die Auswahl enthält keinen Inhalt.") + return set(selected) + + +def _walk(node: ExportNode): + yield node + for child in node.children: + yield from _walk(child) + + +def _note_text(conn, element_id: UUID) -> str: + row = conn.execute("SELECT document_json FROM note_bodies WHERE element_id = %s", (element_id,)).fetchone() + document = row["document_json"] if row else {} + parts = [] + for block in document.get("blocks") or []: + if isinstance(block, dict): + text = str(block.get("text") or "").strip() + if text: + parts.append(text) + return "\n\n".join(parts) + + +def _local_hashes(conn, root: ExportNode, chosen: set[str]) -> list[tuple[str, str, bool]]: + found = [] + for node in _walk(root): + if node.kind != "binding" or node.content_kind != "file" or not node.element_id: + continue + asset = conn.execute( + "SELECT sha256, status FROM media_assets WHERE element_id = %s", + (UUID(node.element_id),), + ).fetchone() + if asset is None or asset["status"] != "active" or not asset["sha256"]: + continue + found.append((node.id, asset["sha256"], node.id in chosen)) + return found + + +def _retention_notices(node: ExportNode, mail: MailPayload, hashes: list[tuple[str, str, bool]]) -> list[Notice]: + notices = [] + seen: set[str] = set() + for attachment in mail.parsed.attachments: + if any(digest == attachment.sha256 and not selected for _node_id, digest, selected in hashes): + if attachment.sha256 in seen: + continue + seen.add(attachment.sha256) + notices.append( + Notice( + node.id, + f"Die Anlage „{attachment.filename}“ bleibt Bestandteil dieser E-Mail. " + "Ein separates Vorkommen derselben Datei ist nicht ausgewählt.", + ) + ) + return notices + + +def _reference_issues(conn, actor, page: Ctx, leaves: list[ExportNode]) -> list[Issue]: + issues = [] + selected_elements = {node.element_id for node in leaves if node.kind == "binding" and node.element_id} + for node in leaves: + if node.kind != "binding" or not node.element_id: + continue + rows = conn.execute( + """ + SELECT refers_to_element_id + FROM element_references + WHERE element_id = %s + ORDER BY created_at, refers_to_element_id + """, + (UUID(node.element_id),), + ).fetchall() + for row in rows: + target = get_element(conn, row["refers_to_element_id"]) + if target is None or not element_rights(conn, actor, target, page).read: + issues.append(Issue(node.id, node.title, "reference", "Ein Antwortbezug lässt sich nicht auflösen.")) + continue + if str(target["id"]) not in selected_elements and str(target["id"]) != node.element_id: + continue + return issues + + +def _layout(root, chosen, loaded, notices, generated: str): + used: set[str] = {"index.html", "inhalt.md"} + files: list[tuple[str, bytes]] = [] + entries: list[Entry] = [] + notice_for = {} + for notice in notices: + notice_for.setdefault(notice.node_id, []).append(notice.message) + + def add(parts: list[str], data: bytes) -> str: + path = _unique_path(parts, used) + files.append((path, data)) + return path + + def rewrite(path: str, data: bytes) -> None: + for index, (existing, _data) in enumerate(files): + if existing == path: + files[index] = (path, data) + return + + def emit(node: ExportNode, prefix: list[str]) -> None: + folders = [child for child in node.children if _is_folder(child) and _included(child, chosen)] + numbers = {child.id: index + 1 for index, child in enumerate(folders)} + for child in node.children: + if child.id in numbers: + folder = prefix + [f"{numbers[child.id]:02d} {_segment(child.title)}"] + if child.kind == "binding" and child.content_kind == "email": + _emit_email(child, folder, add, rewrite, entries, loaded, notice_for, generated) + else: + emit(child, folder) + else: + _emit_loose(child, prefix, add, entries, loaded, notice_for, generated) + + 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_loose(node, prefix, add, entries, loaded, notice_for, generated: str) -> None: + if node.kind == "binding" and node.id in loaded and node.content_kind != "email": + payload = loaded[node.id] + if node.content_kind == "note": + path = add(prefix + [f"{_segment(node.title)}.md"], _note_markdown(node, str(payload), generated).encode("utf-8")) + entries.append(_entry(node, path, [], None)) + elif isinstance(payload, FilePayload): + path = add(prefix + [payload.filename], payload.data) + entries.append(_entry(node, path, [(payload.filename, path)], None)) + if node.kind == "binding": + for child in node.children: + if child.kind == "annotation" and child.id in loaded and not (node.content_kind == "email" and node.id in loaded): + path = add(prefix + [_annotation_filename(child, prefix)], _annotation_markdown(child).encode("utf-8")) + entries.append(_entry(child, path, [], None)) + elif node.kind == "annotation" and node.id in loaded: + path = add(prefix + [_annotation_filename(node, prefix)], _annotation_markdown(node).encode("utf-8")) + entries.append(_entry(node, path, [], None)) + + +def _entry(node: ExportNode, path: str | None, links, notice: str | None) -> Entry: + return Entry( + node.id, + node.title, + _label(node), + path, + links, + node.dates or {}, + node.direction, + node.summary, + notice, + [], + _recorded(node), + ) + + +def _attach_replies(conn, actor, page, entries: list[Entry], leaves: list[ExportNode]) -> None: + by_element: dict[str, str] = {} + nodes = {node.id: node for node in leaves} + for entry in entries: + node = nodes.get(entry.node_id) + if node and node.kind == "binding" and node.element_id and entry.path and node.element_id not in by_element: + by_element[node.element_id] = entry.path + for entry in entries: + node = nodes.get(entry.node_id) + if node is None or node.kind != "binding" or not node.element_id: + continue + rows = conn.execute( + """ + SELECT refers_to_element_id + FROM element_references + WHERE element_id = %s + ORDER BY created_at, refers_to_element_id + """, + (UUID(node.element_id),), + ).fetchall() + for row in rows: + target_id = str(row["refers_to_element_id"]) + target = get_element(conn, row["refers_to_element_id"]) + if target is None or not element_rights(conn, actor, target, page).read: + continue + path = by_element.get(target_id) + if path is None: + continue + entry.replies.append((target["title"], path)) + + +def _with_overview(title: str, generated: str, entries: list[Entry], files: list[tuple[str, bytes]]): + html_doc = _html_overview(title, generated, entries) + markdown = _markdown_overview(title, generated, entries) + return [("index.html", html_doc.encode("utf-8")), ("inhalt.md", markdown.encode("utf-8")), *files] + + +def _html_overview(title: str, generated: str, entries: list[Entry]) -> str: + items = [] + for entry in entries: + bits = [f"

{html.escape(entry.title)}

", f"

{html.escape(entry.kind_label)}

"] + facts = _fact_lines(entry, generated) + if facts: + bits.append("") + if entry.summary: + bits.append(f"

Kurzfassung: {html.escape(entry.summary)}

") + for label, path in _entry_links(entry): + bits.append(f'

{html.escape(label)}

') + for reply_title, path in entry.replies: + bits.append( + f'

Antwort auf {html.escape(reply_title)}

' + ) + if entry.notice: + bits.append(f"

{html.escape(entry.notice)}

") + items.append(f"
{''.join(bits)}
") + body = "".join(items) or "

Die bestätigte Auswahl enthält keinen ausgebbaren Inhalt.

" + return ( + "" + f"Übergabe {html.escape(title)}" + "" + f"

Übergabe {html.escape(title)}

" + f"

Erzeugt am {html.escape(generated)}. Fachliche Daten stehen bei den einzelnen Inhalten und sind kein Erzeugungszeitpunkt.

" + f"{body}" + ) + + +def _markdown_overview(title: str, generated: str, entries: list[Entry]) -> str: + lines = [ + f"# Übergabe {title}", + "", + f"Erzeugt am {generated}. Fachliche Daten stehen bei den einzelnen Inhalten und sind kein Erzeugungszeitpunkt.", + "", + ] + for entry in entries: + lines.append(f"## {entry.title}") + lines.append("") + lines.append(entry.kind_label) + lines.append("") + for fact in _fact_lines(entry, generated): + lines.append(f"- {fact}") + if entry.summary: + lines.append(f"- Kurzfassung: {entry.summary}") + for label, path in _entry_links(entry): + lines.append(f"- [{label}]({_href(path)})") + for reply_title, path in entry.replies: + lines.append(f"- Antwort auf [{reply_title}]({_href(path)})") + if entry.notice: + lines.append("") + lines.append(entry.notice) + lines.append("") + return "\n".join(lines).rstrip() + "\n" + + +def _entry_links(entry: Entry) -> list[tuple[str, str]]: + if entry.links: + return entry.links + if entry.path: + return [(entry.kind_label, entry.path)] + return [] + + +def _fact_lines(entry: Entry, generated: str) -> list[str]: + dates = entry.dates or {} + lines = [] + if dates.get("document_on"): + lines.append(f"Fachdatum: {dates['document_on']}") + if dates.get("sent_on"): + lines.append(f"Gesendet: {dates['sent_on']}") + if dates.get("received_on"): + lines.append(f"Empfangen: {dates['received_on']}") + if entry.recorded_at: + lines.append(f"Erfasst am: {entry.recorded_at}") + if entry.direction in _DIRECTION: + lines.append(_DIRECTION[entry.direction]) + lines.append(f"Stand der Ausgabe: {generated}") + return lines + + +def _note_markdown(node: ExportNode, body: str, generated: str) -> str: + lines = [f"# {node.title}", ""] + lines.extend(f"- {fact}" for fact in _fact_lines(_entry(node, None, [], None), generated)) + if node.summary: + lines.extend(["", f"Kurzfassung: {node.summary}"]) + lines.extend(["", body, ""]) + return "\n".join(lines) + + +def _mail_markdown(node, mail: MailPayload, text_path: str, eml_path: str, attachments, notice: str, generated: str) -> str: + parsed = mail.parsed + lines = [f"# {node.title}", "", "Lesefassung. Das unveränderte Original ist die EML-Datei.", ""] + lines.extend(f"- {fact}" for fact in _fact_lines(_entry(node, None, [], None), generated)) + if parsed.sender: + lines.append(f"- Von: {parsed.sender}") + if parsed.recipient: + lines.append(f"- An: {parsed.recipient}") + if parsed.copy: + lines.append(f"- Kopie: {parsed.copy}") + lines.append(f"- [EML-Original]({_href(_relative(text_path, eml_path))})") + lines.extend(["", parsed.text or "Der Text steht im EML-Original.", ""]) + if attachments: + lines.append("## Anlagen") + lines.append("") + for label, path in attachments: + lines.append(f"- [{label}]({_href(_relative(text_path, path))})") + lines.append("") + if notice: + lines.extend([notice, ""]) + return "\n".join(lines) + + +def _stitch_replies(files: list[tuple[str, bytes]], entries: list[Entry]) -> None: + positions = {path: index for index, (path, _data) in enumerate(files)} + for entry in entries: + if not entry.replies: + continue + target = entry.path if entry.path and entry.path.endswith(".md") else None + if target is None: + target = next((path for label, path in entry.links if label == "Lesefassung"), None) + if target is None or target not in positions: + continue + extra = ["", "## Antwortbezug", ""] + for title, path in entry.replies: + extra.append(f"- [{title}]({_href(_relative(target, path))})") + extra.append("") + index = positions[target] + files[index] = (target, files[index][1] + ("\n".join(extra)).encode("utf-8")) + + +def _annotation_markdown(node: ExportNode) -> str: + lines = [f"# {node.title}", ""] + if node.annotation_author or node.annotation_at: + who = node.annotation_author or "Unbekannt" + when = node.annotation_at or "" + lines.append(f"Verfasst von {who}" + (f", {when}" if when else "") + ".") + lines.append("") + lines.append(node.annotation_body or "") + lines.append("") + return "\n".join(lines) + + +def _annotation_filename(node: ExportNode, _prefix) -> str: + return f"{_segment(node.title)}.md" + + +def _is_folder(node: ExportNode) -> bool: + return node.kind in {"chapter", "matter"} or (node.kind == "binding" and node.content_kind == "email") + + +def _included(node: ExportNode, chosen: set[str]) -> bool: + if node.kind == "binding" and node.content_kind == "email": + return node.id in chosen + return any(child.id in chosen for child in _walk(node) if child.kind in _NODE_KINDS) + + +def _label(node: ExportNode) -> str: + return node.label or _KIND_LABEL.get(node.content_kind or node.kind, "Inhalt") + + +def _recorded(node: ExportNode) -> str | None: + if not node.dates: + return None + return node.dates.get("recorded_at") + + +def _segment(value: str) -> str: + cleaned = [] + for char in value or "": + if char in '\\/:*?"<>|' or ord(char) < 32: + cleaned.append(" ") + else: + cleaned.append(char) + text = " ".join("".join(cleaned).split()).strip(" .") + return (text or "Inhalt")[:80] + + +def _file_segment(value: str) -> str: + name = (value or "datei").replace("\\", "/").split("/")[-1] + return _segment(name) or "datei" + + +def _unique_path(parts: list[str], used: set[str]) -> str: + folder = [_segment(part) for part in parts[:-1]] + filename = _file_segment(parts[-1]) + path = "/".join([*folder, filename]) + if path not in used: + used.add(path) + return path + stem, dot, ext = filename.rpartition(".") + if not dot: + stem, extension = filename, "" + else: + extension = f".{ext}" + number = 2 + while True: + candidate = "/".join([*folder, f"{stem} ({number}){extension}"]) + if candidate not in used: + used.add(candidate) + return candidate + number += 1 + + +def _href(path: str) -> str: + return "/".join(quote(part) for part in PurePosixPath(path).parts) + + +def _relative(from_path: str, to_path: str) -> str: + source = PurePosixPath(from_path).parent.parts + target = PurePosixPath(to_path).parts + shared = 0 + while shared < len(source) and shared < len(target) and source[shared] == target[shared]: + shared += 1 + hops = [".."] * (len(source) - shared) + return "/".join([*hops, *target[shared:]]) or "." + + +def _zip_bytes(files: list[tuple[str, bytes]]) -> bytes: + buffer = io.BytesIO() + with zipfile.ZipFile(buffer, "w", compression=zipfile.ZIP_DEFLATED) as archive: + for path, data in files: + info = zipfile.ZipInfo(path) + info.flag_bits |= 0x800 + info.compress_type = zipfile.ZIP_DEFLATED + info.date_time = datetime.now(timezone.utc).timetuple()[:6] + archive.writestr(info, data) + return buffer.getvalue() + + +def _zip_name(title: str) -> str: + return f"Übergabe {_segment(title)}.zip" diff --git a/backend/app/main.py b/backend/app/main.py index cc3ee99..f748a18 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.export import router as export_router from app.api.routes import router from app.api.sources import router as sources_router from app.core.errors import Problem, problem_response @@ -115,6 +116,7 @@ def create_app() -> FastAPI: app.include_router(router) app.include_router(sources_router) + app.include_router(export_router) return app diff --git a/backend/app/present.py b/backend/app/present.py index fe163bb..beb6a87 100644 --- a/backend/app/present.py +++ b/backend/app/present.py @@ -936,6 +936,7 @@ LABELS = { "annotation_created": "Kontextbezogene Anmerkung erfasst", "file_added": "Datei hinzugefügt", "external_ref_added": "Externe Referenz erfasst", + "export_created": "Übergabepaket erzeugt", "binding_created": "Einbindung ergänzt", "binding_removed": "Einbindung entfernt", "element_deleted": "Element gelöscht", diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py index e67e3e3..1fe3d3d 100644 --- a/backend/tests/conftest.py +++ b/backend/tests/conftest.py @@ -8,6 +8,7 @@ from __future__ import annotations import os import tempfile +import time import psycopg import pytest @@ -28,17 +29,31 @@ os.environ["MEDIA_ROOT"] = tempfile.mkdtemp(prefix="tsumugu-pytest-") def _reset(settings) -> None: - with psycopg.connect(settings.dsn(), autocommit=True) as conn: - conn.execute( - """ - TRUNCATE TABLE - media_operations, - domain_events, - auth_accounts, - data_rooms - RESTART IDENTITY CASCADE - """ - ) + # The suite truncates between tests while the app pool may still release + # the previous request's transaction. A deadlock abort would roll back that + # transaction and the next login would fail. Waiting and retrying keeps the + # reset outside the product path. + last_error: Exception | None = None + for attempt in range(8): + try: + with psycopg.connect(settings.dsn(), autocommit=True) as conn: + conn.execute("SET lock_timeout = '1500ms'") + conn.execute( + """ + TRUNCATE TABLE + media_operations, + domain_events, + auth_accounts, + data_rooms + RESTART IDENTITY CASCADE + """ + ) + return + except (psycopg.errors.DeadlockDetected, psycopg.errors.LockNotAvailable) as exc: + last_error = exc + time.sleep(0.15 * (attempt + 1)) + if last_error is not None: + raise last_error @pytest.fixture(scope="session") @@ -83,6 +98,9 @@ def clean(database, client): @pytest.fixture -def db(database): +def db(database, clean): with psycopg.connect(database.dsn(), row_factory=psycopg.rows.dict_row) as conn: - yield conn + try: + yield conn + finally: + conn.rollback() diff --git a/backend/tests/test_export.py b/backend/tests/test_export.py new file mode 100644 index 0000000..2346c2b --- /dev/null +++ b/backend/tests/test_export.py @@ -0,0 +1,602 @@ +"""Handover package: hierarchy, complete mail, source identity, rights, failures.""" + +from __future__ import annotations + +import io +import json +import zipfile +from email.message import EmailMessage +from urllib.parse import unquote, urljoin + +import pytest + +from app.core.errors import Problem +from app.mailpack import choose_message, parse_mail +from app.sources import pull_paperless_original +from tests.support import ORIGIN, Actor, document, grant, register + +PDF_A = b"%PDF-1.4\n1 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nA\n" +PDF_B = b"%PDF-1.4\n2 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nB\n" +PDF_C = b"%PDF-1.4\n3 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nC\n" + + +def _eml(message_id: str, body: str, attachments: list[tuple[str, bytes]], subject: str = "Schreiben") -> bytes: + message = EmailMessage() + message["Subject"] = subject + message["From"] = "kanzlei@example.test" + message["To"] = "ada@example.test" + message["Message-ID"] = message_id + message["Date"] = "Thu, 12 Mar 2026 10:00:00 +0100" + message.set_content(body) + for name, data in attachments: + message.add_attachment(data, maintype="application", subtype="pdf", filename=name) + return message.as_bytes() + + +def _walk(node): + yield node + for child in node.get("children") or []: + yield from _walk(child) + + +def _parents(node, parent=None, found=None): + found = found if found is not None else {} + found[node["id"]] = parent + for child in node.get("children") or []: + _parents(child, node, found) + return found + + +def _under(node_id: str, title: str, parents: dict) -> bool: + current = parents.get(node_id) + while current is not None: + if current.get("title") == title: + return True + current = parents.get(current["id"]) + return False + + +def _post_zip(actor: Actor, matter_id: str, body: dict): + headers = { + "Origin": ORIGIN, + "X-CSRF-Token": actor.csrf, + "Content-Type": "application/json", + "X-Scope-Kind": actor.scope["kind"], + "X-Scope-Id": actor.scope["id"], + } + return actor.client.post(f"/api/v1/matters/{matter_id}/export", json=body, headers=headers) + + +def _archive(blob: bytes) -> zipfile.ZipFile: + return zipfile.ZipFile(io.BytesIO(blob)) + + +def _joined(archive: zipfile.ZipFile) -> str: + parts = [] + for name in archive.namelist(): + parts.append(name) + if name.endswith((".md", ".html", ".eml")): + parts.append(archive.read(name).decode("utf-8", errors="replace")) + return "\n".join(parts) + + +def _links_resolve(archive: zipfile.ZipFile) -> None: + html = archive.read("index.html").decode("utf-8") + names = set(archive.namelist()) + for chunk in html.split('href="')[1:]: + href = unquote(chunk.split('"', 1)[0]) + assert href in names, href + for name in archive.namelist(): + if not name.endswith(".md"): + continue + text = archive.read(name).decode("utf-8") + base = name.rsplit("/", 1)[0] + "/" if "/" in name else "" + for chunk in text.split("](")[1:]: + href = unquote(chunk.split(")", 1)[0]) + if href.startswith("http"): + continue + target = urljoin(base, href) + assert target in names, (name, href, target) + + +def test_duplicate_attachments_stay_distinct_and_identity_is_exact(): + raw = _eml("", "Volltext", [("lage.pdf", PDF_A), ("lage.pdf", PDF_B)]) + parsed = parse_mail(raw) + assert [item.filename for item in parsed.attachments] == ["lage.pdf", "lage (2).pdf"] + assert parsed.attachments[0].data == PDF_A + assert parsed.attachments[1].data == PDF_B + assert parsed.text == "Volltext" + right = _eml("", "richtig", []) + wrong = _eml("", "falsch", []) + assert choose_message(right, [wrong], "") == right + assert choose_message(wrong, [right], "") == right + with pytest.raises(Exception, match="mehrdeutig"): + choose_message(wrong, [right, right], "") + with pytest.raises(Exception, match="nicht eindeutig"): + choose_message(wrong, [], "uid:INBOX:4") + bare = _eml("", "ohne id", []) + # A message built without Message-ID still matches a stored uid fallback. + assert choose_message(bare, [], "uid:INBOX:4") == bare + + +def test_paperless_original_never_uses_preview(monkeypatch): + calls = [] + + def fake_file(base, token, path, max_bytes=40 * 1024 * 1024): + calls.append(path) + return None + + monkeypatch.setattr("app.sources._paperless_file", fake_file) + monkeypatch.setattr("app.sources._paperless_metadata", lambda *args, **kwargs: None) + with pytest.raises(Problem, match="gibt es in Paperless nicht"): + pull_paperless_original("http://paper.example", "token", "15", 1000) + assert calls == ["/api/documents/15/download/"] + + +def test_handover_package_follows_the_confirmed_selection(client, db, monkeypatch): + raw = _eml( + "", + "Der vollständige Brieftext bleibt erhalten.", + [("lage.pdf", PDF_A), ("lage.pdf", PDF_B)], + ) + monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw) + monkeypatch.setattr( + "app.retrieval.pull_paperless_original", + lambda *args, **kwargs: (PDF_B, "application/pdf", "archiv.pdf"), + ) + ada = Actor(client, "ada-export@example.test", "Ada Export") + register(db, ada.email, ada.name) + ada.login() + matter = ada.request("POST", "/api/v1/matters", json={"title": "Schaden"}, status=201) + vertrag = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Vertrag"}, status=201) + schrift = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Schrift"}, status=201) + note = ada.request( + "POST", + "/api/v1/notes", + json={ + "title": "Vertragnotiz", + "document": document("Nur der Vertrag"), + "context": {"kind": "matter", "id": matter["id"]}, + "chapter_id": vertrag["id"], + }, + status=201, + ) + ada.request( + "POST", + "/api/v1/files", + data={"title": "Einzeldatei", "context_kind": "matter", "context_id": matter["id"], "chapter_id": vertrag["id"]}, + files={"upload": ("einzel.pdf", PDF_C, "application/pdf")}, + status=201, + ) + ada.request( + "POST", + "/api/v1/files", + data={"title": "Schreiben-Datei", "context_kind": "matter", "context_id": matter["id"], "chapter_id": schrift["id"]}, + files={"upload": ("schreiben.pdf", PDF_C, "application/pdf")}, + status=201, + ) + ada.request( + "POST", + "/api/v1/notes", + json={ + "title": "Randnotiz", + "document": document("Randwort bleibt draussen"), + "context": {"kind": "matter", "id": matter["id"]}, + "chapter_id": schrift["id"], + }, + status=201, + ) + child = ada.request( + "POST", + "/api/v1/matters", + json={"title": "Nebenpunkt", "parent_matter_id": matter["id"]}, + status=201, + ) + ada.request( + "POST", + "/api/v1/notes", + json={ + "title": "Teilnotiz", + "document": document("Im Teilvorgang"), + "context": {"kind": "matter", "id": child["id"]}, + }, + status=201, + ) + mailbox = ada.request( + "POST", + "/api/v1/connectors", + json={ + "kind": "imap", + "name": "Postfach", + "host": "mail.example.test", + "username": "ada", + "password": "secret-pass", + }, + status=201, + ) + ada.request( + "POST", + "/api/v1/connectors", + json={ + "kind": "paperless", + "name": "Archiv", + "base_url": "http://paper.example", + "token": "paperless-token", + }, + status=201, + ) + ada.request( + "POST", + "/api/v1/external-refs", + json={ + "title": "Schreiben mit Anlagen", + "source": "imap", + "external_id": "", + "context": {"kind": "matter", "id": matter["id"]}, + "detail": {"connector_id": mailbox["id"], "mailbox": "INBOX", "uid": 9}, + }, + status=201, + ) + ada.request( + "POST", + "/api/v1/external-refs", + json={ + "title": "Archivstück", + "source": "paperless", + "external_id": "15", + "context": {"kind": "matter", "id": matter["id"]}, + "chapter_id": vertrag["id"], + }, + status=201, + ) + ada.request( + "POST", + "/api/v1/files", + data={"title": "Gespiegelte Anlage", "context_kind": "matter", "context_id": matter["id"]}, + files={"upload": ("lage.pdf", PDF_A, "application/pdf")}, + status=201, + ) + ada.request( + "POST", + "/api/v1/files", + data={"title": "Nur der Name", "context_kind": "matter", "context_id": matter["id"]}, + files={"upload": ("lage.pdf", PDF_C, "application/pdf")}, + status=201, + ) + first = ada.request( + "POST", + "/api/v1/notes", + json={ + "title": "Anschreiben", + "document": document("Erstes Schreiben"), + "context": {"kind": "matter", "id": matter["id"]}, + "communication_direction": "in", + "dates": {"document_on": "2026-03-12"}, + }, + status=201, + ) + reply = ada.request( + "POST", + "/api/v1/notes", + json={ + "title": "Antwort", + "document": document("Spätere Antwort"), + "context": {"kind": "matter", "id": matter["id"]}, + "communication_direction": "out", + "dates": {"document_on": "2026-05-18"}, + }, + status=201, + ) + ada.request( + "POST", + f"/api/v1/elements/{reply['id']}/references", + json={"refers_to_element_id": first["id"], "context": {"kind": "matter", "id": matter["id"]}}, + status=204, + ) + foreign_parent = ada.request("POST", "/api/v1/matters", json={"title": "Fremder Rahmen"}, status=201) + foreign = ada.request( + "POST", + "/api/v1/matters", + json={"title": "Fremder Vorgang", "parent_matter_id": foreign_parent["id"]}, + status=201, + ) + ada.request( + "POST", + "/api/v1/notes", + json={ + "title": "Fremdtext", + "document": document("Nicht mitnehmen"), + "context": {"kind": "matter", "id": foreign["id"]}, + }, + status=201, + ) + ada.request( + "POST", + f"/api/v1/matters/{matter['id']}/cross-links", + json={ + "target_matter_id": foreign["id"], + "target_context": {"kind": "matter", "id": foreign_parent["id"]}, + }, + status=201, + ) + detail = ada.request("GET", f"/api/v1/matters/{matter['id']}") + note_binding = next(item["id"] for item in detail["bindings"] if item["element"]["title"] == "Vertragnotiz") + ada.request( + "POST", + f"/api/v1/bindings/{note_binding}/annotations", + json={"body": "Kontextvermerk speziell"}, + status=201, + ) + tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"] + flat = list(_walk(tree)) + parents = _parents(tree) + assert "Fremdtext" not in json.dumps(tree) + by_title = {} + for node in flat: + by_title.setdefault(node["title"], []).append(node) + schrift_ids = { + node["id"] + for node in flat + if node["kind"] in {"binding", "annotation"} and _under(node["id"], "Schrift", parents) + } + selected = {node["id"] for node in flat if node["kind"] in {"binding", "annotation"} and node["exportable"]} + selected -= schrift_ids + selected.add(next(node["id"] for node in by_title["Schreiben-Datei"])) + mirrored = next(node["id"] for node in by_title["Gespiegelte Anlage"]) + name_only = next(node["id"] for node in by_title["Nur der Name"]) + selected.discard(mirrored) + selected.discard(name_only) + body = {"context": {"kind": "matter", "id": matter["id"]}, "selected": sorted(selected)} + review = ada.request("POST", f"/api/v1/matters/{matter['id']}/export/review", json=body) + assert review["ready"] is True + assert any("bleibt Bestandteil" in item["message"] for item in review["notices"]) + assert all("Nur der Name" not in item["message"] for item in review["notices"]) + response = _post_zip(ada, matter["id"], body) + assert response.status_code == 200, response.text + archive = _archive(response.content) + names = archive.namelist() + assert "index.html" in names and "inhalt.md" in names + assert any(name.startswith("01 Vertrag/") for name in names) + schrift_names = [name for name in names if name.startswith("02 Schrift/")] + assert schrift_names == ["02 Schrift/schreiben.pdf"] + assert any("Nebenpunkt" in name and name.endswith("Teilnotiz.md") for name in names) + mail_names = [name for name in names if "Schreiben mit Anlagen" in name] + assert any(name.endswith("/nachricht.eml") for name in mail_names) + assert sorted(name.rsplit("/", 1)[-1] for name in mail_names if "/anlagen/" in name) == ["lage (2).pdf", "lage.pdf"] + assert archive.read(next(name for name in mail_names if name.endswith("/anlagen/lage.pdf"))) == PDF_A + assert archive.read(next(name for name in mail_names if name.endswith("/anlagen/lage (2).pdf"))) == PDF_B + whole = _joined(archive) + assert "Der vollständige Brieftext bleibt erhalten." in whole + assert "Randwort bleibt draussen" not in whole + assert "Gespiegelte Anlage" not in whole + assert "Fremdtext" not in whole + assert "bleibt Bestandteil" in whole + note_file = next(name for name in names if name.endswith("/Vertragnotiz.md")) + annotation_file = next(name for name in names if "Anmerkung zu Vertragnotiz" in name) + assert "Kontextvermerk speziell" not in archive.read(note_file).decode("utf-8") + assert "Kontextvermerk speziell" in archive.read(annotation_file).decode("utf-8") + assert "Anschreiben" in whole and "Antwort auf" in whole + assert "Erzeugt am" in archive.read("index.html").decode("utf-8") + assert "Fachdatum: 2026-03-12" in whole + assert "Nur der Vertrag" in whole + _links_resolve(archive) + reply_only = { + "context": body["context"], + "selected": [node["id"] for node in by_title["Antwort"]], + } + narrowed = _post_zip(ada, matter["id"], reply_only) + assert narrowed.status_code == 200, narrowed.text + assert "Anschreiben" not in _joined(_archive(narrowed.content)) + changed = ada.request( + "PATCH", + f"/api/v1/notes/{note['id']}", + json={ + "expected_version": note["version"], + "document": document("Neutext der Notiz"), + "context": {"kind": "matter", "id": matter["id"]}, + }, + ) + ada.request( + "POST", + "/api/v1/notes", + json={ + "title": "Später ergänzt", + "document": document("Darf nicht still hinein"), + "context": {"kind": "matter", "id": matter["id"]}, + }, + status=201, + ) + assert "Neutext der Notiz" not in whole + assert "Später ergänzt" not in whole + again = _post_zip(ada, matter["id"], body) + assert again.status_code == 200, again.text + second = _joined(_archive(again.content)) + assert "Neutext der Notiz" in second + assert "Später ergänzt" not in second + assert changed["version"] == note["version"] + 1 + + +def test_export_names_gaps_and_hides_unreadable_counterparts(client, db, monkeypatch): + ada = Actor(client, "ada-gap@example.test", "Ada Gap") + ben = Actor(client, "ben-gap@example.test", "Ben Gap") + register(db, ada.email, ada.name) + register(db, ben.email, ben.name) + ada.login() + case = ada.request("POST", "/api/v1/cases", json={"title": "Freigabeakte"}, status=201) + matter = ada.request("POST", "/api/v1/matters", json={"title": "Geteilt"}, status=201) + ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201) + visible = ada.request( + "POST", + "/api/v1/notes", + json={"title": "Sichtbare Notiz", "document": document("Sichtbar"), "context": {"kind": "matter", "id": matter["id"]}}, + status=201, + ) + hidden = ada.request( + "POST", + "/api/v1/notes", + json={"title": "GeheimtitelXQ", "document": document("Verborgen"), "context": {"kind": "matter", "id": matter["id"]}}, + status=201, + ) + ada.request( + "POST", + f"/api/v1/elements/{visible['id']}/references", + json={"refers_to_element_id": hidden["id"], "context": {"kind": "matter", "id": matter["id"]}}, + status=204, + ) + ada.request( + "PUT", + "/api/v1/exceptions", + json={ + "resource_kind": "element", + "resource_id": hidden["id"], + "context": {"kind": "case", "id": case["id"]}, + "remove_read": True, + }, + ) + first = ada.request( + "POST", + "/api/v1/connectors", + json={"kind": "imap", "name": "Alt", "host": "mail.example.test", "username": "ada", "password": "secret-pass"}, + status=201, + ) + second = ada.request( + "POST", + "/api/v1/connectors", + json={"kind": "imap", "name": "Neu", "host": "mail.example.test", "username": "ada", "password": "secret-pass"}, + status=201, + ) + ada.request( + "POST", + "/api/v1/external-refs", + json={ + "title": "Verwaiste Post", + "source": "imap", + "external_id": "", + "context": {"kind": "matter", "id": matter["id"]}, + "detail": {"connector_id": first["id"], "mailbox": "INBOX", "uid": 3}, + }, + status=201, + ) + ada.request("DELETE", f"/api/v1/connectors/{first['id']}", status=204) + ada.request( + "POST", + "/api/v1/connectors", + json={"kind": "imap", "name": "Weiter", "host": "mail.example.test", "username": "ada", "password": "secret-pass"}, + status=201, + ) + calls = [] + + def pull(*args, **kwargs): + calls.append(args) + return _eml("", "darf nicht ersatzweise kommen", []) + + monkeypatch.setattr("app.retrieval.pull_rfc822", pull) + context = {"kind": "case", "id": case["id"]} + tree = ada.request( + "GET", + f"/api/v1/matters/{matter['id']}/export-tree", + params={"context_kind": "case", "context_id": case["id"]}, + )["tree"] + assert "GeheimtitelXQ" not in json.dumps(tree) + leaves = [node for node in _walk(tree) if node["kind"] in {"binding", "annotation"}] + visible_node = next(node for node in leaves if node["title"] == "Sichtbare Notiz") + orphan = next(node for node in leaves if node["title"] == "Verwaiste Post") + review = ada.request( + "POST", + f"/api/v1/matters/{matter['id']}/export/review", + json={"context": context, "selected": [visible_node["id"], orphan["id"]]}, + ) + assert review["ready"] is False + assert any(item["code"] == "reference" for item in review["issues"]) + assert any(item["code"] == "missing" for item in review["issues"]) + blob = json.dumps(review) + assert "GeheimtitelXQ" not in blob + assert calls == [] + assert second["id"] not in blob + failed = _post_zip(ada, matter["id"], {"context": context, "selected": [visible_node["id"], orphan["id"]]}) + assert failed.status_code == 422 + assert "GeheimtitelXQ" not in failed.text + assert failed.headers["content-type"].startswith("application/problem+json") or "problem" in failed.headers["content-type"] + + ambiguous = ada.request( + "POST", + "/api/v1/external-refs", + json={ + "title": "Ohne Zugang", + "source": "imap", + "external_id": "", + "context": {"kind": "matter", "id": matter["id"]}, + "detail": {"mailbox": "INBOX", "uid": 8}, + }, + status=201, + ) + del ambiguous + tree = ada.request( + "GET", + f"/api/v1/matters/{matter['id']}/export-tree", + params={"context_kind": "case", "context_id": case["id"]}, + )["tree"] + open_mail = next(node for node in _walk(tree) if node["title"] == "Ohne Zugang") + pending = ada.request( + "POST", + f"/api/v1/matters/{matter['id']}/export/review", + json={"context": context, "selected": [open_mail["id"]]}, + ) + assert pending["issues"][0]["code"] == "ambiguous" + assert {item["name"] for item in pending["issues"][0]["choices"]} == {"Neu", "Weiter"} + monkeypatch.setattr("app.retrieval.EXPORT_BYTE_LIMIT", 40) + huge = _eml("", "GEKÜRZT-VERBOTEN " * 20, []) + monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: huge) + assigned = ada.request( + "POST", + f"/api/v1/matters/{matter['id']}/export/review", + json={"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}}, + ) + assert assigned["issues"][0]["code"] == "too_large" + assert "GEKÜRZT-VERBOTEN" not in json.dumps(assigned) + wrong = _eml("", "FALSCHE-NACHRICHT", []) + monkeypatch.setattr("app.retrieval.EXPORT_BYTE_LIMIT", 80 * 1024 * 1024) + monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: wrong) + identity = ada.request( + "POST", + f"/api/v1/matters/{matter['id']}/export/review", + json={"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}}, + ) + assert identity["issues"][0]["code"] == "identity" + assert "FALSCHE-NACHRICHT" not in json.dumps(identity) + blocked = _post_zip( + ada, + matter["id"], + {"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}}, + ) + assert blocked.status_code == 422 + assert "FALSCHE-NACHRICHT" not in blocked.text + + grant(ada, case["id"], ben.email, share=False) + ben.login() + ben_tree = ben.request( + "GET", + f"/api/v1/matters/{matter['id']}/export-tree", + params={"context_kind": "case", "context_id": case["id"]}, + )["tree"] + assert "GeheimtitelXQ" not in json.dumps(ben_tree) + shared = next(node for node in _walk(ben_tree) if node["title"] == "Sichtbare Notiz") + assert shared["exportable"] is False + denied = ben.request( + "POST", + f"/api/v1/matters/{matter['id']}/export/review", + json={"context": context, "selected": [shared["id"]]}, + ) + assert denied["issues"][0]["code"] == "rights" + ada.login() + owner_direct = ada.request("GET", f"/api/v1/matters/{matter['id']}") + hidden_binding = next(item["id"] for item in owner_direct["bindings"] if item["element"]["title"] == "GeheimtitelXQ") + ben.login() + missing = ben.request( + "POST", + f"/api/v1/matters/{matter['id']}/export/review", + json={"context": context, "selected": [f"binding:{hidden_binding}"]}, + status=422, + ) + assert "GeheimtitelXQ" not in json.dumps(missing) + assert "unbekannten oder nicht sichtbaren" in missing["detail"] diff --git a/docs/architecture/ARCHITECTURE_DISCOVERY.md b/docs/architecture/ARCHITECTURE_DISCOVERY.md new file mode 100644 index 0000000..4b05ad0 --- /dev/null +++ b/docs/architecture/ARCHITECTURE_DISCOVERY.md @@ -0,0 +1,266 @@ +# Architecture Discovery — Tsumugu und Jinkendo-Familie + +**Stand:** 15. Oktober 2026 +**Art:** Read-only-Analyse. Keine Implementierung, keine Migration, keine Änderung an laufenden Systemen. +**Gegenstand:** Vorbereitung eines universellen Vorgangs- und Aktenmanagers (Tsumugu) auf Basis des bestehenden Jinkendo-Ökosystems. +**Quellen:** Code und Spezifikationen in `tsumugu`, `shinkan-jinkendo`, `kairo-jinkendo`, `mitai-jinkendo`. + +## Einordnung + +Dieses Dokument ist der Discovery-Bericht. Es beschreibt den Ist-Stand und die daraus folgenden Architekturvorschläge für Tsumugu. + +Daraus soll eine **universelle Architekturleitlinie der Jinkendo-Familie** entstehen. Die Leitlinie hält fest, was für jede Anwendung gilt: Identität, Mandant, Berechtigung, Daten, Audit, Deploy, Integrationsgrenzen. Aus dieser Leitlinie wird anschließend die **Zielarchitektur des konkreten Programms** abgeleitet. Tsumugu ist das erste Programm, für das diese Ableitung vorgesehen ist. Shinkan, Kairo und Mitai bleiben eigene Produkte mit eigenen Zielarchitekturen. + +Parallel dazu entsteht eine **universelle Designrichtlinie für das Frontend**. Sie ist ein eigenes Dokument. Farben, Layout, Komponenten und Interaktion gehören dorthin. Dieser Bericht behandelt sie nicht. + +Die Vorschläge in den Abschnitten 5 bis 8 sind keine Beschlüsse. Verbindlich werden sie erst durch eine Freigabe. + +## Annahmen und Grenzen + +- Die Host-`.env` auf dem Raspberry Pi und der Reverse Proxy auf der Synology wurden nicht inspiziert. Aussagen über Produktionswerte, die nur dort stehen, sind ungeprüft. +- Tests wurden nicht ausgeführt. „Implementiert und getestet“ bedeutet, dass Testdateien im Repository liegen. +- Paperless-ngx kommt in den durchsuchten Repositories nicht vor. +- Die fachliche Spezifikation des Vorgangsmanagers lag nicht vor. Fehlende Produktanforderungen werden hier nicht als verbindlich gesetzt. +- Das Root-`README.md` von Mitai beschreibt noch BodyTrack. Maßgeblich für das Produkt ist `CLAUDE.md` in `mitai-jinkendo`. +- Der Abschnitt „Startzustand“ in `kairo-jinkendo/README.md` ist älter als der Code. + +## Reife-Legende + +| Stufe | Bedeutung | +|---|---| +| Implementiert und getestet | Code und zugehörige Tests liegen im Repository | +| Implementiert, Validierung offen | Code vorhanden, Produktion oder fachliche Wirkung nicht belegt | +| In Entwicklung | Laufende Umsetzung, Docs und Code weichen voneinander ab | +| Spezifiziert | Beschrieben, im Code dieses Gegenstands nicht vorhanden | +| Nicht vorhanden | Weder Code noch wirksame Spezifikation | +| Ungeprüft | Liegt außerhalb der gelesenen Repositories, zum Beispiel Host-Konfiguration | + +--- + +## 1. Ist-Architektur + +### Gemeinsamer Betriebsrahmen + +Mitai, Shinkan, Kairo, Kanshō und Tsumugu laufen als getrennte Compose-Projekte auf demselben Raspberry Pi (`192.168.2.49`). TLS endet auf dem Synology-NAS `192.168.2.63`. Der Gitea-Runner deployed `develop` nach Development und `main` nach Produktion. Jede Anwendung hat eine eigene PostgreSQL-Datenbank im Compose-Netz. + +| | Development | Production | +|---|---|---| +| Tsumugu | `3094` / `8094`, dev.tsumugu.jinkendo.de | `3007` / `8007`, tsumugu.jinkendo.de | +| Shinkan | Frontend `3098` | Frontend `3003`, Backend nur `127.0.0.1:8003` | +| Kairo | Frontend `3097`, Backend `8097` | Frontend `3004`, Backend `8004` | + +Quellen: `tsumugu/docs/DEPLOYMENT.md`, `shinkan-jinkendo/docker-compose.yml`, `kairo-jinkendo/docs/DEPLOYMENT.md`, `kairo-jinkendo/docker-compose.yml`. + +Technologie, soweit eine Anwendung über das Gerüst hinaus ist: Python 3.12, FastAPI, psycopg2, bcrypt, React 18, Vite, PostgreSQL 16, Nginx im Frontend-Image, nummerierte SQL-Migrationen beim Backend-Start. Ein gemeinsames Python-Paket oder eine gemeinsame Datenbank gibt es nicht. + +### Tsumugu + +Deploy-Gerüst ohne Domäne. `backend/main.py` stellt `GET /api/health` bereit und schaltet OpenAPI ab (`docs_url=None`). Der Health-Check prüft Postgres und gibt `status`, `app`, `env` und `db` zurück. `frontend/nginx.conf` leitet `/api/` an das Backend weiter und setzt keine Security-Header. + +Postgres veröffentlicht keinen Host-Port (`docker-compose.yml`). Das Backend hängt an allen Interfaces (`${TSUMUGU_BACKEND_PORT:-8007}:8000`). Das Frontend hängt an `${TSUMUGU_FRONTEND_PORT:-3007}:80`. + +| Funktion | Stufe | +|---|---| +| Health, Compose, Gitea-Deploy | Implementiert | +| Auth, Mandant, Fachdomäne, Audit, Tests | Nicht vorhanden | + +### Shinkan + +Trainer- und Vereinsplattform. Stand im Repo: `APP_VERSION` 0.8.238, `DB_SCHEMA_VERSION` 20260607095 (`backend/version.py`). Vertrieblich gilt Gate V0: bekannte Vereine, keine öffentliche Vermarktung (`docs/product-readiness/PRODUCT_READINESS.md`). + +Identität: Tabelle `profiles`, opaque Session-Token in `sessions`, Header `X-Auth-Token`. Passwörter bcrypt, Legacy-SHA256 wird beim Login angehoben (`backend/auth.py`). Das Frontend legt den Token unter `localStorage.authToken` ab (`frontend/src/api/client.js`). + +Mandant: der Verein. `TenantContext` löst `profile_id`, Plattformrolle, `effective_club_id` und Mitgliedschaften pro Request auf (`backend/tenant_context.py`). Der Client sendet `X-Active-Club-Id`. Inhalte der Bibliothek tragen `visibility` mit den Werten `private`, `club` und `official`. Listen filtern über `library_content_visibility_sql()`. + +Autorisierung liegt auf mehreren Ebenen parallel: + +| Ebene | Ort | Durchsetzung im Repo | +|---|---|---| +| Plattformrolle `profiles.role` | `backend/club_tenancy.py` | Wirksam für Admin-Pfade | +| Vereinsrollen | `club_member_roles` | Wirksam in Legacy-Helfern, parallel zur Capability-Matrix | +| Capability | `backend/capabilities.py` | Hard-Block nur bei `CAPABILITY_ENFORCE=1`. Code-Fallback `"0"`. Variable fehlt in `docker-compose.yml` | +| Vereinskontingent | `backend/club_features.py` | Hard-Block bei `CLUB_FEATURE_ENFORCE=1`. Code-Fallback `"0"`. Compose-Default `1` | +| Objektsichtbarkeit | Access Layer | Für Bibliothek und Medien mit Integrationstests | + +`CAPABILITY_ENFORCE` und der tatsächliche Prod-Wert von `CLUB_FEATURE_ENFORCE` sind auf dem Host ungeprüft. Die Entscheidungsnotiz vom Juni 2026 und Compose widersprechen sich; das ist in `docs/product-readiness/README.md` als Dokumentdrift vermerkt. + +### Kairo + +Operativer Program Director. Der Code ist eine laufende Anwendung, kein reines Spec-Paket. `backend/version.py` nennt `0.20.2-ap2.2d`. Die Migrationen reichen bis `backend/migrations/033_unified_schedules.sql`. `docs/MIGRATIONS.md` und mehrere Architecture-Maps beschreiben einen älteren Stand. Verlässlicher sind der Code und `docs/product/Kairo_Implementation_Truth_Table_v0.1.md`. + +Identität: `users` und Sessions, Header `X-Auth-Token`. Mandant: `tenants` und `tenant_memberships` mit Rollen owner, admin, member. Der Actor (Mensch, Agent, Arbeitsgruppe, externes System) ist vom User getrennt. `TenantContext` liefert `user_id`, `tenant_id` und Capabilities (`backend/tenant_context.py`). + +`require_capability` blockt bei Modus `enforce` und protokolliert bei Modus `probe`. Der Code-Default ist `probe` (`backend/capabilities.py`). Compose setzt `CAPABILITY_ENFORCE` nicht. Actor-Service-Tokens erzwingen die Prüfung immer (`backend/operational_auth.py`). + +Fachlich vorhanden und mit pytest hinterlegt: Initiativen, Maßnahmen, Zuweisungen, Roadmap, Projekte, Tasks, Schedules, Steering-Kernel, Operational API. LLM-Ausführung, MCP, Billing und SSO sind spezifiziert und im Code nicht ausgeführt. Prompt-Rendering existiert ohne Modellaufruf. + +### Mitai + +Persönliche Tracking-PWA der Familie. Daten hängen an `profile_id`. Ein Mandant, ein Verein oder ein geteilter Datenraum ist nicht modelliert (`backend/schema.sql`, Designprinzip `AUTH_SESSION_DESIGN_PRINCIPLES.md`). + +Die Session-Schicht entspricht der Familie: opaque Token, bcrypt, `require_auth`, Rate-Limits auf Login, Registrierung und Passwort-Reset (`backend/auth.py`, `backend/routers/auth.py`). Kontingente hängen am Account über `check_feature_access`. + +Daneben besteht Legacy: `get_pid()` in `backend/routers/profiles.py` übernimmt den Header `X-Profile-Id` und fällt sonst auf das erste Profil der Datenbank zurück. `GET /api/profiles` listet nach `require_auth` alle Profile. Dedizierte Auth-Tests sind kaum vorhanden. Dieses Legacy ist der Grund, Mitai als Strukturidee zu lesen und den Zugriffscode für Tsumugu neu zu schreiben. + +--- + +## 2. Architekturstandards, die sich aus dem Ist-Stand ergeben + +Diese Punkte sind heute über die Produkte verteilt. Sie sind Kandidaten für die spätere Familienleitlinie, noch nicht die Leitlinie selbst. + +1. **Vier getrennte Prüfungen.** Identität, Capability, Kontingent, Objekt-Governance. Quelle: `shinkan-jinkendo/docs/jinkendo-family/FAMILY_ENTITLEMENT_MODEL.md`. Eine Anwendung lässt eine Schicht weg, wenn sie sie nicht braucht, und dokumentiert das. +2. **Subjekt der Identität kommt aus der Session.** Der Client wählt keine fremde Profil- oder User-ID als Autorität. +3. **Mandanten-ID kommt aus dem Kontext.** Request-Body und beliebige Header werden gegen die Mitgliedschaft geprüft. Fremde Objekt-IDs antworten mit 404. Quelle: `kairo-jinkendo/docs/architecture/Kairo_Tenant_Invariants_v0.1.md`. +4. **Capability und Kontingent sind verschiedene Fragen.** Ein Plan schaltet keine Rolle um. Quelle: Shinkan E-02 in `docs/product-readiness/PRODUCT_READINESS.md`. +5. **Objektsichtbarkeit ist eine eigene Achse**, sobald in einem Mandanten private und gemeinsame Daten nebeneinander liegen. Shinkan modelliert das als `private` / `club` / `official`. Kairo hat diese Achse nicht. +6. **Schemaänderungen sind nummerierte SQL-Dateien**, angewandt beim Start, gebucht in `schema_migrations`. +7. **Eigene Datenbank und eigenes Compose-Projekt pro Anwendung.** Integration über API, nicht über gemeinsame Tabellen. +8. **Deploy-Linie:** Branch `develop` und `main`, Health-Check, Secrets nur in der Host-`.env`, TLS am äußeren Proxy. + +Was die Leitlinie zusätzlich festlegen muss, weil es heute driftet: + +- Ob Capability-Prüfung in neuen Anwendungen im Modus `enforce` startet. Shinkan fällt auf `"0"` zurück, Kairo auf `probe`. +- Ob das Backend nur an `127.0.0.1` gebunden wird. Shinkan tut das. Kairo und Tsumugu veröffentlichen den API-Port auf allen Interfaces. +- Welche Audit-Felder jede Anwendung mindestens schreibt. Kairo schreibt `action`, `user_id`, `tenant_id`, `details` (`backend/services/audit.py`) und bietet keine Lese-API. + +--- + +## 3. Sicherheitsstatus und offene Risiken + +Shinkan ist der relevante Maßstab für Zugriff von außen, weil dort die Produktionsreife gerade hergestellt wird. Der Befund: der Rand ist im Repository gehärtet, die fachliche Durchsetzung von Rollen ist im Default ein Protokoll, und mehrere V1-Nachweise liegen außerhalb des Codes. + +### Shinkan, äußerer Rand + +Im Repository umgesetzt: + +- Backend `127.0.0.1:8003`, Postgres `127.0.0.1:5434`. Öffentlich auf dem Host ist der Frontend-Port `3003` (`docker-compose.yml`). +- OpenAPI in Produktion aus, abgesichert durch `backend/tests/test_security_release.py`. +- Medien-Static default aus. Auslieferung über berechtigte API-Pfade und kurzlebige Media-Grants. +- Nginx setzt CSP, `X-Content-Type-Options`, `X-Frame-Options`, `Referrer-Policy`, `Permissions-Policy` (`frontend/nginx.conf`). HSTS steht in dieser Datei nicht. +- Login-Limit, Sperre nach Fehlversuchen, optionales TOTP. Admin-TOTP ist default aus (`REQUIRE_ADMIN_TOTP`). +- Onboarding-Gate sperrt die Fach-API, bis E-Mail und Verein stehen. +- Cross-Tenant-Tests für den Access Layer liegen in `backend/tests/test_access_layer_integration.py`. + +Offen: + +| ID | Thema | Stufe | Beleg | +|---|---|---|---| +| L-09 | Security-Intake ohne Befunde | Ungeprüft, Lauf laut Doku offen | `docs/product-readiness/06-security-intake.md` | +| L-11 | Capability-Hard-Block default aus | Implementiert, Validierung in Produktion offen | `backend/capabilities.py` | +| L-10 | Kontingent-Hard-Block abhängig von Env | Implementiert, Host-Wert ungeprüft | Compose-Default `1`, Code-Fallback `0` | +| L-04 / P-08 | HSTS am öffentlichen Proxy | Ungeprüft | Nicht im Repo | +| L-14 | `POST /api/auth/register` offen, Limit 3/Stunde | Implementiert und getestet | `backend/routers/auth.py` | +| P-18 | Token im `localStorage` | Implementiert. HttpOnly-Cookie nur eingeordnet | `frontend/src/api/client.js` | +| L-07 / P-09 | Kein durchgängiges Admin-Audit | Nicht vorhanden | Product-Readiness-Matrix | +| — | `GET /api/version` ohne Auth, inkl. Schemaversion | Implementiert, Validierung offen | `backend/main.py` | +| L-01, L-02, L-03, L-05, L-06 | Rechtstexte, Personenbilder, Löschung, AV, VVT | Teilweise oder offen | `02-compliance-und-betrieb.md` | + +Ein Outsider ohne Konto erreicht Health, Version, Registrierung, Passwort-Reset und die statische SPA. Fachdaten der Bibliothek verlangen eine Session und den Access Layer. Ein gestohlener Token aus dem `localStorage` trägt die Rechte dieser Session. Die CSP mit `script-src 'self'` verkleinert die Fläche dafür. + +### Kairo und Mitai, soweit für Tsumugu relevant + +Kairo isoliert Mandanten in Services und Tests und lässt Rollen im Default passieren, solange `CAPABILITY_ENFORCE` auf `probe` steht. Das Backend ist auf allen Interfaces veröffentlicht. + +Mitai bindet neue Fachrouter an `session['profile_id']` und hält gleichzeitig den ungebundenen Profil-Header. Wer dieses Muster kopiert, öffnet fremde Profildaten für jeden eingeloggten Benutzer. + +### Tsumugu heute + +Es gibt keine Authentifizierung. Health ist unauthentifiziert und nennt Umgebung und Datenbankstatus. Der API-Port ist auf dem Host veröffentlicht. Security-Header fehlen. Das ist für ein Gerüst erwartbar und wird zum Risiko, sobald Fachendpunkte an dieselbe Compose-Datei anschließen, ohne die Bindung und die Header vorher zu ändern. + +--- + +## 4. Wiederverwendbare Bausteine + +Übernahme bedeutet: das Muster im Tsumugu-Repository neu implementieren. Eine gemeinsame Bibliothek oder Datenbank koppelt die Anwendungen und ist für den Start ungeeignet. + +| Baustein | Herkunft | Umgang | +|---|---|---| +| Compose, Workflows `develop`/`main`, Health-Deploy | Tsumugu, Mechanik aus Kanshō (`docs/DEPLOYMENT.md`) | Direkte Wiederverwendung des Gerüsts | +| Nummerierte SQL-Migrationen beim Start | Shinkan, Kairo, Mitai | Muster, eigener Runner | +| Opaque Session, `X-Auth-Token`, bcrypt, Logout durch Löschen der Session | Familie | Muster. Subjekt-ID nur aus der Session | +| Tenant, Membership, Capability-Registry, `require_capability` | Kairo | Muster. Eigener Namespace `tsumugu.*` | +| Objektsichtbarkeit privat und gemeinsam, zentraler Filter, Governance-Übergänge | Shinkan Access Layer | Anpassung. Datenraum statt Verein, Wert `official` entfällt | +| Audit-Schreiben mit JSON-Details | `kairo-jinkendo/backend/services/audit.py` | Anpassung. `resource_type` und `resource_id` von Anfang an. Lese-API für die Chronologie | +| Prompt- und Config-Registry ohne Modellaufruf | Kairo | Muster für spätere KI. Eigene Keys | +| Actor-Service-Token für Agents | `kairo-jinkendo/backend/operational_auth.py` | Muster für die spätere Integration. Tokens bleiben an den Tsumugu-Datenraum gebunden | +| `X-Profile-Id`, offene Profil-CRUD, `get_pid` | Mitai `backend/routers/profiles.py` | Eigenständige Neuimplementierung. Dieses Muster wird nicht übernommen | +| Vereinsrollen, Sparten, Abo-Pläne, Sportkatalog | Shinkan | Bleiben in Shinkan | + +--- + +## 5. Architekturvorschläge für den Vorgangsmanager + +Diese Vorschläge leiten sich aus dem Ist-Stand ab. Sie werden zur Zielarchitektur von Tsumugu, sobald die Familienleitlinie und die fachliche Spezifikation sie tragen. + +**Identität.** User und Session nach Familienmuster. Die wirksame User-ID kommt aus der Session. + +**Mandant.** Ein Datenraum mit Mitgliedschaft und Rollen, nach dem Kairo-Muster `tenant` plus `tenant_memberships`. Der Verein ist kein Subjekt von Tsumugu. + +**Objekt-Governance.** Akten, Unterakten und andere Fachobjekte tragen eine Sichtbarkeit innerhalb des Datenraums: privat für den Ersteller, gemeinsam für Mitglieder des Raums. Virtuelle Zusammenstellungen speichern Referenzen auf Objekte, keine Kopien. Die konkrete Stufenliste legt die Leitlinie fest; Shinkans Dreierwert `private` / `club` / `official` ist die Vorlage, nicht das Schema. + +**Externe Quellen.** Paperless-ngx und spätere Quellen sind Referenzen (Quelle, externe ID, Anzeige-Metadaten). Das Dokument bleibt im Quellsystem. Eine Paperless-Integration existiert in den gelesenen Repositories nicht. + +**Chronologie, Aufgaben, Fristen.** Chronologie ist ein Lesemodell über Audit und Fachereignisse. Aufgaben und Fristen sind eigene Objekte. Sie werden nicht aus Kairo-Tabellen importiert. + +**Finanzen.** Manuelle Zuordnung von Finanz- und Erstattungsvorgängen zu Akten, sobald die Fachspec die Felder festlegt. Kein Zahlungsdienst im ersten Schnitt. Shinkan hat Stripe bewusst zurückgestellt (E-06). + +**Audit.** Append-only, mit Akteur, Datenraum, Aktion, Ressourcentyp, Ressourcen-ID und Zeit. Kairo zeigt das Schreiben. Das Schema von Kairo reicht für eine Aktenchronologie nicht aus, weil Ressource und Actor dort fehlen. + +**Berechtigung.** Capability-Registry mit Modus `enforce` ab dem ersten fachlichen Endpoint. Kontingente (Schicht C des Familienmodells) bleiben aus, bis ein Billing-Subjekt beschlossen ist. + +**Deploy.** Das bestehende Tsumugu-Gerüst bleibt. Vor Fachendpunkten: Backend nur an `127.0.0.1`, Security-Header wie in `shinkan-jinkendo/frontend/nginx.conf`, HSTS-Nachweis am Synology-Proxy für `tsumugu.jinkendo.de` und `dev.tsumugu.jinkendo.de`. + +**Spätere Kairo- und KI-Anbindung.** HTTP-API. Ein Agent handelt mit einem an den Datenraum gebundenen Token, analog zu Kairos Actor-Service-Tokens. Prompt-Registry kann vor dem ersten Modellaufruf existieren. + +--- + +## 6. Abweichungen und Zielkonflikte + +**Shinkan-Verein und Tsumugu-Datenraum.** Shinkan löst Mehrbenutzerfähigkeit über Verein, Vereinsrollen, Plattformrollen, Kontingente und Sichtbarkeit. Das passt zur Vereinsplattform und ist für einen universellen Vorgangsmanager zu eng an Bibliothek, Abo und Sport gekoppelt. Die vier Prüfungen bleiben brauchbar. Das Subjekt „Verein“ bleibt in Shinkan. + +**Mitai-Profil und gemeinsame Räume.** Mitai ist das schlankere Identitätsmodell: ein Account, Entitlements am Account, keine zweite Organisationsachse. Gemeinsame Datenräume trägt dieses Modell nicht. Der Profil-Header ist für jede Anwendung mit mehreren Personen ungeeignet. + +**Kairo-Tenant und private Objekte.** Kairo trennt Mandanten und antwortet auf fremde IDs mit 404. Innerhalb eines Mandanten gibt es keine Achse „privat neben gemeinsam“. Für Akten und virtuelle Zusammenstellungen braucht Tsumugu beide Achsen: Datenraumgrenze und Objektsichtbarkeit. + +**Probe-Default.** Shinkan und Kairo lassen fehlende Capabilities im Standard zu und protokollieren sie. Ein Vorgangsmanager, der private und gemeinsame Daten von Beginn an hält, übernimmt diesen Default nur nach ausdrücklicher Freigabe. + +**Dokumentdrift.** Product-Readiness, Entscheidungsnotizen und Compose nennen für dieselben Schalter verschiedene Defaults. Eine Familienleitlinie braucht eine Stelle, die den wirksamen Default nennt, und einen Verweis auf den Code, der ihn liest. + +**Designrichtlinie.** Frontend-Muster der drei Anwendungen (API-Clients, Auth-Context, Navigation) sind heute produktlokal. Sie gehören in die parallele Designrichtlinie, sobald dort Komponenten und Interaktion festgelegt werden. Dieser Bericht setzt keine UI fest. + +--- + +## 7. Offene Entscheidungen + +Freigabe nötig, bevor die technische Spezifikation von Tsumugu diese Punkte als verbindlich übernimmt. + +| ID | Frage | Vorschlag aus dem Ist-Stand | +|---|---|---| +| E-01 | Subjekt für gemeinsame Daten | Datenraum mit Mitgliedschaft. Private Objekte darin. Der Verein ist kein Subjekt | +| E-02 | Registrierung zum Start | Geschlossen oder nur per Einladung. Eine offene Register-Route wie in Shinkan braucht einen eigenen Beschluss | +| E-03 | Capability-Modus | `enforce` ab dem ersten fachlichen Endpoint | +| E-04 | Paperless | Referenz auf Quelle und externe ID. Kein Dokumentenspeicher in Tsumugu, solange die Fachspec keinen verlangt | +| E-05 | Kontingente und Abo | Schicht C erst spezifizieren, wenn es ein Billing-Subjekt gibt | +| E-06 | Backend-Port | Nur `127.0.0.1`, wie Shinkan. Heute veröffentlicht Tsumugu `8007` auf allen Interfaces | +| E-07 | Spätere Kairo-Kopplung | HTTP und datenraumgebundene Tokens. Keine gemeinsame Datenbank, keine gemeinsamen Capability-Keys | +| E-08 | Ort der Familienleitlinie | Eigenes Dokument, aus dem Programm-Zielarchitekturen abgeleitet werden. Dieser Bericht bleibt die Ist-Aufnahme | + +E-08 ist eine Arbeitsentscheidung für die Dokumentenstruktur. Sie ändert keinen Code. + +--- + +## 8. Empfehlungen für die spätere technische Spezifikation + +Reihenfolge für die Tsumugu-Spezifikation, nachdem die Leitlinie die Familienregeln festgezogen hat: + +1. Datenraum, Mitgliedschaft, Objektsichtbarkeit, Audit-Schema mit Ressource und Akteur. +2. Deploy-Härtung des bestehenden Gerüsts: localhost-Backend, Security-Header, HSTS-Nachweis. +3. Akten, Unterakten, virtuelle Zusammenstellungen als Referenzen. +4. Externe Quellen, zuerst Paperless-ngx als Referenz. +5. Chronologie als Lesemodell, danach Aufgaben und Fristen. +6. Manuelle Finanz- und Erstattungszuordnung gemäß Fachspec. +7. Integrationspunkte für Kairo und KI, ohne Implementierung des Modellaufrufs. + +Die fachlichen Regeln zu Zuordnungsvorschlägen, Fristen und Erstattung bleiben der separaten Produktspezifikation vorbehalten. + +Die Familienleitlinie selbst sollte die acht Standards aus Abschnitt 2 in normative Sätze überführen, die Drift der Defaults auflösen und pro Anwendung nur noch die Abweichung dokumentieren. Die Designrichtlinie entsteht daneben und referenziert die Leitlinie dort, wo eine UI eine Berechtigung oder einen Datenraum sichtbar macht. diff --git a/docs/product/TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md b/docs/product/TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md new file mode 100644 index 0000000..0da7184 --- /dev/null +++ b/docs/product/TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md @@ -0,0 +1,110 @@ +# Tsumugu – Befund zur Connector-Einbindung + +**Stand:** 17.10.2026 · **Zweck:** Übergabe an die fachliche Planung. Keine neue Produktentscheidung und kein Implementierungsauftrag. + +Geprüft wurde der Bestand in `C:/Dev/tsumugu`: ob Paperless und IMAP so gebaut sind, dass später weitere Connectoren dazukommen können. Jeder Connector braucht einen Zugang, eine innere Navigation auf die eigenen Inhalte, eine Vorschau und eine eindeutige Referenz auf das Inhaltselement. + +## 1. Befund + +Paperless und IMAP sind nicht modular. Sie teilen eine Hülle für Zugang und Referenz. Verhalten, Navigation, Vorschau und die stabile Adresse in der Quelle sind je Quelle fest eingebaut. Ein weiterer Connector lässt sich nicht nur registrieren. + +Die Protokollarbeit selbst ist vorhanden und brauchbar: Paperless-Suche und Dateilesen, IMAP-Anmeldung, Fächer, Nachrichtenliste und Briefvorschau. Ein Umbau verschiebt diese Teile hinter eine gemeinsame Naht. Er schreibt sie nicht neu. + +## 2. Was bereits fachlich feststeht + +Diese Punkte stammen aus der Produktspezifikation und der UX-Ergänzung. Dieser Befund ändert sie nicht. + +- Paperless-Dokumentdateien bleiben im Archiv und werden referenziert. Tsumugu hält Herkunft und Anzeigedaten. +- Externe Verweise, etwa auf eine E-Mail im IMAP-Konto, sind grundsätzlich möglich. Eine eigene Ablage gespeicherter E-Mails ist davon getrennt und hier nicht umgesetzt. +- Eine E-Mail wird vor dem Übernehmen gelesen. Übernommen wird sie erst ausdrücklich. Paperless bleibt ein eigener Vorschauweg. +- Bidirektionale Paperless-Metadaten und Finanzfunktionen folgen nach dem ersten Schnitt. Dieser Befund betrifft sie nicht. +- Die UX-Ergänzung verbietet, für die laufende Inhaltsdarstellung eine neue Importplattform zu bauen. Ein späterer Connector-Umbau ist ein eigener Auftrag, keine Folge dieser UX-Vorgabe. + +## 3. Gemeinsame Hülle im Bestand + +| Schicht | Was sie heute leistet | Grenze | +|---|---|---| +| Tabelle `connectors` | Name, Art, Einstellungen und Geheimnis je Besitzer. Geheimnisse bleiben auf dem Server. | Die Art ist auf `paperless` und `imap` geprüft. | +| Element `external_ref` | Gemeinsamer Inhaltsträger, einbindbar wie Notiz und Datei. | Die Herkunft steckt in der externen Referenz, nicht in einer Connector-Schnittstelle. | +| Tabelle `external_references` | Quelle, externe ID, JSON-Detail. | Die Art ist auf `paperless`, `url` und `imap` geprüft. Kein Eindeutigkeitsindex. `connector_id` ist nur bei IMAP ein JSON-Feld, keine Beziehung zum Zugang. | +| `create_external` und `POST /api/v1/external-refs` | Erzeugt Element, Referenz, Einbindung und fachliche Daten an einer Stelle. | Das Detailobjekt mischt Paperless- und IMAP-Felder. | +| Rechteprüfung vor dem Lesen | Beide Vorschaupfade prüfen das Leserecht am Element. | Danach verzweigt der Server nach Quellenname. | + +Daneben existiert `POST /api/v1/sources/link` mit einer engeren Quellenliste. Die Oberfläche übernimmt über `POST /api/v1/external-refs`. Die Art `url` steht in der Prüfliste und im API-Schema, hat aber weder Zugang noch Navigation noch Vorschau. + +## 4. Fähigkeiten gegen den gewünschten Connector + +| Fähigkeit | Paperless | IMAP | Gemeinsame Schicht | +|---|---|---|---| +| Zugang | Adresse und API-Schlüssel. Ein Paperless pro Konto: ein zweites Speichern überschreibt das erste. | Server, Benutzer, Passwort, SSL oder STARTTLS. Mehrere Konten. | Dieselbe Tabelle. Die Kardinalität ist im Code fest. | +| Prüfen | Zählt sichtbare Dokumente. | Meldet sich am Postfach an. | Eine Route `POST /api/v1/connectors/{id}/probe`, innen eine Verzweigung nach Art. | +| Innere Navigation | Eine Suche. Ohne Zugangs-ID, immer das zuletzt angelegte Paperless. Keine Korrespondenten, Tags oder Ordner. | Konto, Fächerbaum, Nachrichtenliste, Suche im offenen Fach, ältere Seiten. | Keine gemeinsame Navigation. Eigene Routen unter `/api/v1/sources/paperless` und `/api/v1/sources/imap`. | +| Vorschau vor dem Übernehmen | Nur die Trefferliste. Der Inhalt wird erst nach dem Einbinden geladen. | Brief mit Absender, Empfänger, Text und Anhangsnamen. Übernehmen ist ein eigener Schritt. | Nur der IMAP-Picker hat diese Vorschau. | +| Vorschau am Element | Binärdatei über `/api/v1/external-refs/{id}/content`. PDF oder Bild. | JSON über `/api/v1/external-refs/{id}/mail`. | `present.py` kennt die Vorschauarten nur für diese beiden Quellen. Der Leser verzweigt auf den Quellnamen. | +| Referenz | `external_id` ist die Paperless-Dokumentnummer. Der Zugang steht nicht an der Referenz. | `external_id` ist die Message-ID. Fach, UID und `connector_id` liegen im JSON-Detail. | Gleiche Spalten, andere Identität. | + +## 5. Die Referenz ist nicht stabil auflösbar + +Tsumugu vergibt dem Inhaltselement eine eigene ID. Die Adresse in der Quelle ist davon getrennt. Dieselbe Paperless-Nummer oder dieselbe Message-ID kann mehrfach eingebunden werden. + +Beim Lesen eines Paperless-Dokuments wählt der Server den zuletzt angelegten Paperless-Zugang des Besitzers. Ein Wechsel des Schlüssels lenkt alle bestehenden Referenzen um. Zwei Paperless-Instanzen kann ein Konto nicht auseinanderhalten. + +Bei IMAP reicht die gespeicherte Message-ID nicht für die Vorschau. Aufgelöst wird über Fach und UID. Eine UID gilt nur in einem Fach und überlebt ein Verschieben der Nachricht nicht. + +## 6. Wo ein weiterer Connector heute anstößt + +| Schicht | Geschlossene Stelle | Folge | +|---|---|---| +| Datenbank | Prüflisten `connectors_kind` und `external_references_source` | Neue Art braucht eine Migration. | +| API-Schema | `ConnectorIn.kind` und `ExternalIn.source` | Felder beider Quellen liegen in einem Modell. | +| Serverlogik | `backend/app/sources.py`, `backend/app/api/sources.py` | Suchen, Lesen und Prüfen sind Funktionen je Quelle. | +| Darstellung | `backend/app/present.py` | Die Vorschauart hängt am Quellnamen. | +| Oberfläche | `Sources.jsx`, `ReadingPane.jsx`, `content.jsx`, `widgets.jsx`, `Cases.jsx` | Bezeichnung, Picker und Leser verzweigen auf `paperless` und `imap`. | + +## 7. Technischer Zielzuschnitt, falls ein Umbau beauftragt wird + +Das ist ein Zuschnitt aus der Codeprüfung, keine fachliche Festlegung. + +Jede Quelle liefert fünf Operationen: + +1. Art, Anzeigename und ob ein Konto einen oder viele Zugänge haben darf. +2. Zugang mit öffentlichen Einstellungen, serverseitigem Geheimnis und Prüfung am konkreten Zugang. +3. Navigation an diesem Zugang. Sie liefert Knoten oder Inhaltselemente. Suche ist ein Filter darauf. +4. Eine Vorschau am Element, nach Leserecht. Das Medium ist binär, Text oder strukturiert. +5. Eine Referenz aus Zugangs-ID und externer ID, die diese Vorschau später wiederfindet. + +Die Oberfläche bleibt eine Quellenliste, ein Browser und ein Leser. Der Leser wählt die Darstellung nach dem Medium. Der Fächerbaum bleibt die Darstellung der IMAP-Navigation, nicht ein zweiter API-Weg. + +## 8. Aufwand + +Schätzung des Coding-Agenten vom 17.10.2026 für eine Person, die den Bestand kennt. Paperless und IMAP verhalten sich danach wie jetzt. IMAP-Parsing und Paperless-Dateilesen werden verschoben. + +| Schritt | Tage | Inhalt | +|---|---|---| +| Vertrag und Daten | 1–2 | Prüflisten öffnen, Zugangs-ID fest an die Referenz binden, bestehende Paperless- und IMAP-Referenzen zuordnen. | +| Adapter | 2 | Paperless und IMAP hinter Prüfung, Navigation und Vorschau. Bestehende Tests bleiben grün. | +| Eine Lese-API | 1–2 | Navigation und Vorschau über den Zugang beziehungsweise das Element. Alte Quellenrouten danach entfernen. | +| Oberfläche | 2–3 | Quellenformulare, Picker und Leser auf das Medium umstellen. | +| **Gesamt** | **6–9** | Verhalten bleibt. | + +Nur die Servernaht, ohne die Oberfläche umzustellen, liegt bei 3–4 Tagen. Der nächste Connector muss die Oberfläche dann selbst mitbringen. + +Nach dem ganzen Schnitt: ein schlichter Connector mit Suche und Dateivorschau etwa 1–2 Tage. Einer mit eigener Navigation, vergleichbar mit IMAP, etwa 3–4 Tage. + +Größenordnung des betroffenen Bestands: `backend/app/sources.py` etwa 700 Zeilen, `frontend/src/pages/Sources.jsx` etwa 570 Zeilen, Tests `backend/tests/test_mailboxes.py` und `backend/tests/test_paperless_files.py`. + +## 9. Was daraus nicht folgt + +- Kein Auftrag, den Umbau jetzt umzusetzen. +- Keine neue Importplattform und keine Änderung an Paperless-Originalen. +- Keine bidirektionale Metadatensynchronisation. +- Keine Entscheidung, ob dieselbe Quelle nur einmal eingebunden werden darf. +- Keine Entscheidung, ob ein Konto mehrere Paperless-Zugänge haben muss. +- Keine Aussage, welcher Connector als nächster fachlich gebraucht wird. + +## 10. Nur bei einem Umbauauftrag zu klären + +1. Darf dieselbe externe ID im selben Zugang mehrfach eingebunden werden, oder ist die Referenz je Zugang eindeutig? +2. Braucht ein Konto mehr als ein Paperless, oder bleibt genau ein Paperless fachlich richtig? +3. Reicht als stabile IMAP-Adresse die Message-ID, wenn Fach und UID sich ändern können? Die heutige Vorschau hängt an Fach und UID. +4. Bleibt `url` eine externe Referenz ohne Zugang, oder fällt die Art aus der Connector-Liste? diff --git a/docs/product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md b/docs/product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md new file mode 100644 index 0000000..bc0d2ba --- /dev/null +++ b/docs/product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md @@ -0,0 +1,74 @@ +# Tsumugu – Erste Lieferung: vollständiges Übergabepaket + +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 + +Einen Vorgang oder ausgewählte Teile daraus vollständig und mit verständlicher Struktur an den Anwalt übergeben. Das Paket muss ohne Tsumugu-Anmeldung und ohne Zugang zu Paperless oder zum E-Mail-Konto nutzbar sein. + +## Bestätigte Entscheidungen aus der Planung + +- Zuerst genügt ein vollständiges Übergabepaket. Ein laufender Lese- und Downloadzugang ist für diese erste Lieferung nicht erforderlich. +- Die Auswahl ist auf jeder Hierarchieebene bis zum einzelnen Inhalt möglich. Übergeordnetes An- oder Abwählen wirkt auf alle darunterliegenden Vorkommen. Einzelne Unterelemente lassen sich anschließend anders auswählen. Teilweise ausgewählte Eltern zeigen einen Zwischenzustand. +- Eine ausgewählte E-Mail wird vollständig mit ihren Anhängen exportiert. Wird dieselbe Anlage als eigenständiger Inhalt an anderer Stelle abgewählt, entfällt nur dieses Vorkommen. Die Anlage bleibt Bestandteil der E-Mail. +- Ein Hinweis auf eine solche weiterhin enthaltene Anlage kann erscheinen; er darf keine angebliche globale Entfernung anzeigen. +- Strukturinformationen sollen mitgegeben werden, etwa durch Verzeichnisse und begleitende Dokumentation. Die konkrete Darstellung unten ist ein Umsetzungsvorschlag. +- Die ausgewählte Designrichtung und bestätigte Fachentscheidungen bleiben erhalten. Maßgeblich ist der aktuelle Quellenstand einschließlich der jüngeren Präzisierungen zu Typ-Symbolen, Antwortbezügen und optionaler Kommunikationsrichtung. +- Rechnungen, Arztrechnungen, Zahlungen, Erstattungen und Einreichungen bleiben zurückgestellt. Der Wunsch nach universell erweiterbaren Connectoren bleibt erhalten. + +## Vorgeschlagene Liefergrenze + +Aktion „Übergabepaket erstellen“ am vorhandenen Vorgang. Auswahl von direkten Inhalten, Kapiteln und ausgewählten Teilvorgängen; Auswahlbaum, Prüfübersicht und ZIP-Download bilden einen durchgängigen Ablauf. Der Baum bildet die tatsächlich vorhandene Hierarchie ab und führt keine zusätzliche Tiefe oder Unterkapitel ein. Querverweise erzeugen keine Elternschaft und wählen ihre Ziele nicht automatisch aus. + +Das ZIP enthält eine lesbare HTML-Übersicht mit relativen Links sowie Markdown-Dokumentation. Kapitel und Teilvorgänge werden als Verzeichnisse abgebildet. Nummerierte Namen erhalten die im Export bestätigte Reihenfolge; gleichnamige Dateien dürfen sich nicht überschreiben. Nicht ausgewählte Geschwister und fremde Herkunftskontexte werden nicht mitdokumentiert. Ausgewählte Notizen und kontextbezogene Anmerkungen werden verständlich und voneinander getrennt wiedergegeben. + +Eigene Dateien und Paperless-Dokumente werden als Originaldateien exportiert. Eine zusätzliche Leseversion ist möglich, muss aber als solche erkennbar sein. Eine Vorschau ersetzt kein Original. Paperless bleibt das Archiv; die Exportkopie verändert weder das Original noch seine Metadaten. + +Eine ausgewählte E-Mail enthält das unveränderte vollständige EML-Original, eine lesbare Darstellung und separat zugängliche Anlagen. Die vollständige E-Mail ist in diesem Schnitt eine Einheit: Anlagen innerhalb der E-Mail werden nicht herausgefiltert. Ein separat eingebundenes Anlage-Vorkommen bleibt unabhängig auswählbar. Ist dessen Gleichheit mit einem E-Mail-Anhang zuverlässig bekannt, zeigt die Prüfübersicht den Hinweis auf die verbleibende enthaltene Kopie; Namen allein belegen keine Identität. + +Das Paket hält einen Übergabestand fest. Exportzeitpunkt und fachliche Datumsangaben werden getrennt. Spätere Änderungen aktualisieren eine bereits erzeugte Ausgabe nicht. Eine erneute Ausgabe verwendet eine erneut bestätigte Auswahl, ohne neu hinzugekommene Inhalte still einzuschließen. Eine gespeicherte Auswahlverwaltung und ein Vergleich mehrerer Ausgaben sind keine Pflicht dieser Lieferung. + +Vor Fertigstellung werden fehlende Originale, Anlagen, Rechte und nicht auflösbare Referenzen benannt. Kein stiller Wechsel auf gekürzten Vorschautext und kein unbemerktes Weglassen. Bei Fehlern kann der Nutzer wiederholen oder betroffene Vorkommen ausdrücklich aus der Auswahl entfernen. Die Vorschlagsregel für die externe Übergabe ist: Lesen und bestehende Freigabebefugnis je ausgewähltem Inhalt im richtigen Kontext prüfen; daraus keine neue allgemeine Downloadpolitik ableiten. + +## Connectoren: notwendiger erster Schritt + +Den bestehenden Paperless- und IMAP-Code hinter einer kleinen gemeinsamen Schnittstelle für vollständigen Inhaltsabruf wiederverwenden. Die Schnittstelle unterscheidet Vorschau von Original und Anlagen und meldet fehlende Fähigkeiten ausdrücklich. Vorhandene geschützte Dateidownloads werden weiterverwendet. + +Eine Referenz muss beim Export genau der richtigen Quelle und ihrem Zugang zugeordnet sein. Bei mehrdeutigen Bestandsreferenzen eine bewusste Zuordnung verlangen. Kein Rückgriff auf einen beliebigen zuletzt eingerichteten Zugang. Bei IMAP muss geprüft werden, dass die gefundene Nachricht die referenzierte Nachricht ist; geänderte Ordner oder UIDs dürfen keine falsche Nachricht liefern. Bei fehlender oder mehrdeutiger Identität verständlich abbrechen. + +Kein vollständiger Umbau aller Quellenformulare, Picker und Leser in diesem Lieferpaket. Keine neue Quelle, keine Metadatensynchronisation und kein Zugriff für Empfänger auf Quellenzugänge. Die im Connectoren-Befund geschätzten 6–9 Tage betreffen den dort beschriebenen vollständigen Umbau, nicht die Exportlieferung. Deren Aufwand ist nach dem gezielten Bestandsabgleich neu zu schätzen. + +## Konkreter Abnahmeablauf + +Mit synthetischen Daten einen Vorgang mit zwei Kapiteln, einem Teilvorgang, Paperless-Dokument, eigener Datei, Notiz und zwei aufeinander bezogenen Schreiben vorbereiten. Eine E-Mail hat zwei Anlagen; eine davon ist zusätzlich eigenständig eingebunden. + +1. Oben alles auswählen, ein Kapitel abwählen und darin eine Einzeldatei wieder auswählen. Zwischenzustände und resultierender Paketinhalt stimmen überein. +2. Notiz und einzelne Inhalte gezielt ausschließen. Strukturwege zu ausgewählten Inhalten bleiben erhalten; ausgeschlossene Inhalte fehlen. +3. Die E-Mail auswählen und das separat eingebundene Anlage-Vorkommen abwählen. EML und beide Anlagen bleiben im E-Mail-Verzeichnis vollständig enthalten; der separate Eintrag fehlt. Den Hinweis bei zuverlässig bekannter Identität prüfen. +4. Das ZIP außerhalb von Tsumugu ohne Quellenanmeldung öffnen. Übersicht, Struktur, Ordnung, Dateien, Notiztext und enthaltene Antwortbezüge sind verständlich und die relativen Links funktionieren. +5. Zwei gleichnamige Anlagen und eine Nachricht oberhalb der bisherigen Vorschaugrenze prüfen. Keine Anlage geht durch Namensgleichheit verloren; keine Vorschaukürzung gelangt als vollständiger Export ins Paket. +6. Eine Quelle unerreichbar machen und eine Referenz nicht mehr auflösbar machen. Es entsteht kein irreführend vollständiges Paket und keine falsche Ersatzdatei. +7. Mit eingeschränktem Benutzer prüfen: fehlende Freigabebefugnis und verborgene Kontexte bleiben geschützt. Gegenstücke außerhalb der Auswahl werden nicht automatisch mitgenommen oder benannt. +8. Nach Erzeugung eine Notiz ändern und einen neuen Inhalt ergänzen. Das erste ZIP bleibt unverändert; eine neue Ausgabe erfordert eine bestätigte Auswahl. + +## Vorbereiteter Auftrag für Cursor + +Setze die erste Exportlieferung gemäß diesem Dokument in der bestehenden Tsumugu-Anwendung um. Lies zuvor AGENTS.md, die aktuelle Fachspec, UX-Ergänzung, ausgewählte Designvorgaben und den Connectoren-Befund. Gleiche den aktuellen Code und laufende Änderungen erneut ab und erhalte fremde Arbeit. Die bestätigten Entscheidungen sind bereits als F-07a–c in der führenden Fachspec gesichert. Halte die hier vorgeschlagenen Lieferdetails davon unterscheidbar und dokumentiere notwendige Präzisierungen gezielt; keine erneute vollständige Grundlagen-Spezifikation. + +Prüfe zuerst gezielt Originaldownload, vollständigen E-Mail-/Anlagenabruf und eindeutige Quellenauflösung. Gib daraus eine kurze Aufwandseinschätzung für diese Lieferung ab. Baue anschließend den durchgängigen Ablauf Auswahl → Prüfung → Paket → Download. Routineentscheidungen triff im Bestand. Wenn eine fachliche Abweichung nötig wird, benenne sie ausdrücklich, statt den Umfang still zu verkleinern. + +Verwende vorhandene Tests und ergänze aussagekräftige Prüfungen für Auswahl, vollständige Anlagen, Quellidentität, Rechte, Exportstruktur und Fehlerfälle. Führe den Abnahmeablauf mit synthetischen Daten aus, einschließlich tatsächlicher Bedienung am Desktop und auf einem schmalen Bildschirm. Keine Nutzerdaten oder produktiven Datenbanken für Prüfungen verändern. + +Liefere einen lokal prüfbaren integrierten Stand mit kurzem Prüfbericht und verbleibenden Grenzen. Geplante und bestandene Prüfungen unterscheiden. Dieser vorbereitete Auftrag enthält keinen Push, kein Deployment und keinen Versand des Pakets. Ein später ausdrücklich beauftragter Development-Deploy ist ein eigener Übergabeschritt. + +## Führende Quellen + +- C:/Dev/tsumugu/AGENTS.md +- C:/Dev/tsumugu/docs/product/TSUMUGU_PRODUCT_SPEC.md +- C:/Dev/tsumugu/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md +- C:/Dev/tsumugu/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md +- C:/Dev/tsumugu/docs/product/TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md +- C:/Dev/tsumugu/docs/MVP_ANNAHMEN.md +- C:/Dev/jinkendo-app-design-2026-10-17/JINKENDO_APP_DESIGN_CONCEPT.md + +Danach: echten Übergabefall erproben, konkrete Lücken schließen und entscheiden, ob der laufende Anwaltszugang oder die vollständige Vereinheitlichung der Connectoren als Nächstes mehr Nutzen bringt. Beide Fähigkeiten bleiben erhalten. diff --git a/docs/product/TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md b/docs/product/TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md index 172493d..cdc8ee8 100644 --- a/docs/product/TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md +++ b/docs/product/TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md @@ -1,6 +1,8 @@ # Tsumugu: Kommunikationsrichtung – Spezifikation und Cursor-Auftrag -**Stand:** 17.10.2026 · **Fassung:** 1.0 · **Umfang:** bestehendes MVP gezielt ergänzen, lokal prüfbar umsetzen. +**Stand:** 17.10.2026 · **Fassung:** 1.1 · **Umfang:** sichtbare Symbole tatsächlich ersetzen und Kommunikationsrichtung in der Zeile hervorheben; bestehende Fachlogik erhalten. + +**Aktuelle Korrektur nach Live-Prüfung:** Die sichtbare Notiz verwendet weiterhin ein Blatt. Im Projekt ist `frontend/public/ui/content-symbols-v1/light/note.svg` ebenfalls noch eine Datei-Kontur, während die gelieferte Quelle die Sprechblase mit Stift enthält. Der Austausch ist daher ausdrücklich auszuführen, nicht nur die URL beizubehalten. Der vorhandene 16px-Diagonalpfeil im Metadatentext entspricht der alten Größenvorgabe, ist aber zu unscheinbar. Diese Fassung ersetzt Position, Form und Größe verbindlich durch führende gefüllte Dreiecke. Keine neue fachliche Grundlagenrunde. ## Ziel und Einordnung @@ -10,7 +12,11 @@ Dieser Auftrag präzisiert F-06e der [Produktspezifikation](TSUMUGU_PRODUCT_SPEC ## 1. Darstellung -- Inhaltstyp-Symbol behalten. Daneben ein kleines Richtungssignal mit sichtbarem Text **„Eingang“** oder **„Ausgang“**. Keine eigene kombinierte Bilddatei für jede Kombination aus Format und Richtung. +- **Reihenfolge am Anfang jeder Inhaltszeile:** feste Richtungsspalte, danach Inhaltstyp-Symbol, danach Titel/Text. Das Richtungssignal darf nicht weiter als winziger Pfeil im Metadatentext stehen. Ein Drag-Griff darf die fachliche Richtungsspalte nicht ersetzen; Sortierbedienung gesondert anordnen. +- **Eingang:** gefülltes Dreieck zeigt nach rechts, hinein in die Zeile. **Ausgang:** gefülltes Dreieck zeigt nach links, heraus aus der Zeile. Einheitlich horizontale Richtung, keine Diagonalpfeile. Dunkelgrün auf hellen Flächen bzw. Mint auf dunklen Flächen, keine reduzierte Deckkraft. +- Richtungsspalte ungefähr 36px breit, Dreieck als SVG 28px am Desktop und mindestens 24px am Handy. Auf Höhe des Typsymbols/Titelanfangs ausrichten. Das tatsächliche gefüllte Motiv muss deutlich sichtbar sein; nicht durch innenliegende große Leerflächen oder zusätzliche Verkleinerung abschwächen. Sichtbarer Text **„Eingang“** bzw. **„Ausgang“** bleibt in den Metadaten. Keine künstliche Dopplung weiterer kleiner Richtungspfeile daneben. +- Ohne bekannte Richtung kein Dreieck, aber dieselbe Spaltenbreite: Typ-Symbole und Titel bleiben in allen Zeilen bündig. Keine Attrappe für „intern“ oder „unbekannt“ ergänzen. Keine eigene kombinierte Bilddatei für jede Kombination aus Format und Richtung. +- **Notizsymbol wirklich ersetzen:** in beiden Farbvarianten und allen tatsächlich genutzten Formaten die gelieferte runde Sprechblase mit Stift übernehmen. Weder Blattumriss noch Haftnotiz weiterverwenden. Das PDF bleibt eine Dokumentform; unbekannter Dateityp darf ein generisches Dateisymbol behalten. Paperless nicht pauschal als PDF ausgeben. - Bekannte Beteiligte als **„Von: …“** beziehungsweise **„An: …“** anzeigen. Keine Person erfinden, wenn nur die Richtung bekannt ist. Bei Bedarf sind beide Angaben in den Details sichtbar. - Kommunikationsdatum verständlich benennen, etwa „Eingegangen am“ bzw. „Versendet am“. Dokumentdatum, Zugangsdatum, Versanddatum und Import-/Änderungszeitpunkt nicht gleichsetzen. Bestehende fachliche Sortierung und manuelle Reihenfolge nicht stillschweigend verändern. - Beispiel einer Zeile: `PDF · [Richtungszeichen] Eingang · Von: Hausverwaltung Müller · Eingegangen am 12.10.2026`, darunter Titel und kurzer Auszug. Bei Ausgang entsprechend Empfänger und Versanddatum. @@ -49,14 +55,15 @@ Im Bearbeiten-Dialog reicht eine Auswahl **„Keine Angabe / Eingang / Ausgang ## 5. Fertige Zeichen verwenden -Symbolpaket **1.2**, weiterhin unter: +Symbolpaket **1.3**, weiterhin unter: `C:/Dev/jinkendo-app-design-2026-10-17/assets/content-symbols-v1/` - `light/communication-in.svg`, `light/communication-out.svg`: dunkelgrün für helle Arbeitsflächen. - `dark/communication-in.svg`, `dark/communication-out.svg`: mintfarben für dunkle Flächen. - Entsprechende PNGs unter `/png/24`, `48`, `96`. -- Passende SVG-Größe ungefähr 16–18px neben dem sichtbaren Text. Die gelieferten Konturen aus Lucide verwenden und Lizenz übernehmen; keine Emoji-Pfeile oder frei gezeichneten Ersatzsymbole. Das bestehende `note.svg` bleibt die Sprechblase mit Stift aus Fassung 1.1. +- Gefüllte, bereits gedrehte Dreiecke verwenden: `communication-in.svg` rechts, `communication-out.svg` links. Größe/Position nach Abschnitt 1, keine 16–18px-Konturpfeile mehr. Die Originalkontur stammt aus Lucide `triangle`, gedreht und gefüllt; Lizenz übernehmen. Keine Unicode-Zeichen, Emoji-Pfeile oder frei gezeichneten Ersatzsymbole. Das gelieferte `note.svg` zeigt die Sprechblase mit Stift. +- Dateien tatsächlich in das ausgelieferte App-Assetverzeichnis übernehmen. Paketpfad allein im Auftrag oder identische Dateinamen sind kein Nachweis. Quelle und App-Kopie per Hash/Inhalt vergleichen, bei Notiz und beiden Richtungszeichen je `light`/`dark`. Cache-Aktualisierung durch passende Versions-/Hash-URLs oder vorhandene Buildstrategie sicherstellen. Ein Nutzer soll die Korrektur nach normalem Neuladen sehen, ohne Browserdaten löschen zu müssen. Keine neue Bibliothek installieren. Das Richtungszeichen ergänzt Typ und Quelle; ein PDF aus Paperless behält sein PDF-Symbol und seine Quellenangabe. @@ -64,7 +71,10 @@ Keine neue Bibliothek installieren. Das Richtungszeichen ergänzt Typ und Quelle Vor Änderungen den aktuellen Stand prüfen und laufende Änderungen erhalten. Bei Erstellung dieses Auftrags waren bereits `content.jsx`, `ReadingPane.jsx`, `Sources.jsx`, API-Schemas und Korrespondenzdaten vorhanden. Wiederverwenden, keine zweite parallele Richtungslogik aufbauen. -Insbesondere prüfen/korrigieren: +Insbesondere prüfen/korrigieren. Die folgenden fachlichen Einstiegspunkte stammen aus Fassung 1.0; inzwischen vorhandene korrekte Umsetzung erhalten: + +- `DirectionMark` rendert derzeit 16px-Konturpfeile. Auf führende Dreiecksspalte umstellen und in allen tatsächlich verwendeten Zeilen/Leserstellen prüfen. +- Tatsächlichen Inhalt von `frontend/public/ui/content-symbols-v1/light/note.svg` und `dark/note.svg` mit den gelieferten Quellen vergleichen und ersetzen. Das beobachtete Problem ist keine bloße falsche Typbezeichnung: Die sichtbare Notiz lädt bereits den Pfad `note.svg`, dessen App-Datei aber einen Blattumriss enthält. - `mailFacts` in `frontend/src/pages/content.jsx` verwendet bisher für jede Richtung außer `out` den Text „Eingang“. Fehlend/ungültig muss ohne Richtung bleiben. - `dateFlow` leitet bisher aus `sent_on`/`received_on` Richtungsangaben ab und zeigt bei beiden „Eingang · Ausgang“. Durch die fachlich eindeutige Logik ersetzen; Datumsfelder erhalten. @@ -83,5 +93,7 @@ Mit synthetischen Daten prüfen und konkrete Ergebnisse liefern: 6. Benutzerwechsel bei gleichem Kontext ändert die Richtung nicht. Zweite Einbindung mit anderer Bezugsseite wird nicht durch die erste Korrektur überschrieben. Keine Einsicht in fremde Kontexte. 7. Leserecht allein erlaubt keine Änderung der Kommunikationsangaben. Vorhandene Antwortbezüge, Ordnung und Dokumentöffnung funktionieren weiter. 8. Desktop und Handy, lange Namen/Titel und Bedienung per Tastatur prüfen. Relevante fachliche Tests für Speicherung/Zuordnung/Rechte und vorhandenen Frontend-Build ausführen. Screenshots der synthetischen Beispiele liefern; ausgeführte und nicht ausführbare Prüfungen trennen. +9. Führende Dreiecke bei normalem Zoom prüfen: Eingang zeigt rechts hinein, Ausgang links heraus. Beide ohne Hover gut erkennbar. Eine dritte Zeile ohne Richtung hält dieselbe Ausrichtung. Dreieck ist weder Button noch Aufklappsteuerung; Kennzeichnung mit sichtbarem Text und zugänglichem Namen konsistent. +10. Echte Notiz und Datei/PDF nebeneinander ansehen: Sprechblase mit Stift gegenüber Blatt, sofort unterscheidbare Silhouetten. Geladene tatsächliche Asset-URLs und deren Inhalt prüfen; gleichnamige alte Dateien oder ein lediglich erfolgreicher Build reichen nicht als Erfüllung. Screenshots beider Inhaltstypen und Richtungen am Desktop und Handy mitliefern. Arbeite bis zur lokal prüfbaren Umsetzung. Keine erneute Spezifikationsrunde als Endergebnis. Kein Commit, Push oder Deployment durch diesen Auftrag; ein Push auf `develop` würde Development auslösen. Ergebnisse, betroffene Dateien, Prüfungen und tatsächliche Einschränkungen knapp übergeben. Es wird keine erfolgreiche Live-Integration durch das bloße Vorhandensein der Dateien behauptet. diff --git a/docs/product/TSUMUGU_PRODUCT_SPEC.md b/docs/product/TSUMUGU_PRODUCT_SPEC.md index 8d8398a..bbb742f 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.31, optionale Kommunikationsrichtung unabhängig von Inhaltstyp und Quelle präzisiert. +**Stand:** 17.10.2026 · **Arbeitsstand:** 0.33, sichtbarer Symbolaustausch und führende Kommunikationsdreiecke präzisiert; nächste Exportlieferung bleibt gesichert. **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. @@ -374,13 +374,35 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G ### F-06e – Eingehende und ausgehende Kommunikation: 17.10.2026 +**Nachtrag aus erneuter Live-Prüfung:** Der Nutzer beanstandet weiterhin ähnliche Inhaltssymbole und eine zu unauffällige Richtung. Notiz muss tatsächlich die gelieferte Sprechblase mit Stift verwenden; die App-Kopie enthält bislang weiterhin eine Blattkontur. Kleine 16px-Diagonalpfeile im Metadatentext werden ersetzt: gefülltes Dreieck ganz vorne in einer festen Richtungsspalte, Eingang nach rechts in die Zeile, Ausgang nach links heraus. Danach Typ-Symbol und Titel. Desktop 28px, Handy mindestens 24px; keine reduzierte Deckkraft. Ohne Richtung bleibt die Spalte leer und gleich breit. Sichtbare Beschriftung bleibt erhalten; Dreiecke sind keine Aufklapp-/Abspielschaltflächen. Paket 1.3 und Kommunikationsauftrag 1.1 enthalten die aktualisierten Dateien und die Abnahme einschließlich tatsächlicher Asset-Inhalte und Cache-Aktualisierung. + **Nutzerbedarf und Auftrag:** Die Richtung der Kommunikation ist für das Verständnis des Vorgangs entscheidend. Der Nutzer beauftragt nach Besprechung der Trennung von Inhaltstyp und Richtung die Spezifikation und einen Cursor-Prompt. -**Konkrete Ausgestaltung:** Eingang/Ausgang sind optionale Kommunikationsangaben zusätzlich zum unveränderten Inhaltstyp-Symbol. Eigene Gedankenaufzeichnungen benötigen keine Richtung, Telefonnotizen können Eingang oder Ausgang dokumentieren. Kleine Richtungszeichen mit sichtbarem Text ergänzen bekannte Beteiligte und passend benannte Kommunikationsdaten. Ohne sichere Angabe kein Richtungszeichen und kein automatischer Eingang. Bezugsseite ist die im Vorgang vertretene Person/Organisation, unabhängig vom angemeldeten Betrachter. Abweichende Perspektiven bei Mehrfacheinbindung bleiben kontextbezogen, ohne Kopie des gemeinsamen Inhalts oder neue Rechte. +**Konkrete Ausgestaltung:** Eingang/Ausgang sind optionale Kommunikationsangaben zusätzlich zum unveränderten Inhaltstyp-Symbol. Eigene Gedankenaufzeichnungen benötigen keine Richtung, Telefonnotizen können Eingang oder Ausgang dokumentieren. Führende gefüllte Richtungsdreiecke mit sichtbarem Text ergänzen bekannte Beteiligte und passend benannte Kommunikationsdaten. Ohne sichere Angabe kein Richtungszeichen und kein automatischer Eingang. Bezugsseite ist die im Vorgang vertretene Person/Organisation, unabhängig vom angemeldeten Betrachter. Abweichende Perspektiven bei Mehrfacheinbindung bleiben kontextbezogen, ohne Kopie des gemeinsamen Inhalts oder neue Rechte. **Präzisierung gegenüber F-06d:** Datumsfelder allein sind kein allgemeiner Richtungsnachweis; ein Schriftstück kann sowohl Versand- als auch Zugangsdatum haben. Keine gleichzeitige Richtung „Eingang · Ausgang“ daraus ableiten. Eindeutige explizite Quelldaten dürfen vorbelegen, manuelle Korrektur oder bewusstes Leeren bleiben erhalten. Kein Pflichtfeld, keine Massenklassifizierung, kein Versandworkflow und kein neues Parteienregister. -**Lieferung:** Symbolpaket 1.2 ergänzt zwei einzelne Richtungszeichen. Fachliche Details, gezielte technische Einstiegspunkte und Abnahme stehen in [TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md). Der Beziehungsausbau F-06d wird erhalten; die Richtungsregeln werden durch diesen späteren Auftrag präzisiert. +**Lieferung:** Symbolpaket 1.3 enthält die korrigierten Richtungsdreiecke und die klar unterscheidbare Notizform. Fachliche Details, gezielte technische Einstiegspunkte und Abnahme stehen in [TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md), Fassung 1.1. Der Beziehungsausbau F-06d wird erhalten; die Richtungsregeln werden durch diesen späteren Auftrag präzisiert. + +### F-07a – Nächste Phase: vollständiges Übergabepaket für den Anwalt: 17.10.2026 + +**Nutzerbedarf und Lieferentscheidung:** Vorgänge oder gezielt ausgewählte Teile sollen mit ihrer Struktur und den enthaltenen Dokumenten, E-Mails und Anlagen an den Anwalt übergeben werden können. Auf Nachfrage genügt für die unmittelbar nächste Lieferung zunächst ein vollständiges Übergabepaket. Ein laufender Lese-/Downloadzugang und eine Kombination beider Wege bleiben mögliche spätere Ausbauschritte. Rechnungen, Arztrechnungen, Zahlungen, Erstattungen und Einreichungen werden vorerst weiter zurückgestellt, nicht gestrichen. Die konkrete Reihenfolge dieser Phase präzisiert F-05a; die frühere technische Paketnummerierung legt keine andere Rangfolge fest. + +**Weitere Zielrichtung:** Universell erweiterbare Connectoren für zusätzliche Quellen und Ablagen sind gewünscht. Der Connectoren-Befund ist Bestandsanalyse und Aufwandsschätzung, keine Freigabe eines vollständigen Umbaus. Für den Export notwendiger vollständiger Inhaltsabruf und eindeutige Quellenauflösung werden vom späteren vollständigen Connector-Umbau unterschieden. + +**Ausgestaltung für den vorbereiteten Coding-Auftrag:** Strukturierte ZIP-Ausgabe, lesbare HTML-Übersicht, Markdown-Dokumentation, Originaldateien, vollständige E-Mails mit Anlagen und eine Vollständigkeitsprüfung. Dies sind konkrete Umsetzungsvorschläge des Lieferpakets, keine rückwirkend bestätigten Formatentscheidungen. Liefergrenze, Quellen und Abnahme stehen in [Erste Exportlieferung und Cursor-Auftrag](TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md). Der Dokumentationsauftrag selbst startet keine Implementierung und kein Deployment. + +### F-07b – Hierarchische Auswahl nach Vorkommen: bestätigt am 17.10.2026 + +**Beschluss:** Die Auswahl ist auf jeder Hierarchieebene des Exportumfangs möglich. Auf oberster Ebene können alle Inhalte an- oder abgewählt werden; dasselbe gilt auf jeder darunterliegenden Ebene bis zum einzelnen Inhalt beziehungsweise zur Einzeldatei. Eine übergeordnete Auswahl wirkt auf alle untergeordneten Vorkommen. Danach sind einzelne Unterauswahlen möglich; teilweise ausgewählte Ebenen erhalten einen eindeutigen Zwischenzustand. + +**Auswirkungen:** Notizen und kontextbezogene Anmerkungen folgen derselben Auswahlregel; die zuvor vorgeschlagene Sonderregel einer ausschließlich separaten Auswahl wird dadurch ersetzt. Auswahl wirkt auf die jeweilige Einbindung beziehungsweise das Vorkommen, nicht als globale Sperre des gemeinsamen Inhalts. Die E-Mail-Einheit ist in F-07c präzisiert. Neue Hierarchietiefen, Unterkapitel oder eine automatische Aufnahme von Querverweiszielen werden hierdurch nicht beschlossen. + +### F-07c – Ausgewählte E-Mail enthält ihre vollständigen Anlagen: bestätigt am 17.10.2026 + +**Beschluss:** E-Mails werden mit ihren Anhängen exportiert, auch wenn derselbe Anhang als eigenständiges Element an anderer Stelle abgewählt ist. Die ausgewählte E-Mail bleibt vollständig einschließlich ihrer Anlagen; das Abwählen betrifft ausschließlich das separate Vorkommen. Ein Hinweis auf die weiterhin über die E-Mail enthaltene Datei kann erscheinen. + +**Auswirkungen:** Das unveränderte vollständige E-Mail-Original darf nicht wegen einer separat abgewählten Anlage reduziert werden. Eine vollständige E-Mail und separat eingebundene Anlage-Vorkommen bleiben in der Auswahl unterscheidbar. Ein Dateiname allein genügt nicht für eine behauptete Identität. Dies korrigiert ausdrücklich den zwischenzeitlichen Assistentenvorschlag, abgewählte Anlagen aus einer E-Mail zu entfernen. ## 6. Fortschreibung @@ -446,4 +468,8 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G 17.10.2026, Arbeitsstand 0.31: F-06e und Cursor-Auftrag zur optionalen Kommunikationsrichtung ergänzt. Unbekannt ist kein Eingang; Bezugsseite, manuelle Korrekturen und Mehrfacheinbindung berücksichtigt. Symbolpaket 1.2 um Eingang/Ausgang ergänzt. Keine Anwendungscode- oder Deploymentänderung durch diesen Dokumentationsauftrag. +17.10.2026, Arbeitsstand 0.32: F-07a–c aus der fachlichen Weiterplanung ergänzt. Erste nächste Lieferung ist ein vollständiges Anwalts-Übergabepaket. Auswahl auf jeder Hierarchieebene nach Vorkommen; ausgewählte E-Mails bleiben mit allen Anlagen vollständig, auch bei separat abgewählten Anlage-Vorkommen. Finanzthemen weiter zurückgestellt; Connector-Ziel und gesonderter Umbau bleiben erhalten. Lieferpaket und vorbereiteten Cursor-Auftrag im Produktverzeichnis abgelegt. Keine Änderung an Anwendungscode, Datenbanken oder Deployments. + +17.10.2026, Arbeitsstand 0.33: Sichtprüfung zu F-06e bestätigt Blatt statt Sprechblase bei Notizen und zu kleine Richtungspfeile. Paket 1.3 liefert gefüllte Dreiecke; Auftrag 1.1 verlangt führende Richtungsspalte, tatsächlichen Austausch der Notizdateien und Prüfung der ausgelieferten Inhalte. Fachliche Exportplanung aus 0.32 erhalten. Keine Anwendungscodeänderung oder Deployment durch diese Fortschreibung. + 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_SYMBOLS_LOGOFRAME_AUFTRAG.md b/docs/product/TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md index 6ea8682..a3894a3 100644 --- a/docs/product/TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md +++ b/docs/product/TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md @@ -4,7 +4,7 @@ ## Fertige Lieferungen lesen und verwenden -1. [Inhalts-/Struktursymbole](C:/Dev/jinkendo-app-design-2026-10-17/assets/content-symbols-v1/README.md): inzwischen 26 Motive, Paketfassung 1.2, je eine einzelne SVG-Datei für helle und dunkle Flächen; transparente PNGs zusätzlich. Lizenz mit übernehmen. Keine neue Iconbibliothek installieren; keine SVG-Geometrien neu zeichnen. Die zwei zusätzlichen Richtungszeichen ergänzen den Inhaltstyp gemäß [Kommunikationsauftrag](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md). +1. [Inhalts-/Struktursymbole](C:/Dev/jinkendo-app-design-2026-10-17/assets/content-symbols-v1/README.md): inzwischen 26 Motive, Paketfassung 1.3, je eine einzelne SVG-Datei für helle und dunkle Flächen; transparente PNGs zusätzlich. Lizenz mit übernehmen. Keine neue Iconbibliothek installieren; keine SVG-Geometrien neu zeichnen. Die zwei Richtungszeichen sind jetzt gefüllte Dreiecke für die führende Richtungsspalte gemäß [Kommunikationsauftrag 1.1](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md). 2. [Logo auf dunkler Fläche](C:/Dev/jinkendo-app-design-2026-10-17/assets/logos-on-dark-v1/README.md): vorbereitete transparente gerahmte PNGs aller fünf Produkte sowie CSS für einen stationären Rahmen um die vorhandene Markenanimation. 3. [Bestehender Animationsauftrag](TSUMUGU_ENSO_ANIMATION_AUFTRAG.md): gilt weiter; durch diesen Auftrag wird nur die passende dunkle Trägerfläche ergänzt. Die Favicons bleiben die statischen Innenmotive v2. @@ -14,6 +14,8 @@ Die angemeldete Development-Ansicht wurde am 17.10.2026 lesend angesehen. Im dun ## A. Typ-Symbol als zuverlässige Orientierung +- **Erneute Prüfung:** Der sichtbare Eintrag lädt `note.svg`, aber die aktuelle App-Kopie enthält weiterhin einen Blattumriss. Daher die tatsächlichen Dateien `light/note.svg`, `dark/note.svg` und verwendete PNGs durch die gelieferten Sprechblasen mit Stift ersetzen, Inhalte/Hashes zwischen Quelle und App-Kopie vergleichen und im ausgelieferten Zustand ansehen. Nur gleiche Dateinamen oder vorhandene URLs belegen den Austausch nicht. Paketversion/Asset-Cache so aktualisieren, dass normales Neuladen die neue Fassung zeigt. + - **Präzisierung 17.10.2026, Symbolpaket 1.1:** Eine einzelne Notiz ist typischerweise eine Gesprächsnotiz, ein Gedankenprotokoll oder eine eigene Aufzeichnung. Dafür das überarbeitete `note.svg` verwenden: **runde Sprechblase mit Stift**, deutlich andere Silhouette als PDF/Schriftstück. Die alte Haftnotiz nicht weiterverwenden. Bereits übernommene Notiz-SVGs und PNGs in beiden Farbvarianten ersetzen und die Auslieferung der neuen Dateien prüfen. Die Sprechblase steht für die aufgezeichnete Notiz, nicht für eine neu zu bauende Chatfunktion. Paperless bleibt eine Quellenangabe; bekannte PDF-Dateien erhalten das PDF-Symbol. - Führendes Inhaltstyp-Symbol in jeder Eintragszeile, auch ohne abrufbare Vorschau. PDF, Textdokument, Notiz, Bild usw. über die gelieferten Motive unterscheiden. Titel, fachliches Datum, Beschreibung und lesbare Typ-/Quellenangabe bleiben erhalten. - PDF-/Textseiten und Notizen brauchen standardmäßig keine unlesbare kleine Seitenansicht. Bei Fotos oder anderen wirklich aussagekräftigen Motiven kann eine zusätzliche Miniatur sinnvoll bleiben; der Inhaltstyp bleibt erkennbar. Keine neue umfangreiche Ansichtsverwaltung bauen. diff --git a/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md b/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md index 6ed9c3a..5f9ed86 100644 --- a/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md +++ b/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md @@ -1,6 +1,6 @@ # Tsumugu – Ergänzung zur Bedienung, Orientierung und Aktenordnung im MVP -**Stand:** 17.10.2026 · **Fassung:** 0.5, optionale Kommunikationsrichtung mit eindeutiger Bezugsseite ergänzt +**Stand:** 17.10.2026 · **Fassung:** 0.6, tatsächlicher Notizsymbol-Austausch und führende gefüllte Richtungsdreiecke **Zweck:** Referenz für die Überarbeitung der bestehenden MVP-Anwendung durch den Coding-Agenten. **Bezug:** [Fachliche Produktspezifikation](TSUMUGU_PRODUCT_SPEC.md), insbesondere S-01a–d, F-04a und F-05a; [technischer Entwurf](../architecture/TSUMUGU_TECHNICAL_SPEC.md). @@ -11,7 +11,7 @@ ## 1. Ziel und Verbindlichkeit -**Neueste Präzisierung F-06e:** Inhaltstyp, Quelle und Kommunikationsrichtung getrennt darstellen. Eingang/Ausgang erscheinen als kleines Zusatzzeichen mit Text; unbekannte Richtung oder eigene Gedanken bleiben ohne Richtungssignal. Die Richtung bezieht sich auf die vertretene Seite im aktiven Vorgang, nicht auf den angemeldeten Nutzer. Datumsfelder allein begründen keine eindeutige Richtung, beide Felder nicht zu „Eingang · Ausgang“ verbinden. Bestehende Vorbelegung nur bei belastbaren Quelldaten, bewusste Korrektur/Leeren erhalten. [Spezifikation und konkreter Cursor-Auftrag](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md), einschließlich fertiger SVG-/PNG-Zeichen im Symbolpaket 1.2. +**Neueste Präzisierung F-06e:** Inhaltstyp, Quelle und Kommunikationsrichtung getrennt darstellen. Eingang/Ausgang erscheinen als gefülltes Dreieck ganz vorne in einer festen Richtungsspalte: Eingang nach rechts hinein, Ausgang nach links heraus, Desktop 28px/Handy mindestens 24px. Danach Inhaltstyp und Titel; Text „Eingang“/„Ausgang“ bleibt sichtbar. Unbekannte Richtung oder eigene Gedanken lassen diese Spalte leer und gleich breit. Die Notizdateien tatsächlich durch die gelieferte Sprechblase mit Stift ersetzen und ausgelieferten Inhalt prüfen. Die Richtung bezieht sich auf die vertretene Seite im aktiven Vorgang, nicht auf den angemeldeten Nutzer. Datumsfelder allein begründen keine eindeutige Richtung, beide Felder nicht zu „Eingang · Ausgang“ verbinden. Bestehende Vorbelegung nur bei belastbaren Quelldaten, bewusste Korrektur/Leeren erhalten. [Spezifikation und konkreter Cursor-Auftrag, Fassung 1.1](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md), einschließlich fertiger SVG-/PNG-Zeichen im Symbolpaket 1.3. Die bestehende erste Lieferung „Organisieren und Nachverfolgen“ soll im Alltag verständlich und praktisch bedienbar werden. Die Überarbeitung umfasst Darstellung und Bedienabläufe sowie die dafür erforderlichen gezielten Anpassungen an Schnittstellen und Speicherung. Ein reiner Austausch von Farben und Abständen erfüllt diesen Auftrag nicht. @@ -306,6 +306,8 @@ Ein Push auf `develop` löst laut Repository einen Development-Deploy aus. Der r ## 15. Fortschreibung +- **0.6:** Erneute Prüfung: Notiz erscheint weiterhin als Blatt; 16px-Diagonalpfeile sind zu unauffällig. Führende feste Richtungsspalte mit gefüllten Dreiecken und tatsächlich ersetzte Notiz-Assets verbindlich. SVG-/PNG-Dateien und Cache-Aktualisierung prüfen. Keine Änderung der Kommunikationsbedeutung. + - **0.5:** F-06e: optionale Kommunikationsrichtung unabhängig von Format/Quelle, stabile Bezugsseite, sichtbare Zeichen mit Text und keine falschen Standardwerte. Symbolpaket 1.2 und gesonderter Cursor-Auftrag verlinkt. Beziehungsausbau aus 0.4 bleibt erhalten. - **0.3:** Aktueller Nutzerbedarf F-06c: gelieferte Typ-Symbole als verlässliche Orientierung; Miniaturen nur bei erkennbarem Nutzen; Notiz mit Auszug; keine Leerboxen oder ewiges Thumbnail-Laden; große Leseansicht bleibt. Frühere pauschale Thumbnail-Pflicht ersetzt. Kein Fachmodell-/Rechtewechsel. diff --git a/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md b/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md new file mode 100644 index 0000000..fc96d58 --- /dev/null +++ b/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md @@ -0,0 +1,83 @@ +# Tsumugu – Übergabe zur fachlichen Weiterplanung + +**Stand:** 17.10.2026 · **Zweck:** Einstieg in einen neuen fachlichen Planungschat nach Auswahl des Designkonzepts. Keine neue Produktentscheidung und kein zusätzlicher Implementierungsauftrag. + +## 1. Aktueller Auftrag und Arbeitsweise + +Lars möchte nach der Designauswahl die fachliche Umsetzung der weiteren Anforderungen planen. Das vorhandene MVP dient als Keimzelle. Detaillierung bleibt pragmatisch: nur Entscheidungen klären, die den nächsten nutzbaren Ausbau tatsächlich beeinflussen. Bereits bestätigte Grundsätze nicht erneut interviewen. Anforderungen dürfen durch zeitliche Zurückstellung nicht verschwinden. + +Die ausgewählte Tsumugu-Oberfläche wird im vorhandenen Produkt umgesetzt. Daraus sollen nach tatsächlicher Nutzung gemeinsame Jinkendo-Designregeln entstehen. Die fachliche Weiterplanung ist ein eigener Arbeitsstrang. Eine endgültige Familien-Designbibliothek ist keine Vorbedingung für den nächsten fachlichen Schritt. + +## 2. Führende Quellen und gezielte Lesereihenfolge + +1. Diese Übergabe, anschließend [Produktspezifikation, aktuell 0.33](TSUMUGU_PRODUCT_SPEC.md), vor allem gesicherter Kern, Entscheidungen F-01 bis F-05 und Strukturentscheidungen S-01. Die Fachspec bleibt führend; F-06c präzisiert die Inhaltsdarstellung, F-06d die Antwortbezüge, F-06e die davon unabhängige optionale Kommunikationsrichtung. Symbolpaket 1.3 enthält die runde Sprechblase mit Stift sowie gefüllte Dreiecke, Eingang rechts/Ausgang links, für eine feste führende Spalte. Die erneute Live-Prüfung zeigte noch Blatt statt Notizsymbol; tatsächlichen Austausch prüfen. [Aktueller Kommunikationsauftrag, Fassung 1.1](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md). +2. [UX-Ergänzung, aktuell 0.6](TSUMUGU_UX_MVP_ERGAENZUNG.md): Bedienanforderungen der bestehenden ersten Lieferung. Inhaltstyp-Symbole tragen die Orientierung; Miniaturen ergänzen bei erkennbarem Nutzen, der große Leser bleibt. Kommunikationsrichtung benötigt eine klare Bezugsseite; unbekannt bleibt unbekannt. Führende Dreiecke lösen kleine Diagonalpfeile ab. +3. [Designkonzept, aktuell 0.7](C:/Dev/jinkendo-app-design-2026-10-17/JINKENDO_APP_DESIGN_CONCEPT.md) und [Umsetzungsauftrag](C:/Dev/jinkendo-app-design-2026-10-17/UMSETZUNGSAUFTRAG_TSUMUGU.md): zuletzt ausgewählte Gestaltungsrichtung und konkrete Aufträge. Die Bildreferenzen sind dort lokal verlinkt. Originalmotive ersetzen freie Logo-Nachbauten. Für Browser-Tabs gelten die statischen [Favicons v2](C:/Dev/jinkendo-app-design-2026-10-17/assets/favicons-v2/README.md). Eine kurze Ensō-Rotation am Login/App-Einstieg ist als [Animationspaket](C:/Dev/jinkendo-app-design-2026-10-17/assets/enso-motion-v1/README.md) mit [Cursor-Auftrag](TSUMUGU_ENSO_ANIMATION_AUFTRAG.md) geliefert. Zuletzt wurden einzelne Inhalts-/Struktursymbole und gerundete Logo-Rahmen für dunkle Flächen beauftragt und bereitgestellt: [aktueller Cursor-Auftrag](TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md). Typ-Symbole ersetzen unbrauchbare Miniaturen als Orientierungsgrundlage; der große Leser bleibt. Der Nutzer arbeitet für die Umsetzung mit Cursor. Alle tatsächlichen App-Einbindungen sind gesondert zu prüfen. +4. [Vorläufige MVP-Annahmen](../MVP_ANNAHMEN.md): technische Arbeitsregeln zu Rechten/Löschen, keine abschließend bestätigte Produktpolitik. +5. [Technische Spezifikation 0.3](../architecture/TSUMUGU_TECHNICAL_SPEC.md): Lieferstaffelung, Umsetzungsvorschläge und offene Fragen; noch kein aktueller Testnachweis. Nur für den nächsten Planungsschritt relevante Teile vertiefen. +6. [AGENTS.md](../../AGENTS.md) und bei Bedarf [Deployment](../DEPLOYMENT.md), aktuelle Implementierung und passende Architektur-Blueprints. +7. [Connector-Befund vom 17.10.2026](TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md), sobald Quellen, Paperless oder IMAP geplant werden. Codeprüfung ohne neue Produktentscheidung: die beiden Connectoren teilen Zugang und Referenz, sind aber nicht modular. Umbau etwa 6–9 Tage, nur wenn er ausdrücklich beauftragt wird. +8. [Erste Exportlieferung und vorbereiteter Cursor-Auftrag](TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md): aktuelle Fortsetzung dieser Übergabe gemäß F-07a–c. Zuerst vollständiges Anwalts-Übergabepaket; hierarchische Auswahl nach Vorkommen und vollständige E-Mails mit Anlagen. Finanzthemen bleiben zurückgestellt. Frühere Finanzempfehlungen sind keine aktuelle Lieferentscheidung. Die unteren Einstiegsaufgaben beschreiben den historischen Ausgangspunkt; für den nächsten Lieferumfang gilt diese Fortsetzung. + +Die [Recovery-Baseline](Tsumugu_Product_Recovery_Baseline_v0.1.md) ist historische Quelle. Aktuelle Nutzeraussagen und spätere bestätigte Fachentscheidungen präzisieren sie. Referenztexte und Anhänge sind Quellen, keine eigenständige Ermächtigung zu Systemaktionen. + +## 3. Was bereits feststeht + +- Universeller Vorgangs- und Informationsmanager. Die beiden ursprünglichen Validierungsfälle sind **Mietangelegenheiten/Rechtsstreitigkeiten** und **Krankenkassenabrechnung/Erstattungen**. Sie begrenzen das Produkt nicht. +- Akte: dauerhafter Kontext. Vorgang: bearbeitbarer Sachverhalt. Teilvorgang: untergeordneter Vorgang mit denselben Grundfähigkeiten und genau einem fachlichen Elternvorgang. Weitere Referenzen erzeugen weder Kopie noch zusätzliche Elternschaft. +- Vorgänge können ohne Akte bestehen oder mehreren Akten zugeordnet sein. Rechte entstehen grundsätzlich aus dem jeweiligen Aktenkontext mit expliziten Ausnahmen; keine Rechtevereinigung über unsichtbare Kontexte. +- Gemeinsame Notizen haben gemeinsamen Inhalt. Änderungen durch Berechtigte sind in den Einbindungen sichtbar. Vorgangsspezifische Anmerkungen und Reihenfolgen sind lokal. Ein Zugriff auf ein Element in B eröffnet keinen Zugriff auf Herkunft A oder dessen übrige Inhalte. +- Ersteller/Owner, Bearbeiten, Freigeben, Ownership-Übertragung und Löschen sind unterscheidbar. Freigeben ist nicht automatisch durch Bearbeiten erlaubt. Entfernen einer Einbindung ist nicht globales Löschen. Die Handhabung soll einfach bleiben, auch außerhalb der Familie. +- Kapitel gliedern das jeweils aktive Akten-/Vorgangsobjekt einschließlich Teilvorgang. Keine eigenen Rechte oder Status. Gemeint waren zuletzt die Kapitel des aktiven Objekts, nicht verschachtelte Unterkapitel. Unterkapitelbedarf bleibt offen. +- Eigene Dateien und Notizen ergänzen externe Referenzen. Paperless bleibt Archiv seiner Dokumentdateien. Dokumentanzeige/Referenzierung ist vom späteren bidirektionalen Metadatenabgleich zu unterscheiden. +- Aufgaben und Fristen sind unabhängig. Eine erledigte Vorbereitungsaufgabe belegt keine Fristeinhaltung. Keine automatische juristische Fristberechnung beschlossen. +- Sichten sind dynamische Auswahlen. Virtuelle Zusammenstellungen ordnen ausgewählte Verweise bewusst an. Späterer gezielter Zugang für einen Anwalt ist gewünscht; Herkunftsbestände bleiben geschützt. Neue Inhalte einer geteilten Zusammenstellung erfordern zusätzliche ausdrückliche Freigabe. + +## 4. Lieferumfang und weiterer fachlicher Bedarf + +**Bestätigter erster Schnitt F-05a: „Organisieren und Nachverfolgen“.** Persönliche/gemeinsame Datenräume, Akten/Vorgänge/Verknüpfungen, Notizen/eigene Dateien/manuelle Paperless-Referenzen, fachliche Chronologie, Aufgaben und unabhängige Fristen sowie zentrale Übersicht offener Arbeit. Die Anwendung existiert; die Gestaltung wird überarbeitet. Ihre aktuelle Vollständigkeit ist nicht durch diese Übergabe geprüft. + +Die folgenden Fähigkeiten bleiben erhalten. Die Tabelle ist eine Planungsübersicht, keine neu beschlossene Reihenfolge: + +| Bereich | Gesichert | Für den nächsten passenden Ausbau noch konkretisieren | +|---|---|---| +| Organisation und Nachverfolgung | Fachliches Modell und erster Lieferumfang. | Tatsächliche Restlücken gegen Nutzung prüfen; nur relevante Ergänzungen zu Status, Friständerung, Erinnerung, Chronologie und Struktur auswählen. | +| Rechnungen und Erstattungen | Mehrere Rechnungen je Vorgang; eigene Zahlungs-/Erstattungsstände; manuelle Teil-/Sammelzuordnungen; akzeptierter Eigenanteil; offener Klärungsbedarf bleibt nachzuverfolgen. | Konkrete Daten, Betragszuordnung, Status-/Abschlussregeln, Korrekturen und kleinster nutzbarer Ablauf. Keine automatische Bankintegration voraussetzen. | +| Paperless-Metadaten | Ausgewählte Felder bidirektional; feldweise Zuständigkeit; zulässige einseitige Änderungen automatisch; konkurrierende unterschiedliche Werte erhalten bis zur Entscheidung. | Echte Feldschlüssel/Typen, Identität und Berechtigungen, Synchronisationsauslöser, Konfliktbedienung, Fehler/Wiederholung; nur ausdrücklich beauftragter Anschlusstest. | +| Sichten, Zusammenstellungen und Teilen | Begriffe und Schutzprinzipien bestätigt; gezielter späterer Anwaltszugang. | Liefergrenze, erlaubte Inhalte, Dynamik gegenüber bewusster Auswahl, Empfängerzugang, Entzug und Umgang mit später ergänzten Inhalten. | +| Weitere Ressourcentypen | Eigenständige Ablage etwa für E-Mails/Anhänge, Fotos und später Audio grundsätzlich möglich. | Je konkretem Bedarf den kleinsten Import-/Bearbeitungsablauf wählen. Eine Darstellung im Designbild ist keine automatische Implementierungsfreigabe. | +| KI und Kairo-Anbindung | Geschützte Vorgangsdaten perspektivisch für KI nutzbar; Aufgaben später auch in Kairo anlegen/verfolgen. | Konkreter Nutzen, Datenumfang, Berechtigung und Schnittstelle. Kein autonomer Agent als Pflicht des bestehenden MVP. | + +**Wichtige Finanzsemantik:** `erstattet_am` bedeutet im bestehenden Nutzerbestand das Datum der Erstattungsmitteilung, nicht tatsächlichen Zahlungseingang. Der Erstattungsbetrag wird bisher an der Rechnung geführt; Rechnungen werden Erstattungsbelegen zugeordnet. Rechnungszahlung, Erstattungsmitteilung, tatsächlicher Geldeingang und fachlicher Abschluss sind getrennt. Teilzahlungen, Rückfragen und akzeptierte nicht erstattbare Anteile sind berücksichtigt; ein erledigter Vorgang darf nicht ungeprüft alle Rechnungen erledigen. + +**Sieben benannte Bestandsfelder:** Rechnungsbetrag, Erstattungsbetrag, Zahlungsziel, bezahlt_am, erstattet_am, eingerecht_am, Ablaufdatum der Aufbewahrungsfrist. Das sind Nutzerbezeichnungen, keine geprüften API-Schlüssel. Ablaufdatum bedeutet keine beschlossene automatische Löschung. + +Finanzfunktionen und ausgewählte bidirektionale Metadaten folgen gemäß F-05a nach dem ersten Schnitt. Ihre gegenseitige Reihenfolge ist **nicht** separat beschlossen. Umfang/Lieferposition virtueller Zusammenstellungen sind ebenfalls nicht automatisch durch die technischen Paketnummern festgelegt. + +## 5. Befunde der Kontext- und Dokumentprüfung + +1. Die Fachspec enthält historische Etappenformulierungen wie „keine Implementierung“ oder „nächster Schritt MVP-Abgrenzung“. Spätere Nutzeraufträge und die vorhandene Anwendung haben diese Etappen überholt. Die Passagen sind kein aktuelles Verbot der bereits beauftragten Umsetzung. +2. Die technische Spec enthält noch „erster Implementierungsauftrag nur P0“. Das passt nicht zum inzwischen vorhandenen MVP und ist kein Neustartauftrag. Technische Paketvorschläge sind keine zusätzlich bestätigte Produktrangfolge. +3. Die technische Spec nennt **eine Unterakten- und eine Teilvorgangsebene** als MVP-Ausgestaltung. Die Fachspec lässt die generelle Tiefe offen; das gewählte Design fordert Verständlichkeit auch bei anspruchsvolleren Strukturen. Die eine Ebene darf nicht als endgültige Produktgrenze gelten; beliebige Rekursion ist ebenso wenig als bereits bestätigte MVP-Pflicht zu behaupten. Vor dem betroffenen Ausbau konkreten Bedarf und tatsächlichen Bestand abgleichen. +4. Die Rechte-/Löschannahmen sind ausdrücklich vorläufig. Die gültigen Schutzprinzipien bleiben erhalten; die Arbeitsannahmen werden nicht allein durch Implementierung zu endgültigen Fachbeschlüssen. +5. UI- und Logo-Richtung sind ausgewählt. Die drei PNG-Referenzen liegen nutzbar vor. **Nachtrag desselben Tages:** Der Nutzer beanstandet die vom Coder erfundenen Logo-Nachbauten. Daraufhin wurden alle fünf Motive direkt aus der ausgewählten Tafel extrahiert, pixelweise geprüft und mit technisch skalierten Icon-Dateien in [approved-logos-v1](C:/Dev/jinkendo-app-design-2026-10-17/assets/approved-logos-v1/README.md) bereitgestellt. Diese Dateien sind jetzt unverändert zu verwenden. Keine neuen Logos generieren oder nachzeichnen. Echte Vektormaster liegen weiterhin nicht vor; Einbindung und tatsächliche Darstellung im Produkt sind noch zu prüfen. +6. Im Repository waren am 17.10.2026 laufende Frontendänderungen vorhanden, unter anderem an Akten-, Vorgangs-, Shell- und Leseransichten. Das belegt Arbeit am Bestand, keinen erfolgreichen Abschluss oder Deploy. Im neuen Chat aktuellen Stand erneut lesen und fremde Änderungen erhalten. + +**Speicherprüfung:** Der lange Gesprächsverlauf liegt teilweise verdichtet vor. Die Projektdateien wurden deshalb erneut gezielt gelesen. Am geprüften Standardpfad `C:/Users/lars/.codex/memories` wurde kein lokaler Memory-Ordner gefunden; auch `C:/Users/lars/.codex/state/plugins/product-design/user-context.md` war nicht vorhanden. Daraus folgt keine vollständige Aussage über sämtliche App-/Account-Memory-Einstellungen. Diese Übergabe und die Quellen sind die explizite, überprüfbare Grundlage für die Fortsetzung. Es wurden keine Memory-Einstellungen verändert und keine Zugangsdaten übernommen. + +## 6. Einstieg im neuen Planungschat + +Der neue Chat sollte im Projekt `C:/Dev/tsumugu` laufen und „Tsumugu – Fachliche Weiterentwicklung“ heißen. Ein neuer Chat ist empfohlen, nicht technisch zwingend. Der bestehende Chat bleibt als Design- und Quellenhistorie erhalten. + +Erste konkrete Aufgabe: + +1. Diese Übergabe und gezielt die führenden Quellen lesen. Aktuellen Implementierungs-/Lieferstand feststellen; bereits geprüfte Ergebnisse des Coding-Agenten einbeziehen, soweit verfügbar. +2. Eine kompakte Übersicht **bestätigt / tatsächlich umgesetzt / noch offen / zurückgestellt** erstellen. „Umgesetzt“ nur mit passendem aktuellem Nachweis belegen, nicht aus einem Entwurf oder Statussatz ableiten. +3. Zwei bis drei sinnvolle nächste nutzbare Ausbauschritte mit Nutzen, Abhängigkeiten und kleinen Abnahmeabläufen vergleichen. Reihenfolge als Vorschlag kennzeichnen. Als naheliegenden Kandidaten den Krankenkassen-/Erstattungsfall einschließlich der dafür nötigen Paperless-Felder betrachten; nicht stillschweigend festlegen. +4. Nur die für die nächste Lieferentscheidung blockierenden Fragen klären. Danach ein kleines fachliches Lieferpaket und einen konkreten Coding-Auftrag formulieren. Bereits beschlossene Grundbegriffe und Rechteprinzipien nicht erneut grundsätzlich zur Wahl stellen. + +Die Fachplanung kann beginnen, während die Designumsetzung läuft. Die Beobachtungen daraus fließen ein, sobald vorhanden. Wir warten nicht auf einen vollständig ausformulierten Jinkendo-Familienstandard. + +## Kopierbarer Startauftrag + +Lies zuerst C:\Dev\tsumugu\docs\product\TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md und die dort gezielt genannten führenden Quellen. Plane mit mir die nächsten fachlichen Ausbauschritte von Tsumugu auf Basis des bestehenden MVP. Prüfe den aktuellen Umsetzungsstand, unterscheide bestätigte Anforderungen, belegte Implementierung, offene Entscheidungen und zurückgestellte Fähigkeiten. Empfiehl einen kleinen nächsten nutzbaren Lieferumfang mit Abnahmeablauf. Erhalte die bereits ausgewählte Designrichtung und alle bestätigten Fachentscheidungen. Beginne pragmatisch; keine erneute vollständige Grundlagen-Spezifikation und noch keine Implementierung im Rahmen dieses Planungsauftrags. diff --git a/frontend/src/pages/Cases.jsx b/frontend/src/pages/Cases.jsx index bdb9599..b3b71dc 100644 --- a/frontend/src/pages/Cases.jsx +++ b/frontend/src/pages/Cases.jsx @@ -8,7 +8,7 @@ import { ErrorNote, ShareBox } from "./widgets.jsx"; import { ContentBoard, DirectionChoice, MarkdownEditor, ObjectMenu, OrderChoice, RecordTree, SurfaceView, TargetLine, Trail, WorkLists, WorkSwitch, saveChapterOrder, writeSelection } from "./content.jsx"; import { ReadingPane } from "./ReadingPane.jsx"; import { StructureNavigator, Workspace, rememberScroll, restoreScroll, useWorkspaceLayout } from "./workspace.jsx"; -import { NavIcon } from "./icons.jsx"; +import { IconButton, NavIcon } from "./icons.jsx"; export function CaseList() { const { session } = useContext(SessionContext); @@ -519,6 +519,13 @@ export function CaseDetail() {

{record.title}

{record.status === "open" ? "Offen" : "Geschlossen"} + {record.rights.edit ? ( + + + + + + ) : null}
@@ -533,9 +540,6 @@ export function CaseDetail() { {record.rights.edit ? : null} {record.rights.edit ? : null} {record.rights.share || record.is_owner ? : null} - {record.rights.edit ? : null} - {record.rights.edit ? : null} - {record.rights.edit ? : null}
diff --git a/frontend/src/pages/ExportPackage.jsx b/frontend/src/pages/ExportPackage.jsx new file mode 100644 index 0000000..6366a5d --- /dev/null +++ b/frontend/src/pages/ExportPackage.jsx @@ -0,0 +1,229 @@ +import { useEffect, useRef, useState } from "react"; +import { api, downloadPost } from "../api.js"; + +function leafIds(node, into = []) { + if (!node) return into; + if (node.kind === "binding" || node.kind === "annotation") into.push(node.id); + (node.children || []).forEach((child) => leafIds(child, into)); + return into; +} + +function checkState(node, selected) { + const ids = leafIds(node); + if (!ids.length) return "off"; + const count = ids.filter((id) => selected.has(id)).length; + if (count === 0) return "off"; + if (count === ids.length) return "on"; + return "mixed"; +} + +function withNode(node, selected, on) { + const next = new Set(selected); + leafIds(node).forEach((id) => { + if (on) next.add(id); + else next.delete(id); + }); + return next; +} + +function initialSelection(node) { + const next = new Set(); + function visit(current) { + if ((current.kind === "binding" || current.kind === "annotation") && current.exportable) { + next.add(current.id); + } + (current.children || []).forEach(visit); + } + visit(node); + return next; +} + +function CheckBox({ state, disabled, onChange, label }) { + const ref = useRef(null); + useEffect(() => { + if (ref.current) ref.current.indeterminate = state === "mixed"; + }, [state]); + return ( + + ); +} + +function TreeRows({ node, depth, selected, onToggle }) { + const state = checkState(node, selected); + const ids = leafIds(node); + return ( + <> + + {(node.children || []).map((child) => ( + + ))} + + ); +} + +export function ExportPackage({ matterId, context, onClose }) { + const [tree, setTree] = useState(null); + const [selected, setSelected] = useState(() => new Set()); + const [review, setReview] = useState(null); + const [assignments, setAssignments] = useState({}); + const [error, setError] = useState(""); + const [pending, setPending] = useState(false); + const [downloaded, setDownloaded] = useState(false); + const query = context?.kind && context?.id ? `?context_kind=${context.kind}&context_id=${context.id}` : ""; + + useEffect(() => { + let alive = true; + api(`/api/v1/matters/${matterId}/export-tree${query}`).then((payload) => { + if (!alive) return; + setTree(payload.tree); + setSelected(initialSelection(payload.tree)); + }).catch((err) => { + if (alive) setError(err.message); + }); + return () => { + alive = false; + }; + }, [matterId, query]); + + function toggle(node, on) { + setSelected((current) => withNode(node, current, on)); + setReview(null); + setDownloaded(false); + } + + async function examine() { + setError(""); + setPending(true); + setDownloaded(false); + try { + const payload = await api(`/api/v1/matters/${matterId}/export/review`, { + method: "POST", + body: { + context: context || null, + selected: [...selected], + assignments, + }, + }); + setReview(payload); + } catch (err) { + setError(err.message); + } finally { + setPending(false); + } + } + + async function download() { + setError(""); + setPending(true); + try { + await downloadPost(`/api/v1/matters/${matterId}/export`, { + context: context || null, + selected: [...selected], + assignments, + }, "uebergabe.zip"); + setDownloaded(true); + } catch (err) { + setError(err.message); + } finally { + setPending(false); + } + } + + const ambiguous = (review?.issues || []).filter((issue) => issue.choices?.length); + + return ( +
+

+ Die Auswahl gilt für diese Ausgabe. Ein bereits heruntergeladenes Paket verändert sich nicht, + wenn danach Inhalte geändert oder ergänzt werden. +

+ {error ?

{error}

: null} + {!tree ?

Auswahl wird geladen …

: null} + {tree && !review ? ( + <> +
+ +
+
+ + +
+ + ) : null} + {review ? ( + <> +
+ {review.issues?.length ? review.issues.map((issue) => ( +

+ {issue.title}: {issue.message} +

+ )) :

Die Auswahl ist vollständig und kann ausgegeben werden.

} + {review.notices?.map((notice) => ( +

{notice.message}

+ ))} + {ambiguous.map((issue) => ( + + ))} +
    + {(review.entries || []).map((entry) => ( +
  • + {entry.kind_label}: {entry.title} + {entry.path ? · {entry.path} : null} +
  • + ))} +
+
+ {downloaded ? ( +

Das Paket wurde heruntergeladen. Es hält den Stand dieses Zeitpunkts fest.

+ ) : null} +
+ + {review.ready ? ( + + ) : ( + + )} +
+ + ) : null} +
+ ); +} diff --git a/frontend/src/pages/Matters.jsx b/frontend/src/pages/Matters.jsx index 979825d..eacb6e7 100644 --- a/frontend/src/pages/Matters.jsx +++ b/frontend/src/pages/Matters.jsx @@ -9,7 +9,8 @@ import { ChapterForm, FileForm, NoteForm } from "./Cases.jsx"; import { ContentBoard, ObjectMenu, Placements, RecordTree, SurfaceView, TargetLine, Trail, WorkLists, WorkSwitch, matterOpenHref, saveChapterOrder, writeChapter } from "./content.jsx"; import { ReadingPane } from "./ReadingPane.jsx"; import { StructureNavigator, Workspace, rememberScroll, restoreScroll, useWorkspaceLayout } from "./workspace.jsx"; -import { NavIcon } from "./icons.jsx"; +import { IconButton, NavIcon } from "./icons.jsx"; +import { ExportPackage } from "./ExportPackage.jsx"; function pageContext(params) { const kind = params.get("context_kind"); @@ -466,10 +467,19 @@ export function MatterDetail() {

{record.title}

{record.status === "open" ? "Offen" : "Geschlossen"} + {canEdit ? ( + + + + setModal("move")} /> + + + ) : null}
{width < 1500 ? : null} + {canEdit ? ( : null} {canEdit ? : null} {record.rights.share || record.is_owner ? : null} - {canEdit ? : null} - {canEdit ? : null} - {canEdit ? : null} - {canEdit ? : null}
@@ -538,6 +544,9 @@ export function MatterDetail() { ) : null} + setModal("")}> + setModal("")} /> + setModal("")}> { setModal(""); load(); }} /> diff --git a/frontend/src/pages/content.jsx b/frontend/src/pages/content.jsx index 643f6c2..b8a5812 100644 --- a/frontend/src/pages/content.jsx +++ b/frontend/src/pages/content.jsx @@ -3,6 +3,7 @@ import { Link } from "react-router-dom"; import { api, fetchFile, fetchPaperless } from "../api.js"; import { contentSourceSymbol, contentSymbol } from "../content-symbol.mjs"; import { MarkdownView } from "../markdown.jsx"; +import { IconButton, NavIcon } from "./icons.jsx"; import { Modal } from "./Modal.jsx"; import { ErrorNote } from "./widgets.jsx"; @@ -933,8 +934,8 @@ export function ContentBoard({

{section.title}

{canEdit && section.id !== "loose" ? ( - - + renameChapter(section)} /> + removeChapter(section)} /> ) : null} {section.id !== "loose" ? ( @@ -955,8 +956,8 @@ export function ContentBoard({ ) : null} {movable ? ( - - + moveChapter(section.id, -1)} /> + moveChapter(section.id, 1)} /> ) : null} @@ -1026,7 +1027,7 @@ export function ContentBoard({
{canEdit ? (
- Bezug +