Files
tsumugu/backend/app/api/routes.py
T
LarsandCursor 448e9a06ff
Deploy Development / deploy (push) Successful in 33s
Test Suite / pytest-backend (push) Successful in 56s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 9s
Oeffne Kapitel und Dokument auf derselben Arbeitsflaeche, damit Pfad, Rechte und eigene Reihenfolge beim Lesen erhalten bleiben.
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-17 14:19:06 +02:00

1549 lines
53 KiB
Python

"""HTTP routes for the first usable delivery."""
from __future__ import annotations
from datetime import date, datetime, timedelta, timezone
from uuid import UUID
from fastapi import APIRouter, Depends, File, Form, Request, Response, UploadFile
from fastapi.responses import JSONResponse
from psycopg import Connection
from app.access.policy import (
Ctx,
account_by_email,
case_rights,
deadline_rights,
element_rights,
ensure_member_or_personal,
get_case,
get_deadline,
get_element,
get_matter,
get_task,
list_cases,
list_matters,
room_name,
matter_rights,
parse_context,
parse_query_context,
require_case,
require_matter,
task_rights,
)
from app.api.deps import Principal, get_conn, get_principal, get_session
from app.api.schemas import (
AcceptInviteIn,
AccountIn,
AnnotationIn,
BootstrapIn,
AssigneeIn,
BindingIn,
CaseIn,
CaseLinkIn,
CasePatch,
ChapterDateIn,
ChapterIn,
ChapterOrderIn,
CrossLinkIn,
DeadlineIn,
DeadlinePatch,
DeleteElementIn,
ExceptionIn,
ExternalIn,
FulfillIn,
GrantIn,
InvitationIn,
LoginIn,
MatterIn,
MatterPatch,
MemberIn,
BindingOrderIn,
ContentOrderIn,
ChapterMoveIn,
DatesPatch,
NoteIn,
NotePatch,
RoomIn,
ScopeIn,
TaskDeadlineIn,
SummaryPatch,
TaskIn,
TaskPatch,
)
from app.auth.accounts import create_account, list_rooms, normalize_email, start_session
from app.auth.security import (
clear_session_cookie,
hash_secret,
new_secret,
session_expiry,
set_session_cookie,
verify_password,
)
from app.core.errors import Problem, forbidden, not_found, too_many, unprocessable
from app.core.timeutil import dump_date, dump_dt, utcnow
from app.media.storage import content_disposition, read_bytes
from app.media.storage import asset_path
from app.ops import (
add_annotation,
assign_task,
bind_element,
create_case,
create_chapter,
create_cross_link,
create_deadline,
create_external,
create_file,
create_matter,
create_note,
create_task,
delete_cross_link,
delete_element,
detach_binding,
fulfill_deadline,
grant_access,
link_matter_to_case,
link_task_deadline,
patch_case,
patch_deadline,
patch_matter,
patch_task,
revoke_grant,
move_binding_chapter,
reorder_bindings,
reorder_chapters,
set_chapter_date,
set_content_order,
set_exception,
unlink_matter_case,
update_dates,
update_note,
update_summary,
)
from app.present import (
LABELS,
binding_payload,
case_detail,
case_summary,
deadline_payload,
course_items,
matter_detail,
matter_summary,
note_update_payload,
task_payload,
)
from app.seed import demo_public
router = APIRouter()
_login_attempts: dict[str, list[datetime]] = {}
def _chosen_home(conn, principal: Principal, requested: UUID | None) -> UUID:
scope_id = requested or principal.scope_id
room = conn.execute("SELECT id, kind FROM data_rooms WHERE id = %s", (scope_id,)).fetchone()
if room is None:
raise not_found()
ensure_member_or_personal(conn, principal.account_id, room["kind"], room["id"])
return room["id"]
def _created(path: str, payload: dict) -> JSONResponse:
return JSONResponse(status_code=201, content=payload, headers={"Location": path})
def _ctx_model(value) -> Ctx | None:
return None if value is None else Ctx(value.kind, value.id)
def _session_body(conn, account_id: UUID, scope_kind: str, scope_id: UUID, csrf: str, epoch: int) -> dict:
account = conn.execute(
"SELECT id, email, display_name, is_superadmin FROM auth_accounts WHERE id = %s",
(account_id,),
).fetchone()
room = conn.execute("SELECT id, kind, name FROM data_rooms WHERE id = %s", (scope_id,)).fetchone()
return {
"account": {
"id": str(account["id"]),
"email": account["email"],
"display_name": account["display_name"],
"is_superadmin": account["is_superadmin"],
},
"scope": {"kind": scope_kind, "id": str(room["id"]), "name": room["name"]},
"rooms": list_rooms(conn, account_id),
"csrf_token": csrf,
"epoch": epoch,
}
def _limit_login(key: str) -> None:
now = utcnow()
window = [item for item in _login_attempts.get(key, []) if now - item < timedelta(minutes=10)]
if len(window) >= 8:
_login_attempts[key] = window
raise too_many()
window.append(now)
_login_attempts[key] = window
@router.post("/api/v1/auth/login")
def login(body: LoginIn, request: Request, conn: Connection = Depends(get_conn)):
email = normalize_email(body.email)
_limit_login(f"{request.client.host if request.client else 'local'}:{email}")
account = conn.execute(
"SELECT * FROM auth_accounts WHERE email = %s",
(email,),
).fetchone()
if account is None or account["status"] != "active" or not verify_password(body.password, account["password_hash"]):
raise Problem(401, "Anmeldung fehlgeschlagen", "E-Mail oder Passwort ist nicht richtig.", "unauthorized")
settings = request.app.state.settings
token, csrf = start_session(conn, settings, account["id"])
payload = _session_body(conn, account["id"], "personal", account["id"], csrf, 1)
response = JSONResponse(payload)
set_session_cookie(response, request, settings, token)
return response
@router.post("/api/v1/auth/logout", status_code=204)
def logout(request: Request, session: dict = Depends(get_session), conn: Connection = Depends(get_conn)):
conn.execute("UPDATE auth_sessions SET revoked_at = now() WHERE id = %s", (session["id"],))
response = Response(status_code=204)
clear_session_cookie(response, request, request.app.state.settings)
return response
@router.get("/api/v1/auth/session")
def session_view(session: dict = Depends(get_session), conn: Connection = Depends(get_conn)):
return _session_body(
conn,
session["account_id"],
session["scope_kind"],
session["scope_id"],
session["csrf_token"],
session["epoch"],
)
@router.post("/api/v1/auth/session/scope")
def choose_scope(
body: ScopeIn,
request: Request,
session: dict = Depends(get_session),
conn: Connection = Depends(get_conn),
):
from app.access.policy import ensure_member_or_personal
room = ensure_member_or_personal(conn, session["account_id"], body.kind, body.id)
row = conn.execute(
"""
UPDATE auth_sessions
SET scope_kind = %s, scope_id = %s, epoch = epoch + 1
WHERE id = %s
RETURNING epoch, csrf_token
""",
(body.kind, room["id"], session["id"]),
).fetchone()
return _session_body(conn, session["account_id"], body.kind, room["id"], row["csrf_token"], row["epoch"])
@router.get("/api/v1/auth/demo")
def demo(request: Request):
return demo_public(request.app.state.settings)
def _superadmin_exists(conn: Connection) -> bool:
return conn.execute("SELECT 1 FROM auth_accounts WHERE is_superadmin LIMIT 1").fetchone() is not None
@router.get("/api/v1/auth/bootstrap")
def bootstrap_available(conn: Connection = Depends(get_conn)):
if _superadmin_exists(conn):
raise not_found()
return {"available": True}
@router.post("/api/v1/auth/bootstrap")
def bootstrap(body: BootstrapIn, request: Request, conn: Connection = Depends(get_conn)):
conn.execute("LOCK TABLE auth_accounts IN EXCLUSIVE MODE")
if _superadmin_exists(conn):
raise not_found()
account = create_account(conn, body.email, body.display_name, body.password, is_superadmin=True)
settings = request.app.state.settings
token, csrf = start_session(conn, settings, account["id"])
payload = _session_body(conn, account["id"], "personal", account["id"], csrf, 1)
response = JSONResponse(status_code=201, content=payload)
set_session_cookie(response, request, settings, token)
return response
def _require_superadmin(conn: Connection, principal: Principal) -> None:
row = conn.execute(
"SELECT is_superadmin FROM auth_accounts WHERE id = %s",
(principal.account_id,),
).fetchone()
if row is None or not row["is_superadmin"]:
raise forbidden("Nur der Betreiber kann Nutzer anlegen.")
@router.get("/api/v1/accounts")
def accounts(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
_require_superadmin(conn, principal)
rows = conn.execute(
"""
SELECT id, email, display_name, is_superadmin, created_at
FROM auth_accounts
WHERE origin = 'operator' AND status = 'active'
ORDER BY display_name, email
"""
).fetchall()
return {
"items": [
{
"id": str(row["id"]),
"email": row["email"],
"display_name": row["display_name"],
"is_superadmin": row["is_superadmin"],
"created_at": dump_dt(row["created_at"]),
}
for row in rows
],
"next_cursor": None,
}
@router.post("/api/v1/accounts")
def post_account(body: AccountIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
_require_superadmin(conn, principal)
account = create_account(conn, body.email, body.display_name, body.password)
return _created(
f"/api/v1/accounts/{account['id']}",
{
"id": str(account["id"]),
"email": account["email"],
"display_name": account["display_name"],
"is_superadmin": account["is_superadmin"],
},
)
@router.post("/api/v1/invitations")
def invite(
body: InvitationIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
room = conn.execute("SELECT * FROM data_rooms WHERE id = %s", (body.room_id,)).fetchone()
if room is None or room["kind"] != "organization":
raise not_found()
membership = conn.execute(
"""
SELECT role FROM room_memberships
WHERE room_id = %s AND subject_id = %s AND status = 'active'
""",
(room["id"], principal.account_id),
).fetchone()
if membership is None or membership["role"] != "manager":
raise forbidden()
email = normalize_email(body.email)
if account_by_email(conn, email):
raise unprocessable("Es gibt bereits ein Konto. Füge die Person als Mitglied hinzu.")
token = new_secret()
row = conn.execute(
"""
INSERT INTO auth_invitations (email, room_id, token_hash, invited_by, expires_at)
VALUES (%s, %s, %s, %s, %s)
RETURNING id, expires_at
""",
(email, room["id"], hash_secret(token), principal.account_id, utcnow() + timedelta(days=7)),
).fetchone()
return _created(
f"/api/v1/invitations/{row['id']}",
{"id": str(row["id"]), "email": email, "expires_at": row["expires_at"].isoformat(), "token": token},
)
@router.post("/api/v1/invitations/{invitation_id}/accept")
def accept_invite(
invitation_id: UUID,
body: AcceptInviteIn,
request: Request,
conn: Connection = Depends(get_conn),
):
row = conn.execute("SELECT * FROM auth_invitations WHERE id = %s", (invitation_id,)).fetchone()
if row is None or row["accepted_at"] is not None or row["expires_at"] <= utcnow():
raise not_found()
if row["token_hash"] != hash_secret(body.token):
raise not_found()
account = create_account(conn, row["email"], body.display_name, body.password)
conn.execute(
"""
INSERT INTO room_memberships (room_id, subject_id, role)
VALUES (%s, %s, 'member')
""",
(row["room_id"], account["id"]),
)
conn.execute("UPDATE auth_invitations SET accepted_at = now() WHERE id = %s", (invitation_id,))
settings = request.app.state.settings
token, csrf = start_session(conn, settings, account["id"])
payload = _session_body(conn, account["id"], "personal", account["id"], csrf, 1)
response = JSONResponse(status_code=201, content=payload)
set_session_cookie(response, request, settings, token)
return response
@router.get("/api/v1/rooms")
def rooms(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
return {"items": list_rooms(conn, principal.account_id), "next_cursor": None}
@router.post("/api/v1/rooms")
def create_room(body: RoomIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
from uuid import uuid4
room_id = uuid4()
conn.execute(
"""
INSERT INTO data_rooms (id, kind, name, created_by)
VALUES (%s, 'organization', %s, %s)
""",
(room_id, body.name.strip(), principal.account_id),
)
conn.execute(
"""
INSERT INTO room_memberships (room_id, subject_id, role)
VALUES (%s, %s, 'manager')
""",
(room_id, principal.account_id),
)
return _created(f"/api/v1/rooms/{room_id}", {"id": str(room_id), "kind": "organization", "name": body.name.strip()})
@router.get("/api/v1/rooms/{room_id}/members")
def members(room_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
_require_manager(conn, principal, room_id)
rows = conn.execute(
"""
SELECT m.subject_id, m.role, a.email, a.display_name
FROM room_memberships m
JOIN auth_accounts a ON a.id = m.subject_id
WHERE m.room_id = %s AND m.status = 'active'
ORDER BY a.display_name, a.id
""",
(room_id,),
).fetchall()
return {
"items": [
{
"subject_id": str(row["subject_id"]),
"email": row["email"],
"display_name": row["display_name"],
"role": row["role"],
}
for row in rows
]
}
@router.post("/api/v1/rooms/{room_id}/members")
def add_member(
room_id: UUID,
body: MemberIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
_require_manager(conn, principal, room_id)
account = account_by_email(conn, body.email)
if account is None or account["status"] != "active":
raise not_found()
conn.execute(
"""
INSERT INTO room_memberships (room_id, subject_id, role, status)
VALUES (%s, %s, %s, 'active')
ON CONFLICT (room_id, subject_id) DO UPDATE SET role = EXCLUDED.role, status = 'active'
""",
(room_id, account["id"], body.role),
)
return {"subject_id": str(account["id"]), "role": body.role}
@router.delete("/api/v1/rooms/{room_id}/members/{subject_id}", status_code=204)
def remove_member(
room_id: UUID,
subject_id: UUID,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
_require_manager(conn, principal, room_id)
if subject_id == principal.account_id:
managers = conn.execute(
"""
SELECT count(*) AS n FROM room_memberships
WHERE room_id = %s AND role = 'manager' AND status = 'active'
""",
(room_id,),
).fetchone()
if managers["n"] <= 1:
raise unprocessable("Der letzte Verwalter kann den Datenraum nicht verlassen.")
conn.execute(
"""
UPDATE room_memberships SET status = 'removed'
WHERE room_id = %s AND subject_id = %s
""",
(room_id, subject_id),
)
return Response(status_code=204)
def _require_manager(conn, principal: Principal, room_id: UUID) -> None:
membership = conn.execute(
"""
SELECT role FROM room_memberships
WHERE room_id = %s AND subject_id = %s AND status = 'active'
""",
(room_id, principal.account_id),
).fetchone()
room = conn.execute("SELECT kind FROM data_rooms WHERE id = %s", (room_id,)).fetchone()
if room is None or room["kind"] != "organization" or membership is None or membership["role"] != "manager":
raise forbidden()
@router.get("/api/v1/principals")
def find_principal(email: str, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
account = account_by_email(conn, email)
if account is None or account["status"] != "active":
raise not_found()
return {"id": str(account["id"]), "email": account["email"], "display_name": account["display_name"]}
@router.get("/api/v1/cases")
def cases(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
items = []
for case, rights in list_cases(conn, principal.account_id):
summary = case_summary(case, rights)
summary["home_scope_name"] = room_name(conn, case["home_scope_id"])
summary["kind_label"] = "Unterakte" if case["parent_case_id"] else "Akte"
summary["parent_title"] = None
if case["parent_case_id"]:
parent = get_case(conn, case["parent_case_id"])
if parent is not None and case_rights(conn, principal.account_id, parent).read:
summary["parent_title"] = parent["title"]
items.append(summary)
return {"items": items, "next_cursor": None}
@router.post("/api/v1/cases")
def post_case(body: CaseIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
case = create_case(
conn,
principal.account_id,
_chosen_home(conn, principal, body.home_scope_id),
body.title,
body.parent_case_id,
body.rights_mode,
)
rights = case_rights(conn, principal.account_id, case)
return _created(f"/api/v1/cases/{case['id']}", case_summary(case, rights))
@router.get("/api/v1/cases/{case_id}")
def get_one_case(case_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
case, rights = require_case(conn, principal.account_id, case_id, "read")
return case_detail(conn, principal.account_id, case, rights)
@router.patch("/api/v1/cases/{case_id}")
def patch_one_case(
case_id: UUID,
body: CasePatch,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
case = patch_case(conn, principal.account_id, case_id, body.expected_version, body.title, body.status)
rights = case_rights(conn, principal.account_id, case)
return case_summary(case, rights)
@router.post("/api/v1/cases/{case_id}/chapters")
def post_case_chapter(
case_id: UUID,
body: ChapterIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
row = create_chapter(conn, principal.account_id, "case", case_id, body.title, body.position, None, body.document_on)
return _created(
f"/api/v1/cases/{case_id}/chapters/{row['id']}",
{"id": str(row["id"]), "title": row["title"], "position": row["position"], "document_on": dump_date(row["document_on"])},
)
@router.post("/api/v1/cases/{case_id}/chapters/order")
def post_case_chapter_order(
case_id: UUID,
body: ChapterOrderIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
version = reorder_chapters(conn, principal.account_id, "case", case_id, body.expected_version, body.chapter_ids, None)
return {"version": version}
@router.post("/api/v1/cases/{case_id}/grants")
def post_case_grant(
case_id: UUID,
body: GrantIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
account = account_by_email(conn, body.email)
if account is None:
raise not_found()
grant = grant_access(
conn, principal.account_id, "case", case_id, account["id"], body.can_read, body.can_edit, body.can_share, None
)
return _created(f"/api/v1/grants/{grant['id']}", {"id": str(grant["id"])})
@router.get("/api/v1/matters")
def matters(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
items = [matter_summary(conn, principal.account_id, matter) for matter, _contexts in list_matters(conn, principal.account_id)]
return {"items": items, "next_cursor": None}
@router.post("/api/v1/matters")
def post_matter(body: MatterIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
matter = create_matter(
conn,
principal.account_id,
_chosen_home(conn, principal, body.home_scope_id),
body.title,
body.parent_matter_id,
_ctx_model(body.context),
)
return _created(f"/api/v1/matters/{matter['id']}", matter_summary(conn, principal.account_id, matter))
@router.get("/api/v1/matters/{matter_id}")
def get_one_matter(
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")
return matter_detail(conn, principal.account_id, matter, rights, context)
@router.patch("/api/v1/matters/{matter_id}")
def patch_one_matter(
matter_id: UUID,
body: MatterPatch,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
matter = patch_matter(
conn, principal.account_id, matter_id, body.expected_version, body.title, body.status, _ctx_model(body.context)
)
return matter_summary(conn, principal.account_id, matter)
@router.post("/api/v1/matters/{matter_id}/chapters")
def post_matter_chapter(
matter_id: UUID,
body: ChapterIn,
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)
row = create_chapter(
conn, principal.account_id, "matter", matter_id, body.title, body.position, context, body.document_on
)
return _created(
f"/api/v1/matters/{matter_id}/chapters/{row['id']}",
{"id": str(row["id"]), "title": row["title"], "position": row["position"], "document_on": dump_date(row["document_on"])},
)
@router.post("/api/v1/matters/{matter_id}/chapters/order")
def post_matter_chapter_order(
matter_id: UUID,
body: ChapterOrderIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
version = reorder_chapters(
conn, principal.account_id, "matter", matter_id, body.expected_version, body.chapter_ids, _ctx_model(body.context)
)
return {"version": version}
@router.patch("/api/v1/chapters/{chapter_id}")
def patch_chapter_date(
chapter_id: UUID,
body: ChapterDateIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
version = set_chapter_date(
conn, principal.account_id, chapter_id, body.expected_version, body.document_on, _ctx_model(body.context)
)
return {"version": version, "document_on": dump_date(body.document_on)}
@router.post("/api/v1/matters/{matter_id}/case-links")
def post_case_link(
matter_id: UUID,
body: CaseLinkIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
link = link_matter_to_case(conn, principal.account_id, matter_id, body.case_id, _ctx_model(body.context))
return _created(f"/api/v1/matter-case-links/{link['id']}", {"id": str(link["id"]), "case_id": str(body.case_id)})
@router.delete("/api/v1/matter-case-links/{link_id}", status_code=204)
def delete_case_link(link_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
unlink_matter_case(conn, principal.account_id, link_id)
return Response(status_code=204)
@router.post("/api/v1/matters/{matter_id}/cross-links")
def post_cross_link(
matter_id: UUID,
body: CrossLinkIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
row = create_cross_link(
conn,
principal.account_id,
matter_id,
body.target_matter_id,
_ctx_model(body.source_context),
Ctx(body.target_context.kind, body.target_context.id),
)
return _created(f"/api/v1/matter-cross-links/{row['id']}", {"id": str(row["id"])})
@router.delete("/api/v1/matter-cross-links/{link_id}", status_code=204)
def remove_cross_link(
link_id: UUID,
context_kind: str | None = None,
context_id: str | None = None,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
delete_cross_link(conn, principal.account_id, link_id, parse_query_context(context_kind, context_id))
return Response(status_code=204)
@router.post("/api/v1/matters/{matter_id}/grants")
def post_matter_grant(
matter_id: UUID,
body: GrantIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
account = account_by_email(conn, body.email)
if account is None:
raise not_found()
grant = grant_access(
conn, principal.account_id, "matter", matter_id, account["id"], body.can_read, body.can_edit, body.can_share, None
)
return _created(f"/api/v1/grants/{grant['id']}", {"id": str(grant["id"])})
@router.delete("/api/v1/grants/{grant_id}", status_code=204)
def delete_grant(grant_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
revoke_grant(conn, principal.account_id, grant_id)
return Response(status_code=204)
@router.put("/api/v1/exceptions")
def put_exception(body: ExceptionIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
set_exception(
conn,
principal.account_id,
body.resource_kind,
body.resource_id,
Ctx(body.context.kind, body.context.id),
body.remove_read,
body.remove_edit,
body.remove_share,
)
return {"ok": True}
@router.post("/api/v1/notes")
def post_note(body: NoteIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
created = create_note(
conn,
principal.account_id,
principal.scope_id,
body.title,
body.document.model_dump(),
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(
f"/api/v1/notes/{element['id']}",
note_update_payload(conn, principal.account_id, element, created["document"]),
)
@router.patch("/api/v1/notes/{element_id}")
def patch_note(
element_id: UUID,
body: NotePatch,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
updated = update_note(
conn,
principal.account_id,
element_id,
body.expected_version,
body.document.model_dump(),
_ctx_model(body.context),
)
return note_update_payload(conn, principal.account_id, updated["element"], updated["document"])
@router.post("/api/v1/bindings")
def post_binding(body: BindingIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
binding = bind_element(
conn,
principal.account_id,
body.element_id,
Ctx(body.source_context.kind, body.source_context.id),
Ctx(body.target.kind, body.target.id),
_ctx_model(body.target_context),
body.chapter_id,
)
return _created(f"/api/v1/bindings/{binding['id']}", {"id": str(binding["id"])})
@router.delete("/api/v1/bindings/{binding_id}", status_code=204)
def delete_binding(
binding_id: UUID,
context_kind: str | None = None,
context_id: str | None = None,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
detach_binding(conn, principal.account_id, binding_id, parse_query_context(context_kind, context_id))
return Response(status_code=204)
@router.post("/api/v1/bindings/{binding_id}/annotations")
def post_annotation(
binding_id: UUID,
body: AnnotationIn,
context_kind: str | None = None,
context_id: str | None = None,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
row = add_annotation(
conn, principal.account_id, binding_id, body.body, parse_query_context(context_kind, context_id)
)
return _created(f"/api/v1/bindings/{binding_id}/annotations/{row['id']}", {"id": str(row["id"]), "body": row["body"]})
@router.post("/api/v1/external-refs")
def post_external(body: ExternalIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
element = create_external(
conn,
principal.account_id,
principal.scope_id,
body.title,
body.source,
body.external_id,
Ctx(body.context.kind, body.context.id),
_ctx_model(body.placement),
body.chapter_id,
body.dates.document_on,
body.dates.sent_on,
body.dates.received_on,
body.detail.model_dump(exclude_none=True) if body.detail else None,
)
return _created(f"/api/v1/elements/{element['id']}", {"id": str(element["id"]), "title": element["title"]})
@router.post("/api/v1/files")
def post_file(
request: Request,
title: str = Form(),
context_kind: str = Form(),
context_id: UUID = Form(),
upload: UploadFile = File(),
placement_kind: str | None = Form(default=None),
placement_id: UUID | None = Form(default=None),
chapter_id: UUID | None = Form(default=None),
document_on: str | None = Form(default=None),
sent_on: str | None = Form(default=None),
received_on: str | None = Form(default=None),
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
settings = request.app.state.settings
cleaned_title = title.strip()
if not cleaned_title or len(cleaned_title) > 200:
raise unprocessable("Der Titel fehlt oder ist zu lang.")
data = upload.file.read(settings.upload_max_bytes + 1)
context = parse_context({"kind": context_kind, "id": str(context_id)}, required=True)
placement = None
if placement_kind or placement_id:
placement = parse_context({"kind": placement_kind, "id": str(placement_id)}, required=True)
request.state.cleanup_files = []
element = create_file(
conn,
principal.account_id,
principal.scope_id,
cleaned_title,
upload.filename or "datei",
data,
context,
placement,
chapter_id,
_parse_date(document_on),
_parse_date(sent_on),
_parse_date(received_on),
settings.media_root,
settings.upload_max_bytes,
request.state.cleanup_files,
)
return _created(f"/api/v1/elements/{element['id']}", {"id": str(element["id"]), "title": element["title"]})
@router.get("/api/v1/files/{element_id}/content")
def download_file(
element_id: UUID,
request: Request,
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)
element = get_element(conn, element_id)
if element is None or element["kind"] != "file":
raise not_found()
rights = element_rights(conn, principal.account_id, element, context)
if not rights.read:
raise not_found()
asset = conn.execute(
"SELECT id, original_filename, content_type, status FROM media_assets WHERE element_id = %s",
(element_id,),
).fetchone()
if asset is None or asset["status"] != "active":
raise not_found()
payload = read_bytes(asset_path(request.app.state.settings.media_root, asset["id"]))
return Response(
content=payload,
media_type=asset["content_type"],
headers={
"Content-Disposition": content_disposition(asset["original_filename"]),
"X-Content-Type-Options": "nosniff",
"Cache-Control": "private, no-store",
},
)
@router.post("/api/v1/elements/{element_id}/delete", status_code=204)
def destroy_element(
element_id: UUID,
body: DeleteElementIn,
request: Request,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
request.state.delete_after_commit = []
delete_element(
conn,
principal.account_id,
element_id,
body.expected_version,
request.app.state.settings.media_root,
request.state.delete_after_commit,
)
return Response(status_code=204)
@router.get("/api/v1/elements")
def elements(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
rows = conn.execute(
"""
SELECT * FROM elements
WHERE owner_subject_id = %s AND deleted_at IS NULL
AND NOT EXISTS (SELECT 1 FROM bindings b WHERE b.element_id = elements.id)
ORDER BY updated_at DESC, id DESC
LIMIT 100
""",
(principal.account_id,),
).fetchall()
return {
"items": [{"id": str(row["id"]), "kind": row["kind"], "title": row["title"], "version": row["version"]} for row in rows],
"next_cursor": None,
}
@router.post("/api/v1/tasks")
def post_task(body: TaskIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
task = create_task(
conn, principal.account_id, principal.scope_id, body.title, body.due_on, body.matter_id, _ctx_model(body.context)
)
rights = task_rights(conn, principal.account_id, task, _ctx_model(body.context))
return _created(f"/api/v1/tasks/{task['id']}", task_payload(conn, principal.account_id, task, rights))
@router.patch("/api/v1/tasks/{task_id}")
def patch_one_task(
task_id: UUID,
body: TaskPatch,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
task = patch_task(
conn,
principal.account_id,
task_id,
body.expected_version,
body.title,
body.due_on,
body.clear_due_on,
body.status,
_ctx_model(body.context),
)
rights = task_rights(conn, principal.account_id, task, _ctx_model(body.context))
return task_payload(conn, principal.account_id, task, rights)
@router.post("/api/v1/tasks/{task_id}/assignee")
def post_assignee(
task_id: UUID,
body: AssigneeIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
assignee = None
if body.email:
account = account_by_email(conn, body.email)
if account is None:
raise not_found()
assignee = account["id"]
task = assign_task(conn, principal.account_id, task_id, assignee, _ctx_model(body.context))
rights = task_rights(conn, principal.account_id, task, _ctx_model(body.context))
return task_payload(conn, principal.account_id, task, rights)
@router.post("/api/v1/tasks/{task_id}/deadline-links", status_code=204)
def post_task_deadline(
task_id: UUID,
body: TaskDeadlineIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
link_task_deadline(conn, principal.account_id, task_id, body.deadline_id, _ctx_model(body.context))
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(
conn, principal.account_id, principal.scope_id, body.title, body.due_on, body.matter_id, _ctx_model(body.context)
)
return _created(f"/api/v1/deadlines/{deadline['id']}", deadline_payload(conn, principal.account_id, deadline))
@router.patch("/api/v1/deadlines/{deadline_id}")
def patch_one_deadline(
deadline_id: UUID,
body: DeadlinePatch,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
deadline = patch_deadline(
conn, principal.account_id, deadline_id, body.expected_version, body.title, body.due_on, _ctx_model(body.context)
)
return deadline_payload(conn, principal.account_id, deadline)
@router.post("/api/v1/deadlines/{deadline_id}/fulfill")
def post_fulfill(
deadline_id: UUID,
body: FulfillIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
deadline = fulfill_deadline(conn, principal.account_id, deadline_id, body.expected_version, _ctx_model(body.context))
return deadline_payload(conn, principal.account_id, deadline)
@router.get("/api/v1/views/open-tasks")
def open_tasks(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
rows = conn.execute(
"""
SELECT * FROM tasks
WHERE deleted_at IS NULL AND task_status = 'open'
ORDER BY due_on NULLS LAST, created_at, id
LIMIT 200
"""
).fetchall()
items = []
for task in rows:
if _task_visible(conn, principal.account_id, task):
items.append(task_payload(conn, principal.account_id, task))
return {"items": items, "next_cursor": None}
@router.get("/api/v1/views/open-deadlines")
def open_deadlines(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
rows = conn.execute(
"""
SELECT * FROM deadlines
WHERE deleted_at IS NULL AND deadline_status = 'open'
ORDER BY due_on, created_at, id
LIMIT 200
"""
).fetchall()
items = []
for deadline in rows:
if _deadline_visible(conn, principal.account_id, deadline):
items.append(deadline_payload(conn, principal.account_id, deadline))
return {"items": items, "next_cursor": None}
@router.get("/api/v1/placement-targets")
def placement_targets(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
items = []
for case, rights in list_cases(conn, principal.account_id):
if rights.edit:
items.append({"kind": "case", "id": str(case["id"]), "title": case["title"]})
for matter, contexts in list_matters(conn, principal.account_id):
editable = [item for item in contexts if item["rights"]["edit"]]
if editable:
items.append(
{
"kind": "matter",
"id": str(matter["id"]),
"title": matter["title"],
"contexts": [
{
"kind": "direct" if item["kind"] == "matter" else item["kind"],
"id": item["id"],
"title": item["title"],
}
for item in editable
],
}
)
return {"items": items}
@router.get("/api/v1/search")
def search(q: str, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
term = q.strip()
if len(term) < 2:
raise unprocessable("Bitte mindestens zwei Zeichen suchen.")
pattern = "%" + term.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
items = []
for case, rights in list_cases(conn, principal.account_id):
if rights.read and term.casefold() in case["title"].casefold():
items.append({"kind": "case", "id": str(case["id"]), "title": case["title"], "contexts": []})
for matter, contexts in list_matters(conn, principal.account_id):
if term.casefold() in matter["title"].casefold():
items.append(
{
"kind": "matter",
"id": str(matter["id"]),
"title": matter["title"],
"contexts": [
{"kind": "direct" if item["kind"] == "matter" else item["kind"], "id": item["id"], "title": item["title"]}
for item in contexts
],
}
)
elements = conn.execute(
"""
SELECT e.*
FROM elements e
LEFT JOIN note_bodies n ON n.element_id = e.id
WHERE e.deleted_at IS NULL
AND (e.title ILIKE %s ESCAPE '\\' OR COALESCE(n.document_json::text, '') ILIKE %s ESCAPE '\\')
ORDER BY e.updated_at DESC
LIMIT 100
""",
(pattern, pattern),
).fetchall()
for element in elements:
from app.access.policy import visible_bindings_for_element
bindings = visible_bindings_for_element(conn, principal.account_id, element)
owner = element["owner_subject_id"] == principal.account_id
if not bindings and not owner:
continue
if not bindings and owner:
direct = element_rights(conn, principal.account_id, element, None)
if not direct.read:
continue
items.append(
{
"kind": element["kind"],
"id": str(element["id"]),
"title": element["title"],
"contexts": [
{
"kind": item["context_kind"],
"id": item["context_id"],
"title": item["context_title"],
"binding_id": item["id"],
"chapter_id": item.get("chapter_id"),
}
for item in bindings
],
}
)
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.patch("/api/v1/elements/{element_id}/summary")
def patch_element_summary(
element_id: UUID,
body: SummaryPatch,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
element = update_summary(
conn,
principal.account_id,
element_id,
body.expected_version,
body.summary,
_ctx_model(body.context),
)
return {"id": str(element["id"]), "version": element["version"], "summary": element["summary"]}
@router.patch("/api/v1/bindings/{binding_id}/chapter")
def patch_binding_chapter(
binding_id: UUID,
body: ChapterMoveIn,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
version = move_binding_chapter(
conn,
principal.account_id,
binding_id,
body.expected_version,
body.chapter_id,
_ctx_model(body.context),
)
return {"version": 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,
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(
"""
SELECT *
FROM domain_events
WHERE (resource_kind = 'case' AND resource_id = %(case)s)
OR (context_kind = 'case' AND context_id = %(case)s)
OR resource_id IN (SELECT matter_id FROM matter_case_links WHERE case_id = %(case)s)
OR resource_id IN (
SELECT element_id FROM bindings WHERE context_kind = 'case' AND context_id = %(case)s
UNION
SELECT b.element_id
FROM bindings b
JOIN matter_case_links l ON b.context_kind = 'matter' AND b.context_id = l.matter_id
WHERE l.case_id = %(case)s
)
ORDER BY COALESCE(occurred_on, occurred_at::date), occurred_at, id
""",
{"case": case_id},
).fetchall()
return _event_page(_visible_events(conn, principal.account_id, rows, page), cursor)
@router.get("/api/v1/matters/{matter_id}/chronology")
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),
):
context = parse_query_context(context_kind, context_id)
matter, _rights = require_matter(conn, principal.account_id, matter_id, context, "read")
page = context or Ctx("matter", matter["id"])
rows = conn.execute(
"""
SELECT *
FROM domain_events
WHERE resource_id = %(matter)s
OR (context_kind = 'matter' AND context_id = %(matter)s)
OR resource_id IN (
SELECT element_id FROM bindings WHERE context_kind = 'matter' AND context_id = %(matter)s
)
OR resource_id IN (
SELECT id FROM tasks WHERE matter_id = %(matter)s
UNION
SELECT id FROM deadlines WHERE matter_id = %(matter)s
)
ORDER BY COALESCE(occurred_on, occurred_at::date), occurred_at, id
""",
{"matter": matter_id},
).fetchall()
return _event_page(_visible_events(conn, principal.account_id, rows, page), cursor)
def _parse_date(value: str | None) -> date | None:
if value is None or value == "":
return None
try:
return date.fromisoformat(value)
except ValueError as exc:
raise unprocessable("Ein Datum ist ungültig.") from exc
def _task_visible(conn, actor: UUID, task: dict) -> bool:
if task_rights(conn, actor, task, None).read:
return True
matter = get_matter(conn, task["matter_id"]) if task["matter_id"] else None
if matter is None:
return False
return any(task_rights(conn, actor, task, Ctx(item["kind"], UUID(item["id"]))).read for item in _case_contexts(conn, actor, matter))
def _deadline_visible(conn, actor: UUID, deadline: dict) -> bool:
if deadline_rights(conn, actor, deadline, None).read:
return True
matter = get_matter(conn, deadline["matter_id"]) if deadline["matter_id"] else None
if matter is None:
return False
return any(
deadline_rights(conn, actor, deadline, Ctx(item["kind"], UUID(item["id"]))).read
for item in _case_contexts(conn, actor, matter)
)
def _case_contexts(conn, actor, matter) -> list[dict]:
from app.access.policy import readable_matter_contexts
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"],
"resource_id": str(event["resource_id"]),
}
)
return items
def _event_title(conn, actor: UUID, event: dict, page: Ctx) -> str | None:
kind = event["resource_kind"]
resource_id = event["resource_id"]
if kind == "case":
case = get_case(conn, resource_id)
if case is None or not case_rights(conn, actor, case).read:
return None
return case["title"]
if kind == "matter":
matter = get_matter(conn, resource_id)
if matter is None:
return None
context = page if page.kind == "case" else None
if not matter_rights(conn, actor, matter, context).read and not matter_rights(conn, actor, matter, None).read:
return None
if page.kind == "case" and not matter_rights(conn, actor, matter, page).read:
return None
return matter["title"]
if kind == "element":
element = get_element(conn, resource_id)
if element is None or not element_rights(conn, actor, element, page).read:
return None
return element["title"]
if kind == "task":
task = get_task(conn, resource_id)
if task is None or not task_rights(conn, actor, task, None if page.kind == "matter" else page).read:
if task is None or not task_rights(conn, actor, task, page).read:
return None
return task["title"] if task else None
if kind == "deadline":
deadline = get_deadline(conn, resource_id)
if deadline is None:
return None
direct = deadline_rights(conn, actor, deadline, None)
via = deadline_rights(conn, actor, deadline, page)
if not direct.read and not via.read:
return None
return deadline["title"]
return None