diff --git a/backend/app/api/routes.py b/backend/app/api/routes.py index 23ba4f2..4720057 100644 --- a/backend/app/api/routes.py +++ b/backend/app/api/routes.py @@ -58,12 +58,14 @@ from app.api.schemas import ( MemberIn, BindingOrderIn, ContentOrderIn, + ChapterMoveIn, DatesPatch, NoteIn, NotePatch, RoomIn, ScopeIn, TaskDeadlineIn, + SummaryPatch, TaskIn, TaskPatch, ) @@ -105,12 +107,14 @@ from app.ops import ( patch_matter, patch_task, revoke_grant, + move_binding_chapter, reorder_bindings, set_content_order, set_exception, unlink_matter_case, update_dates, update_note, + update_summary, ) from app.present import ( LABELS, @@ -512,6 +516,12 @@ def cases(principal: Principal = Depends(get_principal), conn: Connection = Depe for case, rights in list_cases(conn, principal.account_id): summary = case_summary(case, rights) summary["home_scope_name"] = room_name(conn, case["home_scope_id"]) + summary["kind_label"] = "Unterakte" if case["parent_case_id"] else "Akte" + summary["parent_title"] = None + if case["parent_case_id"]: + parent = get_case(conn, case["parent_case_id"]) + if parent is not None and case_rights(conn, principal.account_id, parent).read: + summary["parent_title"] = parent["title"] items.append(summary) return {"items": items, "next_cursor": None} @@ -1236,6 +1246,42 @@ def patch_element_dates( return {"id": str(element["id"]), "version": element["version"]} +@router.patch("/api/v1/elements/{element_id}/summary") +def patch_element_summary( + element_id: UUID, + body: SummaryPatch, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + element = update_summary( + conn, + principal.account_id, + element_id, + body.expected_version, + body.summary, + _ctx_model(body.context), + ) + return {"id": str(element["id"]), "version": element["version"], "summary": element["summary"]} + + +@router.patch("/api/v1/bindings/{binding_id}/chapter") +def patch_binding_chapter( + binding_id: UUID, + body: ChapterMoveIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + version = move_binding_chapter( + conn, + principal.account_id, + binding_id, + body.expected_version, + body.chapter_id, + _ctx_model(body.context), + ) + return {"version": version} + + @router.get("/api/v1/cases/{case_id}/course") def case_course(case_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): case, rights = require_case(conn, principal.account_id, case_id, "read") diff --git a/backend/app/api/schemas.py b/backend/app/api/schemas.py index 9cca4cd..7373c01 100644 --- a/backend/app/api/schemas.py +++ b/backend/app/api/schemas.py @@ -156,6 +156,18 @@ class DatesPatch(APIModel): context: ContextIn | None = None +class SummaryPatch(APIModel): + expected_version: int = Field(ge=1) + summary: str | None = Field(default=None, max_length=400) + context: ContextIn | None = None + + +class ChapterMoveIn(APIModel): + expected_version: int = Field(ge=1) + chapter_id: UUID | None = None + context: ContextIn | None = None + + class NotePatch(APIModel): expected_version: int = Field(ge=1) document: DocumentIn diff --git a/backend/app/ops.py b/backend/app/ops.py index 3addbe3..2974784 100644 --- a/backend/app/ops.py +++ b/backend/app/ops.py @@ -898,3 +898,41 @@ def update_dates( bump_version(conn, "elements", element_id, expected) record_dates(conn, actor, element["home_scope_id"], element_id, context or Ctx("matter", element_id), document_on, sent_on, received_on) return get_element(conn, element_id) + + +def update_summary(conn, actor: UUID, element_id: UUID, expected: int, summary: str | None, context: Ctx | None) -> dict: + element, rights = require_element(conn, actor, element_id, context, "edit") + if not rights.edit: + raise forbidden() + cleaned = (summary or "").strip() + if len(cleaned) > 400: + raise unprocessable("Die Kurzbeschreibung ist zu lang.") + bump_version(conn, "elements", element_id, expected) + conn.execute("UPDATE elements SET summary = %s WHERE id = %s", (cleaned or None, element_id)) + audit(conn, actor, element["home_scope_id"], "summary_changed", "element", element_id, context) + return get_element(conn, element_id) + + +def move_binding_chapter(conn, actor: UUID, binding_id: UUID, expected: int, chapter_id: UUID | None, context: Ctx | None) -> int: + """Move one visible binding inside its container. No new binding and no grant.""" + binding = conn.execute("SELECT * FROM bindings WHERE id = %s", (binding_id,)).fetchone() + if binding is None: + raise not_found() + kind = binding["context_kind"] + container_id = binding["context_id"] + if kind == "case": + container, rights = require_case(conn, actor, container_id, "edit") + table = "cases" + page = Ctx("case", container_id) + else: + container, rights = require_matter(conn, actor, container_id, context, "edit") + table = "matters" + page = context or Ctx("matter", container_id) + if not rights.edit: + raise forbidden() + require_element(conn, actor, binding["element_id"], page, "read") + chapter_for(conn, chapter_id, kind, container_id) + version = bump_version(conn, table, container_id, expected) + conn.execute("UPDATE bindings SET chapter_id = %s WHERE id = %s", (chapter_id, binding_id)) + audit(conn, actor, container["home_scope_id"], "binding_chapter", kind, container_id, page) + return version diff --git a/backend/app/present.py b/backend/app/present.py index a0b7ad5..112dea4 100644 --- a/backend/app/present.py +++ b/backend/app/present.py @@ -73,21 +73,58 @@ def _dates(conn, element: dict) -> dict: } +def _plain_excerpt(document: dict | None) -> str | None: + if not isinstance(document, dict): + return None + parts = [] + for block in document.get("blocks") or []: + if not isinstance(block, dict): + continue + text = str(block.get("text") or "").strip() + if text: + parts.append(text) + raw = " ".join(parts).strip() + if not raw: + return None + return raw[:180] + + +def _preview_meta(kind: str, content_type: str | None, source: str | None) -> dict: + if kind == "note": + return {"available": False, "media": "note", "source": "note"} + media = (content_type or "").split(";")[0].strip().lower() + if kind == "file" and media.startswith("image/"): + return {"available": True, "media": "image", "source": "file"} + if kind == "file" and media == "application/pdf": + return {"available": True, "media": "pdf", "source": "file"} + if kind == "external_ref" and source == "paperless": + return {"available": True, "media": "paperless", "source": "paperless"} + if kind == "file": + return {"available": False, "media": "file", "source": "file"} + return {"available": False, "media": "none", "source": source} + + def _element_body(conn, element: dict) -> dict: payload = { "id": str(element["id"]), "kind": element["kind"], "title": element["title"], + "summary": element.get("summary") or None, + "excerpt": None, "version": element["version"], "owner_subject_id": str(element["owner_subject_id"]), "dates": _dates(conn, element), + "preview": _preview_meta(element["kind"], None, None), } if element["kind"] == "note": body = conn.execute( "SELECT document_json FROM note_bodies WHERE element_id = %s", (element["id"],), ).fetchone() - payload["document"] = body["document_json"] if body else {"version": 1, "blocks": []} + document = body["document_json"] if body else {"version": 1, "blocks": []} + payload["document"] = document + payload["excerpt"] = _plain_excerpt(document) + payload["preview"] = _preview_meta("note", None, "note") elif element["kind"] == "file": asset = conn.execute( """ @@ -103,6 +140,7 @@ def _element_body(conn, element: dict) -> dict: "byte_size": asset["byte_size"], "status": asset["status"], } + payload["preview"] = _preview_meta("file", asset["content_type"], "file") elif element["kind"] == "external_ref": ref = conn.execute( "SELECT source, external_id, detail FROM external_references WHERE element_id = %s", @@ -114,6 +152,7 @@ def _element_body(conn, element: dict) -> dict: "external_id": ref["external_id"], "detail": ref["detail"] or {}, } + payload["preview"] = _preview_meta("external_ref", None, ref["source"]) return payload @@ -224,36 +263,144 @@ def course_items(bindings: list[dict]) -> list[dict]: return dated + undated +def _matter_href(matter_id: UUID, context: Ctx | None) -> str: + href = f"/matters/{matter_id}" + if context is not None and context.kind == "case": + href += f"?context_kind=case&context_id={context.id}" + return href + + +def _append_matter_steps(conn, actor: UUID, trail: list[dict], matter: dict, context: Ctx | None) -> None: + """Object path only. The same labels apply from a case, a list or a direct link.""" + page = context if context is not None and context.kind == "case" else None + if matter["parent_matter_id"]: + parent = get_matter(conn, matter["parent_matter_id"]) + if parent is not None and matter_title_if_readable(conn, actor, parent["id"]): + trail.append({"label": f"Vorgang {parent['title']}", "href": _matter_href(parent["id"], page if _parent_keeps_context(conn, actor, parent, page) else None)}) + kind = "Teilvorgang" if matter["parent_matter_id"] else "Vorgang" + trail.append({"label": f"{kind} {matter['title']}", "href": None}) + + +def _parent_keeps_context(conn, actor: UUID, parent: dict, page: Ctx | None) -> bool: + return page is not None and matter_rights(conn, actor, parent, page).read + + def case_trail(conn, actor: UUID, case: dict) -> list[dict]: trail = [{"label": "Akten", "href": "/cases"}] if case["parent_case_id"]: parent = get_case(conn, case["parent_case_id"]) if parent is not None and case_rights(conn, actor, parent).read: - trail.append({"label": parent["title"], "href": f"/cases/{parent['id']}"}) - trail.append({"label": case["title"], "href": None}) + trail.append({"label": f"Akte {parent['title']}", "href": f"/cases/{parent['id']}"}) + kind = "Unterakte" if case["parent_case_id"] else "Akte" + trail.append({"label": f"{kind} {case['title']}", "href": None}) return trail def matter_trail(conn, actor: UUID, matter: dict, context: Ctx | None) -> list[dict]: - if context is not None and context.kind == "case": - case = get_case(conn, context.id) - if case is not None and case_rights(conn, actor, case).read: - trail = case_trail(conn, actor, case) - trail[-1]["href"] = f"/cases/{case['id']}" - trail.append({"label": matter["title"], "href": None}) - return trail trail = [{"label": "Vorgänge", "href": "/matters"}] - if matter["parent_matter_id"]: - parent = get_matter(conn, matter["parent_matter_id"]) - if parent is not None and matter_rights(conn, actor, parent, context).read: - href = f"/matters/{parent['id']}" - if context is not None and context.kind == "case": - href += f"?context_kind=case&context_id={context.id}" - trail.append({"label": parent["title"], "href": href}) - trail.append({"label": matter["title"], "href": None}) + _append_matter_steps(conn, actor, trail, matter, context) return trail +def _case_chain_label(conn, actor: UUID, case: dict) -> str: + parts = [] + current = case + guard = 0 + while current is not None and guard < 4: + if not case_rights(conn, actor, current).read: + break + kind = "Unterakte" if current["parent_case_id"] else "Akte" + parts.append(f"{kind} {current['title']}") + parent_id = current["parent_case_id"] + current = get_case(conn, parent_id) if parent_id else None + guard += 1 + parts.reverse() + return " → ".join(parts) + + +def _placement_rows(conn, matter_id: UUID) -> list[dict]: + return conn.execute( + """ + SELECT c.* + FROM matter_case_links l + JOIN cases c ON c.id = l.case_id AND c.deleted_at IS NULL + WHERE l.matter_id = %s + ORDER BY c.title, c.id + """, + (matter_id,), + ).fetchall() + + +def matter_placements(conn, actor: UUID, matter_id: UUID, context: Ctx | None) -> list[dict]: + """Readable case assignments of this matter and its readable parent chain.""" + items = [] + seen: set[UUID] = set() + matter = get_matter(conn, matter_id) + guard = 0 + while matter is not None and guard < 4: + for link in _placement_rows(conn, matter["id"]): + if link["id"] in seen or not case_rights(conn, actor, link).read: + continue + seen.add(link["id"]) + items.append( + { + "case_id": str(link["id"]), + "label": _case_chain_label(conn, actor, link), + "href": f"/cases/{link['id']}", + "current": context is not None and context.kind == "case" and context.id == link["id"], + } + ) + parent_id = matter["parent_matter_id"] + if parent_id is None or matter_title_if_readable(conn, actor, parent_id) is None: + break + matter = get_matter(conn, parent_id) + guard += 1 + return items + + +def _matter_node(row: dict) -> dict: + return { + "id": str(row["id"]), + "title": row["title"], + "status": row["record_status"], + "kind_label": "Teilvorgang" if row["parent_matter_id"] else "Vorgang", + "parent_matter_id": str(row["parent_matter_id"]) if row["parent_matter_id"] else None, + "children": [], + } + + +def _matter_tree(conn, actor: UUID, case_id: UUID, linked: list[dict]) -> list[dict]: + """One level: a Teilvorgang sits under its Vorgang, not beside it.""" + context = Ctx("case", case_id) + rows = list(linked) + seen = {row["id"] for row in rows} + for row in list(rows): + children = conn.execute( + """ + SELECT * FROM matters + WHERE parent_matter_id = %s AND deleted_at IS NULL + ORDER BY title, id + """, + (row["id"],), + ).fetchall() + for child in children: + if child["id"] in seen: + continue + if matter_rights(conn, actor, child, context).read: + rows.append(child) + seen.add(child["id"]) + nodes = {row["id"]: _matter_node(row) for row in rows} + roots = [] + for row in rows: + parent_id = row["parent_matter_id"] + node = nodes[row["id"]] + if parent_id and parent_id in nodes: + nodes[parent_id]["children"].append(node) + else: + roots.append(node) + return roots + + def case_summary(case: dict, rights) -> dict: return { "id": str(case["id"]), @@ -307,15 +454,8 @@ def case_detail(conn, actor: UUID, case: dict, rights) -> dict: matter_right = matter_rights(conn, actor, link, Ctx("case", case["id"])) if not matter_right.read: continue - matters.append( - { - "id": str(link["id"]), - "link_id": str(link["link_id"]), - "title": link["title"], - "status": link["record_status"], - } - ) - payload["matters"] = matters + matters.append(link) + payload["matters"] = _matter_tree(conn, actor, case["id"], matters) context = Ctx("case", case["id"]) payload["bindings"] = _ordered_bindings( conn, actor, "case", case["id"], context, payload["content_order"], payload["content_order_dir"] @@ -331,7 +471,8 @@ def case_detail(conn, actor: UUID, case: dict, rights) -> dict: """, (case["id"],), ).fetchall(): - if not matter_rights(conn, actor, link, context).read: + matter_right = matter_rights(conn, actor, link, context) + if not matter_right.read: continue items = _ordered_bindings( conn, @@ -348,12 +489,29 @@ def case_detail(conn, actor: UUID, case: dict, rights) -> dict: { "matter_id": str(link["id"]), "title": link["title"], + "version": link["version"], + "rights": matter_right.as_dict(), + "chapters": _chapters(conn, "matter", link["id"]), "content_order": link.get("content_order") or "position", "content_order_dir": link.get("content_order_dir") or "asc", "bindings": items, } ) payload["contained"] = contained + payload["tasks"] = [] + payload["deadlines"] = [] + payload["task_deadline_links"] = [] + + def _walk(nodes): + for node in nodes: + yield node + yield from _walk(node["children"]) + + for node in _walk(payload["matters"]): + tracked = _tracking(conn, actor, UUID(node["id"]), context) + payload["tasks"].extend(tracked["tasks"]) + payload["deadlines"].extend(tracked["deadlines"]) + payload["task_deadline_links"].extend(tracked["links"]) if rights.share or case["owner_subject_id"] == actor: payload["grants"] = _grants(conn, "case", case["id"]) return payload @@ -373,7 +531,9 @@ def matter_summary(conn, actor: UUID, matter: dict) -> dict: "title": matter["title"], "status": matter["record_status"], "version": matter["version"], + "kind_label": "Teilvorgang" if matter["parent_matter_id"] else "Vorgang", "parent_matter_id": str(matter["parent_matter_id"]) if matter["parent_matter_id"] else None, + "parent_title": matter_title_if_readable(conn, actor, matter["parent_matter_id"]), "home_scope_id": str(matter["home_scope_id"]), "home_scope_name": room_name(conn, matter["home_scope_id"]), "contexts": matter_contexts(conn, actor, matter), @@ -401,6 +561,7 @@ def matter_detail(conn, actor: UUID, matter: dict, rights, context: Ctx | None) "content_order": matter.get("content_order") or "position", "content_order_dir": matter.get("content_order_dir") or "asc", "trail": matter_trail(conn, actor, matter, context), + "placements": matter_placements(conn, actor, matter["id"], context), "kind_label": "Teilvorgang" if matter["parent_matter_id"] else "Vorgang", "rights": rights.as_dict(), "context": None if context is None else context.as_dict(), @@ -452,19 +613,31 @@ def matter_detail(conn, actor: UUID, matter: dict, rights, context: Ctx | None) payload["content_order"], payload["content_order_dir"], ) - payload["tasks"] = [] + tracked = _tracking(conn, actor, matter["id"], context) + payload["tasks"] = tracked["tasks"] + payload["deadlines"] = tracked["deadlines"] + payload["task_deadline_links"] = tracked["links"] + if rights.share or matter["owner_subject_id"] == actor: + payload["grants"] = _grants(conn, "matter", matter["id"]) + if matter["owner_subject_id"] == actor: + payload["exception"] = _exception(conn, "matter", matter["id"], context) + return payload + + +def _tracking(conn, actor: UUID, matter_id: UUID, context: Ctx | None) -> dict: + tasks = [] for task in conn.execute( """ SELECT * FROM tasks WHERE matter_id = %s AND deleted_at IS NULL ORDER BY due_on NULLS LAST, created_at """, - (matter["id"],), + (matter_id,), ).fetchall(): task_right = task_rights(conn, actor, task, context) if task_right.read: - payload["tasks"].append(task_payload(conn, actor, task, task_right)) - payload["deadlines"] = [] + tasks.append(task_payload(conn, actor, task, task_right)) + deadlines = [] visible_deadlines = set() for deadline in conn.execute( """ @@ -472,14 +645,14 @@ def matter_detail(conn, actor: UUID, matter: dict, rights, context: Ctx | None) WHERE matter_id = %s AND deleted_at IS NULL ORDER BY due_on, created_at """, - (matter["id"],), + (matter_id,), ).fetchall(): deadline_right = deadline_rights(conn, actor, deadline, context) if deadline_right.read: - payload["deadlines"].append(deadline_payload(conn, actor, deadline)) + deadlines.append(deadline_payload(conn, actor, deadline)) visible_deadlines.add(deadline["id"]) - visible_tasks = {UUID(item["id"]) for item in payload["tasks"]} links = [] + visible_tasks = {UUID(item["id"]) for item in tasks} if visible_tasks and visible_deadlines: for link in conn.execute( "SELECT task_id, deadline_id FROM task_deadline_links WHERE task_id = ANY(%s::uuid[])", @@ -487,12 +660,7 @@ def matter_detail(conn, actor: UUID, matter: dict, rights, context: Ctx | None) ).fetchall(): if link["deadline_id"] in visible_deadlines: links.append({"task_id": str(link["task_id"]), "deadline_id": str(link["deadline_id"])}) - payload["task_deadline_links"] = links - if rights.share or matter["owner_subject_id"] == actor: - payload["grants"] = _grants(conn, "matter", matter["id"]) - if matter["owner_subject_id"] == actor: - payload["exception"] = _exception(conn, "matter", matter["id"], context) - return payload + return {"tasks": tasks, "deadlines": deadlines, "links": links} def task_payload(conn, actor: UUID, task: dict, rights=None) -> dict: @@ -600,6 +768,8 @@ LABELS = { "correspondence_received": "Zugang", "correspondence_recorded": "Erfassung", "chapter_created": "Kapitel angelegt", + "summary_changed": "Kurzbeschreibung geändert", + "binding_chapter": "In ein Kapitel eingeordnet", "content_order": "Ordnungsart geändert", "content_reordered": "Eigene Reihenfolge geändert", } diff --git a/backend/migrations/20261017T090000Z_element_summary.sql b/backend/migrations/20261017T090000Z_element_summary.sql new file mode 100644 index 0000000..8456b66 --- /dev/null +++ b/backend/migrations/20261017T090000Z_element_summary.sql @@ -0,0 +1,5 @@ +ALTER TABLE elements + ADD COLUMN summary text; + +ALTER TABLE elements + ADD CONSTRAINT elements_summary_len CHECK (summary IS NULL OR char_length(summary) BETWEEN 1 AND 400); diff --git a/backend/tests/test_order.py b/backend/tests/test_order.py index fa67ebf..d14adbc 100644 --- a/backend/tests/test_order.py +++ b/backend/tests/test_order.py @@ -359,13 +359,84 @@ def test_direct_matter_trail_invents_no_case(client, db): ben.login() opened = ben.request("GET", f"/api/v1/matters/{matter['id']}?context_kind=case&context_id={child['id']}") labels = [item["label"] for item in opened["trail"]] - assert labels[0] == "Akten" - assert "Wohnung" in labels - assert "Nebenkosten" in labels - assert "Vermietung" not in labels - assert "Geheim" not in labels + assert labels == ["Vorgänge", "Vorgang Nebenkosten"] + assert opened["context"]["id"] == child["id"] + assert [item["label"] for item in opened["placements"]] == ["Unterakte Wohnung"] + assert opened["placements"][0]["current"] is True assert all(item["title"] != "Geheim" for item in opened["case_links"]) ada.login() direct = ada.request("GET", f"/api/v1/matters/{matter['id']}") - assert direct["trail"][0]["label"] == "Vorgänge" - assert "Vermietung" not in [item["label"] for item in direct["trail"]] + assert [item["label"] for item in direct["trail"]] == labels + assert "Geheim" not in " ".join(item["label"] for item in opened["placements"]) + assert any(item["label"] == "Akte Geheim" for item in direct["placements"]) + + +def test_teilvorgang_keeps_its_parent_in_the_trail(client, db): + ada = Actor(client, "ada-child@example.test", "Ada Kind") + register(db, ada.email, ada.name) + ada.login() + parent = matter_of(ada, "Hauptvorgang") + child = ada.request( + "POST", + "/api/v1/matters", + json={"title": "Prüfung", "parent_matter_id": parent["id"]}, + status=201, + ) + direct = ada.request("GET", f"/api/v1/matters/{child['id']}") + assert [item["label"] for item in direct["trail"]] == ["Vorgänge", "Vorgang Hauptvorgang", "Teilvorgang Prüfung"] + case = case_of(ada, "Sammelakte") + ada.request("POST", f"/api/v1/matters/{parent['id']}/case-links", json={"case_id": case["id"]}, status=201) + opened = ada.request("GET", f"/api/v1/matters/{child['id']}?context_kind=case&context_id={case['id']}") + assert [item["label"] for item in opened["trail"]] == [item["label"] for item in direct["trail"]] + assert opened["trail"][1]["href"].endswith(f"context_id={case['id']}") + assert opened["placements"][0]["label"] == "Akte Sammelakte" + assert opened["placements"][0]["current"] is True + listed = ada.request("GET", "/api/v1/matters") + rows = {item["title"]: item for item in listed["items"]} + assert rows["Prüfung"]["kind_label"] == "Teilvorgang" + assert rows["Prüfung"]["parent_title"] == "Hauptvorgang" + assert rows["Hauptvorgang"]["kind_label"] == "Vorgang" + + +_PNG = bytes.fromhex( + "89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c489" + "0000000a49444154789c63000100000500010d0a2db40000000049454e44ae426082" +) + + +def test_summary_and_preview_follow_the_read_right(client, db): + ada = Actor(client, "ada-preview@example.test", "Ada Vorschau") + ben = Actor(client, "ben-preview@example.test", "Ben Vorschau") + register(db, ada.email, ada.name) + register(db, ben.email, ben.name) + ada.login() + matter = matter_of(ada, "Mappe") + _note(ada, "Einwendungstext", matter) + detail = _matter(ada, matter["id"]) + note = detail["bindings"][0]["element"] + assert note["excerpt"] == "Einwendungstext" + assert note["summary"] is None + assert note["preview"]["available"] is False + ada.request( + "PATCH", + f"/api/v1/elements/{note['id']}/summary", + json={ + "expected_version": note["version"], + "summary": "Kurze Einwendung", + "context": {"kind": "matter", "id": matter["id"]}, + }, + ) + ada.request( + "POST", + "/api/v1/files", + data={"title": "Scan", "context_kind": "matter", "context_id": matter["id"]}, + files={"upload": ("punkt.png", _PNG, "image/png")}, + status=201, + ) + detail = _matter(ada, matter["id"]) + by_title = {item["element"]["title"]: item["element"] for item in detail["bindings"]} + assert by_title["Einwendungstext"]["summary"] == "Kurze Einwendung" + assert by_title["Scan"]["preview"] == {"available": True, "media": "image", "source": "file"} + ben.login() + ben.request("GET", f"/api/v1/matters/{matter['id']}", status=404) + ben.request("GET", f"/api/v1/files/{by_title['Scan']['id']}/content", status=404) diff --git a/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md b/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md index b6a8c96..21b7775 100644 --- a/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md +++ b/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md @@ -216,7 +216,7 @@ Gemeinsame Spalten der fachlichen Ankerobjekte `cases`, `matters`, `elements`, ` Auth-Tabellen `auth_accounts` und `auth_sessions` folgen dem Auth-Blueprint. Ein Anzeigename ist kein Identitätsbeweis. -Akten und Vorgänge speichern `content_order` (`date` oder `position`) und `content_order_dir` (`asc` oder `desc`). Bestehende Zeilen bleiben auf `position`, damit eine schon gesetzte Einbindungsreihenfolge nicht ersetzt wird. Neue Akten und Vorgänge beginnen mit fachlichem Datum aufsteigend. `bindings.position` gehört zur Einbindung. Die Datumssortierung schreibt sie nicht um. `PATCH /api/v1/cases/{id}/content-order` und `POST /api/v1/cases/{id}/bindings/order` sowie die gleichen Pfade unter `matters` prüfen das Bearbeitungsrecht im Handlungskontext und `expected_version`. Der fachliche Verlauf liest die Datumsfelder der sichtbaren Unterlagen einmal je Element. Das Änderungsprotokoll bleibt `GET .../chronology`, seitenweise über `cursor`. +Akten und Vorgänge speichern `content_order` (`date` oder `position`) und `content_order_dir` (`asc` oder `desc`). Bestehende Zeilen bleiben auf `position`, damit eine schon gesetzte Einbindungsreihenfolge nicht ersetzt wird. Neue Akten und Vorgänge beginnen mit fachlichem Datum aufsteigend. `bindings.position` gehört zur Einbindung. Die Datumssortierung schreibt sie nicht um. `PATCH /api/v1/cases/{id}/content-order` und `POST /api/v1/cases/{id}/bindings/order` sowie die gleichen Pfade unter `matters` prüfen das Bearbeitungsrecht im Handlungskontext und `expected_version`. Der fachliche Verlauf liest die Datumsfelder der sichtbaren Unterlagen einmal je Element. Das Änderungsprotokoll bleibt `GET .../chronology`, seitenweise über `cursor`. Der Breadcrumb eines Vorgangs ist der Objektpfad `Vorgänge` und gegebenenfalls der lesbare Elternvorgang; lesbare Aktenzuordnungen stehen separat in `placements` und wechseln den Handlungskontext nur bei bewusster Auswahl. `elements.summary` ist eine optionale gemeinsame Kurzbeschreibung. Ein Textauszug entsteht nur aus vorhandenem Notiztext. Bild- und PDF-Vorschauen verwenden denselben berechtigten Dateiabruf wie das Öffnen. ### 4.3 Überblick diff --git a/docs/product/TSUMUGU_PRODUCT_SPEC.md b/docs/product/TSUMUGU_PRODUCT_SPEC.md index 89b41c0..6bbdc4a 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.26, UX-/Ordnungsbedarf der ersten Lieferung ergänzt. +**Stand:** 17.10.2026 · **Arbeitsstand:** 0.27, zweite UX-Überarbeitung und Vorschauzeilen konkretisiert. **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. @@ -352,6 +352,12 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G **Empfohlene konkrete Ausgestaltung:** Klickbare Breadcrumbs und sichtbare Gliederung, gespeicherte Datumssortierung beziehungsweise eigene Reihenfolge je Container, kompakte Inhaltslisten, unmittelbar lesbare Unterlagen, zentral erreichbare Aufgaben/Fristen und separat aufrufbares Änderungsprotokoll. Umfang, Sortierregeln, Datenschutzgrenzen, Abnahmekriterien und der Rahmen eines späteren Coding-Auftrags stehen in [TSUMUGU_UX_MVP_ERGAENZUNG.md](TSUMUGU_UX_MVP_ERGAENZUNG.md). Diese Details werden als aktuelle Umsetzungsempfehlungen ausgewiesen, nicht als frühere Nutzerbeschlüsse. Keine Änderung der Rechte-/Ownership-/Löschregeln und keine Ausweitung auf die zurückgestellten Finanz- oder Synchronisationsfunktionen. +### F-06b – Zweite UX-Prüfung und konkreter Überarbeitungsauftrag: 17.10.2026 + +**Nutzerauftrag:** Nach gemeldetem Abschluss des ersten Umbaus kritisiert der Nutzer weiterhin wechselnde Breadcrumbs, fehlendes Drag-and-drop, redundante Inhalts-/Struktur-/Verlaufsbereiche und mangelnde Orientierung. Er wünscht eine anschaulichere Aufbereitung mit Thumbnails, kurzen Inhaltsbeschreibungen und verständlicher Einordnung. Nach Vergleich der Entwürfe ist „Vorschauzeilen“ ausgewählt; die Anforderungen sollen aktualisiert und dem Coder als Auftrag übergeben werden. + +**Festgelegte Ausgestaltung für diesen Auftrag:** Stabile objektbezogene Breadcrumbs; Aktenzuordnung und tatsächlicher geprüfter Handlungskontext separat; eine zentrale, zwischen Inhalten, Aufgaben und ergänzenden Ansichten wechselnde Arbeitsfläche; kompakte Gliederungsnavigation; Vorschauzeilen mit echter Vorschau beziehungsweise transparenter Ersatzdarstellung, Kurzbeschreibung und Herkunft. Drag-and-drop in der eigenen Reihenfolge ist nun verpflichtend, zusätzlich zum Tastatur-/Touchweg. Eine zweite Kachelansicht bleibt optional. Details und 20 Abnahmekriterien stehen in der UX-Ergänzung, Fassung 0.2. Die dortigen Regeln ersetzen die widersprechenden Gestaltungsspielräume der Fassung 0.1; Rechte- und Fachmodell bleiben erhalten. + ## 6. Fortschreibung 16.10.2026, Arbeitsstand 0.1: Recovery vollständig gelesen, Repository-Unterlagen gezielt abgeglichen, ursprüngliche Nutzernachrichten geprüft und Ergänzungen gesichert. Historische Baseline unverändert übernommen. @@ -406,4 +412,6 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G 17.10.2026, Arbeitsstand 0.26: Nutzerbedarf F-06a nach der lesenden Prüfung der bestehenden Development-Oberfläche aufgenommen. Ergänzung `TSUMUGU_UX_MVP_ERGAENZUNG.md` als Referenz für den gewünschten Coding-Auftrag erstellt: Orientierung, fachliche Daten und kontextbezogene Ordnung, Arbeitsansichten, zurückgenommenes Änderungsprotokoll und prüfbare Abnahme. Konkrete UX-Ausgestaltung als Umsetzungsempfehlung von ausdrücklichen Nutzeranforderungen getrennt. Keine Änderungen an Anwendungscode, Datenbanken oder Deployments. +17.10.2026, Arbeitsstand 0.27: Zweite Oberflächenprüfung und Auftrag F-06b aufgenommen; UX-Ergänzung auf Fassung 0.2 konkretisiert. Auswahl Vorschauzeilen, stabile Breadcrumbs mit separatem Kontext, eine zentrale Arbeitsfläche, gemeinsame Aktenlesesicht, Vorschauen/Beschreibungen und verpflichtendes Drag-and-drop festgehalten. Bestehende Anwendung und lokale Codeänderungen unberührt; separater Umsetzungsauftrag wird dem Nutzer als Prompt bereitgestellt. + 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_UX_MVP_ERGAENZUNG.md b/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md index 1ce4415..2d4b8be 100644 --- a/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md +++ b/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md @@ -1,9 +1,12 @@ # Tsumugu – Ergänzung zur Bedienung, Orientierung und Aktenordnung im MVP -**Stand:** 17.10.2026 · **Fassung:** 0.1 +**Stand:** 17.10.2026 · **Fassung:** 0.2, nach zweiter Oberflächenprüfung + **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). +**Aktuelle Umsetzungsvorgabe:** Vorschauzeilen als Standard, stabile objektbezogene Breadcrumbs, getrennte Anzeige der Aktenzuordnung, eine zentrale wechselnde Arbeitsfläche und verpflichtendes Drag-and-drop für die eigene Reihenfolge. Diese Fassung ersetzt die widersprechenden Freiheiten der Fassung 0.1. Bereits funktionierende Teile des ersten Umbaus bleiben erhalten. + ## 1. Ziel und Verbindlichkeit 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. @@ -14,12 +17,14 @@ Die folgenden Quellen sind zu unterscheiden: - **Ausdrücklicher Nutzerbedarf:** Die derzeitige Optik ist verwirrend; Hierarchien sind nicht erkennbar; lange Aktionsprotokolle überladen Objekte. Fachliche Daten und alternative Ordnungsmöglichkeiten fehlen in der nutzbaren Inhaltsdarstellung. Das Änderungsprotokoll bleibt zur Nachvollziehbarkeit sinnvoll, kann aber über ein Menü erreichbar sein. Die innere Aktenordnung ist ein wesentlicher Informationsträger. - **Bereits bestätigtes Fachmodell:** Eigenständige und mehrfach zugeordnete Vorgänge, gemeinsam verwendete Elemente mit Kontextrechten, reine Gliederung durch Kapitel sowie getrennte Aufgaben und Fristen bleiben erhalten. -- **Konkrete Ausgestaltung für diese Überarbeitung:** Navigation, Seitenaufbau, zwei Ordnungsarten, Datumsdarstellung und Interaktionsregeln werden nachfolgend als pragmatische Umsetzungsvorgaben beschrieben. Sie sind Empfehlungen aus der aktuellen UX-Prüfung und keine rückwirkend behaupteten früheren Produktbeschlüsse. Der Umsetzungsauftrag, der auf diese Datei verweist, legt sie als Arbeitsgrundlage zugrunde. Routineentscheidungen zur Darstellung trifft der Agent selbst. +- **Konkrete Ausgestaltung für diese Überarbeitung:** Nach der zweiten Prüfung und dem Vergleich zweier Entwürfe ist „Vorschauzeilen“ die ausgewählte Richtung. Der Nutzer beauftragt die Fortschreibung dieser Anforderungen und die Übergabe an den Coder. Die nachfolgenden Regeln legen den nächsten Umsetzungsauftrag fest; sie werden nicht rückwirkend als Entscheidungen aus dem ursprünglichen Fachinterview ausgegeben. Routineentscheidungen zur Darstellung trifft der Agent selbst. Diese Ergänzung präzisiert die Bedienung des MVP. Sie ändert keine Rechte-, Ownership-, Lösch- oder Datenraumregeln. Bei Widersprüchen in älteren Dokumenten sind deren damaliger Stand und der aktuelle Auftrag zu beachten; ein historischer Spezifikationsauftrag ist kein Verbot einer inzwischen ausdrücklich beauftragten Implementierung. ## 2. Ausgangsbefunde und Prüfgrenzen +### 2.1 Erste Prüfung – historischer Ausgangspunkt + Grundlage ist eine angemeldete, lesende Prüfung der Development-Anwendung am 17.10.2026: Übersicht, Akten- und Vorgangslisten, vorhandene Detailseiten und Erfassungsdialoge für Vorgänge, Unterlagen, Aufgaben und Fristen. Es wurden keine fachlichen Daten gespeichert, gelöscht oder freigegeben. Die Befunde belegen sichtbare Bedienprobleme; sie sind kein vollständiger Funktionstest des Backends. | Sichtbarer Befund | Geforderte Verbesserung | @@ -35,6 +40,20 @@ Grundlage ist eine angemeldete, lesende Prüfung der Development-Anwendung am 17 Datumsfelder und Positionswerte sind im technischen Entwurf und teilweise im Code bereits vorhanden. Der Agent prüft ihren tatsächlichen Zustand und verwendet sie, soweit passend. Aus einer fehlenden nutzbaren Anzeige folgt nicht, dass das gesamte Datenmodell neu gebaut werden muss. +### 2.2 Zweite Prüfung – Grundlage des nächsten Umbaus + +Die erneute lesende Prüfung zeigt Verbesserungen: vereinfachte Navigation, direkt anlegbare eigenständige Vorgänge, Ordnungsarten und zurückgenommene Verwaltungsaktionen. Diese Fortschritte erhalten. Es wurden weiterhin keine fachlichen Daten verändert. Die zweite Prüfung ist kein Nachweis bestandener Speichertests oder eines erfolgreichen Drag-and-drop-Vorgangs. + +| Aktueller Befund | Korrektur in Fassung 0.2 | +|---|---| +| Derselbe Vorgang zeigt über die Übersicht einen Aktenpfad und über die Vorgangsliste einen anderen Breadcrumb. | Breadcrumb beschreibt den stabilen Objektpfad; Aktenzuordnung und geprüfter Handlungskontext werden separat dargestellt und erhalten. | +| Inhaltsliste, „Struktur und Zuordnung“ sowie Verlauf/Protokoll bleiben große Bereiche derselben Seite. | Eine zentrale Arbeitsfläche; ergänzende Ansichten ersetzen ihren Inhalt. Struktur dient als kompakte Navigation. | +| Direkte Akteninhalte und Inhalte enthaltener Vorgänge werden in separaten Blöcken einschließlich Leerzuständen dargestellt. | Eine Inhaltskomponente mit klarer Auswahl des betrachteten Bereichs und Herkunftsangaben. | +| Titel-/Datumszeilen und formularlastige Dokumentdetails vermitteln wenig Inhalt. | Vorschauzeilen mit Thumbnail, Kurzbeschreibung und direkter Leseansicht. | +| Es gibt Verschiebeschaltflächen, aber keine erkennbare Drag-and-drop-Implementierung im geprüften Frontend. | Drag-and-drop einschließlich Einfügeposition, Speicherung und alternativem Tastatur-/Touchweg wird Pflicht. | + +Die vorherigen Vorgaben waren bei Breadcrumbs und Seitenaufbau zu offen; Drag-and-drop war ausdrücklich optional. Die gemeldeten Probleme werden daher als präzisierter Auftrag behandelt, nicht pauschal als Verletzung damaliger Pflichten. + ## 3. Arbeitsablauf als Maßstab Der folgende Ablauf muss mit der überarbeiteten Anwendung durchgängig möglich sein: @@ -44,7 +63,7 @@ Der folgende Ablauf muss mit der überarbeiteten Anwendung durchgängig möglich 3. Ein Schreiben als eigene Datei oder Paperless-Referenz hinzufügen und eine Notiz ergänzen. 4. Ein fachliches Datum erfassen oder bewusst offenlassen. 5. Die Inhalte nach fachlichem Datum oder in eigener Reihenfolge anordnen. -6. Eine Unterlage öffnen, lesen und eine kontextbezogene Anmerkung ergänzen. +6. Eine Unterlage anhand ihrer Vorschau und Kurzbeschreibung erkennen, direkt öffnen, lesen und eine kontextbezogene Anmerkung ergänzen. 7. Eine Aufgabe und unabhängig davon eine Frist erfassen. 8. Später den Vorgang und die offene Arbeit über die Übersicht oder die jeweiligen Listen wiederfinden. 9. Eine Änderung bei Bedarf im separat aufrufbaren Änderungsprotokoll nachvollziehen. @@ -70,29 +89,56 @@ Aufgaben & Fristen bietet eine zentrale, filterbare Sicht mit klar erkennbarer Z Akten, Unterakten, Vorgänge, Teilvorgänge, Kapitel und Querverweise dürfen optisch nicht wie gleichartige, unverbundene Karten wirken. -- Jede Detailseite zeigt einen klickbaren Breadcrumb-Pfad mit sichtbaren, berechtigt zugänglichen Stationen, anschließend Titel, Status und verständliche Objektart. -- Beispiel eines Zugangswegs: „Akten → Vermietung → Wohnung Jakisch → Nebenkosten 2025“. Der Pfad stellt den tatsächlich verwendeten Weg dar; er erfindet keine verpflichtende Hauptakte. -- Bei mehreren Aktenzuordnungen bleibt erkennbar, über welchen Weg der Vorgang geöffnet wurde. Weitere lesbare Zuordnungen sind separat erreichbar. Ein Wechsel verwendet den dafür serverseitig geprüften Handlungskontext. -- Ein direkter Einstieg in einen eigenständigen Vorgang funktioniert ohne erfundene Elternakte. Breadcrumbs dürfen keine unbekannten oder unberechtigten Herkunftsnamen offenlegen. +- Jede Detailseite zeigt einen klickbaren, objektbezogenen Breadcrumb mit sichtbaren, berechtigt zugänglichen Stationen, anschließend Titel, Status und verständliche Objektart. Der Breadcrumb ist keine Besuchshistorie. +- Eine Akte zeigt ihre tatsächliche sichtbare Unteraktenhierarchie, beispielsweise „Akten → Vermietung → Musterwohnung“. Ein Vorgang zeigt „Vorgänge → Nebenkosten 2025“, unabhängig vom Einstieg über Übersicht, Suche oder Aktenansicht. Ein Teilvorgang kann seine lesbare fachliche Elternkette ergänzen. Querverweise erzeugen keine zusätzliche Elternkette. +- Eine Unterlage ergänzt den Pfad ihres aktuell geöffneten Containers, beispielsweise „Vorgänge → Nebenkosten 2025 → Einwendungen zur Abrechnung“. Bei Mehrfacheinbindung kann dieselbe Unterlage in unterschiedlichen Containern unterschiedliche Pfade haben. Innerhalb desselben Containers bleibt der Pfad bei wechselndem Einstieg stabil. +- Die relevante Aktenzuordnung wird daneben verständlich als „In Akte: Vermietung → Musterwohnung“ angezeigt und ist navigierbar. Weitere lesbare Zuordnungen sind dort auswählbar. Es gibt keine künstliche Hauptakte. Bei eigenständigen Vorgängen entfällt die Aktenangabe, solange keine passende Zuordnung gewählt ist. +- Die visuelle Stabilisierung darf den tatsächlichen Handlungskontext nicht entfernen oder still wechseln. Kontextparameter, serverseitige Berechtigungsprüfung sowie Zuordnung von Anmerkungen bleiben beim Öffnen, Bearbeiten, Weiterlesen, Zurückkehren und Neuladen erhalten. Ein Kontextwechsel ist eine bewusste Auswahl und wird serverseitig geprüft. Keine Rechtevereinigung über andere Zuordnungen und kein automatischer Rückfall auf einen weitergehenden Owner-Zugriff. +- Direkteinstieg und Rücknavigation funktionieren ohne vorherigen Besuch einer Akte. Breadcrumbs dürfen keine unbekannten oder unberechtigten Herkunftsnamen offenlegen. Eine Darstellungskorrektur eröffnet keinen bisher unzulässigen Direktzugriff. - Unterakten und Teilvorgänge sind als untergeordnete Objekte erkennbar. Querverweise werden als zusätzliche Verknüpfungen kenntlich gemacht und verändern keine fachliche Hauptzuordnung. - Kapitel erscheinen als Gliederungsüberschriften innerhalb der Inhalte. Sie erhalten weder eigene Rechte noch einen eigenen Bearbeitungsstatus. -Breadcrumbs lösen die Navigation. Für die Gliederung innerhalb des aktuellen Objekts braucht es zusätzlich sichtbare Abschnitte, Einrückung oder eine kompakte ausklappbare Strukturübersicht. Kein ständig vollständig aufgeklappter Gesamtbaum aller Akten erforderlich. +Neben der zentralen Inhaltsfläche steht auf Desktop eine kompakte Gliederungsnavigation mit den relevanten Unterakten, Vorgängen und Kapiteln. Die Auswahl ist sichtbar markiert und bestimmt den betrachteten Bereich. Sie enthält keine zweite Dokumentliste. Auf schmalen Displays wird diese Navigation als ausklappbare Bereichsauswahl angeboten. Kein ständig vollständig aufgeklappter Gesamtbaum aller Akten erforderlich. ## 6. Aufbau von Akten und Vorgängen Oben: Breadcrumb, Titel, Status, gegebenenfalls eine kurze Beschreibung und eine eindeutige Hauptaktion zum Hinzufügen von Inhalten. Verwaltungsaktionen sind ergänzend zugänglich. -Der Arbeitsbereich stellt Unterlagen und Notizen in den Mittelpunkt. Aufgaben und Fristen erscheinen kompakt daneben oder unmittelbar anschließend. Struktur, Zuordnungen und Verlauf sind über klar beschriftete Bereiche oder Register zugänglich. Die genaue Aufteilung darf der Agent passend zum vorhandenen Frontend gestalten; die Prioritäten gelten unabhängig von der gewählten Komponente. +Die Seite besitzt genau eine zentrale Arbeitsfläche. Standard ist „Inhalte“. „Aufgaben & Fristen“ ist ein zweites Register derselben Fläche. „Fachlicher Verlauf“, „Änderungsprotokoll“ und „Zuordnungen“ öffnen sich über das Objektmenü als eigene Ansicht in dieser Fläche. Immer nur die gewählte Ansicht anzeigen; die bisherige Inhaltsliste wird beim Wechsel nicht zusätzlich darüber stehen gelassen. Objektkopf und Gliederungsnavigation bleiben zur Orientierung erhalten. Rückkehr zu den Inhalten erhält Auswahl, Filter, Ordnung und nach Möglichkeit die Leseposition. + +Der große Sammelblock „Struktur und Zuordnung“ entfällt. Seine fachliche Gliederung wandert in die Bereichsnavigation; Aktionen wie Kapitel anlegen, Zuordnen, Querverweis und Teilen sind am passenden Objekt-/Abschnittsmenü verfügbar. Kein Ersatz durch mehrere neue gleichartige Akkordeons oder eine ständig sichtbare zweite Verwaltungsleiste. Leere Teilvorgänge, Querverweise, Unterakten und Kapitel dürfen keinen langen Stapel großer Leerzustände vor den Inhalten erzeugen. Eine kompakte Aktion zum erstmaligen Anlegen genügt. Benötigte Funktionen bleiben auffindbar. -Die Aktenansicht unterscheidet eindeutig: +Die Aktenansicht verwendet eine gemeinsame Inhaltskomponente mit einer kompakten Bereichsauswahl. Sie unterscheidet eindeutig: - **Direkt in dieser Akte:** unmittelbar eingebundene Inhalte. - **In enthaltenen Vorgängen:** Inhalte der zugeordneten Vorgänge, jeweils mit sichtbarer berechtigter Herkunft und Öffnung im passenden Kontext. -Für den MVP genügt eine klar benannte Umschaltung oder ein ergänzender Abschnitt mit Zugriff auf diese Inhalte. Eine rekursive Gesamtsicht über beliebig tiefe Hierarchien ist nicht erforderlich. Die eigene Reihenfolge gilt für die direkten Einträge des jeweiligen Containers. Eine ergänzende Gesamtsicht ist eine abgeleitete Lesesicht und erzeugt weder neue Einbindungen noch eine konkurrierende Aktenordnung. Bei Mehrfachvorkommen bleibt der Herkunftskontext eindeutig. +Zusätzlich bietet „Alle Inhalte“ eine gemeinsame Lesesicht auf direkte Inhalte und die Inhalte der unmittelbar zugeordneten Vorgänge. Herkunft ist an jeder Vorschauzeile als kurze Angabe erkennbar, beispielsweise „Direkt in dieser Akte“ oder „Aus Vorgang Nebenkosten 2025“. In der Akte ist dies der normale Überblick; ein leerer direkter Inhaltsbereich wird nicht als zusätzlicher Block davor angezeigt. Die Bereichsauswahl kann auf direkte Einträge, einen Vorgang oder ein Kapitel einschränken. Genau eine Liste bleibt sichtbar. Eine rekursive Gesamtsicht über beliebig tiefe Hierarchien ist nicht erforderlich. + +„Alle Inhalte“ ist eine abgeleitete Lesesicht, die fachlich nach Datum sortierbar ist. Sie erzeugt keine neuen Einbindungen, keine zweite manuelle Gesamtordnung und keine Änderung an den gespeicherten Ordnungen der Herkunftsvorgänge. Für „Eigene Reihenfolge“ muss ein einzelner bearbeitbarer Container ausgewählt sein; die Oberfläche bietet dafür einen verständlichen Auswahlweg. Kein mehrdeutiges Ziehen über mehrere Herkunftscontainer. + +Bei Mehrfachvorkommen bleibt die konkrete Einbindung eindeutig. Dasselbe Element darf in der Lesesicht nicht wie mehrere unabhängige Originale wirken: Mehrere sichtbare Herkunftseinbindungen als solche kenntlich machen, vor dem Öffnen gegebenenfalls die konkrete Einbindung auswählen. Inhalte und Anmerkungen ausschließlich aus dem gewählten geprüften Kontext öffnen. Verborgene Einbindungen weder zählen noch benennen. + +### 6.1 Vorschauzeilen als verbindlicher Standard + +Eine Vorschauzeile ist eine kompakte horizontale Inhaltskarte mit: + +- kleinem Thumbnail beziehungsweise einer klaren Ersatzdarstellung; +- gut lesbarem Titel; +- fachlichem Datum, Typ und Quelle in einer zurückhaltenden Metadatenzeile; +- ein bis zwei Zeilen Kurzbeschreibung oder Textauszug; +- Herkunfts-/Kapitelangabe, soweit für die aktuelle Ansicht erforderlich; +- einem kleinen Aktionsmenü sowie einem Ziehgriff im eigenen Ordnungsmodus. + +Ein Klick auf Vorschau oder Titel öffnet die Leseansicht. Nicht die ganze Zeile mit großen Verschiebe- und Verwaltungsbuttons füllen. Unbekannte Inhalte transparent kennzeichnen, statt Beschreibungen oder Datumsangaben zu erfinden. + +Die Kurzbeschreibung ist optional und am Element bearbeitbar, sofern die bestehenden Inhaltsrechte dies erlauben. Sie ist gemeinsame Metainformation, keine lokale Anmerkung. Ohne manuell gepflegte Beschreibung kann ein vorhandener, sicher verfügbarer Textauszug dienen. Keine KI-Zusammenfassung und keine neue OCR-/Importplattform als Voraussetzung. Die kontextbezogene Anmerkung bleibt separat. + +Für unterstützte eigene PDFs/Bilder und vorhandene sichere Paperless-Vorschaumöglichkeiten tatsächliche Thumbnails nutzen. Für Notizen einen Textauszug und eine eindeutige Typdarstellung verwenden. Ist eine Vorschau nicht verfügbar oder sicher nicht herstellbar, einen erkennbaren Ersatz mit Öffnungsweg anzeigen. Eine bloße generische Ikone für jedes Dokument erfüllt den Thumbnail-Auftrag nicht; ebenso wenig fest eingebaute Mustervorschauen in der tatsächlichen Anwendung. + +Eine Dokumentkachel-Ansicht ist eine optionale spätere Darstellungsalternative. Für diesen Auftrag genügt die ausgewählte Vorschauzeilen-Ansicht. Keine Pflicht, beide Entwurfsvarianten parallel zu implementieren. Falls beide entstehen, verwenden sie dieselben Einbindungen, Filter und Reihenfolgen und werden nicht als zwei Listen gleichzeitig angezeigt. ## 7. Fachliche Daten und Ordnung der Inhalte @@ -124,7 +170,10 @@ Weitere frei kombinierbare Sortierregeln oder ein allgemeiner Regelbaukasten sin - Gleichdatierte oder undatierte Einträge erhalten eine stabile Reihenfolge, etwa anhand vorhandener Positionswerte und einer eindeutigen technischen Kennung. Technische Gleichstandsregeln werden nicht als fachliche Daten ausgegeben. - Neue Einträge stehen im Modus „Eigene Reihenfolge“ zunächst am Ende des gewählten Abschnitts; eine gezielte Einfügeposition ist möglich, falls bereits einfach unterstützt. Keine unvorhersehbare Umordnung bestehender Einträge. - Ein Wechsel zur Datumssortierung zerstört die eigene Reihenfolge nicht. Die Rückkehr stellt sie wieder her. Für neue Container ist „Fachliches Datum, aufsteigend“ der einfache Default; vorhandene Reihenfolgen werden bei der Einführung nicht ungefragt ersetzt. -- Verschieben ist nur im Modus „Eigene Reihenfolge“ aktiv. Es funktioniert über verständliche Bedienelemente, etwa „Nach oben“/„Nach unten“; Drag-and-drop kann ergänzen. Tastatur und Touch müssen ohne Drag-and-drop auskommen. +- Drag-and-drop ist im Modus „Eigene Reihenfolge“ verpflichtend: sichtbarer Ziehgriff, erkennbar mitbewegter Eintrag, eindeutige Einfügelinie vor beziehungsweise nach dem Ziel, Abbruch ohne Änderung und nach dem Ablegen zuverlässig gespeicherte Position. Auch an Anfang und Ende eines Abschnitts ablegen können. Bei langen Listen erforderliches Scrollen während des Ziehens unterstützen. +- Im Datumssortiermodus kein wirkungsloses Ziehen anbieten. Für manuelles Ordnen muss der Modus sichtbar gewechselt werden. In einer zusammengesetzten Lesesicht zunächst den einzelnen bearbeitbaren Container wählen. +- Tastatur und Touch erhalten zusätzlich einen vollständigen Weg ohne Drag-and-drop, beispielsweise kleine Menüaktionen „Nach oben“/„Nach unten“. Leser erhalten keine aktiven Verschiebeaktionen. Erfolgreiches Speichern, laufender Vorgang, Fehler und Versionskonflikt verständlich anzeigen; eine fehlgeschlagene Speicherung darf nicht wie eine dauerhaft übernommene Ordnung erscheinen. +- Der Pflichtumfang für Drag-and-drop ist die Reihenfolge innerhalb eines Kapitels beziehungsweise des ungegliederten Bereichs. Der Kapitelwechsel erfolgt über eine eindeutige Aktion „In Kapitel einordnen“. Ein Kapitelwechsel innerhalb desselben Containers ändert keine Ownership oder Freigabe. Kapitelübergreifendes Drag-and-drop ist optional und muss dieselbe Regel einhalten. - Sortieren ist kein Verschieben in einen anderen Vorgang und verändert keine Rechte, Inhalte, Ownership oder Freigaben. - Reorder-Anfragen werden serverseitig geprüft. Fremde oder nicht lesbare Einträge dürfen nicht über übermittelte IDs bearbeitet oder offengelegt werden. Die Reihenfolge ausschließlich sichtbarer Einträge darf verborgene Positionen nicht als Lücken oder Anzahl verraten. Verdeckte Einbindungen dürfen beim Speichern nicht verloren gehen. - Gleichzeitige Änderungen dürfen keine fremden Einbindungen oder Reihenfolgen still überschreiben. Eine einfache Versionsprüfung mit verständlicher Aufforderung zum Neuladen genügt. @@ -141,7 +190,7 @@ Diese drei Zwecke erhalten getrennte Zugänge: | Fachlicher Verlauf | Dokumente, Kommunikation und fachliche Ereignisse anhand ihrer ausdrücklich vorhandenen fachlichen Zeitbezüge. Datumstypen bleiben unterscheidbar. | | Änderungsprotokoll | Wer hat wann etwas erfasst, geändert, zugeordnet oder entfernt? Technische Nachvollziehbarkeit bei Bedarf. | -Das Änderungsprotokoll wird über das Objektmenü, ein Register oder einen standardmäßig geschlossenen Bereich geöffnet. Es bleibt vollständig und berechtigt abrufbar. Lange Protokolle werden begrenzt nachgeladen oder paginiert; kein unendlicher Aktionsstapel in der normalen Objektansicht. Fehlende historische Informationen werden nicht erfunden. +Fachlicher Verlauf und Änderungsprotokoll werden über das Objektmenü als eigene Ansicht der zentralen Arbeitsfläche geöffnet. Kein angehängter Bereich unter der Inhaltsliste und kein zweites dauerhaftes Registerband am Seitenende. Das Protokoll bleibt vollständig und berechtigt abrufbar. Lange Protokolle werden begrenzt nachgeladen oder paginiert; kein unendlicher Aktionsstapel in der normalen Objektansicht. Fehlende historische Informationen werden nicht erfunden. Das Ausblenden in der Arbeitsansicht bedeutet weder das Löschen von Audit-Einträgen noch das Abschalten der Protokollierung. Nicht jede technische Aktion erzeugt einen fachlichen Verlaufseintrag. Derselbe Dokumentzugang darf dort nicht durch mehrere technische Ereignisse als mehrere fachliche Vorgänge erscheinen. Im Protokoll bleiben tatsächlich unterschiedliche Aktionen nachvollziehbar. @@ -149,12 +198,13 @@ Fehlt für einen Eintrag ein fachliches Datum, wird dies transparent behandelt; ## 9. Unterlagen öffnen und bearbeiten -Ein Klick auf eine Unterlage führt unmittelbar zu einer brauchbaren Lese-/Detailansicht mit Titel, Inhalt beziehungsweise sicherer Vorschau und den relevanten Metadaten. Eine Desktop-Seitenansicht ist ebenso möglich wie eine gut strukturierte Detailseite. Dialoge nicht beliebig ineinander verschachteln. +Ein Klick auf eine Unterlage führt unmittelbar zu einer brauchbaren Lese-/Detailansicht mit Titel, Inhalt beziehungsweise sicherer Vorschau und den relevanten Metadaten. Eine Desktop-Seitenansicht ist ebenso möglich wie eine gut strukturierte Detailseite. Der Dokumentinhalt beziehungsweise Notiztext erhält die Hauptfläche; ein dauerhaft geöffneter Metadateneditor mit einem separaten „Öffnen“-Button als einzigem Lesezugang genügt bei unterstützten Vorschautypen nicht. Datums-/Beschreibungsbearbeitung und Anmerkungen bleiben kompakt erreichbar. Bei nicht unterstützten oder nicht erreichbaren externen Vorschauen ist ein eindeutiger Öffnungsweg mit Erklärung zulässig. Dialoge nicht beliebig ineinander verschachteln. - Notizen zeigen ihren Text; berechtigte Bearbeitung ist eindeutig erreichbar. - Eigene Dateien und Paperless-Referenzen nutzen vorhandene sichere Vorschau-/Öffnungsmöglichkeiten. Für nicht darstellbare oder nicht erreichbare Inhalte gibt es einen klaren Öffnen-/Downloadweg beziehungsweise eine verständliche Fehlermeldung. - Kontextbezogene Anmerkungen sind am gelesenen Inhalt verfügbar und als solche erkennbar. Ihre Wirkung bleibt vom gemeinsamen Notiztext unterscheidbar. - Weitere Einbindungen, Schreibschutz, Teilen und Entfernen gehören in einen ergänzenden Bereich oder ein Aktionsmenü. Häufiges Lesen wird nicht von diesen Einstellungen überlagert. +- „In weitere Akte/Vorgang einbinden“ ist eine bewusste Aktion mit Zielauswahl und den vorhandenen Freigabe-/Zielbearbeitungsprüfungen. Lokales Ordnen darf keine neue Sichtbarkeit erzeugen. Kein containerübergreifendes Drag-and-drop mit stiller Freigabe und keine Dokumentkopie zur Einordnung. - „Aus diesem Vorgang entfernen“ und „Überall löschen“ bleiben sprachlich und funktional getrennt. Globale Löschwirkung muss vor der Ausführung klar sein; bestehende Schutz- und Bestätigungsregeln bleiben erhalten. - Keine Änderung an Paperless-Originalen, Berechtigungen oder Freigaben allein durch Öffnen und Vorschau. Kein neuer Paperless-Abgleich als Voraussetzung dieses UX-Auftrags. @@ -173,12 +223,12 @@ Formulare zeigen Fehler am betroffenen Feld, sichern Eingaben bei fehlgeschlagen Ziel ist eine ruhige, lesbare Arbeitsoberfläche mit klarer Gewichtung. Vorhandene geeignete Komponenten und das bestehende Erscheinungsbild weiterentwickeln; kein neues Designsystem als Vorprojekt. - Wenige konsistente Schriftgrößen und Abstände; Seitentitel, Abschnittstitel, Zeilentitel und ergänzende Angaben sind klar unterscheidbar. -- Inhalte als kompakte Listen oder Tabellen mit ausgerichtetem Datum, Titel, Typ und wenigen relevanten Kennzeichen. Lange Titel bleiben lesbar; notwendige Information nicht ausschließlich in Tooltips verstecken. +- Vorschauzeilen mit ausgerichteten Thumbnails, lesbaren Titeln, Kurzbeschreibungen und wenigen relevanten Kennzeichen bilden die zentrale Inhaltsansicht. Lange Titel bleiben lesbar; notwendige Information nicht ausschließlich in Tooltips verstecken. - Eine erkennbare Hauptaktion je Arbeitsbereich; sekundäre Aktionen zurückhaltend. Destruktive Aktionen ergänzend und eindeutig. - Weißraum dient der Gruppierung. Große Leerflächen und hohe Karten pro Eintrag dürfen zusammengehörige Arbeit nicht auseinanderziehen. - Status und Dringlichkeit über Text und ergänzende Gestaltung vermitteln, nicht allein über Farbe. - Sichtbare Fokusmarkierungen, beschriftete Eingaben, verständliche Symbolaktionen und ausreichend bedienbare Klickflächen. -- Desktop: Inhalte und aktueller Handlungsbedarf ohne Durchscrollen leerer Strukturabschnitte erreichbar. Kleinere Displays: Struktur, Liste und Vorschau sinnvoll nacheinander; keine unbedienbare verkleinerte Mehrspaltenansicht. +- Desktop: Objektkopf, kompakte Gliederungsnavigation und eine zentrale Arbeitsfläche; keine gleichzeitigen Inhalts-/Historien-/Zuordnungslisten. Kleinere Displays: Gliederung ausklappbar, Vorschauzeilen umbrechen sinnvoll, die Leseansicht bleibt bedienbar; keine unbedienbare verkleinerte Mehrspaltenansicht. - Ladezustand, echter Leerzustand, Fehler und fehlende Berechtigung sind unterscheidbar. Während des Ladens keine irreführende Behauptung „Keine Akte“ oder „Keine Unterlagen“. ## 12. Technischer Rahmen und Datenbestand @@ -189,6 +239,8 @@ Der Agent prüft zunächst aktuellen Code, `AGENTS.md`, Tests und Arbeitsstand. Breadcrumbs, Gesamtsichten, Suchtreffer, Vorschauen, Protokolle und Sortierung verwenden dieselben gültigen Berechtigungen und Handlungskontexte wie der übrige Zugriff. Eine ausgeblendete Schaltfläche ersetzt keine serverseitige Prüfung. Gemeinsam verwendete Elemente bleiben gemeinsam; kein Kopieren zur Vereinfachung der Oberfläche. +Thumbnails, Textauszüge und Kurzbeschreibungen sind geschützte Inhalte. Vorhandene Datei-/Paperless-Adapter und sichere Renderwege verwenden. Cache oder direkte Vorschaulinks dürfen keine öffentlichen Nebenwege schaffen oder entzogene Zugriffe fortbestehen lassen. Berechtigung auch beim Abruf abgeleiteter Inhalte prüfen. Erforderliche Ausgaben begrenzen und Fehler in der Vorschau dürfen die Inhaltsliste nicht unbenutzbar machen. + Nicht Bestandteil dieses Auftrags sind Finanzfunktionen, bidirektionale Paperless-Synchronisation, KI, externer Anwaltszugang, eine allgemeine Workflow-Engine, beliebige dynamische Sichten oder ein umfangreicher Regelbaukasten. Die dafür bestätigten Produktziele bleiben bestehen. ## 13. Abnahme und Nachweise @@ -196,22 +248,29 @@ Nicht Bestandteil dieses Auftrags sind Finanzfunktionen, bidirektionale Paperles | ID | Überprüfbares Ergebnis | |---|---| | UX-01 | Über die Vorgangsübersicht lässt sich ein eigenständiger Vorgang ohne Akte anlegen und anschließend optional zuordnen. Titel, Aktion und Ergebnis stimmen überein. | -| UX-02 | Akte → Unterakte → Vorgang und Vorgang → Teilvorgang sind anhand von Breadcrumb und sichtbarer Gliederung verständlich. Direktlinks und mehrere lesbare Zuordnungen funktionieren ohne Offenlegung verborgener Pfade. | +| UX-02 | Akten-/Unteraktenhierarchie und fachliche Vorgangs-/Teilvorgangsbeziehung sind anhand von objektbezogenem Breadcrumb und kompakter Gliederung verständlich. Aktenzuordnung ist separat erkennbar; Direktlinks und weitere lesbare Zuordnungen offenbaren keine verborgenen Pfade. | | UX-03 | Ein Vorgang mit Unterlagen und ohne Teilvorgänge/Querverweise zeigt seine Inhalte unmittelbar; keine langen leeren Strukturabschnitte davor. | | UX-04 | Mindestens acht gemischte Einträge mit unterschiedlichen Daten, zwei gleichen Daten und zwei fehlenden Daten werden bei beiden Datumsrichtungen stabil und nachvollziehbar angezeigt. Erfassungsdatum ersetzt kein fehlendes Fachdokumentdatum. | | UX-05 | Eine eigene Reihenfolge bleibt nach Neuladen und erneuter Anmeldung erhalten. Wechsel zu Datumsordnung und zurück erhält die eigene Ordnung. Ein neuer Eintrag wird an der dokumentierten Stelle eingefügt. | | UX-06 | Dasselbe Element steht in zwei verschiedenen Containern an unterschiedlichen Positionen. Umordnen in A ändert B nicht. Gemeinsamer Inhalt bleibt gemeinsam; Anmerkungen bleiben kontextbezogen. | | UX-07 | Kapitelgliederung bleibt beim Sortieren erhalten. Direkte Akteninhalte sind von Inhalten ihrer Vorgänge erkennbar unterscheidbar und im passenden Kontext erreichbar. | -| UX-08 | Dokument/Notiz öffnet mit nutzbarem Inhalt beziehungsweise klarem sicheren Öffnungsweg. Entfernen und globales Löschen dominieren diese Ansicht nicht. | +| UX-08 | Unterstützte Dokumente/Notizen öffnen mit direkt nutzbarer Vorschau beziehungsweise Text als Hauptinhalt. Ein bloßer Formularbildschirm mit externem Öffnen-Button genügt dafür nicht. Für nicht verfügbare/unterstützte Vorschauen gibt es einen erklärten sicheren Öffnungsweg. Entfernen und globales Löschen dominieren die Ansicht nicht. | | UX-09 | Änderungen bleiben im separat aufrufbaren Protokoll nachvollziehbar; auch viele Aktionen verlängern die normale Inhaltsseite nicht. Fachlicher Verlauf enthält keine mehrfachen technischen Abbilder desselben fachlichen Ereignisses. | | UX-10 | Aufgabe und Frist lassen sich eindeutig erfassen und zentral wiederfinden. Erledigen der Vorbereitungsaufgabe lässt die unabhängige Frist offen. | | UX-11 | Leser dürfen die gespeicherte gemeinsame Ordnung nicht verändern. Manipulierte Reorder-IDs und Kontextangaben gewähren keinen Zugriff. Verborgene Titel/Anzahlen fehlen auch in Breadcrumb, Gesamtsicht und Änderungsverlauf. Gleichzeitige Änderungen führen nicht zu stillem Datenverlust. | | UX-12 | Bestehende Daten, Referenzen und eigene Dateien bleiben nach erforderlichen Migrationen erhalten. Vorhandene Reihenfolgen werden nicht stillschweigend überschrieben. | | UX-13 | Desktop und schmaler mobiler Bildschirm sind praktisch bedienbar; Reihenfolgeänderung gelingt ohne Drag-and-drop und wesentliche Aktionen per Tastatur. Lade-/Fehlerzustände sind verständlich. | +| UX-14 | Derselbe Vorgang hat über Übersicht, Vorgangsliste, Akte, Suche und Direktlink denselben objektbezogenen Breadcrumb. Die gesonderte Kontextanzeige ist korrekt. Öffnen einer Unterlage, Rückkehr und Neuladen erhalten den geprüften Handlungskontext ohne Erweiterung von Zugriff oder Anmerkungsreichweite. | +| UX-15 | Inhaltsliste, Aufgaben, Verlauf, Änderungsprotokoll und Zuordnungen stehen nicht als parallele Listen untereinander. Menü-/Registerwechsel zeigt genau eine zentrale Ansicht. Rückkehr erhält Auswahl, Filter und Ordnung. Der große Block „Struktur und Zuordnung“ ist entfernt. | +| UX-16 | Ein gefüllter Vorgang zeigt Vorschauzeilen mit realer Vorschau für unterstützte Dokumente, Titel, fachlichem Datum/„Ohne Datum“, Typ/Quelle und Kurzbeschreibung oder vorhandenem Auszug. Ein fehlendes Thumbnail hat einen klaren Ersatz. Keine erfundenen Inhalte und keine fest eingebauten Demo-Thumbnails im Produkt. | +| UX-17 | Mit mindestens acht synthetischen Einträgen sind per tatsächlicher Maus-/Pointer-Interaktion Ziehen nach oben/unten, an Anfang/Ende, Abbruch und bei Bedarf Scrollen nachgewiesen. Einfügelinie und Ergebnis stimmen überein; nach Neuladen bleibt die Ordnung erhalten. Ein Klick auf Pfeilbuttons ersetzt diesen Nachweis nicht. | +| UX-18 | Fehlgeschlagene oder konkurrierende Umordnung wird verständlich behandelt. Leser, Datumsmodus und zusammengesetzte Lesesichten bieten kein wirkungsloses/unzulässiges Drag-and-drop. Tastatur-/Touchalternative ist zusätzlich geprüft. | +| UX-19 | „Alle Inhalte“ einer Akte zeigt direkte und über unmittelbar zugeordnete Vorgänge sichtbare Einträge in einer gemeinsamen Lesesicht mit Herkunft, ohne zusätzlichen leeren Direktblock. Manuelle Ordnung bleibt den einzelnen Containern zugeordnet. Öffnen einer Mehrfacheinbindung verwendet den eindeutig gewählten Kontext. | +| UX-20 | Reale Thumbnails, Textauszüge und Beschreibungen bleiben für unberechtigte Nutzer auch über direkte Abrufe und nach Rechteentzug geschützt. Eine gespeicherte Vorschau umgeht die bestehenden Zugriffsregeln nicht. | -Passende vorhandene Tests weiterverwenden. Neue automatisierte Tests vor allem für persistente Ordnung, stabile Datumslogik, Konflikte, Migrationen und Rechte-/Kontextgrenzen ergänzen. Keine Tests nur zum Nachzeichnen von CSS oder statischen Beschriftungen. Betroffene Frontend-/Backend-Prüfungen ausführen und den vollständigen Kernablauf im Browser prüfen. Visualisierung und tatsächliche Bedienung müssen zusätzlich zu technischen Tests beurteilt werden. +Passende vorhandene Tests weiterverwenden. Neue automatisierte Tests vor allem für persistente Ordnung, stabile Datumslogik, Konflikte, Migrationen, Navigations-/Kontexterhalt und Rechtegrenzen abgeleiteter Inhalte ergänzen. Keine Tests nur zum Nachzeichnen von CSS oder statischen Beschriftungen. Betroffene Frontend-/Backend-Prüfungen ausführen und den vollständigen Kernablauf im Browser prüfen. Visualisierung und tatsächliche Bedienung müssen zusätzlich zu technischen Tests beurteilt werden. Ein technisch erfolgreicher Reorder-API-Test weist kein funktionierendes Drag-and-drop nach. -Zur Übergabe aussagekräftige Screenshots der Übersicht, eines gefüllten Vorgangs und einer geöffneten Unterlage liefern, einschließlich einer schmalen Ansicht. Dafür synthetische Daten verwenden; keine Zugangsdaten oder vertraulichen Bestandsinhalte in Dokumentation oder Screenshots übernehmen. Geplante, bestandene und nicht ausführbare Prüfungen ausdrücklich unterscheiden. +Zur Übergabe aussagekräftige Screenshots der Übersicht, einer gefüllten Akte mit Gliederung, eines Vorgangs mit Vorschauzeilen und einer geöffneten Unterlage liefern, einschließlich einer schmalen Ansicht. Für Drag-and-drop den tatsächlich ausgeführten Ablauf und das Ergebnis vor/nach Neuladen dokumentieren. Dafür synthetische Daten verwenden; keine Zugangsdaten oder vertraulichen Bestandsinhalte in Dokumentation oder Screenshots übernehmen. Geplante, bestandene und nicht ausführbare Prüfungen ausdrücklich unterscheiden. Wird Development bereitgestellt, den ausgelieferten Versions-/Commitstand und den dort tatsächlich geprüften Umfang nennen; ein lokaler Stand ist kein Nachweis des Deploy-Ergebnisses. ## 14. Arbeitsauftrag und Abschluss @@ -224,3 +283,8 @@ Bei ausdrücklicher Beauftragung der Umsetzung auf Basis dieser Ergänzung gilt: 5. Ergebnis mit betroffenen Dateien, kurzen Start-/Prüfhinweisen, Screenshots, ausgeführten Nachweisen und verbleibenden Einschränkungen übergeben. Ein Push auf `develop` löst laut Repository einen Development-Deploy aus. Der reine Dokumentationsauftrag, der diese Ergänzung erstellt, autorisiert weder Implementierung noch Commit, Push, Deployment oder Änderungen an laufenden Systemen. Der spätere Umsetzungsauftrag soll den gewünschten Übergabepunkt ausdrücklich benennen; ohne zusätzliche Angabe bis zur lokal prüfbaren Umsetzung arbeiten und kein Deployment auslösen. Production wird nicht durch diesen UX-Auftrag freigegeben. + +## 15. Fortschreibung + +- **0.1:** Erste lesende Oberflächenprüfung, Ausgangsanforderungen und 13 Abnahmekriterien. +- **0.2:** Zweite Prüfung und Nutzerauftrag zur Übergabe: ausgewählte Vorschauzeilen als Standard; stabile Objektpfade statt einstiegsabhängiger Breadcrumbs; Kontextanzeige separat bei unveränderten Rechteprüfungen; genau eine zentrale Arbeitsfläche; gemeinsame Aktenlesesicht mit Herkunft; echte Vorschauen/Kurzbeschreibungen; Drag-and-drop von optional zu verpflichtend; 20 Abnahmekriterien und konkrete Nachweise. Die weitere Kachelvariante bleibt optional. Diese Fortschreibung ändert ausschließlich die Anforderungsdokumentation. diff --git a/frontend/src/pages/Cases.jsx b/frontend/src/pages/Cases.jsx index 7189197..632915b 100644 --- a/frontend/src/pages/Cases.jsx +++ b/frontend/src/pages/Cases.jsx @@ -5,7 +5,7 @@ import { SessionContext } from "../session.js"; import { Modal } from "./Modal.jsx"; import { MailPicker, PaperlessPicker } from "./Sources.jsx"; import { ErrorNote, ShareBox } from "./widgets.jsx"; -import { ContentBoard, RecordTabs, Trail } from "./content.jsx"; +import { ContentBoard, ObjectMenu, RecordTree, SurfaceView, Trail, WorkLists, WorkSwitch } from "./content.jsx"; export function CaseList() { const { session } = useContext(SessionContext); @@ -58,15 +58,11 @@ export function CaseList() { ))} {items.filter((item) => !roomFilter || item.home_scope_id === roomFilter).length ? ( -
Noch keine Akte. Lege die erste an.
)} @@ -99,11 +95,116 @@ export function CaseList() { ); } +function OutlineLink({ kind, title, to }) { + return ( + + {kind} + {title} + + ); +} + +function CaseOutline({ record, caseId, scope, chapterId, onScope, onChapter }) { + const hasParent = Boolean(record.parent_case_id && record.parent_title); + return ( + + ); +} + +function mergedCaseItems(record, direction, caseId) { + const rows = [ + ...(record.bindings || []).map((binding) => ({ + ...binding, + origin: "Direkt in dieser Akte", + readerHref: `/cases/${caseId}/items/${binding.id}`, + })), + ...(record.contained || []).flatMap((group) => (group.bindings || []).map((binding) => ({ + ...binding, + origin: `Aus Vorgang ${group.title}`, + readerHref: `/matters/${group.matter_id}/items/${binding.id}?context_kind=case&context_id=${caseId}`, + }))), + ]; + const counts = {}; + for (const row of rows) counts[row.element.id] = (counts[row.element.id] || 0) + 1; + const marked = rows.map((row) => ({ ...row, shared: counts[row.element.id] > 1 })); + const dated = marked.filter((row) => row.element.dates?.document_on); + const undated = marked.filter((row) => !row.element.dates?.document_on); + dated.sort((a, b) => a.element.dates.document_on.localeCompare(b.element.dates.document_on) || a.id.localeCompare(b.id)); + if (direction === "desc") dated.reverse(); + undated.sort((a, b) => a.id.localeCompare(b.id)); + return [...dated, ...undated]; +} + export function CaseDetail() { const { id } = useParams(); const [record, setRecord] = useState(null); const [error, setError] = useState(""); const [modal, setModal] = useState(""); + const [view, setView] = useState("contents"); + const [scope, setScope] = useState("all"); + const [chapterId, setChapterId] = useState(""); + const [dateDir, setDateDir] = useState("asc"); + const [outlineOpen, setOutlineOpen] = useState(false); const context = { kind: "case", id }; async function load() { @@ -118,6 +219,11 @@ export function CaseDetail() { if (error && !record) returnAkte wird geladen …
{record.status === "open" ? "Offen" : "Geschlossen"}
- {record.rights.edit ? : null} -Aus dem Vorgang {group.title}
-Dieser Bereich hat in der Akte keine eigenen Unterlagen.
+ ) : null} + {view === "work" ?Unterakten, Vorgänge und Freigaben dieses Objekts.
+ {record.rights.edit ? : null} + {record.rights.edit ? : null} + {record.rights.edit ? : null} +Vorgänge werden geladen …
: items.length ? ( -Noch kein Vorgang.
)} @@ -92,6 +79,68 @@ export function MatterList() { ); } +function MatterOutline({ record, inherited, chapterId, onChapter }) { + const matterQuery = inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : ""; + const hasParent = Boolean(record.parent_matter_id && record.parent_title); + const hasChildren = Boolean(record.submatters?.length); + const hasCases = Boolean(record.placements?.length); + return ( + + ); +} + export function MatterDetail() { const { id } = useParams(); const [params] = useSearchParams(); @@ -101,6 +150,9 @@ export function MatterDetail() { const [modal, setModal] = useState(""); const rightsContext = inherited || { kind: "matter", id }; const placement = inherited?.kind === "case" ? { kind: "matter", id } : null; + const [view, setView] = useState("contents"); + const [chapterId, setChapterId] = useState(""); + const [outlineOpen, setOutlineOpen] = useState(false); async function load() { const query = inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : ""; @@ -116,77 +168,72 @@ export function MatterDetail() { if (error && !record) returnVorgang wird geladen …
{record.kind_label || "Vorgang"} · {record.home_scope_name}{inherited ? " · über die Akte geöffnet" : ""}
+{record.kind_label || "Vorgang"} · {record.home_scope_name}
{record.status === "open" ? "Offen" : "Geschlossen"}
Akte {item.title}
+ )) :Noch keiner Akte zugeordnet.
} + {record.cross_links?.length ? record.cross_links.map((item) => ( +Querverweis {item.title}
+ )) :Kein Querverweis.
} + {record.rights.edit ? : null} +Zurück
{notice}
: null} {binding.rights.edit ? :In diesem Kontext nur lesbar.
} + ) : previewUrl && previewKind === "image" ? ( +{element.preview?.available ? "Vorschau wird geladen …" : "Für diesen Typ gibt es keine eingebaute Vorschau."}
- {previewUrl ? : null}{element.summary}
: null} {binding.rights.edit ? (