Ordne Akten und Vorgaenge nach fachlichem Datum oder eigener Reihenfolge und mache den Inhalt zur Arbeitsansicht.
Deploy Development / deploy (push) Successful in 22s
Test Suite / pytest-backend (push) Successful in 51s
Test Suite / smoke-dev (push) Successful in 1s
Test Suite / frontend-build (push) Successful in 6s

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
LarsandCursor committed 2026-10-17 09:36:48 +02:00
1 parent 27925093e2
commit 52bda91aad
22 files changed
+2079 -258

No files matched your search

+154 -3
View File
@@ -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"],
+22
View File
@@ -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):
+125 -9
View File
@@ -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)
+25
View File
@@ -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
+127 -22
View File
@@ -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",
}
@@ -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'));
+371
View File
@@ -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"]]
@@ -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
+13 -1
View File
@@ -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.
+226
View File
@@ -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.
+7
View File
@@ -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() {
<Route path="cases/:id" element={<CaseDetail />} />
<Route path="matters" element={<MatterList />} />
<Route path="matters/:id" element={<MatterDetail />} />
<Route path="matters/:id/items/:bindingId" element={<Reader />} />
<Route path="cases/:id/items/:bindingId" element={<Reader />} />
<Route path="work" element={<Work />} />
<Route path="settings" element={<Settings />} />
<Route path="rooms" element={<Rooms />} />
<Route path="sources" element={<Sources />} />
<Route path="users" element={<Users />} />
+14
View File
@@ -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) {
+118 -79
View File
@@ -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() {
<main className="page">
<header className="page-head">
<div>
{record.parent_case_id && record.parent_title ? (
<p className="crumb"><Link to={`/cases/${record.parent_case_id}`}>Akte {record.parent_title}</Link></p>
) : null}
<p className="eyebrow">{record.home_scope_name}</p>
<Trail items={record.trail} />
<p className="eyebrow">{record.kind_label || "Akte"} · {record.home_scope_name}</p>
<h1>{record.title}</h1>
<p className="muted">{rightsText(record.rights)} {record.status === "open" ? "Offen" : "Geschlossen"}.</p>
<p className="muted">{record.status === "open" ? "Offen" : "Geschlossen"}</p>
</div>
{record.rights.edit ? <button type="button" onClick={() => setModal("add")}>Inhalt hinzufügen</button> : null}
</header>
<ErrorNote error={error} />
<section className="section">
<div className="section-bar">
<h2>Vorgänge</h2>
{record.rights.edit ? <button type="button" onClick={() => setModal("matter")}>Vorgang anlegen</button> : null}
</div>
{record.matters.length ? (
<div className="tiles">
{record.matters.map((matter) => (
<Link key={matter.id} className="tile" to={`/matters/${matter.id}?context_kind=case&context_id=${id}`}>
<span className="tile__kind">Vorgang</span>
<strong>{matter.title}</strong>
<span>{matter.status === "open" ? "Offen" : "Geschlossen"}</span>
</Link>
))}
<h2>Direkt in dieser Akte</h2>
<ContentBoard
record={record}
containerKind="case"
containerId={id}
onChange={load}
itemHref={(binding) => `/cases/${id}/items/${binding.id}`}
/>
</section>
{record.contained?.length ? (
<section className="section">
<h2>In enthaltenen Vorgängen</h2>
{record.contained.map((group) => (
<div key={group.matter_id} className="contained">
<p className="muted">Aus dem Vorgang <Link to={`/matters/${group.matter_id}?context_kind=case&context_id=${id}`}>{group.title}</Link></p>
<ContentBoard
record={{ ...record, rights: { edit: false }, bindings: group.bindings, content_order: group.content_order, content_order_dir: group.content_order_dir }}
bindings={group.bindings}
sortable={false}
containerKind="matter"
containerId={group.matter_id}
onChange={load}
itemHref={(binding) => `/matters/${group.matter_id}/items/${binding.id}?context_kind=case&context_id=${id}`}
/>
</div>
))}
</section>
) : null}
<details className="fold">
<summary>Struktur und Zuordnung</summary>
<div className="stack">
<div className="row">
{record.rights.edit ? <button type="button" className="quiet" onClick={() => setModal("matter")}>Vorgang anlegen und zuordnen</button> : null}
{record.rights.edit ? <button type="button" className="quiet" onClick={() => setModal("assign")}>Vorhandenen Vorgang zuordnen</button> : null}
{record.rights.edit ? <button type="button" className="quiet" onClick={() => setModal("subcase")}>Unterakte anlegen</button> : null}
{record.rights.edit ? <button type="button" className="quiet" onClick={() => setModal("chapter")}>Kapitel anlegen</button> : null}
{record.rights.share || record.is_owner ? <button type="button" className="quiet" onClick={() => setModal("share")}>Teilen</button> : null}
</div>
) : (
<p className="muted">Diese Akte hat noch keinen Vorgang.</p>
)}
</section>
<section className="section">
<div className="section-bar">
<h2>Unterlagen</h2>
{record.rights.edit ? <button type="button" onClick={() => setModal("add")}>Hinzufügen</button> : null}
{record.matters.length ? (
<ul className="tree">
{record.matters.map((matter) => (
<li key={matter.id}><Link to={`/matters/${matter.id}?context_kind=case&context_id=${id}`}>Vorgang {matter.title}</Link></li>
))}
</ul>
) : <p className="muted">Noch kein zugeordneter Vorgang.</p>}
{record.subcases?.length ? (
<ul className="tree">
{record.subcases.map((item) => (
<li key={item.id} className="tree__child"><Link to={`/cases/${item.id}`}>Unterakte {item.title}</Link></li>
))}
</ul>
) : null}
</div>
</section>
<section className="section">
<div className="section-bar">
<h2>Unterakten</h2>
{record.rights.edit ? <button type="button" onClick={() => setModal("subcase")}>Unterakte anlegen</button> : null}
</div>
{record.subcases?.length ? (
<div className="tiles">
{record.subcases.map((item) => (
<Link key={item.id} className="tile" to={`/cases/${item.id}`}>
<span className="tile__kind">Unterakte</span>
<strong>{item.title}</strong>
<span>{item.rights_mode === "explicit" ? "Eigene Rechte" : "Rechte der Akte"}</span>
</Link>
))}
</div>
) : (
<p className="muted">Keine Unterakte. Ein eigener Bereich mit abweichenden Rechten wird hier angelegt.</p>
)}
</section>
<section className="section">
<div className="section-bar">
<h2>Kapitel</h2>
{record.rights.edit ? <button type="button" onClick={() => setModal("chapter")}>Kapitel anlegen</button> : null}
</div>
<ChapterBoard chapters={record.chapters} bindings={record.bindings} onOpen={setSelected} />
</section>
<div className="row">
{record.rights.share || record.is_owner ? <button type="button" className="quiet" onClick={() => setModal("share")}>Teilen</button> : null}
</div>
<section className="section">
<h2>Chronologie</h2>
<Chronology items={events} />
</section>
<Modal open={modal === "matter"} title="Vorgang anlegen" onClose={() => setModal("")}>
</details>
<RecordTabs coursePath={`/api/v1/cases/${id}/course`} auditPath={`/api/v1/cases/${id}/chronology`} />
<Modal open={modal === "matter"} title="Vorgang anlegen und zuordnen" onClose={() => setModal("")}>
<NewMatter caseId={id} homeScopeId={record.home_scope_id} onChange={() => { setModal(""); load(); }} />
</Modal>
<Modal open={modal === "assign"} title="Vorhandenen Vorgang zuordnen" onClose={() => setModal("")}>
<AssignMatter caseId={id} onChange={() => { setModal(""); load(); }} />
</Modal>
<Modal open={modal === "add"} title="Hinzufügen" onClose={() => setModal("")}>
<div className="choice">
<button type="button" onClick={() => setModal("note")}>Notiz</button>
@@ -226,11 +221,6 @@ export function CaseDetail() {
<Modal open={modal === "share"} title="Teilen" onClose={() => setModal("")}>
<ShareBox path={`/api/v1/cases/${id}/grants`} grants={record.grants || []} onChange={load} />
</Modal>
<Modal open={Boolean(selected)} title={selected?.element.title || "Unterlage"} onClose={() => setSelected(null)}>
{selected ? (
<BindingList bindings={[selected]} context={context} canEdit={record.rights.edit} isOwner={record.is_owner} onChange={() => { setSelected(null); load(); }} />
) : null}
</Modal>
</main>
);
}
@@ -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 (
<form onSubmit={submit} className="stack compact">
<h3>Vorgang anlegen und zuordnen</h3>
<input value={title} onChange={(event) => { setTitle(event.target.value); markDirty(true); }} placeholder="Zum Beispiel Mängelanzeige" required />
<button type="submit">Vorgang verbinden</button>
<label>Titel <input value={title} onChange={(event) => { setTitle(event.target.value); markDirty(true); }} required /></label>
<button type="submit" disabled={pending}>{pending ? "Wird angelegt …" : "Vorgang anlegen und zuordnen"}</button>
<ErrorNote error={error} />
</form>
);
}
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 (
<form onSubmit={submit} className="stack compact">
<label>
Vorhandener Vorgang
<select value={matterId} onChange={(event) => setMatterId(event.target.value)} required>
<option value="">Auswählen</option>
{matters.map((item) => <option key={item.id} value={item.id}>{item.title}</option>)}
</select>
</label>
<button type="submit">Vorhandenen Vorgang zuordnen</button>
<ErrorNote error={error} />
</form>
);
@@ -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 (
<form onSubmit={submit} className="stack compact">
<h3>Notiz</h3>
<input value={title} onChange={(event) => { setTitle(event.target.value); markDirty(true); }} placeholder="Titel" required />
<textarea rows={4} value={text} onChange={(event) => { setText(event.target.value); markDirty(true); }} placeholder="Gemeinsamer Text" />
<label>Titel <input value={title} onChange={(event) => { setTitle(event.target.value); markDirty(true); }} required /></label>
<label>Gemeinsamer Text <textarea rows={4} value={text} onChange={(event) => { setText(event.target.value); markDirty(true); }} /></label>
<label>Bezugsdatum, optional <input type="date" value={documentOn} onChange={(event) => setDocumentOn(event.target.value)} /></label>
{chapterSelect(chapters, chapterId, setChapterId)}
<button type="submit">Notiz anlegen</button>
<button type="submit" disabled={pending}>{pending ? "Wird angelegt …" : "Notiz anlegen"}</button>
<ErrorNote error={error} />
</form>
);
+102 -108
View File
@@ -1,11 +1,12 @@
import { useContext, useEffect, useState } from "react";
import { Link, useParams, useSearchParams } from "react-router-dom";
import { api } from "../api.js";
import { Link, useNavigate, useParams, useSearchParams } from "react-router-dom";
import { api, markDirty } 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 { ChapterBoard, ChapterForm, FileForm, NoteForm } from "./Cases.jsx";
import { ErrorNote, ShareBox } from "./widgets.jsx";
import { ChapterForm, FileForm, NoteForm } from "./Cases.jsx";
import { ContentBoard, RecordTabs, Trail, formatDate } from "./content.jsx";
function pageContext(params) {
const kind = params.get("context_kind");
@@ -16,8 +17,13 @@ function pageContext(params) {
export function MatterList() {
const { session } = useContext(SessionContext);
const [items, setItems] = useState([]);
const navigate = useNavigate();
const [params] = useSearchParams();
const [items, setItems] = useState(null);
const [error, setError] = useState("");
const [creating, setCreating] = useState(params.get("neu") === "1");
const [title, setTitle] = useState("");
const [pending, setPending] = useState(false);
async function load() {
const data = await api("/api/v1/matters");
@@ -33,12 +39,12 @@ export function MatterList() {
<header className="page-head">
<div>
<h1>Vorgänge</h1>
<p className="muted">Ein Vorgang gehört in eine Akte. Lege ihn dort an, dann sammelt die Akte die Arbeit.</p>
<p className="muted">Ein Vorgang kann eigenständig beginnen und später einer Akte zugeordnet werden.</p>
</div>
<Link className="quiet linkish" to="/cases">Zu den Akten</Link>
<button type="button" onClick={() => setCreating(true)}>Vorgang anlegen</button>
</header>
<ErrorNote error={error} />
{items.length ? (
{items === null ? <p className="muted">Vorgänge werden geladen …</p> : items.length ? (
<div className="tiles">
{items.map((item) => {
const context = item.contexts?.[0];
@@ -58,8 +64,30 @@ export function MatterList() {
})}
</div>
) : (
<p className="muted">Noch kein Vorgang. Öffne eine Akte und lege ihn dort an.</p>
<p className="muted">Noch kein Vorgang.</p>
)}
<Modal open={creating} title="Vorgang anlegen" onClose={() => setCreating(false)}>
<form className="stack compact" onSubmit={async (event) => {
event.preventDefault();
if (pending) return;
setError("");
setPending(true);
try {
const matter = await api("/api/v1/matters", { method: "POST", body: { title, home_scope_id: session.scope.id } });
markDirty(false);
setCreating(false);
navigate(`/matters/${matter.id}`);
} catch (err) {
setError(err.message);
} finally {
setPending(false);
}
}}>
<label>Titel <input value={title} onChange={(event) => { setTitle(event.target.value); markDirty(true); }} required /></label>
<button type="submit" disabled={pending}>{pending ? "Wird angelegt …" : "Vorgang anlegen"}</button>
<ErrorNote error={error} />
</form>
</Modal>
</main>
);
}
@@ -69,21 +97,15 @@ export function MatterDetail() {
const [params] = useSearchParams();
const inherited = pageContext(params);
const [record, setRecord] = useState(null);
const [events, setEvents] = useState([]);
const [error, setError] = useState("");
const [modal, setModal] = useState("");
const [selected, setSelected] = useState(null);
const rightsContext = inherited || { kind: "matter", id };
const placement = inherited?.kind === "case" ? { kind: "matter", id } : null;
async function load() {
const query = inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : "";
const [detail, chronology] = await Promise.all([
api(`/api/v1/matters/${id}${query}`),
api(`/api/v1/matters/${id}/chronology${query}`),
]);
const detail = await api(`/api/v1/matters/${id}${query}`);
setRecord(detail);
setEvents(chronology.items);
}
useEffect(() => {
@@ -98,96 +120,73 @@ export function MatterDetail() {
<main className="page">
<header className="page-head">
<div>
{record.parent_matter_id && record.parent_title ? (
<p className="crumb">
<Link to={`/matters/${record.parent_matter_id}${inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : ""}`}>
Vorgang {record.parent_title}
</Link>
</p>
) : null}
<p className="eyebrow">{record.home_scope_name}{inherited ? " · über die Akte geöffnet" : ""}</p>
<Trail items={record.trail} />
<p className="eyebrow">{record.kind_label || "Vorgang"} · {record.home_scope_name}{inherited ? " · über die Akte geöffnet" : ""}</p>
<h1>{record.title}</h1>
<p className="muted">{record.status === "open" ? "Offen" : "Geschlossen"}. Eine Aufgabe und eine Frist bleiben unabhängig.</p>
<p className="muted">{record.status === "open" ? "Offen" : "Geschlossen"}</p>
</div>
{record.rights.edit ? <button type="button" onClick={() => setModal("add")}>Inhalt hinzufügen</button> : null}
</header>
<ErrorNote error={error} />
<section className="section">
<h2>Akten</h2>
{record.case_links?.length ? (
<div className="tiles">
{record.case_links.map((link) => (
<Link key={link.id} className="tile" to={`/cases/${link.case_id}`}>
<span className="tile__kind">Akte</span>
<strong>{link.title}</strong>
</Link>
))}
<div className="work-layout">
<section className="section">
<h2>Unterlagen und Notizen</h2>
<ContentBoard
record={record}
context={inherited}
containerKind="matter"
containerId={id}
onChange={load}
itemHref={(binding) => `/matters/${id}/items/${binding.id}${inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : ""}`}
/>
</section>
<aside className="side-work">
<div className="section-bar">
<h2>Aufgaben und Fristen</h2>
{record.rights.edit ? <button type="button" className="quiet" onClick={() => setModal("work")}>Hinzufügen</button> : null}
</div>
) : (
<p className="muted">Dieser Vorgang liegt noch in keiner Akte.</p>
)}
</section>
<section className="section">
<div className="section-bar">
<h2>Teilvorgänge</h2>
{record.rights.edit ? <button type="button" onClick={() => setModal("submatter")}>Teilvorgang anlegen</button> : null}
</div>
{record.submatters?.length ? (
<div className="tiles">
{record.submatters.map((item) => (
<Link key={item.id} className="tile" to={`/matters/${item.id}${inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : ""}`}>
<span className="tile__kind">Teilvorgang</span>
<strong>{item.title}</strong>
<span>{item.status === "open" ? "Offen" : "Geschlossen"}</span>
</Link>
))}
</div>
) : (
<p className="muted">Kein Teilvorgang. Ein untergeordneter Sachverhalt wird hier angelegt.</p>
)}
</section>
<section className="section">
<div className="section-bar">
<h2>Querverweise</h2>
{record.rights.edit ? <button type="button" onClick={() => setModal("cross")}>Querverweis</button> : null}
</div>
{record.cross_links?.length ? (
<div className="tiles">
{record.cross_links.map((item) => (
<Link key={item.id} className="tile" to={`/matters/${item.matter_id}`}>
<span className="tile__kind">Querverweis</span>
<strong>{item.title}</strong>
</Link>
))}
</div>
) : (
<p className="muted">Kein Querverweis. Er zeigt denselben Vorgang woanders, ohne ihn zu kopieren.</p>
)}
</section>
<section className="section">
<div className="section-bar">
<h2>Nachverfolgung</h2>
{record.rights.edit ? <button type="button" onClick={() => setModal("work")}>Aufgabe oder Frist</button> : null}
</div>
<p className="notice">Das Erledigen einer Aufgabe erfüllt eine verknüpfte Frist nicht.</p>
<WorkLists record={record} context={inherited} onChange={load} />
</section>
<section className="section">
<div className="section-bar">
<h2>Unterlagen</h2>
{record.rights.edit ? <button type="button" onClick={() => setModal("add")}>Hinzufügen</button> : null}
</div>
<ChapterBoard chapters={record.chapters} bindings={record.bindings} onOpen={setSelected} />
{record.rights.edit ? (
<button type="button" className="quiet" onClick={() => setModal("chapter")}>Kapitel anlegen</button>
) : null}
</section>
<div className="row">
{record.rights.share || record.is_owner ? <button type="button" className="quiet" onClick={() => setModal("share")}>Teilen</button> : null}
<p className="muted">Erledigen und Erfüllen bleiben getrennte Aktionen.</p>
<WorkLists record={record} context={inherited} onChange={load} />
</aside>
</div>
<section className="section">
<h2>Chronologie</h2>
<Chronology items={events} />
</section>
<details className="fold">
<summary>Struktur und Zuordnung</summary>
<div className="stack">
<div className="row">
{record.rights.edit ? <button type="button" className="quiet" onClick={() => setModal("submatter")}>Teilvorgang anlegen</button> : null}
{record.rights.edit ? <button type="button" className="quiet" onClick={() => setModal("cross")}>Querverweis</button> : null}
{record.rights.edit ? <button type="button" className="quiet" onClick={() => setModal("chapter")}>Kapitel anlegen</button> : null}
{record.rights.share || record.is_owner ? <button type="button" className="quiet" onClick={() => setModal("share")}>Teilen</button> : null}
</div>
{record.case_links?.length ? (
<ul className="tree">
{record.case_links.map((link) => (
<li key={link.id}>Akte <Link to={`/cases/${link.case_id}`}>{link.title}</Link>{inherited?.id === link.case_id ? " · aktueller Weg" : ""}</li>
))}
</ul>
) : <p className="muted">Noch keiner Akte zugeordnet.</p>}
{record.submatters?.length ? (
<ul className="tree">
{record.submatters.map((item) => (
<li key={item.id} className="tree__child">
<Link to={`/matters/${item.id}${inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : ""}`}>Teilvorgang {item.title}</Link>
</li>
))}
</ul>
) : null}
{record.cross_links?.length ? (
<ul className="tree">
{record.cross_links.map((item) => (
<li key={item.id}>Querverweis <Link to={`/matters/${item.matter_id}`}>{item.title}</Link></li>
))}
</ul>
) : null}
</div>
</details>
<RecordTabs
coursePath={`/api/v1/matters/${id}/course${inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : ""}`}
auditPath={`/api/v1/matters/${id}/chronology${inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : ""}`}
/>
<Modal open={modal === "work"} title="Aufgabe oder Frist" onClose={() => setModal("")}>
<WorkForms matterId={id} context={inherited} tasks={record.tasks} onChange={() => { setModal(""); load(); }} />
</Modal>
@@ -223,11 +222,6 @@ export function MatterDetail() {
<Modal open={modal === "share"} title="Teilen" onClose={() => setModal("")}>
<ShareBox path={`/api/v1/matters/${id}/grants`} grants={record.grants || []} onChange={load} />
</Modal>
<Modal open={Boolean(selected)} title={selected?.element.title || "Unterlage"} onClose={() => setSelected(null)}>
{selected ? (
<BindingList bindings={[selected]} context={rightsContext} canEdit={record.rights.edit} isOwner={record.is_owner} onChange={() => { setSelected(null); load(); }} />
) : null}
</Modal>
</main>
);
}
@@ -252,7 +246,7 @@ function WorkLists({ record, context, onChange }) {
}
return (
<div className="split">
<div className="stack">
<div>
<h3>Aufgaben</h3>
<ul className="work">
@@ -260,7 +254,7 @@ function WorkLists({ record, context, onChange }) {
<li key={task.id}>
<div>
<strong>{task.title}</strong>
<span>{task.status === "done" ? "Erledigt" : "Offen"}{task.due_on ? ` · ${task.due_on}` : ""}</span>
<span>{task.status === "done" ? "Erledigt" : "Offen"}{task.due_on ? ` · ${formatDate(task.due_on)}` : ""}</span>
{task.assignee_display_name ? <small>Zugewiesen: {task.assignee_display_name}</small> : null}
{linked.has(task.id) ? <small>Mit einer Frist verknüpft, ohne sie zu erfüllen.</small> : null}
</div>
@@ -276,7 +270,7 @@ function WorkLists({ record, context, onChange }) {
<li key={deadline.id}>
<div>
<strong>{deadline.title}</strong>
<span>{deadline.status === "fulfilled" ? "Erfüllt" : "Offen"} · {deadline.due_on}</span>
<span>{deadline.status === "fulfilled" ? "Erfüllt" : "Offen"} · {formatDate(deadline.due_on)}</span>
</div>
{deadline.status === "open" ? <button type="button" onClick={() => fulfill(deadline)}>Frist erfüllen</button> : null}
</li>
+10 -3
View File
@@ -1,10 +1,17 @@
import { useEffect } from "react";
import { isDirty, markDirty } from "../api.js";
export function Modal({ open, title, onClose, wide = false, children }) {
function requestClose() {
if (isDirty() && !window.confirm("Ungespeicherte Eingaben verwerfen?")) return;
markDirty(false);
onClose();
}
useEffect(() => {
if (!open) return undefined;
function onKey(event) {
if (event.key === "Escape") onClose();
if (event.key === "Escape") requestClose();
}
document.addEventListener("keydown", onKey);
const previous = document.body.style.overflow;
@@ -17,11 +24,11 @@ export function Modal({ open, title, onClose, wide = false, children }) {
if (!open) return null;
return (
<div className="modal-overlay" onClick={(event) => { if (event.target === event.currentTarget) onClose(); }}>
<div className="modal-overlay" onClick={(event) => { if (event.target === event.currentTarget) requestClose(); }}>
<div className={wide ? "modal modal--wide" : "modal"} role="dialog" aria-modal="true" aria-label={title}>
<header className="modal__bar">
<h2>{title}</h2>
<button type="button" className="quiet" onClick={onClose}>Schließen</button>
<button type="button" className="quiet" onClick={requestClose}>Schließen</button>
</header>
{children}
</div>
+48 -23
View File
@@ -1,23 +1,25 @@
import { useEffect, useState } from "react";
import { Link } from "react-router-dom";
import { api } from "../api.js";
import { ErrorNote, RecordLink } from "./widgets.jsx";
import { formatDate } from "./content.jsx";
export function Overview() {
const [tasks, setTasks] = useState([]);
const [deadlines, setDeadlines] = useState([]);
const [loose, setLoose] = useState([]);
const [tasks, setTasks] = useState(null);
const [deadlines, setDeadlines] = useState(null);
const [recent, setRecent] = useState(null);
const [error, setError] = useState("");
async function load() {
try {
const [taskData, deadlineData, elementData] = await Promise.all([
const [taskData, deadlineData, recentData] = await Promise.all([
api("/api/v1/views/open-tasks"),
api("/api/v1/views/open-deadlines"),
api("/api/v1/elements"),
api("/api/v1/views/recent-matters"),
]);
setTasks(taskData.items);
setDeadlines(deadlineData.items);
setLoose(elementData.items);
setRecent(recentData.items);
setError("");
} catch (err) {
setError(err.message);
@@ -51,24 +53,31 @@ export function Overview() {
load();
}
const today = new Date().toISOString().slice(0, 10);
return (
<main className="page">
<section className="assumption">
<strong>Vorläufige Annahmen.</strong> Es gilt nur der Kontext der Aktion. Eine Einbindung zu entfernen löscht das Element nicht.
Globales Löschen bleibt bei der Eigentümerin oder dem Eigentümer. Eine erledigte Aufgabe erfüllt keine Frist.
</section>
<header className="page-head">
<div>
<h1>Übersicht</h1>
<p className="muted">Offene Arbeit und zuletzt bearbeitete Vorgänge.</p>
</div>
<Link className="linkish" to="/matters?neu=1">Vorgang anlegen</Link>
</header>
<ErrorNote error={error} />
{tasks === null ? <p className="muted">Übersicht wird geladen …</p> : (
<>
<div className="split">
<section className="card">
<h2>Offene Aufgaben</h2>
<p className="muted">Über alle Kontexte, die du lesen darfst. Erledigen lässt eine verknüpfte Frist offen.</p>
{tasks.length ? (
{tasks?.length ? (
<ul className="work">
{tasks.map((task) => (
<li key={task.id}>
<div>
<strong>{task.title}</strong>
<span>{task.due_on ? `Arbeitstermin ${task.due_on}` : "Ohne Arbeitstermin"}</span>
<span>{task.due_on ? `Arbeitstermin ${formatDate(task.due_on)}` : "Ohne Arbeitstermin"}</span>
{task.matter_title ? (
<RecordLink kind="matter" id={task.matter_id} title={task.matter_title} context={task.action_context} />
) : null}
@@ -84,13 +93,13 @@ export function Overview() {
<section className="card">
<h2>Offene Fristen</h2>
<p className="muted">Eine Frist bleibt bestehen, bis sie selbst als erfüllt gekennzeichnet wird.</p>
{deadlines.length ? (
{deadlines?.length ? (
<ul className="work">
{deadlines.map((deadline) => (
<li key={deadline.id}>
<div>
<strong>{deadline.title}</strong>
<span>Frist {deadline.due_on}</span>
<span>{deadline.due_on < today ? "Überfällig" : "Offen"} · Frist {formatDate(deadline.due_on)}</span>
{deadline.matter_title ? (
<RecordLink kind="matter" id={deadline.matter_id} title={deadline.matter_title} context={deadline.action_context} />
) : null}
@@ -104,16 +113,32 @@ export function Overview() {
)}
</section>
</div>
{loose.length ? (
<section className="card">
<h2>Eigene Elemente ohne Einbindung</h2>
<ul>
{loose.map((item) => (
<li key={item.id}>{item.title}</li>
))}
<section className="card">
<h2>Zuletzt bearbeitete Vorgänge</h2>
{recent?.length ? (
<ul className="work">
{recent.map((item) => {
const context = item.contexts?.find((entry) => entry.kind === "case") || item.contexts?.[0];
const params = new URLSearchParams();
if (context && context.kind !== "direct") {
params.set("context_kind", context.kind);
params.set("context_id", context.id);
}
const suffix = params.toString() ? `?${params}` : "";
return (
<li key={item.id}>
<div>
<strong><Link to={`/matters/${item.id}${suffix}`}>{item.title}</Link></strong>
<span>{item.status === "open" ? "Offen" : "Geschlossen"}</span>
</div>
</li>
);
})}
</ul>
</section>
) : null}
) : <p className="muted">Noch kein Vorgang.</p>}
</section>
</>
)}
</main>
);
}
+217
View File
@@ -0,0 +1,217 @@
import { useEffect, useState } from "react";
import { Link, useLocation, useNavigate, useParams, useSearchParams } from "react-router-dom";
import { api, documentToText, fetchFile, fetchPaperless, markDirty, textToDocument } from "../api.js";
import { ErrorNote } from "./widgets.jsx";
import { formatDate, kindLabel, Trail } from "./content.jsx";
function pageContext(params) {
const kind = params.get("context_kind");
const id = params.get("context_id");
if (!kind || !id || kind === "direct") return null;
return { kind, id };
}
export function Reader() {
const location = useLocation();
const kind = location.pathname.startsWith("/cases") ? "cases" : "matters";
const { id, bindingId } = useParams();
const [params] = useSearchParams();
const inherited = pageContext(params);
const [record, setRecord] = useState(null);
const [error, setError] = useState("");
const [previewUrl, setPreviewUrl] = useState("");
const [text, setText] = useState("");
const [note, setNote] = useState("");
const [documentOn, setDocumentOn] = useState("");
const [notice, setNotice] = useState("");
const navigate = useNavigate();
const context = kind === "cases" ? { kind: "case", id } : (inherited || { kind: "matter", id });
const query = kind === "matters" && inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : "";
async function load() {
const detail = await api(`/api/v1/${kind}/${id}${query}`);
const pools = [...(detail.bindings || [])];
for (const group of detail.contained || []) pools.push(...group.bindings);
const binding = pools.find((item) => item.id === bindingId);
if (!binding) {
setRecord(detail);
setError("Diese Unterlage ist in dieser Ansicht nicht sichtbar.");
return;
}
setRecord({ ...detail, binding });
setText(binding.element.kind === "note" ? documentToText(binding.element.document) : "");
setDocumentOn(binding.element.dates?.document_on || "");
setError("");
}
useEffect(() => {
setRecord(null);
setPreviewUrl((current) => {
if (current) URL.revokeObjectURL(current);
return "";
});
load().catch((err) => setError(err.message));
}, [kind, id, bindingId, query]);
useEffect(() => () => {
if (previewUrl) URL.revokeObjectURL(previewUrl);
}, [previewUrl]);
if (error && !record?.binding) {
return <main className="page"><ErrorNote error={error} /><p><Link to={`/${kind}/${id}${query}`}>Zurück</Link></p></main>;
}
if (!record?.binding) return <main className="page"><p className="muted">Unterlage wird geladen …</p></main>;
const binding = record.binding;
const element = binding.element;
const back = `/${kind}/${id}${query}`;
async function openFile() {
setError("");
try {
const blob = element.kind === "external_ref"
? await fetchPaperless(element.id, context)
: await fetchFile(element.id, context);
if (previewUrl) URL.revokeObjectURL(previewUrl);
setPreviewUrl(URL.createObjectURL(blob));
} catch (err) {
setError(err.message);
}
}
async function saveNote(event) {
event.preventDefault();
setError("");
try {
const updated = await api(`/api/v1/notes/${element.id}`, {
method: "PATCH",
body: { expected_version: element.version, document: textToDocument(text), context },
});
markDirty(false);
setNotice(updated.notice || "Der gemeinsame Text ist gespeichert.");
load();
} catch (err) {
setError(err.message);
}
}
async function saveDate(event) {
event.preventDefault();
setError("");
try {
await api(`/api/v1/elements/${element.id}/dates`, {
method: "PATCH",
body: {
expected_version: element.version,
document_on: documentOn || null,
sent_on: element.dates?.sent_on || null,
received_on: element.dates?.received_on || null,
context,
},
});
markDirty(false);
load();
} catch (err) {
setError(err.message);
}
}
async function annotate(event) {
event.preventDefault();
const search = new URLSearchParams();
search.set("context_kind", context.kind);
search.set("context_id", context.id);
try {
await api(`/api/v1/bindings/${binding.id}/annotations?${search}`, { method: "POST", body: { body: note } });
setNote("");
markDirty(false);
load();
} catch (err) {
setError(err.message);
}
}
async function detach() {
if (!window.confirm("Aus diesem Zusammenhang entfernen? Die Unterlage bleibt an anderen Stellen erhalten.")) return;
const search = new URLSearchParams();
search.set("context_kind", context.kind);
search.set("context_id", context.id);
await api(`/api/v1/bindings/${binding.id}?${search}`, { method: "DELETE" });
navigate(back);
}
async function destroy() {
if (!window.confirm("Überall löschen? Alle Einbindungen verschwinden. Eine Paperless-Quelle bleibt unangetastet.")) return;
await api(`/api/v1/elements/${element.id}/delete`, { method: "POST", body: { expected_version: element.version } });
navigate(back);
}
return (
<main className="page reader">
<Trail items={[...(record.trail || []).map((item, index, all) => (index === all.length - 1 ? { ...item, href: back } : item)), { label: element.title, href: null }]} />
<p><Link to={back}>{kind === "cases" ? "Zurück zur Akte" : "Zurück zum Vorgang"}</Link></p>
<header className="page-head">
<div>
<p className="eyebrow">{kindLabel(element.kind)}</p>
<h1>{element.title}</h1>
<p className="muted">Fachliches Datum: {formatDate(element.dates?.document_on)}</p>
</div>
</header>
<ErrorNote error={error} />
{element.kind === "note" ? (
<form className="stack" onSubmit={saveNote}>
<label>
Gemeinsamer Text
<textarea rows={8} value={text} disabled={!binding.rights.edit} onChange={(event) => { setText(event.target.value); markDirty(true); }} />
</label>
<p className="muted">Diese Änderung betrifft den gemeinsamen Inhalt der Notiz.</p>
{notice ? <p className="notice">{notice}</p> : null}
{binding.rights.edit ? <button type="submit">Text speichern</button> : <p className="muted">In diesem Kontext nur lesbar.</p>}
</form>
) : (
<div className="stack">
<button type="button" onClick={openFile}>{element.kind === "external_ref" ? "Paperless öffnen" : "Datei öffnen"}</button>
{previewUrl ? <iframe className="preview" title={element.title} src={previewUrl} /> : null}
</div>
)}
{binding.rights.edit ? (
<form className="stack" onSubmit={saveDate}>
<label>
{element.kind === "note" ? "Bezugsdatum, optional" : "Dokumentdatum, optional"}
<input type="date" value={documentOn} onChange={(event) => { setDocumentOn(event.target.value); markDirty(true); }} />
</label>
<button type="submit" className="quiet">Datum speichern</button>
</form>
) : null}
<section className="section">
<h2>Anmerkung in diesem Zusammenhang</h2>
<p className="muted">Die Anmerkung gilt nur hier, nicht für den gemeinsamen Inhalt.</p>
{binding.annotations?.length ? (
<ul className="notes">
{binding.annotations.map((item) => (
<li key={item.id}><strong>{item.author_display_name}</strong> {item.body}</li>
))}
</ul>
) : <p className="muted">Noch keine Anmerkung.</p>}
{binding.rights.edit ? (
<form className="stack" onSubmit={annotate}>
<label>
Neue Anmerkung
<textarea rows={3} value={note} onChange={(event) => { setNote(event.target.value); markDirty(true); }} required />
</label>
<button type="submit" className="quiet">Anmerkung speichern</button>
</form>
) : null}
</section>
<details className="fold">
<summary>Weitere Aktionen</summary>
<div className="row">
{record.rights?.edit ? <button type="button" className="quiet" onClick={detach}>Aus diesem Zusammenhang entfernen</button> : null}
{record.is_owner ? <button type="button" className="danger" onClick={destroy}>Überall löschen</button> : null}
</div>
</details>
</main>
);
}
+36
View File
@@ -0,0 +1,36 @@
import { useContext } from "react";
import { Link } from "react-router-dom";
import { SessionContext } from "../session.js";
export function Settings() {
const { session } = useContext(SessionContext);
return (
<main className="page">
<header className="page-head">
<div>
<h1>Verwaltung</h1>
<p className="muted">Datenräume, Quellen und Nutzer. Das ist nicht die tägliche Aktenarbeit.</p>
</div>
</header>
<div className="tiles">
<Link className="tile" to="/rooms">
<span className="tile__kind">Verwaltung</span>
<strong>Datenräume</strong>
<span>Räume anlegen und wechseln</span>
</Link>
<Link className="tile" to="/sources">
<span className="tile__kind">Verwaltung</span>
<strong>Quellen</strong>
<span>Paperless und E-Mail</span>
</Link>
{session?.account?.is_superadmin ? (
<Link className="tile" to="/users">
<span className="tile__kind">Verwaltung</span>
<strong>Nutzer</strong>
<span>Konten anlegen</span>
</Link>
) : null}
</div>
</main>
);
}
+11 -10
View File
@@ -2,24 +2,22 @@ import { useContext, useState } from "react";
import { NavLink, Outlet, useNavigate } from "react-router-dom";
import { SessionContext } from "../session.js";
const NAV = [
const WORK = [
{ to: "/", end: true, label: "Übersicht", icon: "home" },
{ to: "/cases", label: "Akten", icon: "folder" },
{ to: "/matters", label: "Vorgänge", icon: "layers" },
{ to: "/rooms", label: "Datenräume", icon: "rooms" },
{ to: "/sources", label: "Quellen", icon: "sources" },
{ to: "/cases", label: "Akten", icon: "folder" },
{ to: "/work", label: "Aufgaben", icon: "check" },
];
function navItems(session) {
if (!session?.account?.is_superadmin) return NAV;
return [...NAV, { to: "/users", label: "Nutzer", icon: "users" }];
}
const ADMIN = [
{ to: "/settings", label: "Verwaltung", icon: "rooms" },
];
export function Shell() {
const { session, logout } = useContext(SessionContext);
const navigate = useNavigate();
const [query, setQuery] = useState("");
const items = navItems(session);
const items = [...WORK, ...ADMIN];
function onSearch(event) {
event.preventDefault();
@@ -73,7 +71,7 @@ export function Shell() {
<Outlet />
</div>
<nav className="bottom-nav" aria-label="Hauptnavigation">
{items.map((item) => (
{[...WORK, ADMIN[0]].map((item) => (
<NavLink key={item.to} to={item.to} end={item.end} className={({ isActive }) => `nav-item${isActive ? " active" : ""}`}>
<NavIcon name={item.icon} />
<span>{item.label}</span>
@@ -102,6 +100,9 @@ function NavIcon({ name }) {
if (name === "users") {
return <svg {...common}><circle cx="12" cy="8" r="3" /><path d="M5 19c1.2-2.4 3.4-3.5 7-3.5s5.8 1.1 7 3.5" /></svg>;
}
if (name === "check") {
return <svg {...common}><path d="M8 12h8" /><path d="M8 7h8" /><path d="M8 17h5" /><path d="M4 7.5 5.2 9 8 6" /></svg>;
}
if (name === "logout") {
return <svg {...common}><path d="M9 6H5a1 1 0 0 0-1 1v10a1 1 0 0 0 1 1h4" /><path d="M14 16l4-4-4-4" /><path d="M18 12H9" /></svg>;
}
+119
View File
@@ -0,0 +1,119 @@
import { useEffect, useState } from "react";
import { api } from "../api.js";
import { ErrorNote, RecordLink } from "./widgets.jsx";
import { formatDate } from "./content.jsx";
function todayIso() {
const now = new Date();
const month = String(now.getMonth() + 1).padStart(2, "0");
const day = String(now.getDate()).padStart(2, "0");
return `${now.getFullYear()}-${month}-${day}`;
}
export function Work() {
const [tasks, setTasks] = useState(null);
const [deadlines, setDeadlines] = useState(null);
const [filter, setFilter] = useState("open");
const [error, setError] = useState("");
const today = todayIso();
async function load() {
const [taskData, deadlineData] = await Promise.all([
api("/api/v1/views/open-tasks"),
api("/api/v1/views/open-deadlines"),
]);
setTasks(taskData.items);
setDeadlines(deadlineData.items);
setError("");
}
useEffect(() => {
load().catch((err) => setError(err.message));
}, []);
async function complete(task) {
await api(`/api/v1/tasks/${task.id}`, {
method: "PATCH",
body: { expected_version: task.version, status: "done", ...(task.action_context ? { context: task.action_context } : {}) },
});
load();
}
async function fulfill(deadline) {
await api(`/api/v1/deadlines/${deadline.id}/fulfill`, {
method: "POST",
body: { expected_version: deadline.version, ...(deadline.action_context ? { context: deadline.action_context } : {}) },
});
load();
}
const taskRows = (tasks || []).filter((task) => filter !== "deadlines" && filter !== "overdue");
const deadlineRows = (deadlines || []).filter((deadline) => {
if (filter === "tasks") return false;
if (filter === "overdue") return deadline.due_on < today;
return true;
});
return (
<main className="page">
<header className="page-head">
<div>
<h1>Aufgaben und Fristen</h1>
<p className="muted">Eine erledigte Aufgabe lässt eine unabhängige Frist offen.</p>
</div>
</header>
<div className="order-bar" role="group" aria-label="Filter">
<button type="button" className={filter === "open" ? "" : "quiet"} onClick={() => setFilter("open")}>Offen</button>
<button type="button" className={filter === "overdue" ? "" : "quiet"} onClick={() => setFilter("overdue")}>Überfällige Fristen</button>
<button type="button" className={filter === "tasks" ? "" : "quiet"} onClick={() => setFilter("tasks")}>Nur Aufgaben</button>
<button type="button" className={filter === "deadlines" ? "" : "quiet"} onClick={() => setFilter("deadlines")}>Nur Fristen</button>
</div>
<ErrorNote error={error} />
{tasks === null || deadlines === null ? <p className="muted">Arbeit wird geladen …</p> : (
<div className="stack">
{filter !== "deadlines" ? (
<section className="card">
<h2>Aufgaben</h2>
{taskRows.length ? (
<ul className="work">
{taskRows.map((task) => (
<li key={task.id}>
<div>
<strong>{task.title}</strong>
<span>{task.due_on ? `Arbeitstermin ${formatDate(task.due_on)}` : "Ohne Arbeitstermin"}</span>
{task.matter_title ? <RecordLink kind="matter" id={task.matter_id} title={task.matter_title} context={task.action_context} /> : <span>Eigenständige Aufgabe</span>}
</div>
<button type="button" onClick={() => complete(task)}>Erledigen</button>
</li>
))}
</ul>
) : <p className="muted">Keine offene Aufgabe in dieser Sicht.</p>}
</section>
) : null}
{filter !== "tasks" ? (
<section className="card">
<h2>Fristen</h2>
{deadlineRows.length ? (
<ul className="work">
{deadlineRows.map((deadline) => {
const overdue = deadline.due_on < today;
return (
<li key={deadline.id}>
<div>
<strong>{deadline.title}</strong>
<span>{overdue ? "Überfällig" : "Offen"} · Frist {formatDate(deadline.due_on)}</span>
{deadline.matter_title ? <RecordLink kind="matter" id={deadline.matter_id} title={deadline.matter_title} context={deadline.action_context} /> : <span>Eigenständige Frist</span>}
</div>
<button type="button" onClick={() => fulfill(deadline)}>Frist erfüllen</button>
</li>
);
})}
</ul>
) : <p className="muted">Keine offene Frist in dieser Sicht.</p>}
</section>
) : null}
</div>
)}
</main>
);
}
+270
View File
@@ -0,0 +1,270 @@
import { useState } from "react";
import { Link } from "react-router-dom";
import { api } from "../api.js";
import { ErrorNote } from "./widgets.jsx";
export function formatDate(value) {
if (!value) return "Ohne Datum";
const [year, month, day] = String(value).slice(0, 10).split("-");
if (!year || !month || !day) return String(value);
return `${day}.${month}.${year}`;
}
export function formatStamp(value) {
if (!value) return "";
const [day, time = ""] = String(value).split("T");
return `${formatDate(day)} ${time.replace("Z", " UTC").slice(0, 8)}`.trim();
}
export function kindLabel(kind) {
if (kind === "note") return "Notiz";
if (kind === "file") return "Datei";
if (kind === "external_ref") return "Paperless";
return "Unterlage";
}
export function fachDate(element) {
return element?.dates?.document_on || null;
}
export function Trail({ items }) {
if (!items?.length) return null;
return (
<nav className="trail" aria-label="Pfad">
{items.map((item, index) => (
<span key={`${item.label}-${index}`}>
{index ? <span className="trail__sep" aria-hidden="true">/</span> : null}
{item.href ? <Link to={item.href}>{item.label}</Link> : <span aria-current="page">{item.label}</span>}
</span>
))}
</nav>
);
}
function sectionsOf(chapters, bindings) {
const buckets = new Map();
const loose = [];
for (const binding of bindings || []) {
if (binding.chapter_id && chapters.some((chapter) => chapter.id === binding.chapter_id)) {
const list = buckets.get(binding.chapter_id) || [];
list.push(binding);
buckets.set(binding.chapter_id, list);
} else {
loose.push(binding);
}
}
const sections = (chapters || [])
.filter((chapter) => (buckets.get(chapter.id) || []).length)
.map((chapter) => ({ id: chapter.id, title: chapter.title, items: buckets.get(chapter.id) }));
if (loose.length || !sections.length) {
sections.push({ id: "loose", title: sections.length ? "Ohne Kapitel" : "", items: loose });
}
return sections;
}
export function ContentBoard({
record,
bindings,
context,
containerKind,
containerId,
sortable = true,
onChange,
itemHref,
}) {
const source = bindings || record?.bindings || [];
const chapters = record?.chapters || [];
const [error, setError] = useState("");
const [pending, setPending] = useState(false);
const custom = record?.content_order === "position";
const direction = record?.content_order_dir === "desc" ? "desc" : "asc";
const sections = sectionsOf(chapters, source);
const canSort = sortable && record?.rights?.edit;
async function saveMode(mode, nextDirection) {
setError("");
setPending(true);
try {
await api(`/api/v1/${containerKind === "case" ? "cases" : "matters"}/${containerId}/content-order`, {
method: "PATCH",
body: {
expected_version: record.version,
mode,
direction: nextDirection,
...(context && containerKind === "matter" ? { context } : {}),
},
});
onChange();
} catch (err) {
setError(err.message);
} finally {
setPending(false);
}
}
async function move(bindingId, delta) {
const next = sections.map((section) => ({ ...section, items: [...section.items] }));
let moved = false;
for (const section of next) {
const index = section.items.findIndex((item) => item.id === bindingId);
const target = index + delta;
if (index < 0 || target < 0 || target >= section.items.length) continue;
const [item] = section.items.splice(index, 1);
section.items.splice(target, 0, item);
moved = true;
}
if (!moved) return;
setError("");
setPending(true);
try {
await api(`/api/v1/${containerKind === "case" ? "cases" : "matters"}/${containerId}/bindings/order`, {
method: "POST",
body: {
expected_version: record.version,
binding_ids: next.flatMap((section) => section.items.map((item) => item.id)),
...(context && containerKind === "matter" ? { context } : {}),
},
});
onChange();
} catch (err) {
setError(err.message);
} finally {
setPending(false);
}
}
return (
<div className="contents">
{canSort ? (
<div className="order-bar" role="group" aria-label="Ordnung der Inhalte">
<button type="button" className={record.content_order !== "position" && direction === "asc" ? "" : "quiet"} disabled={pending} onClick={() => saveMode("date", "asc")}>
Fachliches Datum, aufsteigend
</button>
<button type="button" className={record.content_order !== "position" && direction === "desc" ? "" : "quiet"} disabled={pending} onClick={() => saveMode("date", "desc")}>
Fachliches Datum, absteigend
</button>
<button type="button" className={custom ? "" : "quiet"} disabled={pending} onClick={() => saveMode("position", direction)}>
Eigene Reihenfolge
</button>
</div>
) : (
<p className="muted">{custom ? "Eigene Reihenfolge" : `Fachliches Datum, ${direction === "desc" ? "absteigend" : "aufsteigend"}`}</p>
)}
<ErrorNote error={error} />
{source.length ? (
sections.map((section) => (
<section key={section.id} className="content-section">
{section.title ? <h3 className="chapter-title">{section.title}</h3> : null}
<ol className="content-list">
{section.items.map((binding, index) => {
const element = binding.element;
const href = itemHref(binding);
return (
<li key={binding.id} className="content-row">
<Link className="content-row__main" to={href}>
<span className="content-row__date">{formatDate(fachDate(element))}</span>
<span className="content-row__title">{element.title}</span>
<span className="content-row__kind">{kindLabel(element.kind)}</span>
</Link>
{canSort && custom ? (
<span className="content-row__move">
<button type="button" className="quiet" aria-label={`${element.title} nach oben`} disabled={pending || index === 0} onClick={() => move(binding.id, -1)}>Nach oben</button>
<button type="button" className="quiet" aria-label={`${element.title} nach unten`} disabled={pending || index === section.items.length - 1} onClick={() => move(binding.id, 1)}>Nach unten</button>
</span>
) : null}
</li>
);
})}
</ol>
</section>
))
) : (
<p className="muted">Noch keine Unterlage und keine Notiz.</p>
)}
</div>
);
}
export function CourseList({ items }) {
if (!items) return <p className="muted">Verlauf wird geladen …</p>;
if (!items.length) return <p className="muted">Noch kein fachlicher Verlauf.</p>;
return (
<ol className="timeline">
{items.map((item) => (
<li key={item.id}>
<time>{item.dated ? formatDate(item.document_on) : "Ohne Datum"}</time>
<div>
<strong>{item.title}</strong>
<span>{kindLabel(item.kind)}{item.sent_on ? ` · Versand ${formatDate(item.sent_on)}` : ""}{item.received_on ? ` · Zugang ${formatDate(item.received_on)}` : ""}</span>
</div>
</li>
))}
</ol>
);
}
export function RecordTabs({ coursePath, auditPath }) {
const [tab, setTab] = useState("");
const [course, setCourse] = useState(null);
const [audit, setAudit] = useState(null);
const [cursor, setCursor] = useState(null);
const [error, setError] = useState("");
async function showCourse() {
setTab("course");
if (course) return;
setError("");
try {
const data = await api(coursePath);
setCourse(data.items);
} catch (err) {
setError(err.message);
}
}
async function showAudit(nextCursor) {
setTab("audit");
setError("");
try {
const joiner = auditPath.includes("?") ? "&" : "?";
const data = await api(`${auditPath}${nextCursor ? `${joiner}cursor=${encodeURIComponent(nextCursor)}` : ""}`);
setAudit((current) => (nextCursor ? [...(current || []), ...data.items] : data.items));
setCursor(data.next_cursor);
} catch (err) {
setError(err.message);
}
}
return (
<section className="section">
<div className="order-bar">
<button type="button" className={tab === "course" ? "" : "quiet"} onClick={showCourse}>Fachlicher Verlauf</button>
<button type="button" className={tab === "audit" ? "" : "quiet"} onClick={() => showAudit("")}>Änderungsprotokoll</button>
</div>
<ErrorNote error={error} />
{tab === "course" ? <CourseList items={course} /> : null}
{tab === "audit" ? <AuditLog items={audit} nextCursor={cursor} onMore={() => showAudit(cursor)} /> : null}
</section>
);
}
export function AuditLog({ items, nextCursor, onMore }) {
if (!items) return <p className="muted">Protokoll wird geladen …</p>;
if (!items.length) return <p className="muted">Noch kein Eintrag.</p>;
return (
<div className="stack">
<ol className="timeline">
{items.map((item) => (
<li key={item.id}>
<time>{formatStamp(item.occurred_at)}</time>
<div>
<strong>{item.label}</strong>
<span>{item.title}{item.actor_display_name ? ` · ${item.actor_display_name}` : ""}</span>
</div>
</li>
))}
</ol>
{nextCursor ? <button type="button" className="quiet" onClick={onMore}>Weitere Einträge</button> : null}
</div>
);
}
+47
View File
@@ -56,6 +56,7 @@ button, .linkish {
align-items: center;
justify-content: center;
gap: 6px;
min-height: 44px;
font-size: 14px;
font-weight: 600;
padding: 10px 18px;
@@ -67,6 +68,10 @@ button, .linkish {
text-decoration: none;
transition: opacity 0.15s, transform 0.1s;
}
button:focus-visible, a:focus-visible, input:focus-visible, select:focus-visible, textarea:focus-visible, summary:focus-visible {
outline: 2px solid var(--accent);
outline-offset: 2px;
}
button:active { transform: scale(0.97); }
button:disabled { opacity: 0.5; pointer-events: none; }
button.quiet, button.linkish, .linkish {
@@ -82,6 +87,7 @@ button.danger {
input, select, textarea {
width: 100%;
min-height: 44px;
padding: 8px 10px;
font-size: 15px;
background: var(--surface2);
@@ -397,6 +403,47 @@ label { display: grid; gap: 6px; font-size: 14px; font-weight: 600; color: var(-
.timeline time { color: var(--text3); font-size: 13px; }
.timeline div { display: grid; }
.trail { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; font-size: 13px; margin-bottom: 8px; }
.trail__sep { color: var(--text3); }
.order-bar { display: flex; flex-wrap: wrap; gap: 8px; margin-bottom: 12px; }
.order-bar button { min-height: 44px; }
.content-list { list-style: none; margin: 0; padding: 0; display: grid; }
.content-row { display: grid; grid-template-columns: 1fr auto; gap: 8px; align-items: center; border-top: 1px solid var(--border); }
.content-row__main {
display: grid;
grid-template-columns: 8.5rem 1fr auto;
gap: 12px;
align-items: baseline;
padding: 10px 0;
text-decoration: none;
color: inherit;
min-height: 44px;
}
.content-row__date { color: var(--text2); font-variant-numeric: tabular-nums; }
.content-row__title { font-weight: 650; }
.content-row__kind { color: var(--text3); font-size: 13px; }
.content-row__move { display: flex; gap: 4px; }
.chapter-title { margin: 14px 0 4px; font-size: 14px; }
.fold { border: 1px solid var(--border); border-radius: 12px; padding: 12px 14px; background: var(--surface); margin-top: 16px; }
.fold summary { cursor: pointer; font-weight: 650; min-height: 44px; display: flex; align-items: center; }
.tree { margin: 0; padding-left: 1.1rem; display: grid; gap: 6px; }
.tree__child { margin-left: 1rem; }
.work-layout { display: grid; gap: 16px; }
.side-work { background: var(--surface); border: 1px solid var(--border); border-radius: 12px; padding: 14px; }
.preview { width: 100%; min-height: 70vh; border: 1px solid var(--border); border-radius: 12px; background: #fff; }
.contained { margin-top: 12px; }
.notes { margin: 0; padding-left: 1.1rem; display: grid; gap: 6px; }
@media (max-width: 720px) {
.content-row { grid-template-columns: 1fr; }
.content-row__main { grid-template-columns: 1fr; gap: 2px; }
.work-layout { grid-template-columns: 1fr; }
}
@media (min-width: 1024px) {
.work-layout { grid-template-columns: minmax(0, 1fr) 320px; align-items: start; }
}
@media (min-width: 1024px) {
.app-shell { display: block; max-width: none; margin: 0; width: 100%; min-height: 100%; }
.desktop-sidebar { display: flex; }