554 lines
23 KiB
Python
554 lines
23 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 == ["Vorgänge", "Vorgang Nebenkosten"]
|
|
assert opened["context"]["id"] == child["id"]
|
|
assert [item["label"] for item in opened["placements"]] == ["Unterakte Wohnung"]
|
|
assert opened["placements"][0]["current"] is True
|
|
assert all(item["title"] != "Geheim" for item in opened["case_links"])
|
|
ada.login()
|
|
direct = ada.request("GET", f"/api/v1/matters/{matter['id']}")
|
|
assert [item["label"] for item in direct["trail"]] == labels
|
|
assert "Geheim" not in " ".join(item["label"] for item in opened["placements"])
|
|
assert any(item["label"] == "Akte Geheim" for item in direct["placements"])
|
|
|
|
|
|
def test_teilvorgang_keeps_its_parent_in_the_trail(client, db):
|
|
ada = Actor(client, "ada-child@example.test", "Ada Kind")
|
|
register(db, ada.email, ada.name)
|
|
ada.login()
|
|
parent = matter_of(ada, "Hauptvorgang")
|
|
child = ada.request(
|
|
"POST",
|
|
"/api/v1/matters",
|
|
json={"title": "Prüfung", "parent_matter_id": parent["id"]},
|
|
status=201,
|
|
)
|
|
direct = ada.request("GET", f"/api/v1/matters/{child['id']}")
|
|
assert [item["label"] for item in direct["trail"]] == ["Vorgänge", "Vorgang Hauptvorgang", "Teilvorgang Prüfung"]
|
|
case = case_of(ada, "Sammelakte")
|
|
ada.request("POST", f"/api/v1/matters/{parent['id']}/case-links", json={"case_id": case["id"]}, status=201)
|
|
opened = ada.request("GET", f"/api/v1/matters/{child['id']}?context_kind=case&context_id={case['id']}")
|
|
assert [item["label"] for item in opened["trail"]] == [item["label"] for item in direct["trail"]]
|
|
assert opened["trail"][1]["href"].endswith(f"context_id={case['id']}")
|
|
assert opened["placements"][0]["label"] == "Akte Sammelakte"
|
|
assert opened["placements"][0]["current"] is True
|
|
listed = ada.request("GET", "/api/v1/matters")
|
|
rows = {item["title"]: item for item in listed["items"]}
|
|
assert rows["Prüfung"]["kind_label"] == "Teilvorgang"
|
|
assert rows["Prüfung"]["parent_title"] == "Hauptvorgang"
|
|
assert rows["Hauptvorgang"]["kind_label"] == "Vorgang"
|
|
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)
|