Zeige den Vorgang in seiner Akte, ordne mehrere Aufgaben einer Frist zu und verwende Logo sowie Favicon aus der Lieferung.
Deploy Development / deploy (push) Successful in 27s
Test Suite / pytest-backend (push) Successful in 1m7s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 8s

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
LarsandCursor committed 2026-10-17 14:57:48 +02:00
1 parent 448e9a06ff
commit dc8a9c2db6
41 files changed
+600 -390

No files matched your search

+46
View File
@@ -67,6 +67,8 @@ from app.api.schemas import (
RoomIn,
ScopeIn,
TaskDeadlineIn,
TaskDependencyIn,
TaskElementsIn,
SummaryPatch,
TaskIn,
TaskPatch,
@@ -104,6 +106,9 @@ from app.ops import (
grant_access,
link_matter_to_case,
link_task_deadline,
link_task_dependency,
set_task_elements,
unlink_task_dependency,
patch_case,
patch_deadline,
patch_matter,
@@ -1054,6 +1059,47 @@ def post_task_deadline(
return Response(status_code=204)
@router.put("/api/v1/tasks/{task_id}/elements", status_code=204)
def put_task_elements(
task_id: UUID,
body: TaskElementsIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
set_task_elements(conn, principal.account_id, task_id, body.element_ids, _ctx_model(body.context))
return Response(status_code=204)
@router.post("/api/v1/tasks/{task_id}/dependencies", status_code=204)
def post_task_dependency(
task_id: UUID,
body: TaskDependencyIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
link_task_dependency(conn, principal.account_id, task_id, body.depends_on_task_id, _ctx_model(body.context))
return Response(status_code=204)
@router.delete("/api/v1/tasks/{task_id}/dependencies/{depends_on_task_id}", status_code=204)
def delete_task_dependency(
task_id: UUID,
depends_on_task_id: UUID,
context_kind: str | None = None,
context_id: str | None = None,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
unlink_task_dependency(
conn,
principal.account_id,
task_id,
depends_on_task_id,
parse_query_context(context_kind, context_id),
)
return Response(status_code=204)
@router.post("/api/v1/deadlines")
def post_deadline(body: DeadlineIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
deadline = create_deadline(
+10
View File
@@ -282,3 +282,13 @@ class FulfillIn(APIModel):
class TaskDeadlineIn(APIModel):
deadline_id: UUID
context: ContextIn | None = None
class TaskElementsIn(APIModel):
element_ids: list[UUID] = Field(default_factory=list, max_length=40)
context: ContextIn | None = None
class TaskDependencyIn(APIModel):
depends_on_task_id: UUID
context: ContextIn | None = None
+12
View File
@@ -52,6 +52,18 @@ _PURGE = (
WHERE owner_subject_id IN (SELECT id FROM fixture_accounts)
""",
"""
DELETE FROM task_element_links
WHERE task_id IN (SELECT id FROM tasks WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
OR element_id IN (SELECT id FROM elements WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
OR created_by IN (SELECT id FROM fixture_accounts)
""",
"""
DELETE FROM task_dependencies
WHERE task_id IN (SELECT id FROM tasks WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
OR depends_on_task_id IN (SELECT id FROM tasks WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
OR created_by IN (SELECT id FROM fixture_accounts)
""",
"""
DELETE FROM task_deadline_links
WHERE task_id IN (SELECT id FROM tasks WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
OR deadline_id IN (SELECT id FROM deadlines WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+87
View File
@@ -875,6 +875,93 @@ def link_task_deadline(conn, actor: UUID, task_id: UUID, deadline_id: UUID, cont
)
def set_task_elements(conn, actor: UUID, task_id: UUID, element_ids: list[UUID], context: Ctx | None) -> None:
task = get_task(conn, task_id)
if task is None:
raise not_found()
rights = task_rights(conn, actor, task, context)
if not rights.read:
raise not_found()
if not rights.edit:
raise forbidden()
unique: list[UUID] = []
for element_id in element_ids:
if element_id in unique:
continue
element = get_element(conn, element_id)
if element is None:
raise not_found()
visible = element_rights(conn, actor, element, context)
if not visible.read:
raise not_found()
unique.append(element_id)
conn.execute("DELETE FROM task_element_links WHERE task_id = %s", (task_id,))
for element_id in unique:
conn.execute(
"""
INSERT INTO task_element_links (task_id, element_id, created_by)
VALUES (%s, %s, %s)
""",
(task_id, element_id, actor),
)
def _dependency_chain(conn, start: UUID) -> set[UUID]:
seen: set[UUID] = set()
stack = [start]
while stack:
current = stack.pop()
if current in seen:
continue
seen.add(current)
rows = conn.execute(
"SELECT depends_on_task_id FROM task_dependencies WHERE task_id = %s",
(current,),
).fetchall()
stack.extend(row["depends_on_task_id"] for row in rows)
return seen
def link_task_dependency(conn, actor: UUID, task_id: UUID, depends_on_task_id: UUID, context: Ctx | None) -> None:
if task_id == depends_on_task_id:
raise unprocessable("Eine Aufgabe kann nicht von sich selbst abhängen.")
task = get_task(conn, task_id)
earlier = get_task(conn, depends_on_task_id)
if task is None or earlier is None:
raise not_found()
rights = task_rights(conn, actor, task, context)
earlier_rights = task_rights(conn, actor, earlier, context)
if not rights.read or not earlier_rights.read:
raise not_found()
if not rights.edit:
raise forbidden()
if task_id in _dependency_chain(conn, depends_on_task_id):
raise unprocessable("Diese Abhängigkeit würde einen Kreis bilden.")
conn.execute(
"""
INSERT INTO task_dependencies (task_id, depends_on_task_id, created_by)
VALUES (%s, %s, %s)
ON CONFLICT DO NOTHING
""",
(task_id, depends_on_task_id, actor),
)
def unlink_task_dependency(conn, actor: UUID, task_id: UUID, depends_on_task_id: UUID, context: Ctx | None) -> None:
task = get_task(conn, task_id)
if task is None:
raise not_found()
rights = task_rights(conn, actor, task, context)
if not rights.read:
raise not_found()
if not rights.edit:
raise forbidden()
conn.execute(
"DELETE FROM task_dependencies WHERE task_id = %s AND depends_on_task_id = %s",
(task_id, depends_on_task_id),
)
def set_content_order(
conn,
actor: UUID,
+25
View File
@@ -13,6 +13,7 @@ from app.access.policy import (
get_case,
get_element,
get_matter,
get_task,
matter_rights,
matter_title_if_readable,
readable_matter_contexts,
@@ -756,6 +757,30 @@ def task_payload(conn, actor: UUID, task: dict, rights=None) -> dict:
action = _task_action_context(conn, actor, task)
if action is not None:
payload["action_context"] = action
elements = []
for link in conn.execute(
"SELECT element_id FROM task_element_links WHERE task_id = %s ORDER BY created_at, element_id",
(task["id"],),
).fetchall():
element = get_element(conn, link["element_id"])
if element is None or element["deleted_at"] is not None:
continue
if not element_rights(conn, actor, element, None).read:
continue
elements.append({"id": str(element["id"]), "title": element["title"]})
if elements:
payload["elements"] = elements
depends_on = []
for link in conn.execute(
"SELECT depends_on_task_id FROM task_dependencies WHERE task_id = %s ORDER BY created_at, depends_on_task_id",
(task["id"],),
).fetchall():
earlier = get_task(conn, link["depends_on_task_id"])
if earlier is None or not task_rights(conn, actor, earlier, None).read:
continue
depends_on.append({"id": str(earlier["id"]), "title": earlier["title"], "status": earlier["task_status"]})
if depends_on:
payload["depends_on"] = depends_on
return payload
@@ -0,0 +1,16 @@
CREATE TABLE task_element_links (
task_id uuid NOT NULL REFERENCES tasks (id),
element_id uuid NOT NULL REFERENCES elements (id),
created_by uuid NOT NULL REFERENCES auth_accounts (id),
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (task_id, element_id)
);
CREATE TABLE task_dependencies (
task_id uuid NOT NULL REFERENCES tasks (id),
depends_on_task_id uuid NOT NULL REFERENCES tasks (id),
created_by uuid NOT NULL REFERENCES auth_accounts (id),
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (task_id, depends_on_task_id),
CONSTRAINT task_dependencies_not_self CHECK (task_id <> depends_on_task_id)
);
+30
View File
@@ -42,6 +42,36 @@ def test_t_dl_completed_task_leaves_the_deadline_open(client, db):
kept = next(item for item in open_deadlines["items"] if item["id"] == deadline["id"])
assert kept["status"] == "open"
assert kept["fulfilled_at"] is None
second = ada.request(
"POST",
"/api/v1/tasks",
json={"title": "Schreiben entwerfen", "due_on": "2026-11-20", "matter_id": matter["id"]},
status=201,
)
ada.request(
"POST",
f"/api/v1/tasks/{second['id']}/deadline-links",
json={"deadline_id": deadline["id"]},
status=204,
)
ada.request(
"POST",
f"/api/v1/tasks/{second['id']}/dependencies",
json={"depends_on_task_id": task["id"]},
status=204,
)
ada.request(
"POST",
f"/api/v1/tasks/{task['id']}/dependencies",
json={"depends_on_task_id": second["id"]},
status=422,
)
detail = ada.request("GET", f"/api/v1/matters/{matter['id']}")
milestone = next(item for item in detail["deadlines"] if item["id"] == deadline["id"])
linked = [item for item in detail["task_deadline_links"] if item["deadline_id"] == milestone["id"]]
assert len(linked) == 2
shown = next(item for item in detail["tasks"] if item["id"] == second["id"])
assert shown["depends_on"][0]["id"] == task["id"]
def test_t_anchor_assignee_sees_the_task_but_not_the_hidden_matter(client, db):