Files
tsumugu/backend/tests/test_order.py
T
LarsandCursor 7ef73ad500
Deploy Development / deploy (push) Successful in 23s
Test Suite / pytest-backend (push) Successful in 55s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 5s
Zeige im Breadcrumb die Aktenstruktur und lass Kapitel samt Inhalt an ihren Ort ziehen.
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-17 12:15:23 +02:00

616 lines
26 KiB
Python

"""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 == ["Akten", "Unterakte Wohnung", "Vorgang Nebenkosten"]
assert opened["trail"][-1]["href"] is None
assert opened["context"]["id"] == child["id"]
assert [item["label"] for item in opened["placements"]] == ["Unterakte Wohnung"]
assert opened["placements"][0]["current"] is True
assert all(item["title"] != "Geheim" for item in opened["case_links"])
ada.login()
direct = ada.request("GET", f"/api/v1/matters/{matter['id']}")
assert [item["label"] for item in direct["trail"]] == ["Vorgänge", "Vorgang Nebenkosten"]
assert "Geheim" not in " ".join(item["label"] for item in opened["placements"])
assert any(item["label"] == "Akte Geheim" for item in direct["placements"])
def test_teilvorgang_keeps_its_parent_in_the_trail(client, db):
ada = Actor(client, "ada-child@example.test", "Ada Kind")
register(db, ada.email, ada.name)
ada.login()
parent = matter_of(ada, "Hauptvorgang")
child = ada.request(
"POST",
"/api/v1/matters",
json={"title": "Prüfung", "parent_matter_id": parent["id"]},
status=201,
)
direct = ada.request("GET", f"/api/v1/matters/{child['id']}")
assert [item["label"] for item in direct["trail"]] == ["Vorgänge", "Vorgang Hauptvorgang", "Teilvorgang Prüfung"]
case = case_of(ada, "Sammelakte")
ada.request("POST", f"/api/v1/matters/{parent['id']}/case-links", json={"case_id": case["id"]}, status=201)
opened = ada.request("GET", f"/api/v1/matters/{child['id']}?context_kind=case&context_id={case['id']}")
assert [item["label"] for item in opened["trail"]] == [
"Akten",
"Akte Sammelakte",
"Vorgang Hauptvorgang",
"Teilvorgang Prüfung",
]
assert opened["trail"][2]["href"].endswith(f"context_id={case['id']}")
placed = ada.request("GET", f"/api/v1/matters/{child['id']}")
assert [item["label"] for item in placed["trail"]] == [item["label"] for item in opened["trail"]]
assert opened["placements"][0]["label"] == "Akte Sammelakte"
assert opened["placements"][0]["current"] is True
listed = ada.request("GET", "/api/v1/matters")
rows = {item["title"]: item for item in listed["items"]}
assert rows["Prüfung"]["kind_label"] == "Teilvorgang"
assert rows["Prüfung"]["parent_title"] == "Hauptvorgang"
assert rows["Hauptvorgang"]["kind_label"] == "Vorgang"
chapter = ada.request(
"POST",
f"/api/v1/matters/{child['id']}/chapters?context_kind=case&context_id={case['id']}",
json={"title": "Schriftverkehr"},
status=201,
)
_note(ada, "Einwendung", child, document_on="2024-05-02")
case_view = ada.request("GET", f"/api/v1/cases/{case['id']}")
assert [item["title"] for item in case_view["matters"]] == ["Hauptvorgang"]
assert case_view["matters"][0]["children"][0]["title"] == "Prüfung"
contained = {item["title"]: item for item in case_view["contained"]}
assert contained["Prüfung"]["kind_label"] == "Teilvorgang"
assert contained["Prüfung"]["parent_title"] == "Hauptvorgang"
assert contained["Prüfung"]["chapters"][0]["id"] == chapter["id"]
assert contained["Prüfung"]["bindings"][0]["element"]["title"] == "Einwendung"
def test_chapters_follow_the_container_not_the_entry(client, db):
ada = Actor(client, "ada-ziel@example.test", "Ada Ziel")
ben = Actor(client, "ben-ziel@example.test", "Ben Ziel")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
ada.login()
case = case_of(ada, "Wohnung")
matter = matter_of(ada, "Nebenkosten 2025")
child = ada.request(
"POST",
"/api/v1/matters",
json={"title": "Belegeinsicht", "parent_matter_id": matter["id"]},
status=201,
)
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
case_chapter = ada.request("POST", f"/api/v1/cases/{case['id']}/chapters", json={"title": "Aktenkapitel"}, status=201)
abrechnung = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Abrechnung"}, status=201)
schrift = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Schriftverkehr"}, status=201)
belege = ada.request(
"POST",
f"/api/v1/matters/{child['id']}/chapters?context_kind=case&context_id={case['id']}",
json={"title": "Belege"},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Abrechnungsschreiben",
"document": document("Abrechnungstext"),
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": abrechnung["id"],
},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Einwendung",
"document": document("Einwendungstext"),
"context": {"kind": "matter", "id": child["id"]},
"chapter_id": belege["id"],
},
status=201,
)
ada.request(
"POST",
"/api/v1/notes",
json={
"title": "Fremdes Kapitel",
"document": document("nein"),
"context": {"kind": "matter", "id": matter["id"]},
"chapter_id": case_chapter["id"],
},
status=422,
)
direct = _matter(ada, matter["id"])
via_case = ada.request("GET", f"/api/v1/matters/{matter['id']}?context_kind=case&context_id={case['id']}")
assert [item["title"] for item in direct["chapters"]] == ["Abrechnung", "Schriftverkehr"]
assert [item["id"] for item in via_case["chapters"]] == [item["id"] for item in direct["chapters"]]
assert via_case["context"]["kind"] == "case"
child_view = ada.request("GET", f"/api/v1/matters/{child['id']}?context_kind=case&context_id={case['id']}")
assert [item["title"] for item in child_view["chapters"]] == ["Belege"]
case_view = ada.request("GET", f"/api/v1/cases/{case['id']}")
assert [item["title"] for item in case_view["chapters"]] == ["Aktenkapitel"]
contained = {item["title"]: item for item in case_view["contained"]}
assert [item["title"] for item in contained["Nebenkosten 2025"]["chapters"]] == ["Abrechnung", "Schriftverkehr"]
assert [item["title"] for item in contained["Belegeinsicht"]["chapters"]] == ["Belege"]
binding = binding_for(direct, "Abrechnungsschreiben")
before = len(direct["bindings"])
ada.request(
"PATCH",
f"/api/v1/bindings/{binding['id']}/chapter",
json={"expected_version": direct["version"], "chapter_id": schrift["id"]},
)
moved = _matter(ada, matter["id"])
assert binding_for(moved, "Abrechnungsschreiben")["chapter_id"] == schrift["id"]
assert binding_for(moved, "Abrechnungsschreiben")["element"]["excerpt"] == "Abrechnungstext"
assert len(moved["bindings"]) == before
grant(ada, case["id"], ben.email)
ben.login()
ben.request(
"POST",
f"/api/v1/matters/{matter['id']}/chapters?context_kind=case&context_id={case['id']}",
json={"title": "Unerlaubt"},
status=403,
)
ben.request(
"PATCH",
f"/api/v1/bindings/{binding['id']}/chapter",
json={"expected_version": moved["version"], "chapter_id": abrechnung["id"], "context": {"kind": "case", "id": case["id"]}},
status=403,
)
_PNG = bytes.fromhex(
"89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c489"
"0000000a49444154789c63000100000500010d0a2db40000000049454e44ae426082"
)
def test_summary_and_preview_follow_the_read_right(client, db):
ada = Actor(client, "ada-preview@example.test", "Ada Vorschau")
ben = Actor(client, "ben-preview@example.test", "Ben Vorschau")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
ada.login()
matter = matter_of(ada, "Mappe")
_note(ada, "Einwendungstext", matter)
detail = _matter(ada, matter["id"])
note = detail["bindings"][0]["element"]
assert note["excerpt"] == "Einwendungstext"
assert note["summary"] is None
assert note["preview"]["available"] is False
ada.request(
"PATCH",
f"/api/v1/elements/{note['id']}/summary",
json={
"expected_version": note["version"],
"summary": "Kurze Einwendung",
"context": {"kind": "matter", "id": matter["id"]},
},
)
ada.request(
"POST",
"/api/v1/files",
data={"title": "Scan", "context_kind": "matter", "context_id": matter["id"]},
files={"upload": ("punkt.png", _PNG, "image/png")},
status=201,
)
detail = _matter(ada, matter["id"])
by_title = {item["element"]["title"]: item["element"] for item in detail["bindings"]}
assert by_title["Einwendungstext"]["summary"] == "Kurze Einwendung"
assert by_title["Scan"]["preview"] == {"available": True, "media": "image", "source": "file"}
ben.login()
ben.request("GET", f"/api/v1/matters/{matter['id']}", status=404)
ben.request("GET", f"/api/v1/files/{by_title['Scan']['id']}/content", status=404)
def test_chapters_move_with_their_entries_and_follow_their_date(client, db):
ada = Actor(client, "ada-kapitel-ordnung@example.test", "Ada Kapitel")
ben = Actor(client, "ben-kapitel-ordnung@example.test", "Ben Kapitel")
register(db, ada.email, ada.name)
register(db, ben.email, ben.name)
ada.login()
matter = matter_of(ada, "Nebenkosten")
first = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Abrechnung", "document_on": "2025-03-01"}, status=201)
second = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Schriftverkehr", "document_on": "2025-01-15"}, status=201)
_note(ada, "Schreiben", matter, document_on="2025-06-02")
detail = _matter(ada, matter["id"])
binding = binding_for(detail, "Schreiben")
ada.request(
"PATCH",
f"/api/v1/bindings/{binding['id']}/chapter",
json={"expected_version": detail["version"], "chapter_id": first["id"]},
)
detail = _matter(ada, matter["id"])
assert detail["content_order"] == "date"
assert [item["title"] for item in detail["chapters"]] == ["Schriftverkehr", "Abrechnung"]
dated = detail
assert binding_for(dated, "Schreiben")["chapter_id"] == first["id"]
assert binding_for(dated, "Schreiben")["element"]["excerpt"] == "Schreiben"
ada.request(
"PATCH",
f"/api/v1/matters/{matter['id']}/content-order",
json={"expected_version": dated["version"], "mode": "position", "direction": "asc"},
)
positioned = _matter(ada, matter["id"])
ada.request(
"POST",
f"/api/v1/matters/{matter['id']}/chapters/order",
json={"expected_version": positioned["version"], "chapter_ids": [first["id"], second["id"]]},
)
ordered = _matter(ada, matter["id"])
assert [item["title"] for item in ordered["chapters"]] == ["Abrechnung", "Schriftverkehr"]
assert binding_for(ordered, "Schreiben")["chapter_id"] == first["id"]
assert len(ordered["bindings"]) == 1
case = case_of(ada, "Wohnung")
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
grant(ada, case["id"], ben.email)
ben.login()
ben.request(
"POST",
f"/api/v1/matters/{matter['id']}/chapters/order",
json={
"expected_version": ordered["version"],
"chapter_ids": [second["id"], first["id"]],
"context": {"kind": "case", "id": case["id"]},
},
status=403,
)