From 52bda91aad604f0d95be527e457ac8137c85f645 Mon Sep 17 00:00:00 2001 From: Lars Date: Sat, 17 Oct 2026 09:36:48 +0200 Subject: [PATCH] Ordne Akten und Vorgaenge nach fachlichem Datum oder eigener Reihenfolge und mache den Inhalt zur Arbeitsansicht. Co-authored-by: Cursor --- backend/app/api/routes.py | 157 +++++++- backend/app/api/schemas.py | 22 ++ backend/app/ops.py | 134 ++++++- backend/app/order.py | 25 ++ backend/app/present.py | 149 +++++-- .../20261017T080000Z_content_order.sql | 15 + backend/tests/test_order.py | 371 ++++++++++++++++++ docs/architecture/TSUMUGU_TECHNICAL_SPEC.md | 2 + docs/product/TSUMUGU_PRODUCT_SPEC.md | 14 +- docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md | 226 +++++++++++ frontend/src/App.jsx | 7 + frontend/src/api.js | 14 + frontend/src/pages/Cases.jsx | 197 ++++++---- frontend/src/pages/Matters.jsx | 210 +++++----- frontend/src/pages/Modal.jsx | 13 +- frontend/src/pages/Overview.jsx | 71 ++-- frontend/src/pages/Reader.jsx | 217 ++++++++++ frontend/src/pages/Settings.jsx | 36 ++ frontend/src/pages/Shell.jsx | 21 +- frontend/src/pages/Work.jsx | 119 ++++++ frontend/src/pages/content.jsx | 270 +++++++++++++ frontend/src/styles.css | 47 +++ 22 files changed, 2079 insertions(+), 258 deletions(-) create mode 100644 backend/app/order.py create mode 100644 backend/migrations/20261017T080000Z_content_order.sql create mode 100644 backend/tests/test_order.py create mode 100644 docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md create mode 100644 frontend/src/pages/Reader.jsx create mode 100644 frontend/src/pages/Settings.jsx create mode 100644 frontend/src/pages/Work.jsx create mode 100644 frontend/src/pages/content.jsx diff --git a/backend/app/api/routes.py b/backend/app/api/routes.py index d192ae1..23ba4f2 100644 --- a/backend/app/api/routes.py +++ b/backend/app/api/routes.py @@ -56,6 +56,9 @@ from app.api.schemas import ( MatterIn, MatterPatch, MemberIn, + BindingOrderIn, + ContentOrderIn, + DatesPatch, NoteIn, NotePatch, RoomIn, @@ -102,8 +105,11 @@ from app.ops import ( patch_matter, patch_task, revoke_grant, + reorder_bindings, + set_content_order, set_exception, unlink_matter_case, + update_dates, update_note, ) from app.present import ( @@ -112,6 +118,7 @@ from app.present import ( case_detail, case_summary, deadline_payload, + course_items, matter_detail, matter_summary, note_update_payload, @@ -725,6 +732,7 @@ def post_note(body: NoteIn, principal: Principal = Depends(get_principal), conn: Ctx(body.context.kind, body.context.id), _ctx_model(body.placement), body.chapter_id, + body.dates.document_on if body.dates else None, ) element = created["element"] return _created( @@ -1143,8 +1151,127 @@ def search(q: str, principal: Principal = Depends(get_principal), conn: Connecti return {"items": items[:50], "next_cursor": None} +@router.patch("/api/v1/cases/{case_id}/content-order") +def patch_case_order( + case_id: UUID, + body: ContentOrderIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + version = set_content_order( + conn, principal.account_id, "case", case_id, body.expected_version, body.mode, body.direction, None + ) + return {"version": version, "mode": body.mode, "direction": body.direction} + + +@router.post("/api/v1/cases/{case_id}/bindings/order") +def post_case_binding_order( + case_id: UUID, + body: BindingOrderIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + version = reorder_bindings( + conn, principal.account_id, "case", case_id, body.expected_version, body.binding_ids, None + ) + return {"version": version} + + +@router.patch("/api/v1/matters/{matter_id}/content-order") +def patch_matter_order( + matter_id: UUID, + body: ContentOrderIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + version = set_content_order( + conn, + principal.account_id, + "matter", + matter_id, + body.expected_version, + body.mode, + body.direction, + _ctx_model(body.context), + ) + return {"version": version, "mode": body.mode, "direction": body.direction} + + +@router.post("/api/v1/matters/{matter_id}/bindings/order") +def post_matter_binding_order( + matter_id: UUID, + body: BindingOrderIn, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + version = reorder_bindings( + conn, + principal.account_id, + "matter", + matter_id, + body.expected_version, + body.binding_ids, + _ctx_model(body.context), + ) + return {"version": version} + + +@router.patch("/api/v1/elements/{element_id}/dates") +def patch_element_dates( + element_id: UUID, + body: DatesPatch, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + element = update_dates( + conn, + principal.account_id, + element_id, + body.expected_version, + body.document_on, + body.sent_on, + body.received_on, + _ctx_model(body.context), + ) + return {"id": str(element["id"]), "version": element["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") + detail = case_detail(conn, principal.account_id, case, rights) + return {"items": course_items(detail["bindings"]), "next_cursor": None} + + +@router.get("/api/v1/matters/{matter_id}/course") +def matter_course( + matter_id: UUID, + context_kind: str | None = None, + context_id: str | None = None, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): + context = parse_query_context(context_kind, context_id) + matter, rights = require_matter(conn, principal.account_id, matter_id, context, "read") + detail = matter_detail(conn, principal.account_id, matter, rights, context) + return {"items": course_items(detail["bindings"]), "next_cursor": None} + + +@router.get("/api/v1/views/recent-matters") +def recent_matters(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): + rows = [matter for matter, _contexts in list_matters(conn, principal.account_id)] + rows.sort(key=lambda item: (item["updated_at"], str(item["id"])), reverse=True) + items = [matter_summary(conn, principal.account_id, matter) for matter in rows[:8]] + return {"items": items, "next_cursor": None} + + @router.get("/api/v1/cases/{case_id}/chronology") -def case_chronology(case_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): +def case_chronology( + case_id: UUID, + cursor: str | None = None, + principal: Principal = Depends(get_principal), + conn: Connection = Depends(get_conn), +): case, _rights = require_case(conn, principal.account_id, case_id, "read") page = Ctx("case", case["id"]) rows = conn.execute( @@ -1166,7 +1293,7 @@ def case_chronology(case_id: UUID, principal: Principal = Depends(get_principal) """, {"case": case_id}, ).fetchall() - return {"items": _visible_events(conn, principal.account_id, rows, page)} + return _event_page(_visible_events(conn, principal.account_id, rows, page), cursor) @router.get("/api/v1/matters/{matter_id}/chronology") @@ -1174,6 +1301,7 @@ def matter_chronology( matter_id: UUID, context_kind: str | None = None, context_id: str | None = None, + cursor: str | None = None, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn), ): @@ -1198,7 +1326,7 @@ def matter_chronology( """, {"matter": matter_id}, ).fetchall() - return {"items": _visible_events(conn, principal.account_id, rows, page)} + return _event_page(_visible_events(conn, principal.account_id, rows, page), cursor) def _parse_date(value: str | None) -> date | None: @@ -1237,18 +1365,41 @@ def _case_contexts(conn, actor, matter) -> list[dict]: return [item for item in readable_matter_contexts(conn, actor, matter) if item["kind"] == "case"] +def _event_page(items: list[dict], cursor: str | None, limit: int = 40) -> dict: + start = 0 + if cursor: + ids = [item["id"] for item in items] + if cursor not in ids: + return {"items": [], "next_cursor": None} + start = ids.index(cursor) + 1 + chunk = items[start:start + limit] + next_cursor = chunk[-1]["id"] if chunk and start + limit < len(items) else None + return {"items": chunk, "next_cursor": next_cursor} + + def _visible_events(conn, actor: UUID, rows: list[dict], page: Ctx) -> list[dict]: + names: dict = {} items = [] for event in rows: title = _event_title(conn, actor, event, page) if title is None: continue + actor_id = event["actor_subject_id"] + if actor_id not in names: + row = None + if actor_id is not None: + row = conn.execute( + "SELECT display_name FROM auth_accounts WHERE id = %s", + (actor_id,), + ).fetchone() + names[actor_id] = row["display_name"] if row else None items.append( { "id": str(event["id"]), "action": event["action"], "label": LABELS.get(event["action"], "Ereignis"), "title": title, + "actor_display_name": names[actor_id], "occurred_on": event["occurred_on"].isoformat() if event["occurred_on"] else None, "occurred_at": event["occurred_at"].astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), "resource_kind": event["resource_kind"], diff --git a/backend/app/api/schemas.py b/backend/app/api/schemas.py index 416d562..9cca4cd 100644 --- a/backend/app/api/schemas.py +++ b/backend/app/api/schemas.py @@ -132,6 +132,28 @@ class NoteIn(APIModel): context: ContextIn placement: ContextIn | None = None chapter_id: UUID | None = None + dates: DatesIn | None = None + + +class ContentOrderIn(APIModel): + expected_version: int = Field(ge=1) + mode: Literal["date", "position"] + direction: Literal["asc", "desc"] = "asc" + context: ContextIn | None = None + + +class BindingOrderIn(APIModel): + expected_version: int = Field(ge=1) + binding_ids: list[UUID] = Field(min_length=0, max_length=500) + context: ContextIn | None = None + + +class DatesPatch(APIModel): + expected_version: int = Field(ge=1) + document_on: date | None = None + sent_on: date | None = None + received_on: date | None = None + context: ContextIn | None = None class NotePatch(APIModel): diff --git a/backend/app/ops.py b/backend/app/ops.py index 4ed3b8b..3addbe3 100644 --- a/backend/app/ops.py +++ b/backend/app/ops.py @@ -76,9 +76,10 @@ def create_case(conn, actor: UUID, scope_id: UUID, title: str, parent_case_id: U row = conn.execute( """ INSERT INTO cases ( - home_scope_id, owner_subject_id, created_by, title, rights_mode + home_scope_id, owner_subject_id, created_by, title, rights_mode, + content_order, content_order_dir ) - VALUES (%s, %s, %s, %s, 'explicit') + VALUES (%s, %s, %s, %s, 'explicit', 'date', 'asc') RETURNING * """, (scope_id, actor, actor, title), @@ -92,9 +93,10 @@ def create_case(conn, actor: UUID, scope_id: UUID, title: str, parent_case_id: U row = conn.execute( """ INSERT INTO cases ( - home_scope_id, owner_subject_id, created_by, title, parent_case_id, rights_mode + home_scope_id, owner_subject_id, created_by, title, parent_case_id, rights_mode, + content_order, content_order_dir ) - VALUES (%s, %s, %s, %s, %s, %s) + VALUES (%s, %s, %s, %s, %s, %s, 'date', 'asc') RETURNING * """, (parent["home_scope_id"], actor, actor, title, parent["id"], rights_mode), @@ -156,8 +158,10 @@ def create_matter(conn, actor: UUID, scope_id: UUID, title: str, parent_matter_i if parent_matter_id is None: row = conn.execute( """ - INSERT INTO matters (home_scope_id, owner_subject_id, created_by, title) - VALUES (%s, %s, %s, %s) RETURNING * + INSERT INTO matters ( + home_scope_id, owner_subject_id, created_by, title, content_order, content_order_dir + ) + VALUES (%s, %s, %s, %s, 'date', 'asc') RETURNING * """, (scope_id, actor, actor, title), ).fetchone() @@ -168,9 +172,10 @@ def create_matter(conn, actor: UUID, scope_id: UUID, title: str, parent_matter_i row = conn.execute( """ INSERT INTO matters ( - home_scope_id, owner_subject_id, created_by, title, parent_matter_id + home_scope_id, owner_subject_id, created_by, title, parent_matter_id, + content_order, content_order_dir ) - VALUES (%s, %s, %s, %s, %s) RETURNING * + VALUES (%s, %s, %s, %s, %s, 'date', 'asc') RETURNING * """, (parent["home_scope_id"], actor, actor, title, parent["id"]), ).fetchone() @@ -440,7 +445,17 @@ def record_dates(conn, actor: UUID, scope_id: UUID, element_id: UUID, context: C audit(conn, actor, scope_id, "correspondence_recorded", "element", element_id, context) -def create_note(conn, actor: UUID, scope_id: UUID, title: str, document: dict, context: Ctx, placement: Ctx | None, chapter_id: UUID | None) -> dict: +def create_note( + conn, + actor: UUID, + scope_id: UUID, + title: str, + document: dict, + context: Ctx, + placement: Ctx | None, + chapter_id: UUID | None, + document_on: date | None = None, +) -> dict: document = clean_document(document) target, rights_context = _placement(context, placement) require_container_edit(conn, actor, target, rights_context) @@ -451,6 +466,8 @@ def create_note(conn, actor: UUID, scope_id: UUID, title: str, document: dict, c ) binding = insert_binding(conn, element["id"], target.kind, target.id, chapter_id, actor) audit(conn, actor, scope_id, "note_created", "element", element["id"], rights_context or target) + if document_on is not None: + record_dates(conn, actor, scope_id, element["id"], rights_context or target, document_on, None, None) return {"element": element, "binding": binding, "document": document} @@ -782,3 +799,102 @@ def link_task_deadline(conn, actor: UUID, task_id: UUID, deadline_id: UUID, cont """, (task_id, deadline_id, actor), ) + + +def set_content_order( + conn, + actor: UUID, + kind: str, + container_id: UUID, + expected: int, + mode: str, + direction: str, + context: Ctx | None, +) -> int: + if kind == "case": + container, rights = require_case(conn, actor, container_id, "edit") + table = "cases" + else: + container, rights = require_matter(conn, actor, container_id, context, "edit") + table = "matters" + if not rights.edit: + raise forbidden() + version = bump_version(conn, table, container_id, expected) + conn.execute( + f"UPDATE {table} SET content_order = %s, content_order_dir = %s WHERE id = %s", + (mode, direction, container_id), + ) + audit(conn, actor, container["home_scope_id"], "content_order", kind, container_id, context) + return version + + +def reorder_bindings( + conn, + actor: UUID, + kind: str, + container_id: UUID, + expected: int, + binding_ids: list[UUID], + context: Ctx | None, +) -> int: + 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() + version = bump_version(conn, table, container_id, expected) + rows = conn.execute( + """ + SELECT * FROM bindings + WHERE context_kind = %s AND context_id = %s + ORDER BY position, id + """, + (kind, container_id), + ).fetchall() + visible_ids = [] + for row in rows: + element = get_element(conn, row["element_id"]) + if element is not None and element_rights(conn, actor, element, page).read: + visible_ids.append(row["id"]) + submitted = list(binding_ids) + if len(submitted) != len(set(submitted)): + raise unprocessable("Dieselbe Einbindung steht mehrfach in der Ordnung.") + if any(item not in set(visible_ids) for item in submitted): + raise not_found() + if set(submitted) != set(visible_ids): + raise unprocessable("Die Ordnung ist unvollständig. Bitte neu laden.") + visible_set = set(visible_ids) + coming = iter(submitted) + sequence = [] + for row in rows: + if row["id"] in visible_set: + sequence.append(next(coming)) + else: + sequence.append(row["id"]) + for index, binding_id in enumerate(sequence): + conn.execute("UPDATE bindings SET position = %s WHERE id = %s", (index, binding_id)) + audit(conn, actor, container["home_scope_id"], "content_reordered", kind, container_id, context) + return version + + +def update_dates( + conn, + actor: UUID, + element_id: UUID, + expected: int, + document_on: date | None, + sent_on: date | None, + received_on: date | None, + context: Ctx | None, +) -> dict: + element, rights = require_element(conn, actor, element_id, context, "edit") + if not rights.edit: + raise forbidden() + 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) diff --git a/backend/app/order.py b/backend/app/order.py new file mode 100644 index 0000000..764198a --- /dev/null +++ b/backend/app/order.py @@ -0,0 +1,25 @@ +"""Display order for bindings. Stored positions stay intact when sorting by date.""" + +from __future__ import annotations + + +def arrange(items: list[dict], mode: str, direction: str) -> list[dict]: + """Return a new list. Undated entries stay last in both date directions.""" + if mode == "position": + ordered = sorted(items, key=lambda item: (item["_raw_position"], item["id"])) + else: + dated = [item for item in items if item.get("_document_on")] + undated = [item for item in items if not item.get("_document_on")] + if direction == "desc": + dated.sort(key=lambda item: (item["_raw_position"], item["id"])) + dated.sort(key=lambda item: item["_document_on"], reverse=True) + else: + dated.sort(key=lambda item: (item["_document_on"], item["_raw_position"], item["id"])) + undated.sort(key=lambda item: (item["_raw_position"], item["id"])) + ordered = dated + undated + result = [] + for index, item in enumerate(ordered): + visible = {key: value for key, value in item.items() if not key.startswith("_")} + visible["position"] = index + result.append(visible) + return result diff --git a/backend/app/present.py b/backend/app/present.py index a1ddf96..a0b7ad5 100644 --- a/backend/app/present.py +++ b/backend/app/present.py @@ -22,6 +22,7 @@ from app.access.policy import ( ) from app.access.policy import SHARED_NOTICE from app.core.timeutil import dump_date, dump_dt +from app.order import arrange def rights_dict(rights) -> dict: @@ -179,6 +180,80 @@ def _grants(conn, kind: str, resource_id: UUID) -> list[dict]: ] +def _ordered_bindings(conn, actor: UUID, kind: str, container_id: UUID, context: Ctx, mode: str, direction: str) -> list[dict]: + rows = conn.execute( + """ + SELECT * FROM bindings + WHERE context_kind = %s AND context_id = %s + ORDER BY position, id + """, + (kind, container_id), + ).fetchall() + visible = [] + for binding in rows: + item = binding_payload(conn, actor, binding, context) + if item is None: + continue + item["_raw_position"] = binding["position"] + item["_document_on"] = item["element"]["dates"]["document_on"] + visible.append(item) + return arrange(visible, mode or "position", direction or "asc") + + +def course_items(bindings: list[dict]) -> list[dict]: + """One fachlicher Eintrag je Unterlage. Das Erfassungsdatum ist kein Belegdatum.""" + items = [] + for binding in bindings: + dates = binding["element"]["dates"] + items.append( + { + "id": binding["element"]["id"], + "binding_id": binding["id"], + "title": binding["element"]["title"], + "kind": binding["element"]["kind"], + "document_on": dates["document_on"], + "sent_on": dates["sent_on"], + "received_on": dates["received_on"], + "dated": dates["document_on"] is not None, + } + ) + dated = [item for item in items if item["dated"]] + undated = [item for item in items if not item["dated"]] + dated.sort(key=lambda item: (item["document_on"], item["id"])) + undated.sort(key=lambda item: item["id"]) + return dated + undated + + +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}) + 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}) + return trail + + def case_summary(case: dict, rights) -> dict: return { "id": str(case["id"]), @@ -194,6 +269,10 @@ def case_summary(case: dict, rights) -> dict: def case_detail(conn, actor: UUID, case: dict, rights) -> dict: payload = case_summary(case, rights) + payload["content_order"] = case.get("content_order") or "position" + payload["content_order_dir"] = case.get("content_order_dir") or "asc" + payload["trail"] = case_trail(conn, actor, case) + payload["kind_label"] = "Unterakte" if case["parent_case_id"] else "Akte" payload["home_scope_name"] = room_name(conn, case["home_scope_id"]) payload["is_owner"] = case["owner_subject_id"] == actor if case["parent_case_id"]: @@ -238,19 +317,43 @@ def case_detail(conn, actor: UUID, case: dict, rights) -> dict: ) payload["matters"] = matters context = Ctx("case", case["id"]) - bindings = [] - for binding in conn.execute( + payload["bindings"] = _ordered_bindings( + conn, actor, "case", case["id"], context, payload["content_order"], payload["content_order_dir"] + ) + contained = [] + for link in conn.execute( """ - SELECT * FROM bindings - WHERE context_kind = 'case' AND context_id = %s - ORDER BY position, created_at + SELECT m.* + FROM matter_case_links l + JOIN matters m ON m.id = l.matter_id + WHERE l.case_id = %s AND m.deleted_at IS NULL + ORDER BY m.title, m.id """, (case["id"],), ).fetchall(): - item = binding_payload(conn, actor, binding, context) - if item is not None: - bindings.append(item) - payload["bindings"] = bindings + if not matter_rights(conn, actor, link, context).read: + continue + items = _ordered_bindings( + conn, + actor, + "matter", + link["id"], + context, + link.get("content_order") or "position", + link.get("content_order_dir") or "asc", + ) + if not items: + continue + contained.append( + { + "matter_id": str(link["id"]), + "title": link["title"], + "content_order": link.get("content_order") or "position", + "content_order_dir": link.get("content_order_dir") or "asc", + "bindings": items, + } + ) + payload["contained"] = contained if rights.share or case["owner_subject_id"] == actor: payload["grants"] = _grants(conn, "case", case["id"]) return payload @@ -295,6 +398,10 @@ def matter_detail(conn, actor: UUID, matter: dict, rights, context: Ctx | None) "home_scope_id": str(matter["home_scope_id"]), "home_scope_name": room_name(conn, matter["home_scope_id"]), "is_owner": matter["owner_subject_id"] == actor, + "content_order": matter.get("content_order") or "position", + "content_order_dir": matter.get("content_order_dir") or "asc", + "trail": matter_trail(conn, actor, matter, 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(), "chapters": _chapters(conn, "matter", matter["id"]), @@ -336,19 +443,15 @@ def matter_detail(conn, actor: UUID, matter: dict, rights, context: Ctx | None) if title is not None: crosses.append({"id": str(link["id"]), "matter_id": str(link["to_matter_id"]), "title": title}) payload["cross_links"] = crosses - bindings = [] - for binding in conn.execute( - """ - SELECT * FROM bindings - WHERE context_kind = 'matter' AND context_id = %s - ORDER BY position, created_at - """, - (matter["id"],), - ).fetchall(): - item = binding_payload(conn, actor, binding, page) - if item is not None: - bindings.append(item) - payload["bindings"] = bindings + payload["bindings"] = _ordered_bindings( + conn, + actor, + "matter", + matter["id"], + page, + payload["content_order"], + payload["content_order_dir"], + ) payload["tasks"] = [] for task in conn.execute( """ @@ -497,4 +600,6 @@ LABELS = { "correspondence_received": "Zugang", "correspondence_recorded": "Erfassung", "chapter_created": "Kapitel angelegt", + "content_order": "Ordnungsart geändert", + "content_reordered": "Eigene Reihenfolge geändert", } diff --git a/backend/migrations/20261017T080000Z_content_order.sql b/backend/migrations/20261017T080000Z_content_order.sql new file mode 100644 index 0000000..d262dd8 --- /dev/null +++ b/backend/migrations/20261017T080000Z_content_order.sql @@ -0,0 +1,15 @@ +ALTER TABLE cases + ADD COLUMN content_order text NOT NULL DEFAULT 'position', + ADD COLUMN content_order_dir text NOT NULL DEFAULT 'asc'; + +ALTER TABLE cases + ADD CONSTRAINT cases_content_order CHECK (content_order IN ('date', 'position')), + ADD CONSTRAINT cases_content_order_dir CHECK (content_order_dir IN ('asc', 'desc')); + +ALTER TABLE matters + ADD COLUMN content_order text NOT NULL DEFAULT 'position', + ADD COLUMN content_order_dir text NOT NULL DEFAULT 'asc'; + +ALTER TABLE matters + ADD CONSTRAINT matters_content_order CHECK (content_order IN ('date', 'position')), + ADD CONSTRAINT matters_content_order_dir CHECK (content_order_dir IN ('asc', 'desc')); diff --git a/backend/tests/test_order.py b/backend/tests/test_order.py new file mode 100644 index 0000000..fa67ebf --- /dev/null +++ b/backend/tests/test_order.py @@ -0,0 +1,371 @@ +"""Persistent content order, fachliche dates and context limits.""" + +from __future__ import annotations + +from tests.support import Actor, binding_for, case_of, document, grant, matter_of, register + + +def _note(actor: Actor, title: str, container: dict, *, kind: str = "matter", document_on: str | None = None) -> None: + body = { + "title": title, + "document": document(title), + "context": {"kind": kind, "id": container["id"]}, + } + if document_on: + body["dates"] = {"document_on": document_on} + actor.request("POST", "/api/v1/notes", json=body, status=201) + + +def _matter(actor: Actor, matter_id: str) -> dict: + return actor.request("GET", f"/api/v1/matters/{matter_id}") + + +def _titles(detail: dict) -> list[str]: + return [item["element"]["title"] for item in detail["bindings"]] + + +def test_date_order_keeps_undated_last_and_ignores_recorded_time(client, db): + ada = Actor(client, "ada-order@example.test", "Ada Ordnung") + register(db, ada.email, ada.name) + ada.login() + matter = matter_of(ada, "Fristenmappe") + dates = ["2024-05-02", "2020-01-01", "2024-05-02", "2022-07-07", "2023-03-03", "2021-02-02"] + for index, day in enumerate(dates): + _note(ada, f"D{index}-{day}", matter, document_on=day) + _note(ada, "Ohne-A", matter) + _note(ada, "Ohne-B", matter) + detail = _matter(ada, matter["id"]) + titles = _titles(detail) + assert titles[:6] == ["D1-2020-01-01", "D5-2021-02-02", "D3-2022-07-07", "D4-2023-03-03", "D0-2024-05-02", "D2-2024-05-02"] + assert titles[6:] == ["Ohne-A", "Ohne-B"] + assert all(item["element"]["dates"]["document_on"] is None for item in detail["bindings"] if item["element"]["title"].startswith("Ohne")) + ada.request( + "PATCH", + f"/api/v1/matters/{matter['id']}/content-order", + json={"expected_version": detail["version"], "mode": "date", "direction": "desc"}, + ) + descending = _titles(_matter(ada, matter["id"])) + assert descending[:6] == ["D0-2024-05-02", "D2-2024-05-02", "D4-2023-03-03", "D3-2022-07-07", "D5-2021-02-02", "D1-2020-01-01"] + assert descending[6:] == ["Ohne-A", "Ohne-B"] + + +def test_custom_order_survives_reload_login_and_date_mode(client, db): + ada = Actor(client, "ada-seq@example.test", "Ada Folge") + register(db, ada.email, ada.name) + ada.login() + matter = matter_of(ada, "Reihenfolge") + for title, day in (("Alpha", "2020-01-01"), ("Beta", "2021-01-01"), ("Gamma", "2022-01-01")): + _note(ada, title, matter, document_on=day) + detail = _matter(ada, matter["id"]) + ada.request( + "PATCH", + f"/api/v1/matters/{matter['id']}/content-order", + json={"expected_version": detail["version"], "mode": "position", "direction": "asc"}, + ) + detail = _matter(ada, matter["id"]) + ids = [binding_for(detail, name)["id"] for name in ("Gamma", "Alpha", "Beta")] + ada.request( + "POST", + f"/api/v1/matters/{matter['id']}/bindings/order", + json={"expected_version": detail["version"], "binding_ids": ids}, + ) + ada.login() + restored = _matter(ada, matter["id"]) + assert _titles(restored) == ["Gamma", "Alpha", "Beta"] + ada.request( + "PATCH", + f"/api/v1/matters/{matter['id']}/content-order", + json={"expected_version": restored["version"], "mode": "date", "direction": "asc"}, + ) + dated = _matter(ada, matter["id"]) + assert _titles(dated) == ["Alpha", "Beta", "Gamma"] + ada.request( + "PATCH", + f"/api/v1/matters/{matter['id']}/content-order", + json={"expected_version": dated["version"], "mode": "position", "direction": "asc"}, + ) + assert _titles(_matter(ada, matter["id"])) == ["Gamma", "Alpha", "Beta"] + _note(ada, "Delta", matter) + assert _titles(_matter(ada, matter["id"]))[-1] == "Delta" + + +def test_same_element_has_independent_positions(client, db): + ada = Actor(client, "ada-two@example.test", "Ada Zwei") + register(db, ada.email, ada.name) + ada.login() + left = case_of(ada, "Akte A") + right = case_of(ada, "Akte B") + ada.request( + "POST", + "/api/v1/notes", + json={"title": "Gemeinsam", "document": document("Wort"), "context": {"kind": "case", "id": left["id"]}}, + status=201, + ) + ada.request( + "POST", + "/api/v1/notes", + json={"title": "Nur A", "document": document("A"), "context": {"kind": "case", "id": left["id"]}}, + status=201, + ) + ada.request( + "POST", + "/api/v1/notes", + json={"title": "Nur B", "document": document("B"), "context": {"kind": "case", "id": right["id"]}}, + status=201, + ) + shared = binding_for(ada.request("GET", f"/api/v1/cases/{left['id']}"), "Gemeinsam") + ada.request( + "POST", + "/api/v1/bindings", + json={ + "element_id": shared["element"]["id"], + "source_context": {"kind": "case", "id": left["id"]}, + "target": {"kind": "case", "id": right["id"]}, + }, + status=201, + ) + for case in (left, right): + detail = ada.request("GET", f"/api/v1/cases/{case['id']}") + ada.request( + "PATCH", + f"/api/v1/cases/{case['id']}/content-order", + json={"expected_version": detail["version"], "mode": "position", "direction": "asc"}, + ) + left_detail = ada.request("GET", f"/api/v1/cases/{left['id']}") + right_detail = ada.request("GET", f"/api/v1/cases/{right['id']}") + ada.request( + "POST", + f"/api/v1/cases/{left['id']}/bindings/order", + json={ + "expected_version": left_detail["version"], + "binding_ids": [binding_for(left_detail, "Gemeinsam")["id"], binding_for(left_detail, "Nur A")["id"]], + }, + ) + ada.request( + "POST", + f"/api/v1/cases/{right['id']}/bindings/order", + json={ + "expected_version": right_detail["version"], + "binding_ids": [binding_for(right_detail, "Nur B")["id"], binding_for(right_detail, "Gemeinsam")["id"]], + }, + ) + assert _titles(ada.request("GET", f"/api/v1/cases/{left['id']}")) == ["Gemeinsam", "Nur A"] + assert _titles(ada.request("GET", f"/api/v1/cases/{right['id']}")) == ["Nur B", "Gemeinsam"] + left_note = binding_for(ada.request("GET", f"/api/v1/cases/{left['id']}"), "Gemeinsam") + ada.request( + "POST", + f"/api/v1/bindings/{left_note['id']}/annotations", + json={"body": "Nur in A"}, + status=201, + ) + right_note = binding_for(ada.request("GET", f"/api/v1/cases/{right['id']}"), "Gemeinsam") + assert right_note["annotations"] == [] + assert left_note["element"]["id"] == right_note["element"]["id"] + + +def test_chapters_and_contained_matters_stay_distinct(client, db): + ada = Actor(client, "ada-chap@example.test", "Ada Kapitel") + register(db, ada.email, ada.name) + ada.login() + case = case_of(ada, "Sammelakte") + matter = matter_of(ada, "Enthaltener Vorgang") + ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201) + chapter = ada.request("POST", f"/api/v1/cases/{case['id']}/chapters", json={"title": "Belege"}, status=201) + ada.request( + "POST", + "/api/v1/notes", + json={ + "title": "Im Kapitel", + "document": document("kapitel"), + "context": {"kind": "case", "id": case["id"]}, + "chapter_id": chapter["id"], + "dates": {"document_on": "2021-01-01"}, + }, + status=201, + ) + ada.request( + "POST", + "/api/v1/notes", + json={"title": "Ohne Kapitel", "document": document("lose"), "context": {"kind": "case", "id": case["id"]}}, + status=201, + ) + _note(ada, "Im Vorgang", matter, document_on="2019-01-01") + detail = ada.request("GET", f"/api/v1/cases/{case['id']}") + ada.request( + "PATCH", + f"/api/v1/cases/{case['id']}/content-order", + json={"expected_version": detail["version"], "mode": "date", "direction": "desc"}, + ) + detail = ada.request("GET", f"/api/v1/cases/{case['id']}") + direct = {item["element"]["title"]: item["chapter_id"] for item in detail["bindings"]} + assert direct["Im Kapitel"] == chapter["id"] + assert direct["Ohne Kapitel"] is None + assert [item["element"]["title"] for item in detail["bindings"]] == ["Im Kapitel", "Ohne Kapitel"] + assert detail["contained"][0]["title"] == "Enthaltener Vorgang" + assert detail["contained"][0]["bindings"][0]["element"]["title"] == "Im Vorgang" + assert "Im Vorgang" not in direct + + +def test_course_is_not_a_copy_of_the_audit_log(client, db): + ada = Actor(client, "ada-course@example.test", "Ada Verlauf") + register(db, ada.email, ada.name) + ada.login() + matter = matter_of(ada, "Verlauf") + created = ada.request( + "POST", + "/api/v1/notes", + json={ + "title": "Schreiben", + "document": document("Text"), + "context": {"kind": "matter", "id": matter["id"]}, + "dates": {"document_on": "2024-04-04"}, + }, + status=201, + ) + ada.request( + "PATCH", + f"/api/v1/elements/{created['id']}/dates", + json={"expected_version": created["version"], "document_on": "2024-04-05", "context": {"kind": "matter", "id": matter["id"]}}, + ) + course = ada.request("GET", f"/api/v1/matters/{matter['id']}/course") + audit = ada.request("GET", f"/api/v1/matters/{matter['id']}/chronology") + assert [item["title"] for item in course["items"]] == ["Schreiben"] + assert course["items"][0]["document_on"] == "2024-04-05" + assert "recorded_at" not in course["items"][0] + assert len(audit["items"]) > len(course["items"]) + + +def test_reorder_rejects_readers_foreign_ids_and_conflicts(client, db): + ada = Actor(client, "ada-guard@example.test", "Ada Schutz") + ben = Actor(client, "ben-guard@example.test", "Ben Schutz") + register(db, ada.email, ada.name) + register(db, ben.email, ben.name) + ada.login() + matter = matter_of(ada, "Geschützt") + hidden_case = case_of(ada, "Verborgene Akte") + for title in ("Sichtbar", "Verborgen"): + _note(ada, title, matter) + detail = _matter(ada, matter["id"]) + ada.request( + "PATCH", + f"/api/v1/matters/{matter['id']}/content-order", + json={"expected_version": detail["version"], "mode": "position", "direction": "asc"}, + ) + ada.request( + "POST", + f"/api/v1/matters/{matter['id']}/grants", + json={"email": ben.email, "can_read": True, "can_edit": False, "can_share": False}, + status=201, + ) + ben.login() + ben_view = _matter(ben, matter["id"]) + ben.request( + "POST", + f"/api/v1/matters/{matter['id']}/bindings/order", + json={"expected_version": ben_view["version"], "binding_ids": [item["id"] for item in ben_view["bindings"]]}, + status=403, + ) + ben.request("GET", f"/api/v1/cases/{hidden_case['id']}", status=404) + ada.login() + ada_view = _matter(ada, matter["id"]) + visible_id = binding_for(ada_view, "Sichtbar")["id"] + ada.request( + "POST", + f"/api/v1/matters/{matter['id']}/bindings/order", + json={"expected_version": ada_view["version"], "binding_ids": [visible_id]}, + status=422, + ) + ada.request( + "POST", + "/api/v1/notes", + json={"title": "Fremd", "document": document("x"), "context": {"kind": "case", "id": hidden_case["id"]}}, + status=201, + ) + foreign = binding_for(ada.request("GET", f"/api/v1/cases/{hidden_case['id']}"), "Fremd") + ada.request( + "POST", + f"/api/v1/matters/{matter['id']}/bindings/order", + json={"expected_version": ada_view["version"], "binding_ids": [foreign["id"], visible_id]}, + status=404, + ) + hidden = binding_for(ada_view, "Verborgen") + ada.request( + "PUT", + "/api/v1/exceptions", + json={ + "resource_kind": "element", + "resource_id": hidden["element"]["id"], + "context": {"kind": "matter", "id": matter["id"]}, + "remove_read": True, + }, + ) + masked = _matter(ada, matter["id"]) + assert _titles(masked) == ["Sichtbar"] + ada.request( + "POST", + f"/api/v1/matters/{matter['id']}/bindings/order", + json={"expected_version": masked["version"], "binding_ids": [binding_for(masked, "Sichtbar")["id"]]}, + ) + conflict = ada.request( + "POST", + f"/api/v1/matters/{matter['id']}/bindings/order", + json={"expected_version": masked["version"], "binding_ids": [binding_for(masked, "Sichtbar")["id"]]}, + status=409, + ) + assert conflict["detail"] == "Der Stand hat sich geändert. Bitte neu laden." + kept = db.execute("SELECT id FROM bindings WHERE id = %s", (hidden["id"],)).fetchone() + assert kept is not None + ben.login() + assert "Verborgen" not in str(_matter(ben, matter["id"])) + + +def test_existing_position_mode_is_not_rewritten(client, db): + ada = Actor(client, "ada-keep@example.test", "Ada Bestand") + register(db, ada.email, ada.name) + ada.login() + room = ada.scope["id"] + row = db.execute( + """ + INSERT INTO cases (home_scope_id, owner_subject_id, created_by, title, rights_mode) + VALUES (%s, (SELECT id FROM auth_accounts WHERE email = %s), (SELECT id FROM auth_accounts WHERE email = %s), 'Altakte', 'explicit') + RETURNING id + """, + (room, ada.email, ada.email), + ).fetchone() + db.commit() + detail = ada.request("GET", f"/api/v1/cases/{row['id']}") + assert detail["content_order"] == "position" + assert detail["content_order_dir"] == "asc" + + +def test_direct_matter_trail_invents_no_case(client, db): + ada = Actor(client, "ada-trail@example.test", "Ada Pfad") + ben = Actor(client, "ben-trail@example.test", "Ben Pfad") + register(db, ada.email, ada.name) + register(db, ben.email, ben.name) + ada.login() + parent = case_of(ada, "Vermietung") + child = ada.request( + "POST", + "/api/v1/cases", + json={"title": "Wohnung", "parent_case_id": parent["id"], "rights_mode": "explicit"}, + status=201, + ) + matter = matter_of(ada, "Nebenkosten") + other = case_of(ada, "Geheim") + ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": child["id"]}, status=201) + ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": other["id"]}, status=201) + grant(ada, child["id"], ben.email) + 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 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"]] diff --git a/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md b/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md index bf8f052..b6a8c96 100644 --- a/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md +++ b/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md @@ -216,6 +216,8 @@ 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`. + ### 4.3 Überblick ```mermaid diff --git a/docs/product/TSUMUGU_PRODUCT_SPEC.md b/docs/product/TSUMUGU_PRODUCT_SPEC.md index 86ad5eb..89b41c0 100644 --- a/docs/product/TSUMUGU_PRODUCT_SPEC.md +++ b/docs/product/TSUMUGU_PRODUCT_SPEC.md @@ -1,8 +1,10 @@ # Tsumugu – Fachliche Produktspezifikation -**Stand:** 16.10.2026 · **Arbeitsstand:** 0.25, erster fachlicher Lieferumfang bestätigt. +**Stand:** 17.10.2026 · **Arbeitsstand:** 0.26, UX-/Ordnungsbedarf der ersten Lieferung ergänzt. **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. + Diese Datei sichert bestätigte Anforderungen, den Quellenabgleich und das nächste Interview. Sie nimmt keine offenen Produktentscheidungen vorweg. Datenmodell, konkrete Workflows, MVP-Abnahmebedingungen und Implementierungsaufträge werden nach den jeweiligen Entscheidungen hier ergänzt. Anwendungscode, Datenbanken und Deployments sind nicht Gegenstand dieser Etappe. ## 1. Quellen und Verbindlichkeit @@ -342,6 +344,14 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G **Auswirkungen:** Technische Pakete für Nachverfolgung und Übersichten dürfen nicht auf Finanzfunktionen oder virtuelle Zusammenstellungen warten müssen. Die für echte personenbezogene Daten erforderlichen Schutz-, Release- und Recovery-Verträge gehören zum ersten realen Betrieb und werden nicht bis zum Finanzausbau aufgeschoben. Noch offene Rechte-/Ownership-/Löschregeln bleiben ausdrücklich offen. Es wurde mit dieser Entscheidung noch kein Implementierungsauftrag erteilt. +### F-06a – Orientierung, fachliche Aktenordnung und Änderungsprotokoll: Bedarf präzisiert am 17.10.2026 + +**Ausdrücklicher Nutzerbedarf:** Die aktuelle Anwendung ist optisch verwirrend und unpraktisch; Hierarchien sind nicht erkennbar. Lange Protokolle jeder Aktion überladen das Objekt. Das Änderungsprotokoll bleibt für die Nachvollziehbarkeit der Änderungsreihenfolge sinnvoll, kann aber separat über ein Menü erreichbar sein. Elemente benötigen nutzbare fachliche Datumsangaben und/oder alternative Sortierschlüssel. Die innere Reihenfolge einer Akte ist selbst ein wesentlicher fachlicher Informationsträger. + +**Auswirkungen auf den MVP:** Fachliche Inhaltsordnung, fachlicher Verlauf und technische Änderungshistorie getrennt behandeln. Hierarchie und aktueller Kontext erkennbar machen. Eigenständige Vorgänge und die bestätigte Mehrfachzuordnung bleiben gemäß S-01b erhalten. Ein reiner optischer Austausch ohne Verbesserung der Arbeitsabläufe genügt nicht. + +**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. + ## 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. @@ -394,4 +404,6 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G 16.10.2026, Arbeitsstand 0.25: F-05a bestätigt: erste nutzbare Lieferung „Organisieren und Nachverfolgen“, Finanzfunktionen und bidirektionale Paperless-Synchronisation anschließend. Ersten fachlichen Abnahmeablauf und Auswirkungen auf die technische Lieferstaffelung festgehalten. Technische Spec 0.3 wird daran angeglichen; keine Implementierung. +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. + 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 new file mode 100644 index 0000000..1ce4415 --- /dev/null +++ b/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md @@ -0,0 +1,226 @@ +# Tsumugu – Ergänzung zur Bedienung, Orientierung und Aktenordnung im MVP + +**Stand:** 17.10.2026 · **Fassung:** 0.1 +**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). + +## 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. + +Die Reihenfolge innerhalb einer Akte kann selbst fachliche Information tragen. Nutzer müssen Zusammenhänge erkennen, Inhalte sinnvoll anordnen und die nächste Arbeit schnell erreichen können. Das technische Änderungsprotokoll darf diese Arbeitsansicht nicht bestimmen. + +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. + +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 + +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 | +|---|---| +| Übersicht beginnt mit „Vorläufige Annahmen“ und Erläuterungen interner Rechte-/Fristenlogik. | Arbeit und Inhalte zuerst; allgemeine Annahmen aus dem normalen Arbeitsbereich entfernen. | +| Leere Teilvorgangs- und Querverweisbereiche stehen im Vorgang vor den Unterlagen. | Inhalte und Handlungsbedarf unmittelbar erreichbar; selten benötigte Struktur ergänzend darstellen. | +| Vorgangsübersicht verweist zum Anlegen auf eine Akte. | Vorgang direkt und ohne verpflichtende Aktenzuordnung anlegen können. | +| Hauptnavigation gewichtet Datenräume, Quellen und Nutzer stark; Aufgaben/Fristen fehlen als eigener Einstieg. | Tägliche Arbeit direkt erreichbar; Administration bündeln. | +| Dokumentdialog beginnt mit Entfernen, globalem Löschen und Einbindungsverwaltung. | Inhalt/Vorschau und Lesen/Bearbeiten priorisieren. | +| Technische Aktionsereignisse füllen die Chronologie. | Fachliche Ordnung, fachlichen Verlauf und Änderungsprotokoll trennen. | +| Akte zeigt einen leeren Unterlagenbereich, obwohl ein enthaltener Vorgang eine Unterlage hat. | Direkte Inhalte und Inhalte untergeordneter Vorgänge verständlich unterscheiden. | +| Dialog „Vorgang anlegen“ schließt mit „Vorgang verbinden“. | Aktionen eindeutig nach ihrer tatsächlichen Wirkung benennen. | + +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. + +## 3. Arbeitsablauf als Maßstab + +Der folgende Ablauf muss mit der überarbeiteten Anwendung durchgängig möglich sein: + +1. Einen Vorgang direkt anlegen, zunächst auch ohne Akte. +2. Den Vorgang bei Bedarf einer vorhandenen Akte zuordnen. +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. +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. + +Die Oberfläche muss den aktuellen Kontext und die Wirkung von Änderungen verständlich machen, ohne auf jeder Seite das vollständige Berechtigungsmodell zu erklären. + +## 4. Navigation und Startseite + +Die Hauptnavigation enthält die täglichen Arbeitsbereiche: + +- Übersicht +- Vorgänge +- Akten +- Aufgaben & Fristen + +Quellen, Nutzerverwaltung und Datenraumverwaltung werden in einem verständlich benannten Verwaltungs-/Einstellungsbereich gebündelt. Vorhandene Funktionen bleiben dort erreichbar. Eine vorhandene Auswahl des aktuellen Datenraums bleibt im Arbeitsbereich sichtbar, soweit sie für die Bedienung erforderlich ist; sie muss klar von dessen Verwaltung unterschieden sein. Die bestehende Suche bleibt leicht zugänglich. + +Die Übersicht zeigt offene Aufgaben, anstehende und überfällige Fristen sowie zuletzt verwendete oder zuletzt bearbeitete sichtbare Vorgänge. Eine einfache zuletzt-bearbeitet-Liste genügt; kein neues umfassendes Nutzungs-Tracking aufbauen. „Vorgang anlegen“ ist eine direkt erreichbare Hauptaktion. Keine zusätzlichen dekorativen Kennzahlen ohne Arbeitsnutzen. + +Aufgaben & Fristen bietet eine zentrale, filterbare Sicht mit klar erkennbarer Zuordnung zum lesbaren Fachobjekt. Die Trennung beider Sachverhalte bleibt auch bei gemeinsamer Darstellung verständlich. Nur lesbare Herkunftsobjekte verlinken; bestehende Regeln für eigenständige Aufgaben beibehalten. + +## 5. Hierarchie und Kontext + +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. +- 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. + +## 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. + +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: + +- **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. + +## 7. Fachliche Daten und Ordnung der Inhalte + +### 7.1 Datumsbedeutung + +Die Inhaltsliste zeigt je Eintrag mindestens Titel, Typ und das vorhandene fachliche Datum mit verständlicher Bedeutung. Bei Schreiben ist das regelmäßig das Dokumentdatum, bei einer Notiz oder einem fachlichen Ereignis ein ausdrücklich erfasstes Bezugs-/Ereignisdatum. + +- Dokumentdatum, Versanddatum, Zugangsdatum und technisches Erfassungsdatum bleiben semantisch getrennt. Bestehende Werte erhalten ihre Bedeutung. +- Bei Erfassung und Bearbeitung ist das fachliche Datum leicht erreichbar und optional. Fehlende Daten werden als „Ohne Datum“ erkennbar, ohne Pflicht zu erfundenen Angaben. +- Das Erfassungsdatum wird nicht stillschweigend als Dokument- oder Ereignisdatum verwendet. Dokumenttitel werden nicht automatisch als zuverlässige Datumsquelle interpretiert. +- Eine Metadatenänderung an einem gemeinsam verwendeten Element kann mehrere Kontexte betreffen. Bestehende Berechtigungs- und gemeinsame Änderungsregeln gelten weiter. Für unterschiedliche Aktenordnungen dient die kontextbezogene Position. +- Deutsche Datumsdarstellung verwenden. Technische Zeitstempel im Änderungsprotokoll verständlich lokal anzeigen; Rohwerte und Zeitzonen bleiben bei Bedarf nachvollziehbar. + +### 7.2 Zwei einfache Ordnungsarten + +| Ordnungsart | Verhalten | +|---|---| +| Fachliches Datum | Aufsteigend oder absteigend wählbar; die Richtung ist sichtbar. Undatierte Einträge stehen in beiden Richtungen in einer klar erkennbaren Gruppe am Ende. | +| Eigene Reihenfolge | Nutzer ordnen Einträge gezielt, beispielsweise Schreiben vor Anlage oder Begründung vor Beleg. Das Datum bleibt sichtbar, bestimmt hier aber die Position nicht. | + +Weitere frei kombinierbare Sortierregeln oder ein allgemeiner Regelbaukasten sind kein MVP-Ziel. Eine zusätzliche einfache Titelsortierung ist optional und darf die beiden erforderlichen Modi nicht verzögern. + +### 7.3 Speicherung und Interaktion + +- Eigene Positionen gehören zur Einbindung im jeweiligen Container, nicht zum globalen Dokument. Dieselbe Unterlage kann in Akte A zuerst und in Vorgang B zuletzt stehen. +- Eine Inhaltsordnung innerhalb desselben Vorgangs bleibt dessen Ordnung, auch wenn der Vorgang über unterschiedliche Akten geöffnet wird. Die Position des Vorgangs innerhalb einer Akte gehört dagegen zu seiner dortigen Zuordnung. +- Gewählter Ordnungsmodus, Richtung und eigene Reihenfolge bleiben nach Neuladen und erneutem Anmelden erhalten. Für den MVP gilt eine gemeinsame gespeicherte Ordnung je Container; persönliche Sortierprofile sind nicht erforderlich. Änderungen daran benötigen das passende Bearbeitungsrecht im geprüften Kontext. +- Innerhalb von Kapiteln gilt die gewählte Inhaltsordnung. Die Kapitel selbst bleiben in ihrer eigenen Gliederungsreihenfolge. Ein ungegliederter Bereich bleibt eindeutig. Das Kapitel eines Eintrags wird durch einen Sortierwechsel nicht verändert. +- 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. +- 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. + +Die technische Speicherung kann vorhandene `bindings.position`, Kapitelpositionen und Datumsfelder verwenden. Tabellen-/Feldnamen sind kein neuer Produktvertrag; unnötige parallele Modelle vermeiden. + +## 8. Inhaltsansicht, fachlicher Verlauf und Änderungsprotokoll + +Diese drei Zwecke erhalten getrennte Zugänge: + +| Ansicht | Zweck und Inhalt | +|---|---| +| Inhalte | Fachlich geordnete Unterlagen, Notizen und Gliederung; normale Arbeitsansicht. | +| 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. + +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. + +Fehlt für einen Eintrag ein fachliches Datum, wird dies transparent behandelt; ein technischer Zeitstempel macht ihn nicht nachträglich zu einem datierten fachlichen Ereignis. Eine vollständige neue Ereignis-Engine ist für die Trennung nicht erforderlich. + +## 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. + +- 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. +- „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. + +## 10. Erfassung und Nachverfolgung + +„Vorgang anlegen“ ist in der Vorgangsübersicht verfügbar. Eine Aktenzuordnung ist optional und kann später ergänzt werden. In einer Akte darf die Aktion eindeutig „Vorgang anlegen und zuordnen“ heißen. Eine Auswahl eines bereits existierenden Vorgangs heißt entsprechend „Vorhandenen Vorgang zuordnen“; Anlage und Zuordnung dürfen nicht durch widersprüchliche Beschriftungen vermischt werden. + +Für neue Inhalte genügen klar benannte Einstiege für Notiz, Datei und externe Referenz. Bereits vorhandene E-Mail- oder Paperless-Funktionen bleiben nutzbar; keine neue Importplattform bauen. Kurze Formulare mit Titel, Inhalt/Quelle und optionalem fachlichem Datum; weitere Optionen bei Bedarf. Gewählter Zielkontext und gegebenenfalls Kapitel müssen erkennbar sein. Nach dem Speichern erscheint der Eintrag im Ziel und an der erklärbaren Position. + +„Aufgabe hinzufügen“ und „Frist erfassen“ erhalten eindeutige Einstiege. Ein gemeinsamer Dialog mit einer verständlichen Auswahl ist zulässig; zwei gleichzeitig offene, konkurrierende Formulare vermeiden. Arbeitstermin einer Aufgabe und maßgebliche Frist klar beschriften. Aufgabe erledigen und Frist als erfüllt kennzeichnen bleiben getrennte Aktionen. Lange allgemeine Erklärungen durch kurze kontextuelle Hilfen ersetzen. + +Formulare zeigen Fehler am betroffenen Feld, sichern Eingaben bei fehlgeschlagenem Speichern und verhindern unbeabsichtigte Mehrfachanlage. Bei tatsächlich ungesicherten Eingaben vor dem Verlassen warnen; leere Dialoge ohne unnötige Rückfrage schließen lassen. + +## 11. Visuelle und responsive Umsetzung + +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. +- 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. +- 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 + +Die bestehende Anwendung wird gezielt weiterentwickelt: produktlokal mit FastAPI, PostgreSQL und React gemäß Repository und geltenden Jinkendo-Verträgen. Keine neue Architekturinventur und kein pauschaler Neubau. Die konkreten Blueprint-Quellen sind im technischen Entwurf und im historischen [Technik-Handoff](TECHNICAL_SPEC_HANDOFF.md) verzeichnet; dortige frühere Auftragsgrenzen gelten für jene damalige Spezifikationsetappe. + +Der Agent prüft zunächst aktuellen Code, `AGENTS.md`, Tests und Arbeitsstand. Nicht zugehörige lokale Änderungen bleiben unberührt. Für erforderliche neue persistente Ordnungsangaben gezielte Migrationen mit erhaltendem Umgang mit Bestandsdaten erstellen. Vorhandene manuelle Reihenfolgen und fachliche Daten erhalten; keine Reset-/Seed-Lösung für einen bestehenden Datenbestand. + +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. + +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 + +| 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-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-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. | + +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. + +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. + +## 14. Arbeitsauftrag und Abschluss + +Bei ausdrücklicher Beauftragung der Umsetzung auf Basis dieser Ergänzung gilt: + +1. Bestehenden Stand gezielt prüfen; knapp festhalten, welche Komponenten erhalten und welche angepasst werden. +2. Den beschriebenen Arbeitsablauf durchgängig umsetzen, einschließlich benötigter Persistenz und Rechteprüfung. Nicht nach einer weiteren Konzept- oder Grundlagenphase aufhören. +3. Technischen Entwurf nur an den tatsächlich betroffenen Stellen anpassen, falls Schnittstellen oder Speicherung abweichen. Keine zweite vollständige Spezifikation erzeugen. +4. Technisch und visuell prüfen; erkennbare Bedienprobleme und Regressionen im Auftrag beheben. Routinefragen selbst entscheiden. Nur echte fachliche Widersprüche oder nicht auflösbare Blockaden knapp mit Empfehlung melden und an unabhängigen Teilen weiterarbeiten. +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. diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx index 758c454..f5b8be1 100644 --- a/frontend/src/App.jsx +++ b/frontend/src/App.jsx @@ -11,6 +11,9 @@ import { Rooms } from "./pages/Rooms.jsx"; import { Search } from "./pages/Search.jsx"; import { Sources } from "./pages/Sources.jsx"; import { Users } from "./pages/Users.jsx"; +import { Work } from "./pages/Work.jsx"; +import { Settings } from "./pages/Settings.jsx"; +import { Reader } from "./pages/Reader.jsx"; export function App() { const [session, setSession] = useState(undefined); @@ -78,6 +81,10 @@ export function App() { } /> } /> } /> + } /> + } /> + } /> + } /> } /> } /> } /> diff --git a/frontend/src/api.js b/frontend/src/api.js index 0cf7b7c..a3f75f1 100644 --- a/frontend/src/api.js +++ b/frontend/src/api.js @@ -84,6 +84,20 @@ export async function fetchPaperless(elementId, context) { return response.blob(); } +export async function fetchFile(elementId, context) { + const params = new URLSearchParams(); + if (context?.kind && context?.id) { + params.set("context_kind", context.kind); + params.set("context_id", context.id); + } + const response = await fetch(`/api/v1/files/${elementId}/content?${params}`, { + credentials: "include", + headers: scopeHeaders(), + }); + if (!response.ok) throw new Error("Die Datei ist nicht verfügbar."); + return response.blob(); +} + export async function downloadFile(elementId, context, filename) { const params = new URLSearchParams(); if (context?.kind && context?.id) { diff --git a/frontend/src/pages/Cases.jsx b/frontend/src/pages/Cases.jsx index 2af31b5..7189197 100644 --- a/frontend/src/pages/Cases.jsx +++ b/frontend/src/pages/Cases.jsx @@ -4,7 +4,8 @@ import { api, markDirty, textToDocument } from "../api.js"; import { SessionContext } from "../session.js"; import { Modal } from "./Modal.jsx"; import { MailPicker, PaperlessPicker } from "./Sources.jsx"; -import { BindingList, Chronology, ErrorNote, ShareBox } from "./widgets.jsx"; +import { ErrorNote, ShareBox } from "./widgets.jsx"; +import { ContentBoard, RecordTabs, Trail } from "./content.jsx"; export function CaseList() { const { session } = useContext(SessionContext); @@ -101,19 +102,13 @@ export function CaseList() { export function CaseDetail() { const { id } = useParams(); const [record, setRecord] = useState(null); - const [events, setEvents] = useState([]); const [error, setError] = useState(""); const [modal, setModal] = useState(""); - const [selected, setSelected] = useState(null); const context = { kind: "case", id }; async function load() { - const [detail, chronology] = await Promise.all([ - api(`/api/v1/cases/${id}`), - api(`/api/v1/cases/${id}/chronology`), - ]); + const detail = await api(`/api/v1/cases/${id}`); setRecord(detail); - setEvents(chronology.items); } useEffect(() => { @@ -127,76 +122,76 @@ export function CaseDetail() {
- {record.parent_case_id && record.parent_title ? ( -

Akte {record.parent_title}

- ) : null} -

{record.home_scope_name}

+ +

{record.kind_label || "Akte"} · {record.home_scope_name}

{record.title}

-

{rightsText(record.rights)} {record.status === "open" ? "Offen" : "Geschlossen"}.

+

{record.status === "open" ? "Offen" : "Geschlossen"}

+ {record.rights.edit ? : null}
-
-

Vorgänge

- {record.rights.edit ? : null} -
- {record.matters.length ? ( -
- {record.matters.map((matter) => ( - - Vorgang - {matter.title} - {matter.status === "open" ? "Offen" : "Geschlossen"} - - ))} +

Direkt in dieser Akte

+ `/cases/${id}/items/${binding.id}`} + /> +
+ {record.contained?.length ? ( +
+

In enthaltenen Vorgängen

+ {record.contained.map((group) => ( +
+

Aus dem Vorgang {group.title}

+ `/matters/${group.matter_id}/items/${binding.id}?context_kind=case&context_id=${id}`} + /> +
+ ))} +
+ ) : null} +
+ Struktur und Zuordnung +
+
+ {record.rights.edit ? : null} + {record.rights.edit ? : null} + {record.rights.edit ? : null} + {record.rights.edit ? : null} + {record.rights.share || record.is_owner ? : null}
- ) : ( -

Diese Akte hat noch keinen Vorgang.

- )} - -
-
-

Unterlagen

- {record.rights.edit ? : null} + {record.matters.length ? ( +
    + {record.matters.map((matter) => ( +
  • Vorgang {matter.title}
  • + ))} +
+ ) :

Noch kein zugeordneter Vorgang.

} + {record.subcases?.length ? ( +
    + {record.subcases.map((item) => ( +
  • Unterakte {item.title}
  • + ))} +
+ ) : null}
-
-
-
-

Unterakten

- {record.rights.edit ? : null} -
- {record.subcases?.length ? ( -
- {record.subcases.map((item) => ( - - Unterakte - {item.title} - {item.rights_mode === "explicit" ? "Eigene Rechte" : "Rechte der Akte"} - - ))} -
- ) : ( -

Keine Unterakte. Ein eigener Bereich mit abweichenden Rechten wird hier angelegt.

- )} -
-
-
-

Kapitel

- {record.rights.edit ? : null} -
- -
-
- {record.rights.share || record.is_owner ? : null} -
-
-

Chronologie

- -
- setModal("")}> +
+ + setModal("")}> { setModal(""); load(); }} /> + setModal("")}> + { setModal(""); load(); }} /> + setModal("")}>
@@ -226,11 +221,6 @@ export function CaseDetail() { setModal("")}> - setSelected(null)}> - {selected ? ( - { setSelected(null); load(); }} /> - ) : null} -
); } @@ -284,10 +274,13 @@ function sourceKind(element) { function NewMatter({ caseId, homeScopeId, onChange }) { const [title, setTitle] = useState(""); const [error, setError] = useState(""); + const [pending, setPending] = useState(false); async function submit(event) { event.preventDefault(); + if (pending) return; setError(""); + setPending(true); try { const matter = await api("/api/v1/matters", { method: "POST", body: { title, ...(homeScopeId ? { home_scope_id: homeScopeId } : {}) } }); await api(`/api/v1/matters/${matter.id}/case-links`, { method: "POST", body: { case_id: caseId } }); @@ -296,14 +289,51 @@ function NewMatter({ caseId, homeScopeId, onChange }) { onChange(); } catch (err) { setError(err.message); + } finally { + setPending(false); } } return (

Vorgang anlegen und zuordnen

- { setTitle(event.target.value); markDirty(true); }} placeholder="Zum Beispiel Mängelanzeige" required /> - + + + + + ); +} + +function AssignMatter({ caseId, onChange }) { + const [matters, setMatters] = useState([]); + const [matterId, setMatterId] = useState(""); + const [error, setError] = useState(""); + + useEffect(() => { + api("/api/v1/matters").then((data) => setMatters(data.items)).catch((err) => setError(err.message)); + }, []); + + async function submit(event) { + event.preventDefault(); + setError(""); + try { + await api(`/api/v1/matters/${matterId}/case-links`, { method: "POST", body: { case_id: caseId } }); + onChange(); + } catch (err) { + setError(err.message); + } + } + + return ( +
+ + ); @@ -375,12 +405,16 @@ function chapterSelect(chapters, value, setValue) { export function NoteForm({ context, placement, chapters, onChange }) { const [title, setTitle] = useState(""); const [text, setText] = useState(""); + const [documentOn, setDocumentOn] = useState(""); const [chapterId, setChapterId] = useState(""); const [error, setError] = useState(""); + const [pending, setPending] = useState(false); async function submit(event) { event.preventDefault(); + if (pending) return; setError(""); + setPending(true); try { await api("/api/v1/notes", { method: "POST", @@ -390,24 +424,29 @@ export function NoteForm({ context, placement, chapters, onChange }) { context, ...(placement ? { placement } : {}), ...(chapterId ? { chapter_id: chapterId } : {}), + ...(documentOn ? { dates: { document_on: documentOn } } : {}), }, }); setTitle(""); setText(""); + setDocumentOn(""); markDirty(false); onChange(); } catch (err) { setError(err.message); + } finally { + setPending(false); } } return (

Notiz

- { setTitle(event.target.value); markDirty(true); }} placeholder="Titel" required /> -