Compare commits
49
Commits
V1.0
...
cfa94fc84d
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
cfa94fc84d | ||
|
|
15e0dc7e52 | ||
|
|
2dde62b712 | ||
|
|
363ecdfd0a | ||
|
|
4bd2d047f5 | ||
|
|
f925661937 | ||
|
|
a6dc24d8fe | ||
|
|
64f22360c1 | ||
|
|
bee48bf4a5 | ||
|
|
6e1b0916a6 | ||
|
|
ffdaf1c721 | ||
|
|
0f2b7a8fab | ||
|
|
38406d3293 | ||
|
|
2f7de33049 | ||
|
|
5e32ba547d | ||
|
|
85c0bd1f39 | ||
|
|
f580fb282d | ||
|
|
9089d830b3 | ||
|
|
4327f5a434 | ||
|
|
14aa0a1e95 | ||
|
|
e2475555c0 | ||
|
|
7a1206b18c | ||
|
|
cd239a3ab8 | ||
|
|
d0f09830bb | ||
|
|
a3f328832e | ||
|
|
075525ee17 | ||
|
|
0a5daf6713 | ||
|
|
1d3c938def | ||
|
|
07e46c77f1 | ||
|
|
7b2d0c298e | ||
|
|
5f60e1fe40 | ||
|
|
322ad491c1 | ||
|
|
64dce6c20c | ||
|
|
d39c7d7999 | ||
|
|
30b6544514 | ||
|
|
1765714ccd | ||
|
|
1a2c959309 | ||
|
|
6d7b7c5f85 | ||
|
|
e47f50d513 | ||
|
|
ac3c3d81fe | ||
|
|
21c2d05fb8 | ||
|
|
1c2f045e7d | ||
|
|
037c0724a8 | ||
|
|
eb58dce4cd | ||
|
|
c29bd29f34 | ||
|
|
34c4084a7c | ||
|
|
7e39fbb2bd | ||
|
|
c3a07cee64 | ||
|
|
d6b70d8f92 |
No files matched your search
+38
-10
@@ -1,16 +1,15 @@
|
||||
name: Test Suite
|
||||
|
||||
# One run per push. The deploy starts at the same time and updates the checkout this suite tests,
|
||||
# so the jobs wait until that checkout contains the pushed commit. A workflow_run trigger
|
||||
# (after the deploy) did not start reliably on this Gitea, see git log of this file.
|
||||
on:
|
||||
push:
|
||||
branches: [develop]
|
||||
workflow_run:
|
||||
workflows: ["Deploy Development"]
|
||||
types: [completed]
|
||||
workflow_dispatch:
|
||||
|
||||
jobs:
|
||||
pytest-backend:
|
||||
if: ${{ github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success' }}
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: pytest against Dev Postgres (tsumugu_test)
|
||||
@@ -19,6 +18,19 @@ jobs:
|
||||
APP_DIR="/home/lars/docker/tsumugu-dev"
|
||||
COMPOSE_FILE="docker-compose.dev-env.yml"
|
||||
echo "pytest uses Dev Postgres (${APP_DIR}); event=${{ github.event_name }}"
|
||||
if [ "${{ github.event_name }}" = "push" ]; then
|
||||
for i in $(seq 1 180); do
|
||||
if git -c safe.directory='*' -C "$APP_DIR" merge-base --is-ancestor "${{ github.sha }}" HEAD 2>/dev/null; then
|
||||
echo "Dev checkout contains ${{ github.sha }} (attempt $i)"
|
||||
break
|
||||
fi
|
||||
if [ "$i" -eq 180 ]; then
|
||||
echo "the deploy did not reach ${{ github.sha }} within 15 minutes"
|
||||
exit 1
|
||||
fi
|
||||
sleep 5
|
||||
done
|
||||
fi
|
||||
cd "$APP_DIR"
|
||||
for i in $(seq 1 60); do
|
||||
if [ -f "$APP_DIR/backend/pytest.ini" ] && docker compose -f "$COMPOSE_FILE" exec -T backend true 2>/dev/null; then
|
||||
@@ -59,27 +71,43 @@ jobs:
|
||||
'
|
||||
|
||||
smoke-dev:
|
||||
if: ${{ github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success' }}
|
||||
# After pytest, so the deploy that started with the push has normally finished. The health check retries.
|
||||
needs: pytest-backend
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Non-destructive smoke against the running Dev app
|
||||
run: |
|
||||
set -e
|
||||
echo "live Dev API (tsumugu_dev), read-only health"
|
||||
curl -sf http://localhost:8094/api/health
|
||||
echo
|
||||
curl -sf http://localhost:3094/api/health
|
||||
echo
|
||||
for url in http://localhost:8094/api/health http://localhost:3094/api/health; do
|
||||
for i in $(seq 1 30); do
|
||||
if curl -sf "$url"; then echo; break; fi
|
||||
if [ "$i" -eq 30 ]; then echo "no health answer from $url"; exit 1; fi
|
||||
sleep 10
|
||||
done
|
||||
done
|
||||
echo "LAN smoke OK. Public URL after TLS: https://dev.tsumugu.jinkendo.de"
|
||||
|
||||
frontend-build:
|
||||
if: ${{ github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success' }}
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Frontend production build on Dev checkout
|
||||
run: |
|
||||
set -e
|
||||
APP_DIR="/home/lars/docker/tsumugu-dev"
|
||||
if [ "${{ github.event_name }}" = "push" ]; then
|
||||
for i in $(seq 1 180); do
|
||||
if git -c safe.directory='*' -C "$APP_DIR" merge-base --is-ancestor "${{ github.sha }}" HEAD 2>/dev/null; then
|
||||
echo "Dev checkout contains ${{ github.sha }} (attempt $i)"
|
||||
break
|
||||
fi
|
||||
if [ "$i" -eq 180 ]; then
|
||||
echo "the deploy did not reach ${{ github.sha }} within 15 minutes"
|
||||
exit 1
|
||||
fi
|
||||
sleep 5
|
||||
done
|
||||
fi
|
||||
cd "$APP_DIR/frontend"
|
||||
npm ci
|
||||
npm run build
|
||||
@@ -6,9 +6,9 @@ Remote: `http://192.168.2.144:3000/Lars/tsumugu.git`
|
||||
|
||||
## Stand
|
||||
|
||||
Die erste benutzbare Lieferung organisiert und verfolgt: Anmeldung, Datenräume, Akten und Vorgänge, Notizen, Dateien, manuelle Paperless-Referenzen, Chronologie, Aufgaben und unabhängige Fristen. Finanzfunktionen, automatische Paperless-Synchronisation, KI und externer Anwaltszugang folgen später.
|
||||
Die erste benutzbare Lieferung organisiert und verfolgt: Anmeldung, Datenräume, Akten und Vorgänge, Notizen, Dateien, manuelle Paperless-Referenzen, Chronologie, Aufgaben und unabhängige Fristen. Seitdem hinzugekommen: Paperless- und IMAP-Zugänge mit Auswahl und Vorschau, Antwortbezüge zwischen Unterlagen, Kommunikationsrichtung je Einbindung, Unterkapitel und das Übergabepaket als ZIP. Finanzfunktionen, automatische Paperless-Synchronisation, virtuelle Zusammenstellungen, KI und laufender Anwaltszugang folgen später.
|
||||
|
||||
Ein Push auf `develop` baut und startet Development, ein Merge von `develop` nach `main` die Produktion. Der Gitea-Runner auf dem Raspberry Pi (`192.168.2.49`) übernimmt Build und Deploy. Beim Start führt das Backend die Migrationen aus. In Development legt es synthetische Beispieldaten an, in Production nicht.
|
||||
Ein Push auf `develop` baut und startet Development, ein Merge von `develop` nach `main` die Produktion. Der Gitea-Runner auf dem Raspberry Pi (`192.168.2.49`) übernimmt Build und Deploy. Beim Start führt das Backend die Migrationen aus und entfernt Konten mit Herkunft `fixture`. Synthetische Beispieldaten entstehen in keiner Umgebung automatisch, nur in der Test-Suite auf einer Datenbank `*_test`.
|
||||
|
||||
| | Development | Production |
|
||||
|---|---|---|
|
||||
@@ -19,11 +19,12 @@ Ein Push auf `develop` baut und startet Development, ein Merge von `develop` nac
|
||||
|
||||
Details, Ports und der Synology-Reverse-Proxy: `docs/DEPLOYMENT.md`.
|
||||
|
||||
Development ist nach dem Deploy unter https://dev.tsumugu.jinkendo.de oder http://192.168.2.49:3094 erreichbar. Die Beispielkonten stehen auf der Anmeldeseite:
|
||||
Development ist nach dem Deploy unter https://dev.tsumugu.jinkendo.de oder http://192.168.2.49:3094 erreichbar. Auf einer leeren Datenbank bietet die Anmeldeseite einmalig das Anlegen des Betreiberkontos an; der Betreiber legt danach weitere Konten unter „Verwaltung → Nutzer“ an.
|
||||
|
||||
| | E-Mail | Passwort |
|
||||
|---|---|---|
|
||||
| Ada Beispiel | ada@example.test | Beispiel-Ada-2026 |
|
||||
| Ben Beispiel | ben@example.test | Beispiel-Ben-2026 |
|
||||
Die synthetischen Beispielkonten „Ada Beispiel“ (`ada@example.test`) und „Ben Beispiel“ (`ben@example.test`) mit dem Mietstreit Musterstraße legt nur die Test-Suite an (`backend/app/seed.py`). Die Anmeldeseite zeigt sie ausschließlich in Development mit einer Datenbank `*_test` und `SEED_DEMO=true`. Auf `tsumugu_dev` und `tsumugu` gibt es sie nicht; der Start entfernt sie dort.
|
||||
|
||||
Ada führt den Mietstreit Musterstraße. Ben darf diesen Kontext bearbeiten und sieht die private Verhandlungsstrategie nicht. Vorläufige Rechte- und Löschannahmen: `docs/MVP_ANNAHMEN.md`. `/api/health` prüft weiterhin nur, ob die Anwendung und die Datenbank antworten.
|
||||
Vorläufige Rechte- und Löschannahmen: `docs/MVP_ANNAHMEN.md`. `/api/health` prüft weiterhin nur, ob die Anwendung und die Datenbank antworten.
|
||||
|
||||
## Dokumentation
|
||||
|
||||
Übersicht aller Dokumente: [docs/README.md](docs/README.md). Lokaler Start und Tests: [docs/ENTWICKLUNG_UND_TESTS.md](docs/ENTWICKLUNG_UND_TESTS.md). Letztes Code-Review: [docs/review/](docs/review/README.md).
|
||||
@@ -0,0 +1,26 @@
|
||||
"""The one place where subscription limits will be checked.
|
||||
|
||||
Today there are no limits. The checks are called where a limit will matter, so that a plan
|
||||
can be added without touching the callers.
|
||||
|
||||
Target model (see the entitlements blueprint): the quota subject is the owner of a room, a main
|
||||
user, like the club at Shinkan. A plan, set by the operator, may later cap the number of active
|
||||
employees per main user and per room. The count comes from the database, never from the client.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
|
||||
def ensure_can_create_room(conn, owner_id: UUID) -> None:
|
||||
"""Called before a main user creates a room."""
|
||||
del conn, owner_id
|
||||
|
||||
|
||||
def ensure_can_add_member(conn, owner_id: UUID, room_id: UUID) -> None:
|
||||
"""Called before a person becomes an active member of a room or is invited to it.
|
||||
|
||||
``owner_id`` is the owner of the room, the future quota subject.
|
||||
"""
|
||||
del conn, owner_id, room_id
|
||||
+141
-14
@@ -24,30 +24,52 @@ class Rights:
|
||||
edit: bool = False
|
||||
share: bool = False
|
||||
delete: bool = False
|
||||
# Saving or opening the original outside of Tsumugu. Reading in the app does not need it.
|
||||
download: bool = False
|
||||
|
||||
@classmethod
|
||||
def full(cls) -> Rights:
|
||||
return cls(True, True, True, True)
|
||||
return cls(True, True, True, True, True)
|
||||
|
||||
@classmethod
|
||||
def from_row(cls, row: dict | None) -> Rights:
|
||||
def from_row(cls, row: dict | None, download: bool = False) -> Rights:
|
||||
if row is None:
|
||||
return cls()
|
||||
return cls(bool(row["can_read"]), bool(row["can_edit"]), bool(row["can_share"]), bool(row["can_delete"]))
|
||||
return cls(bool(row["can_read"]), bool(row["can_edit"]), bool(row["can_share"]), bool(row["can_delete"]), download and bool(row["can_read"]))
|
||||
|
||||
def union(self, other: Rights) -> Rights:
|
||||
return Rights(
|
||||
self.read or other.read,
|
||||
self.edit or other.edit,
|
||||
self.share or other.share,
|
||||
self.delete or other.delete,
|
||||
self.download or other.download,
|
||||
)
|
||||
|
||||
def without(self, blocked: Rights) -> Rights:
|
||||
# An exception that takes away reading takes away downloading too.
|
||||
return Rights(
|
||||
self.read and not blocked.read,
|
||||
self.edit and not blocked.edit,
|
||||
self.share and not blocked.share,
|
||||
self.delete and not blocked.delete,
|
||||
self.download and not blocked.read,
|
||||
)
|
||||
|
||||
def allows(self, need: str) -> bool:
|
||||
return bool(getattr(self, need))
|
||||
|
||||
def as_dict(self) -> dict[str, bool]:
|
||||
return {"read": self.read, "edit": self.edit, "share": self.share, "delete": self.delete}
|
||||
return {"read": self.read, "edit": self.edit, "share": self.share, "delete": self.delete, "download": self.read and self.download}
|
||||
|
||||
|
||||
# The room share: what a room role may do with a case or matter that is shared with the room.
|
||||
# Sharing, deleting and ownership never come from a room role. An unknown role gets nothing.
|
||||
ROOM_RIGHTS = {
|
||||
"reader": Rights(read=True),
|
||||
"member": Rights(read=True, edit=True),
|
||||
"manager": Rights(read=True, edit=True),
|
||||
}
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
@@ -189,7 +211,25 @@ def _direct_grant(conn, actor: UUID, kind: str, resource_id: UUID) -> Rights:
|
||||
""",
|
||||
(actor, kind, resource_id),
|
||||
).fetchone()
|
||||
return Rights.from_row(row)
|
||||
if row is None:
|
||||
return Rights()
|
||||
return Rights.from_row(row, _direct_download(conn, kind, resource_id))
|
||||
|
||||
|
||||
def _direct_download(conn, kind: str, resource_id: UUID) -> bool:
|
||||
"""Direct recipients follow the download setting `direct` of the owner of the entry."""
|
||||
table = {"case": "cases", "matter": "matters", "element": "elements"}.get(kind)
|
||||
if table is None:
|
||||
return False
|
||||
row = conn.execute(
|
||||
f"""
|
||||
SELECT a.download_defaults
|
||||
FROM {table} r JOIN auth_accounts a ON a.id = r.owner_subject_id
|
||||
WHERE r.id = %s
|
||||
""",
|
||||
(resource_id,),
|
||||
).fetchone()
|
||||
return bool(row and row["download_defaults"].get("direct", False))
|
||||
|
||||
|
||||
def _exceptions(conn, actor: UUID, kind: str, resource_id: UUID, context: Ctx | None) -> Rights:
|
||||
@@ -223,6 +263,37 @@ def _exceptions(conn, actor: UUID, kind: str, resource_id: UUID, context: Ctx |
|
||||
return blocked
|
||||
|
||||
|
||||
def room_default(conn, actor: UUID, kind: str, resource_id: UUID) -> Rights:
|
||||
"""Rights of the current members of the rooms a case or matter is shared with.
|
||||
|
||||
A room is a team. The rights of one share are the role of the person in that room,
|
||||
capped by the share (`read` or `edit`). Several shares add up. Only an active room,
|
||||
an active membership and an active account count. Anything unclear gives no rights.
|
||||
"""
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT m.role, s.access, r.download_roles
|
||||
FROM room_shares s
|
||||
JOIN room_memberships m ON m.room_id = s.room_id AND m.subject_id = %s AND m.status = 'active'
|
||||
JOIN data_rooms r ON r.id = s.room_id AND r.kind = 'organization' AND r.status = 'active'
|
||||
JOIN auth_accounts a ON a.id = m.subject_id AND a.status = 'active'
|
||||
WHERE s.resource_kind = %s AND s.resource_id = %s
|
||||
""",
|
||||
(actor, kind, resource_id),
|
||||
).fetchall()
|
||||
result = Rights()
|
||||
for row in rows:
|
||||
rights = ROOM_RIGHTS.get(row["role"], Rights())
|
||||
if row["access"] == "read":
|
||||
rights = Rights(read=rights.read)
|
||||
elif row["access"] != "edit":
|
||||
rights = Rights()
|
||||
if rights.read and row["download_roles"].get(row["role"], False):
|
||||
rights = Rights(rights.read, rights.edit, rights.share, rights.delete, True)
|
||||
result = result.union(rights)
|
||||
return result
|
||||
|
||||
|
||||
def case_rights(conn, actor: UUID, case: dict) -> Rights:
|
||||
if case["parent_case_id"] is not None and case["rights_mode"] == "inherit_parent":
|
||||
parent = get_case(conn, case["parent_case_id"])
|
||||
@@ -230,7 +301,7 @@ def case_rights(conn, actor: UUID, case: dict) -> Rights:
|
||||
elif case["owner_subject_id"] == actor:
|
||||
base = Rights.full()
|
||||
else:
|
||||
base = _direct_grant(conn, actor, "case", case["id"])
|
||||
base = _direct_grant(conn, actor, "case", case["id"]).union(room_default(conn, actor, "case", case["id"]))
|
||||
return base.without(_exceptions(conn, actor, "case", case["id"], None))
|
||||
|
||||
|
||||
@@ -244,7 +315,10 @@ def _linked(conn, matter_id: UUID, case_id: UUID) -> bool:
|
||||
|
||||
def matter_rights(conn, actor: UUID, matter: dict, context: Ctx | None) -> Rights:
|
||||
if context is None:
|
||||
base = Rights.full() if matter["owner_subject_id"] == actor else _direct_grant(conn, actor, "matter", matter["id"])
|
||||
if matter["owner_subject_id"] == actor:
|
||||
base = Rights.full()
|
||||
else:
|
||||
base = _direct_grant(conn, actor, "matter", matter["id"]).union(room_default(conn, actor, "matter", matter["id"]))
|
||||
return base.without(_exceptions(conn, actor, "matter", matter["id"], None))
|
||||
|
||||
if context.kind == "case":
|
||||
@@ -384,8 +458,35 @@ def _source_grant(conn, actor: UUID, kind: str, resource_id: UUID) -> dict | Non
|
||||
).fetchone()
|
||||
|
||||
|
||||
def room_source_access(conn, actor: UUID, kind: str, resource_id: UUID, owner_id: UUID) -> bool:
|
||||
"""Whether a room the entry is shared with lets this member read the owner's linked originals.
|
||||
|
||||
The owner has switched it on for this person in that room. Only an active room, an active
|
||||
membership with a reading role and an active account count.
|
||||
"""
|
||||
readers = [role for role, rights in ROOM_RIGHTS.items() if rights.read]
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT 1
|
||||
FROM room_shares s
|
||||
JOIN room_memberships m ON m.room_id = s.room_id AND m.subject_id = %s AND m.status = 'active'
|
||||
JOIN data_rooms r ON r.id = s.room_id AND r.kind = 'organization' AND r.status = 'active'
|
||||
JOIN auth_accounts a ON a.id = m.subject_id AND a.status = 'active'
|
||||
JOIN room_source_access x ON x.room_id = s.room_id AND x.subject_id = m.subject_id AND x.owner_id = %s
|
||||
WHERE s.resource_kind = %s AND s.resource_id = %s AND m.role = ANY(%s)
|
||||
LIMIT 1
|
||||
""",
|
||||
(actor, owner_id, kind, resource_id, readers),
|
||||
).fetchone()
|
||||
return row is not None
|
||||
|
||||
|
||||
def mediated_source_owner(conn, actor: UUID, element: dict, context: Ctx | None) -> UUID | None:
|
||||
"""Owner whose stored connector may serve this reader. None unless the grant allows it."""
|
||||
"""Owner whose stored connector may serve this reader.
|
||||
|
||||
None unless the owner allowed it, either on the personal grant or for this person in a room
|
||||
the entry is shared with. Read rights and exceptions are checked first.
|
||||
"""
|
||||
if context is None or not element_rights(conn, actor, element, context).read:
|
||||
return None
|
||||
if context.kind == "case":
|
||||
@@ -393,19 +494,21 @@ def mediated_source_owner(conn, actor: UUID, element: dict, context: Ctx | None)
|
||||
if resource is None:
|
||||
return None
|
||||
resource = _rights_bearing_case(conn, resource)
|
||||
grant = _source_grant(conn, actor, "case", resource["id"])
|
||||
elif context.kind == "matter":
|
||||
resource = get_matter(conn, context.id)
|
||||
if resource is None:
|
||||
return None
|
||||
grant = _source_grant(conn, actor, "matter", resource["id"])
|
||||
else:
|
||||
return None
|
||||
if resource["owner_subject_id"] == actor:
|
||||
owner = resource["owner_subject_id"]
|
||||
if owner == actor:
|
||||
return None
|
||||
if grant is None or not grant["can_read"] or not grant["use_owner_sources"]:
|
||||
return None
|
||||
return resource["owner_subject_id"]
|
||||
grant = _source_grant(conn, actor, context.kind, resource["id"])
|
||||
if grant is not None and grant["can_read"] and grant["use_owner_sources"]:
|
||||
return owner
|
||||
if room_source_access(conn, actor, context.kind, resource["id"], owner):
|
||||
return owner
|
||||
return None
|
||||
|
||||
|
||||
def element_rights_via_case_or_direct(conn, actor: UUID, element: dict, context: Ctx | None) -> Rights:
|
||||
@@ -571,6 +674,12 @@ def list_cases(conn, actor: UUID) -> list[dict]:
|
||||
AND g.grantee_subject_id = %(actor)s AND NOT g.is_exception AND g.can_read
|
||||
AND g.context_id IS NULL
|
||||
)
|
||||
OR (EXISTS (
|
||||
SELECT 1 FROM room_shares sh
|
||||
JOIN room_memberships sm ON sm.room_id = sh.room_id AND sm.subject_id = %(actor)s AND sm.status = 'active'
|
||||
JOIN data_rooms sr ON sr.id = sh.room_id AND sr.kind = 'organization' AND sr.status = 'active'
|
||||
WHERE sh.resource_kind = 'case' AND sh.resource_id = c.id
|
||||
))
|
||||
OR (
|
||||
c.rights_mode = 'inherit_parent' AND c.parent_case_id IS NOT NULL AND EXISTS (
|
||||
SELECT 1 FROM cases p
|
||||
@@ -583,6 +692,12 @@ def list_cases(conn, actor: UUID) -> list[dict]:
|
||||
AND g.grantee_subject_id = %(actor)s AND NOT g.is_exception
|
||||
AND g.can_read AND g.context_id IS NULL
|
||||
)
|
||||
OR (EXISTS (
|
||||
SELECT 1 FROM room_shares sh
|
||||
JOIN room_memberships sm ON sm.room_id = sh.room_id AND sm.subject_id = %(actor)s AND sm.status = 'active'
|
||||
JOIN data_rooms sr ON sr.id = sh.room_id AND sr.kind = 'organization' AND sr.status = 'active'
|
||||
WHERE sh.resource_kind = 'case' AND sh.resource_id = p.id
|
||||
))
|
||||
)
|
||||
)
|
||||
)
|
||||
@@ -613,6 +728,12 @@ def list_matters(conn, actor: UUID) -> list[tuple[dict, list[dict]]]:
|
||||
AND g.grantee_subject_id = %(actor)s AND NOT g.is_exception AND g.can_read
|
||||
AND g.context_id IS NULL
|
||||
)
|
||||
OR (EXISTS (
|
||||
SELECT 1 FROM room_shares sh
|
||||
JOIN room_memberships sm ON sm.room_id = sh.room_id AND sm.subject_id = %(actor)s AND sm.status = 'active'
|
||||
JOIN data_rooms sr ON sr.id = sh.room_id AND sr.kind = 'organization' AND sr.status = 'active'
|
||||
WHERE sh.resource_kind = 'matter' AND sh.resource_id = m.id
|
||||
))
|
||||
OR EXISTS (
|
||||
SELECT 1 FROM matter_case_links l
|
||||
JOIN cases c ON c.id = l.case_id AND c.deleted_at IS NULL
|
||||
@@ -625,6 +746,12 @@ def list_matters(conn, actor: UUID) -> list[tuple[dict, list[dict]]]:
|
||||
AND g.grantee_subject_id = %(actor)s AND NOT g.is_exception
|
||||
AND g.can_read AND g.context_id IS NULL
|
||||
)
|
||||
OR (EXISTS (
|
||||
SELECT 1 FROM room_shares sh
|
||||
JOIN room_memberships sm ON sm.room_id = sh.room_id AND sm.subject_id = %(actor)s AND sm.status = 'active'
|
||||
JOIN data_rooms sr ON sr.id = sh.room_id AND sr.kind = 'organization' AND sr.status = 'active'
|
||||
WHERE sh.resource_kind = 'case' AND sh.resource_id = c.id
|
||||
))
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
"""Fixed role bundles. Rights are read from the current database state, never from the session.
|
||||
|
||||
Platform: operator or user. Data room: member, manager or reader. There is no role editor.
|
||||
An operator has no read right on content. Unknown role or status is refused.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
from app.core.errors import forbidden
|
||||
|
||||
ROOM_ROLES = ("member", "manager", "reader")
|
||||
|
||||
ROOM_ROLE_LABELS = {
|
||||
"member": "Mitglied",
|
||||
"manager": "Verwalter",
|
||||
"reader": "Leser",
|
||||
}
|
||||
|
||||
|
||||
def account_kind(conn, account_id: UUID) -> str | None:
|
||||
row = conn.execute("SELECT account_kind FROM auth_accounts WHERE id = %s AND status = 'active'", (account_id,)).fetchone()
|
||||
return row["account_kind"] if row else None
|
||||
|
||||
|
||||
def require_main_user(conn, account_id: UUID) -> None:
|
||||
"""Employees work in the rooms they were invited to. They create no rooms of their own."""
|
||||
if account_kind(conn, account_id) != "main":
|
||||
raise forbidden("Als Mitarbeiter arbeitest du in den Räumen, in die du eingeladen wurdest.")
|
||||
|
||||
|
||||
def is_operator(conn, account_id: UUID) -> bool:
|
||||
row = conn.execute(
|
||||
"SELECT is_superadmin FROM auth_accounts WHERE id = %s AND status = 'active'",
|
||||
(account_id,),
|
||||
).fetchone()
|
||||
return bool(row and row["is_superadmin"])
|
||||
|
||||
|
||||
def require_operator(conn, account_id: UUID) -> None:
|
||||
if not is_operator(conn, account_id):
|
||||
raise forbidden("Das darf nur der Betreiber.")
|
||||
|
||||
|
||||
def room_role(conn, account_id: UUID, room_id: UUID) -> str | None:
|
||||
"""The active role of an account in an organization room, or None."""
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT m.role
|
||||
FROM room_memberships m
|
||||
JOIN data_rooms r ON r.id = m.room_id
|
||||
WHERE m.room_id = %s AND m.subject_id = %s AND m.status = 'active' AND r.kind = 'organization'
|
||||
""",
|
||||
(room_id, account_id),
|
||||
).fetchone()
|
||||
if row is None or row["role"] not in ROOM_ROLES:
|
||||
return None
|
||||
return row["role"]
|
||||
|
||||
|
||||
def require_room_manager(conn, account_id: UUID, room_id: UUID) -> None:
|
||||
if room_role(conn, account_id, room_id) != "manager":
|
||||
raise forbidden("Das darf nur ein Verwalter dieses Datenraums.")
|
||||
|
||||
|
||||
def require_room_write(conn, account_id: UUID, room: dict) -> None:
|
||||
"""Creating content needs the own personal room or a member or manager role."""
|
||||
if room["kind"] == "personal":
|
||||
if room["id"] != account_id:
|
||||
raise forbidden("Der persönliche Datenraum gehört zu einem anderen Konto.")
|
||||
require_main_user(conn, account_id)
|
||||
return
|
||||
role = room_role(conn, account_id, room["id"])
|
||||
if role in {"member", "manager"}:
|
||||
return
|
||||
if role == "reader":
|
||||
raise forbidden("Als Leser kannst du in diesem Datenraum nichts anlegen.")
|
||||
raise forbidden("Du bist in diesem Datenraum nicht Mitglied.")
|
||||
|
||||
|
||||
def count_active_operators(conn, *, lock: bool = False) -> int:
|
||||
suffix = " FOR UPDATE" if lock else ""
|
||||
rows = conn.execute(f"SELECT id FROM auth_accounts WHERE is_superadmin AND status = 'active'{suffix}").fetchall()
|
||||
return len(rows)
|
||||
|
||||
|
||||
def count_active_managers(conn, room_id: UUID, *, lock: bool = False) -> int:
|
||||
suffix = " FOR UPDATE" if lock else ""
|
||||
rows = conn.execute(
|
||||
f"""
|
||||
SELECT m.subject_id FROM room_memberships m
|
||||
JOIN auth_accounts a ON a.id = m.subject_id
|
||||
WHERE m.room_id = %s AND m.role = 'manager' AND m.status = 'active' AND a.status = 'active'{suffix}
|
||||
""",
|
||||
(room_id,),
|
||||
).fetchall()
|
||||
return len(rows)
|
||||
|
||||
|
||||
def ensure_can_create(conn, account_id: UUID, scope_id: UUID) -> None:
|
||||
"""Gate for every operation that creates content with this home room."""
|
||||
room = conn.execute("SELECT id, kind FROM data_rooms WHERE id = %s", (scope_id,)).fetchone()
|
||||
if room is None:
|
||||
raise forbidden("Der gewählte Datenraum ist nicht verfügbar.")
|
||||
require_room_write(conn, account_id, room)
|
||||
@@ -0,0 +1,273 @@
|
||||
"""Account administration for the operator and the own account (password, sessions)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends, Response
|
||||
from fastapi.responses import JSONResponse
|
||||
from psycopg import Connection
|
||||
|
||||
from app.access.policy import audit
|
||||
from app.access.roles import require_operator
|
||||
from app.api.deps import Principal, get_conn, get_principal, get_session
|
||||
from app.api.schemas import AccountIn, AccountPatchIn, PasswordChangeIn
|
||||
from app.auth.accounts import (
|
||||
promote_to_main,
|
||||
change_own_password,
|
||||
create_account,
|
||||
generate_password,
|
||||
reset_password,
|
||||
revoke_sessions,
|
||||
set_display_name,
|
||||
set_operator,
|
||||
set_status,
|
||||
)
|
||||
from app.core.errors import not_found, unprocessable
|
||||
from app.core.timeutil import dump_dt
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
_NO_STORE = {"Cache-Control": "no-store"}
|
||||
|
||||
|
||||
def _account_item(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"email": row["email"],
|
||||
"display_name": row["display_name"],
|
||||
"is_superadmin": row["is_superadmin"],
|
||||
"status": row["status"],
|
||||
"must_change_password": row["must_change_password"],
|
||||
"created_at": dump_dt(row["created_at"]),
|
||||
"last_login_at": dump_dt(row["last_login_at"]),
|
||||
"account_kind": row["account_kind"],
|
||||
"sponsor_id": str(row["sponsor_id"]) if row["sponsor_id"] else None,
|
||||
"sponsor_name": row.get("sponsor_name"),
|
||||
}
|
||||
|
||||
|
||||
@router.get("/api/v1/accounts")
|
||||
def accounts(
|
||||
status: str | None = None,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
require_operator(conn, principal.account_id)
|
||||
if status not in {None, "active", "disabled"}:
|
||||
raise unprocessable("Der Statusfilter ist ungültig.")
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT id, email, display_name, is_superadmin, status, must_change_password, created_at, last_login_at,
|
||||
account_kind, sponsor_id,
|
||||
(SELECT s.display_name FROM auth_accounts s WHERE s.id = auth_accounts.sponsor_id) AS sponsor_name
|
||||
FROM auth_accounts
|
||||
WHERE origin = 'operator' AND (%s::text IS NULL OR status = %s::text)
|
||||
ORDER BY status, display_name, email
|
||||
""",
|
||||
(status, status),
|
||||
).fetchall()
|
||||
return {"items": [_account_item(row) for row in rows], "next_cursor": None}
|
||||
|
||||
|
||||
@router.get("/api/v1/accounts/{account_id}")
|
||||
def account_detail(account_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
require_operator(conn, principal.account_id)
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT id, email, display_name, is_superadmin, status, must_change_password, created_at, last_login_at,
|
||||
account_kind, sponsor_id,
|
||||
(SELECT s.display_name FROM auth_accounts s WHERE s.id = auth_accounts.sponsor_id) AS sponsor_name
|
||||
FROM auth_accounts WHERE id = %s AND origin = 'operator'
|
||||
""",
|
||||
(account_id,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise not_found()
|
||||
rooms = conn.execute(
|
||||
"""
|
||||
SELECT r.id, r.name, r.status, m.role
|
||||
FROM room_memberships m
|
||||
JOIN data_rooms r ON r.id = m.room_id
|
||||
WHERE m.subject_id = %s AND m.status = 'active' AND r.kind = 'organization'
|
||||
ORDER BY r.name, r.id
|
||||
""",
|
||||
(account_id,),
|
||||
).fetchall()
|
||||
sessions = conn.execute(
|
||||
"""
|
||||
SELECT count(*) AS n FROM auth_sessions
|
||||
WHERE account_id = %s AND revoked_at IS NULL AND expires_at > now()
|
||||
""",
|
||||
(account_id,),
|
||||
).fetchone()
|
||||
body = _account_item(row)
|
||||
body["rooms"] = [
|
||||
{"id": str(room["id"]), "name": room["name"], "status": room["status"], "role": room["role"]} for room in rooms
|
||||
]
|
||||
body["active_sessions"] = sessions["n"]
|
||||
employees = conn.execute(
|
||||
"""
|
||||
SELECT id, display_name, email, status FROM auth_accounts
|
||||
WHERE sponsor_id = %s ORDER BY display_name, id
|
||||
""",
|
||||
(account_id,),
|
||||
).fetchall()
|
||||
body["employees"] = [
|
||||
{"id": str(e["id"]), "display_name": e["display_name"], "email": e["email"], "status": e["status"]} for e in employees
|
||||
]
|
||||
return JSONResponse(body, headers=_NO_STORE)
|
||||
|
||||
|
||||
@router.post("/api/v1/accounts")
|
||||
def post_account(body: AccountIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
require_operator(conn, principal.account_id)
|
||||
password = body.password or generate_password()
|
||||
account = create_account(
|
||||
conn,
|
||||
body.email,
|
||||
body.display_name,
|
||||
password,
|
||||
is_superadmin=body.is_operator,
|
||||
must_change_password=True,
|
||||
)
|
||||
audit(conn, principal.account_id, None, "account_created", "account", account["id"])
|
||||
if body.is_operator:
|
||||
audit(conn, principal.account_id, None, "operator_granted", "account", account["id"])
|
||||
payload = {
|
||||
"id": str(account["id"]),
|
||||
"email": account["email"],
|
||||
"display_name": account["display_name"],
|
||||
"is_superadmin": account["is_superadmin"],
|
||||
"status": account["status"],
|
||||
"must_change_password": True,
|
||||
"account_kind": account["account_kind"],
|
||||
}
|
||||
if not body.password:
|
||||
payload["temporary_password"] = password
|
||||
return JSONResponse(
|
||||
status_code=201,
|
||||
content=payload,
|
||||
headers={"Location": f"/api/v1/accounts/{account['id']}", **_NO_STORE},
|
||||
)
|
||||
|
||||
|
||||
@router.patch("/api/v1/accounts/{account_id}")
|
||||
def patch_account(
|
||||
account_id: UUID,
|
||||
body: AccountPatchIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
require_operator(conn, principal.account_id)
|
||||
exists = conn.execute("SELECT 1 FROM auth_accounts WHERE id = %s AND origin = 'operator'", (account_id,)).fetchone()
|
||||
if exists is None:
|
||||
raise not_found()
|
||||
if body.display_name is not None:
|
||||
set_display_name(conn, principal.account_id, account_id, body.display_name)
|
||||
if body.account_kind == "main":
|
||||
promote_to_main(conn, principal.account_id, account_id)
|
||||
if body.is_operator is not None:
|
||||
set_operator(conn, principal.account_id, account_id, body.is_operator)
|
||||
if body.status is not None:
|
||||
set_status(conn, principal.account_id, account_id, body.status)
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT id, email, display_name, is_superadmin, status, must_change_password, created_at, last_login_at,
|
||||
account_kind, sponsor_id,
|
||||
(SELECT s.display_name FROM auth_accounts s WHERE s.id = auth_accounts.sponsor_id) AS sponsor_name
|
||||
FROM auth_accounts WHERE id = %s
|
||||
""",
|
||||
(account_id,),
|
||||
).fetchone()
|
||||
return _account_item(row)
|
||||
|
||||
|
||||
@router.post("/api/v1/accounts/{account_id}/password-reset")
|
||||
def post_password_reset(
|
||||
account_id: UUID,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
require_operator(conn, principal.account_id)
|
||||
password = reset_password(conn, principal.account_id, account_id)
|
||||
return JSONResponse({"temporary_password": password}, headers=_NO_STORE)
|
||||
|
||||
|
||||
@router.post("/api/v1/accounts/{account_id}/sessions/revoke")
|
||||
def post_revoke_sessions(
|
||||
account_id: UUID,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
require_operator(conn, principal.account_id)
|
||||
if conn.execute("SELECT 1 FROM auth_accounts WHERE id = %s", (account_id,)).fetchone() is None:
|
||||
raise not_found()
|
||||
count = revoke_sessions(conn, account_id)
|
||||
audit(conn, principal.account_id, None, "sessions_revoked", "account", account_id, detail={"count": count})
|
||||
return {"revoked": count}
|
||||
|
||||
|
||||
@router.post("/api/v1/auth/password", status_code=204)
|
||||
def post_own_password(
|
||||
body: PasswordChangeIn,
|
||||
session: dict = Depends(get_session),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
change_own_password(conn, session["account_id"], session["id"], body.current_password, body.new_password)
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@router.get("/api/v1/auth/sessions")
|
||||
def own_sessions(session: dict = Depends(get_session), conn: Connection = Depends(get_conn)):
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT id, label, created_at, last_seen_at, expires_at
|
||||
FROM auth_sessions
|
||||
WHERE account_id = %s AND revoked_at IS NULL AND expires_at > now()
|
||||
ORDER BY created_at DESC, id
|
||||
""",
|
||||
(session["account_id"],),
|
||||
).fetchall()
|
||||
return JSONResponse(
|
||||
{
|
||||
"items": [
|
||||
{
|
||||
"id": str(row["id"]),
|
||||
"label": row["label"] or "Browser",
|
||||
"created_at": dump_dt(row["created_at"]),
|
||||
"last_seen_at": dump_dt(row["last_seen_at"]),
|
||||
"expires_at": dump_dt(row["expires_at"]),
|
||||
"current": row["id"] == session["id"],
|
||||
}
|
||||
for row in rows
|
||||
]
|
||||
},
|
||||
headers=_NO_STORE,
|
||||
)
|
||||
|
||||
|
||||
@router.delete("/api/v1/auth/sessions/{session_id}", status_code=204)
|
||||
def end_own_session(session_id: UUID, session: dict = Depends(get_session), conn: Connection = Depends(get_conn)):
|
||||
if session_id == session["id"]:
|
||||
raise unprocessable("Diese Sitzung beendest du mit Abmelden.")
|
||||
row = conn.execute(
|
||||
"""
|
||||
UPDATE auth_sessions SET revoked_at = now()
|
||||
WHERE id = %s AND account_id = %s AND revoked_at IS NULL
|
||||
RETURNING id
|
||||
""",
|
||||
(session_id, session["account_id"]),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise not_found()
|
||||
audit(conn, session["account_id"], None, "session_ended", "session", session_id)
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@router.post("/api/v1/auth/sessions/revoke-others")
|
||||
def end_other_sessions(session: dict = Depends(get_session), conn: Connection = Depends(get_conn)):
|
||||
count = revoke_sessions(conn, session["account_id"], keep=session["id"])
|
||||
audit(conn, session["account_id"], None, "sessions_revoked", "account", session["account_id"], detail={"count": count})
|
||||
return {"revoked": count}
|
||||
|
||||
+31
-6
@@ -2,8 +2,18 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import secrets
|
||||
from dataclasses import dataclass
|
||||
from datetime import timedelta
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def discard_stored(item) -> None:
|
||||
discard = getattr(item, "discard", None)
|
||||
if callable(discard):
|
||||
discard()
|
||||
return
|
||||
Path(item).unlink(missing_ok=True)
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import Depends, Request
|
||||
@@ -11,10 +21,19 @@ from psycopg import Connection
|
||||
|
||||
from app.access.policy import ensure_member_or_personal
|
||||
from app.auth.security import hash_secret, read_session_token
|
||||
from app.core.errors import forbidden, unauthorized
|
||||
from app.core.errors import forbidden, password_change_required, scope_changed, unauthorized
|
||||
from app.core.timeutil import utcnow
|
||||
|
||||
|
||||
# While a one-time password is set, only these routes answer.
|
||||
PASSWORD_CHANGE_PATHS = frozenset({
|
||||
"/api/v1/auth/session",
|
||||
"/api/v1/auth/password",
|
||||
"/api/v1/auth/logout",
|
||||
})
|
||||
SEEN_INTERVAL = timedelta(minutes=5)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Principal:
|
||||
account_id: UUID
|
||||
@@ -35,11 +54,11 @@ def get_conn(request: Request):
|
||||
yield conn
|
||||
conn.commit()
|
||||
for path in getattr(request.state, "delete_after_commit", []):
|
||||
Path(path).unlink(missing_ok=True)
|
||||
discard_stored(path)
|
||||
except Exception:
|
||||
conn.rollback()
|
||||
for path in getattr(request.state, "cleanup_files", []):
|
||||
Path(path).unlink(missing_ok=True)
|
||||
discard_stored(path)
|
||||
raise
|
||||
|
||||
|
||||
@@ -50,7 +69,8 @@ def _session_row(conn: Connection, request: Request) -> dict:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT s.id, s.account_id, s.csrf_token, s.scope_kind, s.scope_id, s.epoch,
|
||||
s.expires_at, s.revoked_at, a.email, a.display_name, a.status AS account_status
|
||||
s.expires_at, s.revoked_at, s.last_seen_at, a.email, a.display_name,
|
||||
a.status AS account_status, a.must_change_password
|
||||
FROM auth_sessions s
|
||||
JOIN auth_accounts a ON a.id = s.account_id
|
||||
WHERE s.secret_hash = %s
|
||||
@@ -61,10 +81,15 @@ def _session_row(conn: Connection, request: Request) -> dict:
|
||||
raise unauthorized()
|
||||
if row["account_status"] != "active":
|
||||
raise unauthorized()
|
||||
if row["must_change_password"] and request.url.path not in PASSWORD_CHANGE_PATHS:
|
||||
raise password_change_required()
|
||||
if request.method not in {"GET", "HEAD", "OPTIONS"}:
|
||||
sent = request.headers.get("x-csrf-token") or ""
|
||||
if not sent or sent != row["csrf_token"]:
|
||||
if not sent or not secrets.compare_digest(sent, row["csrf_token"]):
|
||||
raise forbidden("Die Anfrage konnte der Sitzung nicht zugeordnet werden.")
|
||||
seen = row["last_seen_at"]
|
||||
if seen is None or utcnow() - seen > SEEN_INTERVAL:
|
||||
conn.execute("UPDATE auth_sessions SET last_seen_at = now() WHERE id = %s", (row["id"],))
|
||||
return row
|
||||
|
||||
|
||||
@@ -83,7 +108,7 @@ def get_principal(request: Request, conn: Connection = Depends(get_conn)) -> Pri
|
||||
except ValueError as exc:
|
||||
raise forbidden("Der Datenraum ist nicht gewählt.") from exc
|
||||
if kind != row["scope_kind"] or scope_id != row["scope_id"]:
|
||||
raise forbidden("Der gewählte Datenraum entspricht nicht mehr der Sitzung.")
|
||||
raise scope_changed()
|
||||
room = ensure_member_or_personal(conn, row["account_id"], kind, scope_id)
|
||||
return Principal(
|
||||
account_id=row["account_id"],
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
"""Download policy: which room role may save the original of a document or mail.
|
||||
|
||||
Reading inside the app stays possible. The policy is a rule of use, not a copy protection:
|
||||
what the screen shows has to reach the browser.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends
|
||||
from fastapi.responses import JSONResponse
|
||||
from psycopg import Connection
|
||||
from psycopg.types.json import Json
|
||||
|
||||
from app.access.policy import audit
|
||||
from app.access.roles import require_main_user, room_role
|
||||
from app.api.deps import Principal, get_conn, get_principal
|
||||
from app.api.schemas import DownloadPolicyIn
|
||||
from app.core.errors import forbidden, not_found
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
_NO_STORE = {"Cache-Control": "no-store"}
|
||||
ROOM_KEYS = ("manager", "member", "reader")
|
||||
|
||||
|
||||
def _policy(raw: dict, keys: tuple[str, ...]) -> dict[str, bool]:
|
||||
return {key: bool(raw.get(key, True)) for key in keys}
|
||||
|
||||
|
||||
def _room_of_member(conn, account_id: UUID, room_id: UUID) -> dict:
|
||||
# A stranger and an unknown room answer alike.
|
||||
room = conn.execute("SELECT * FROM data_rooms WHERE id = %s AND kind = 'organization'", (room_id,)).fetchone()
|
||||
if room is None or room_role(conn, account_id, room_id) is None:
|
||||
raise not_found()
|
||||
return room
|
||||
|
||||
|
||||
@router.get("/api/v1/rooms/{room_id}/download-policy")
|
||||
def get_room_policy(room_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
room = _room_of_member(conn, principal.account_id, room_id)
|
||||
return JSONResponse(
|
||||
{"roles": _policy(room["download_roles"], ROOM_KEYS), "can_change": room["owner_id"] == principal.account_id},
|
||||
headers=_NO_STORE,
|
||||
)
|
||||
|
||||
|
||||
@router.put("/api/v1/rooms/{room_id}/download-policy")
|
||||
def put_room_policy(
|
||||
room_id: UUID,
|
||||
body: DownloadPolicyIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
room = _room_of_member(conn, principal.account_id, room_id)
|
||||
if room["owner_id"] != principal.account_id:
|
||||
raise forbidden("Das darf nur der Eigentümer des Datenraums.")
|
||||
roles = {"manager": body.manager, "member": body.member, "reader": body.reader}
|
||||
conn.execute("UPDATE data_rooms SET download_roles = %s WHERE id = %s", (Json(roles), room_id))
|
||||
audit(conn, principal.account_id, room_id, "room_download_policy_changed", "room", room_id, detail=roles)
|
||||
return JSONResponse({"roles": roles, "can_change": True}, headers=_NO_STORE)
|
||||
|
||||
|
||||
@router.get("/api/v1/auth/download-defaults")
|
||||
def get_defaults(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
require_main_user(conn, principal.account_id)
|
||||
row = conn.execute("SELECT download_defaults FROM auth_accounts WHERE id = %s", (principal.account_id,)).fetchone()
|
||||
return JSONResponse({"roles": _policy(row["download_defaults"], (*ROOM_KEYS, "direct"))}, headers=_NO_STORE)
|
||||
|
||||
|
||||
@router.put("/api/v1/auth/download-defaults")
|
||||
def put_defaults(
|
||||
body: DownloadPolicyIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
require_main_user(conn, principal.account_id)
|
||||
roles = {"manager": body.manager, "member": body.member, "reader": body.reader, "direct": True if body.direct is None else body.direct}
|
||||
conn.execute("UPDATE auth_accounts SET download_defaults = %s WHERE id = %s", (Json(roles), principal.account_id))
|
||||
audit(conn, principal.account_id, None, "download_defaults_changed", "account", principal.account_id, detail=roles)
|
||||
return JSONResponse({"roles": roles}, headers=_NO_STORE)
|
||||
@@ -8,10 +8,10 @@ from uuid import UUID
|
||||
from fastapi import APIRouter, Depends, Request, Response
|
||||
from psycopg import Connection
|
||||
|
||||
from app.access.policy import Ctx, parse_query_context
|
||||
from app.access.policy import Ctx, get_matter, matter_rights, parse_query_context
|
||||
from app.api.deps import Principal, get_conn, get_principal
|
||||
from app.api.schemas import ExportIn
|
||||
from app.core.errors import unprocessable
|
||||
from app.core.errors import DOWNLOAD_REFUSED, forbidden, unprocessable
|
||||
from app.exporting import build_export, export_tree, review_export
|
||||
|
||||
router = APIRouter()
|
||||
@@ -79,6 +79,12 @@ def post_export(
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
selected, assignments = _selection(body)
|
||||
matter = get_matter(conn, matter_id)
|
||||
if matter is not None:
|
||||
rights = matter_rights(conn, principal.account_id, matter, _context(body.context))
|
||||
# Without any right the export itself answers as before. With read but no download right: refuse.
|
||||
if rights.read and not rights.download:
|
||||
raise forbidden(DOWNLOAD_REFUSED)
|
||||
filename, payload = build_export(
|
||||
conn,
|
||||
principal.account_id,
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
"""Placing a source document into a container: a new reference, or one more binding of an existing element."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import APIRouter, Depends
|
||||
from fastapi.responses import JSONResponse
|
||||
from psycopg import Connection
|
||||
|
||||
from app.access.policy import Ctx
|
||||
from app.api.deps import Principal, get_conn, get_principal
|
||||
from app.api.schemas import ExistingIn, ExternalIn
|
||||
from app.ops import bind_existing_external, create_external, existing_externals
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
def _ctx_model(value) -> Ctx | None:
|
||||
return None if value is None else Ctx(value.kind, value.id)
|
||||
|
||||
|
||||
def place_external(conn, principal: Principal, body: ExternalIn) -> dict:
|
||||
context = Ctx(body.context.kind, body.context.id)
|
||||
placement = _ctx_model(body.placement)
|
||||
if body.bind_element_id is not None:
|
||||
return bind_existing_external(conn, principal.account_id, principal.scope_id, body.bind_element_id, context, placement, body.chapter_id)
|
||||
return create_external(
|
||||
conn,
|
||||
principal.account_id,
|
||||
principal.scope_id,
|
||||
body.title,
|
||||
body.source,
|
||||
body.external_id,
|
||||
context,
|
||||
placement,
|
||||
body.chapter_id,
|
||||
body.dates.document_on,
|
||||
body.dates.sent_on,
|
||||
body.dates.received_on,
|
||||
body.detail.model_dump(mode="json", exclude_none=True) if body.detail else None,
|
||||
duplicate=body.duplicate,
|
||||
)
|
||||
|
||||
|
||||
@router.post("/api/v1/external-refs/existing")
|
||||
def existing(body: ExistingIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
"""Read only: which of these documents are already present around the target. Nothing is written."""
|
||||
items = [
|
||||
{"source": item.source, "external_id": item.external_id, "connector_id": str(item.connector_id) if item.connector_id else None}
|
||||
for item in body.items
|
||||
]
|
||||
result = existing_externals(conn, principal.account_id, Ctx(body.context.kind, body.context.id), _ctx_model(body.placement), items)
|
||||
return JSONResponse(result, headers={"Cache-Control": "no-store"})
|
||||
@@ -0,0 +1,119 @@
|
||||
"""Library endpoints: rooms as tiles, what lies in a room, and sharing several entries at once."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends
|
||||
from fastapi.responses import JSONResponse
|
||||
from psycopg import Connection
|
||||
|
||||
from app.access.policy import parse_query_context, require_case, require_matter
|
||||
from app.access.roles import room_role
|
||||
from app.api.deps import Principal, get_conn, get_principal
|
||||
from app.api.schemas import BatchShareIn
|
||||
from app.core.errors import forbidden
|
||||
from app.library import case_items, case_outline, matter_items, matter_outline, room_contents, room_effect
|
||||
from app.ops import share_with_room
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
_NO_STORE = {"Cache-Control": "no-store"}
|
||||
|
||||
|
||||
@router.get("/api/v1/rooms/overview")
|
||||
def rooms_overview(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
"""The team rooms of the person as tiles. Names of members are only shown to managers."""
|
||||
actor = principal.account_id
|
||||
rooms = conn.execute(
|
||||
"""
|
||||
SELECT r.id, r.name, r.owner_id, r.default_visibility, m.role,
|
||||
(SELECT count(*) FROM room_memberships x WHERE x.room_id = r.id AND x.status = 'active') AS members
|
||||
FROM room_memberships m JOIN data_rooms r ON r.id = m.room_id
|
||||
WHERE m.subject_id = %s AND m.status = 'active' AND r.kind = 'organization' AND r.status = 'active'
|
||||
ORDER BY r.name, r.id
|
||||
""",
|
||||
(actor,),
|
||||
).fetchall()
|
||||
items = []
|
||||
for room in rooms:
|
||||
cases, matters = room_contents(conn, actor, room["id"])
|
||||
people = []
|
||||
if room["role"] == "manager":
|
||||
people = [
|
||||
row["display_name"]
|
||||
for row in conn.execute(
|
||||
"""
|
||||
SELECT a.display_name FROM room_memberships x JOIN auth_accounts a ON a.id = x.subject_id
|
||||
WHERE x.room_id = %s AND x.status = 'active'
|
||||
ORDER BY a.display_name, a.id LIMIT 6
|
||||
""",
|
||||
(room["id"],),
|
||||
).fetchall()
|
||||
]
|
||||
items.append(
|
||||
{
|
||||
"id": str(room["id"]),
|
||||
"name": room["name"],
|
||||
"role": room["role"],
|
||||
"is_owner": room["owner_id"] == actor,
|
||||
"private": room["members"] <= 1,
|
||||
"default_visibility": room["default_visibility"],
|
||||
"member_count": room["members"],
|
||||
"members": people,
|
||||
"case_count": sum(1 for case, _ in cases if not case["parent_case_id"]),
|
||||
"matter_count": sum(1 for matter, _ in matters if not matter["parent_matter_id"]),
|
||||
}
|
||||
)
|
||||
return JSONResponse({"items": items}, headers=_NO_STORE)
|
||||
|
||||
|
||||
@router.get("/api/v1/rooms/{room_id}/contents")
|
||||
def contents(room_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
"""Cases and matters shared with the room that the person may read."""
|
||||
if room_role(conn, principal.account_id, room_id) is None:
|
||||
raise forbidden()
|
||||
cases, matters = room_contents(conn, principal.account_id, room_id)
|
||||
return JSONResponse(
|
||||
{
|
||||
"cases": case_items(conn, principal.account_id, cases),
|
||||
"matters": matter_items(conn, principal.account_id, matters),
|
||||
},
|
||||
headers=_NO_STORE,
|
||||
)
|
||||
|
||||
|
||||
@router.post("/api/v1/rooms/{room_id}/shares")
|
||||
def share_many(
|
||||
room_id: UUID,
|
||||
body: BatchShareIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
"""Share several own entries with the room. All or none: one failure rolls the request back."""
|
||||
for item in body.items:
|
||||
share_with_room(conn, principal.account_id, item.kind, item.id, room_id, body.access)
|
||||
return {
|
||||
"shared": len(body.items),
|
||||
"access": body.access,
|
||||
"effect": room_effect(conn, room_id, principal.account_id, body.access),
|
||||
}
|
||||
|
||||
|
||||
@router.get("/api/v1/cases/{case_id}/outline")
|
||||
def case_outline_view(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 JSONResponse(case_outline(conn, principal.account_id, case), headers=_NO_STORE)
|
||||
|
||||
|
||||
@router.get("/api/v1/matters/{matter_id}/outline")
|
||||
def matter_outline_view(
|
||||
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 JSONResponse(matter_outline(conn, principal.account_id, matter, context), headers=_NO_STORE)
|
||||
@@ -0,0 +1,41 @@
|
||||
"""Account preferences: read the effective value, change the own value, bind the team."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import APIRouter, Depends
|
||||
from fastapi.responses import JSONResponse
|
||||
from psycopg import Connection
|
||||
|
||||
from app.access.policy import audit
|
||||
from app.api.deps import Principal, get_conn, get_principal
|
||||
from app.api.schemas import PreferenceIn
|
||||
from app.preferences import preference_state, store_preference
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
_NO_STORE = {"Cache-Control": "no-store"}
|
||||
|
||||
|
||||
@router.get("/api/v1/auth/preferences/{key}")
|
||||
def get_preference(key: str, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
return JSONResponse(preference_state(conn, principal.account_id, key), headers=_NO_STORE)
|
||||
|
||||
|
||||
@router.put("/api/v1/auth/preferences/{key}")
|
||||
def put_preference(
|
||||
key: str,
|
||||
body: PreferenceIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
state = store_preference(conn, principal.account_id, key, body.value, body.team_mode)
|
||||
audit(
|
||||
conn,
|
||||
principal.account_id,
|
||||
None,
|
||||
"preference_changed",
|
||||
"account",
|
||||
principal.account_id,
|
||||
detail={"key": key, "value": body.value, "team_mode": body.team_mode},
|
||||
)
|
||||
return JSONResponse(state, headers=_NO_STORE)
|
||||
@@ -0,0 +1,797 @@
|
||||
"""Data rooms: members, roles, invitations, and the operator's room overview and audit."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import timedelta
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from fastapi import APIRouter, Depends, Response
|
||||
from fastapi.responses import JSONResponse
|
||||
from psycopg import Connection
|
||||
|
||||
from app.access.policy import account_by_email, audit
|
||||
from app.access.limits import ensure_can_add_member, ensure_can_create_room
|
||||
from app.access.roles import (
|
||||
ROOM_ROLES,
|
||||
account_kind,
|
||||
count_active_managers,
|
||||
require_main_user,
|
||||
require_operator,
|
||||
require_room_manager,
|
||||
room_role,
|
||||
)
|
||||
from app.api.deps import Principal, get_conn, get_principal
|
||||
from app.api.schemas import (
|
||||
InvitationIn,
|
||||
MemberIn,
|
||||
MemberRoleIn,
|
||||
OperatorManagerIn,
|
||||
OperatorOwnerIn,
|
||||
OwnerIn,
|
||||
RoomIn,
|
||||
RoomPatchIn,
|
||||
SourceAccessIn,
|
||||
VisibilityIn,
|
||||
)
|
||||
from app.auth.accounts import normalize_email
|
||||
from app.auth.security import hash_secret, new_secret
|
||||
from app.core.errors import forbidden, not_found, unprocessable
|
||||
from app.core.timeutil import dump_dt, utcnow
|
||||
from app.present import LABELS
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
_NO_STORE = {"Cache-Control": "no-store"}
|
||||
INVITATION_DAYS = 7
|
||||
|
||||
|
||||
def _created(path: str, payload: dict) -> JSONResponse:
|
||||
return JSONResponse(status_code=201, content=payload, headers={"Location": path, **_NO_STORE})
|
||||
|
||||
|
||||
def _require_owner(conn, account_id: UUID, room_id: UUID) -> dict:
|
||||
# An unknown room and a room owned by someone else answer alike: no way to probe ids.
|
||||
room = conn.execute(
|
||||
"SELECT * FROM data_rooms WHERE id = %s AND kind = 'organization'", (room_id,)
|
||||
).fetchone()
|
||||
if room is None or room["owner_id"] != account_id:
|
||||
raise forbidden("Das darf nur der Eigentümer des Datenraums.")
|
||||
return room
|
||||
|
||||
|
||||
def _protect_owner(room: dict, subject_id: UUID) -> None:
|
||||
if room["owner_id"] == subject_id:
|
||||
raise unprocessable("Der Eigentümer bleibt Verwalter. Übertrage den Datenraum zuerst.")
|
||||
|
||||
|
||||
def _room(conn, room_id: UUID) -> dict:
|
||||
row = conn.execute("SELECT * FROM data_rooms WHERE id = %s AND kind = 'organization'", (room_id,)).fetchone()
|
||||
if row is None:
|
||||
raise not_found()
|
||||
return row
|
||||
|
||||
|
||||
def _audit_membership(conn, actor: UUID, room_id: UUID, subject_id: UUID, action: str, role: str | None = None) -> None:
|
||||
audit(
|
||||
conn,
|
||||
actor,
|
||||
room_id,
|
||||
action,
|
||||
"membership",
|
||||
subject_id,
|
||||
detail={"room_id": str(room_id), **({"role": role} if role else {})},
|
||||
)
|
||||
|
||||
|
||||
def _drop_edit_rights_in_room(conn, subject_id: UUID, room_id: UUID) -> None:
|
||||
"""A reader neither edits nor shares objects of this room. Read grants stay."""
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE access_grants g
|
||||
SET can_edit = false, can_share = false
|
||||
WHERE g.grantee_subject_id = %s AND NOT g.is_exception AND (g.can_edit OR g.can_share)
|
||||
AND (
|
||||
(g.resource_kind = 'case' AND g.resource_id IN (SELECT id FROM cases WHERE home_scope_id = %s))
|
||||
OR (g.resource_kind = 'matter' AND g.resource_id IN (SELECT id FROM matters WHERE home_scope_id = %s))
|
||||
OR (g.resource_kind = 'element' AND g.resource_id IN (SELECT id FROM elements WHERE home_scope_id = %s))
|
||||
OR (g.resource_kind = 'task' AND g.resource_id IN (SELECT id FROM tasks WHERE home_scope_id = %s))
|
||||
OR (g.resource_kind = 'deadline' AND g.resource_id IN (SELECT id FROM deadlines WHERE home_scope_id = %s))
|
||||
)
|
||||
""",
|
||||
(subject_id, room_id, room_id, room_id, room_id, room_id),
|
||||
)
|
||||
|
||||
|
||||
def _drop_shares_of(conn, room_id: UUID, subject_id: UUID) -> None:
|
||||
"""Whoever leaves a team, or may no longer write in it, takes the shares of their own entries with them."""
|
||||
conn.execute(
|
||||
"""
|
||||
DELETE FROM room_shares s
|
||||
WHERE s.room_id = %s
|
||||
AND (
|
||||
(s.resource_kind = 'case' AND s.resource_id IN (SELECT id FROM cases WHERE owner_subject_id = %s))
|
||||
OR (s.resource_kind = 'matter' AND s.resource_id IN (SELECT id FROM matters WHERE owner_subject_id = %s))
|
||||
)
|
||||
""",
|
||||
(room_id, subject_id, subject_id),
|
||||
)
|
||||
# Without own shares in the room there is nothing left to lend.
|
||||
conn.execute(
|
||||
"DELETE FROM room_source_access WHERE room_id = %s AND owner_id = %s",
|
||||
(room_id, subject_id),
|
||||
)
|
||||
|
||||
|
||||
def _drop_source_access_to(conn, room_id: UUID, subject_id: UUID) -> None:
|
||||
"""A person who leaves the team loses every source access lent to them there. A return starts without it."""
|
||||
conn.execute(
|
||||
"DELETE FROM room_source_access WHERE room_id = %s AND subject_id = %s",
|
||||
(room_id, subject_id),
|
||||
)
|
||||
|
||||
|
||||
def _lent_to(conn, room_id: UUID, owner_id: UUID) -> set[UUID]:
|
||||
rows = conn.execute(
|
||||
"SELECT subject_id FROM room_source_access WHERE room_id = %s AND owner_id = %s",
|
||||
(room_id, owner_id),
|
||||
).fetchall()
|
||||
return {row["subject_id"] for row in rows}
|
||||
|
||||
|
||||
def _set_role(conn, actor: UUID, room_id: UUID, subject_id: UUID, role: str, *, added: bool) -> None:
|
||||
if role not in ROOM_ROLES:
|
||||
raise unprocessable("Diese Raumrolle gibt es nicht.")
|
||||
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, subject_id, role),
|
||||
)
|
||||
if role == "reader":
|
||||
_drop_edit_rights_in_room(conn, subject_id, room_id)
|
||||
_drop_shares_of(conn, room_id, subject_id)
|
||||
_audit_membership(conn, actor, room_id, subject_id, "membership_added" if added else "membership_role_changed", role)
|
||||
|
||||
|
||||
def _membership(conn, room_id: UUID, subject_id: UUID, *, lock: bool = False) -> dict | None:
|
||||
suffix = " FOR UPDATE" if lock else ""
|
||||
return conn.execute(
|
||||
f"SELECT role, status FROM room_memberships WHERE room_id = %s AND subject_id = %s{suffix}",
|
||||
(room_id, subject_id),
|
||||
).fetchone()
|
||||
|
||||
|
||||
@router.get("/api/v1/rooms")
|
||||
def rooms(
|
||||
include_archived: bool = False,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
from app.auth.accounts import list_rooms
|
||||
|
||||
items = list_rooms(conn, principal.account_id)
|
||||
if include_archived:
|
||||
archived = conn.execute(
|
||||
"""
|
||||
SELECT r.id, r.name, m.role, r.owner_id
|
||||
FROM room_memberships m JOIN data_rooms r ON r.id = m.room_id
|
||||
WHERE m.subject_id = %s AND m.status = 'active' AND r.kind = 'organization' AND r.status = 'archived'
|
||||
ORDER BY r.name, r.id
|
||||
""",
|
||||
(principal.account_id,),
|
||||
).fetchall()
|
||||
items += [
|
||||
{
|
||||
"id": str(row["id"]),
|
||||
"kind": "organization",
|
||||
"name": row["name"],
|
||||
"role": row["role"],
|
||||
"status": "archived",
|
||||
"is_owner": row["owner_id"] == principal.account_id,
|
||||
}
|
||||
for row in archived
|
||||
]
|
||||
return {"items": items, "next_cursor": None}
|
||||
|
||||
|
||||
@router.post("/api/v1/rooms")
|
||||
def create_room(body: RoomIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
require_main_user(conn, principal.account_id)
|
||||
ensure_can_create_room(conn, principal.account_id)
|
||||
room_id = uuid4()
|
||||
name = body.name.strip()
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO data_rooms (id, kind, name, created_by, owner_id, default_visibility, download_roles)
|
||||
SELECT %s, 'organization', %s, %s, %s, %s,
|
||||
jsonb_build_object(
|
||||
'manager', COALESCE((download_defaults ->> 'manager')::boolean, true),
|
||||
'member', COALESCE((download_defaults ->> 'member')::boolean, true),
|
||||
'reader', COALESCE((download_defaults ->> 'reader')::boolean, true)
|
||||
)
|
||||
FROM auth_accounts WHERE id = %s
|
||||
""",
|
||||
(room_id, name, principal.account_id, principal.account_id, body.default_visibility, principal.account_id),
|
||||
)
|
||||
conn.execute(
|
||||
"INSERT INTO room_memberships (room_id, subject_id, role) VALUES (%s, %s, 'manager')",
|
||||
(room_id, principal.account_id),
|
||||
)
|
||||
audit(conn, principal.account_id, room_id, "room_created", "room", room_id)
|
||||
return _created(
|
||||
f"/api/v1/rooms/{room_id}",
|
||||
{"id": str(room_id), "kind": "organization", "name": name, "default_visibility": body.default_visibility},
|
||||
)
|
||||
|
||||
|
||||
@router.patch("/api/v1/rooms/{room_id}")
|
||||
def patch_room(
|
||||
room_id: UUID,
|
||||
body: RoomPatchIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
require_room_manager(conn, principal.account_id, room_id)
|
||||
room = _room(conn, room_id)
|
||||
if body.name is not None and body.name.strip() != room["name"]:
|
||||
conn.execute("UPDATE data_rooms SET name = %s WHERE id = %s", (body.name.strip(), room_id))
|
||||
audit(conn, principal.account_id, room_id, "room_renamed", "room", room_id)
|
||||
if body.default_visibility is not None and body.default_visibility != room["default_visibility"]:
|
||||
_require_owner(conn, principal.account_id, room_id)
|
||||
conn.execute("UPDATE data_rooms SET default_visibility = %s WHERE id = %s", (body.default_visibility, room_id))
|
||||
audit(
|
||||
conn,
|
||||
principal.account_id,
|
||||
room_id,
|
||||
"room_default_changed",
|
||||
"room",
|
||||
room_id,
|
||||
detail={"visibility": body.default_visibility},
|
||||
)
|
||||
if body.status is not None and body.status != room["status"]:
|
||||
_require_owner(conn, principal.account_id, room_id)
|
||||
conn.execute("UPDATE data_rooms SET status = %s WHERE id = %s", (body.status, room_id))
|
||||
if body.status == "archived":
|
||||
# Sessions working in the room return to their personal room.
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE auth_sessions
|
||||
SET scope_kind = 'personal', scope_id = account_id, epoch = epoch + 1
|
||||
WHERE scope_id = %s AND revoked_at IS NULL
|
||||
""",
|
||||
(room_id,),
|
||||
)
|
||||
audit(
|
||||
conn,
|
||||
principal.account_id,
|
||||
room_id,
|
||||
"room_archived" if body.status == "archived" else "room_restored",
|
||||
"room",
|
||||
room_id,
|
||||
)
|
||||
row = _room(conn, room_id)
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"name": row["name"],
|
||||
"status": row["status"],
|
||||
"default_visibility": row["default_visibility"],
|
||||
}
|
||||
|
||||
|
||||
def _set_owner(conn, actor: UUID, room_id: UUID, new_owner: UUID, previous: UUID | None) -> None:
|
||||
conn.execute("UPDATE data_rooms SET owner_id = %s WHERE id = %s", (new_owner, room_id))
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO room_memberships (room_id, subject_id, role, status)
|
||||
VALUES (%s, %s, 'manager', 'active')
|
||||
ON CONFLICT (room_id, subject_id) DO UPDATE SET role = 'manager', status = 'active'
|
||||
""",
|
||||
(room_id, new_owner),
|
||||
)
|
||||
audit(
|
||||
conn,
|
||||
actor,
|
||||
room_id,
|
||||
"room_owner_changed",
|
||||
"room",
|
||||
room_id,
|
||||
detail={"from": str(previous) if previous else None, "to": str(new_owner)},
|
||||
)
|
||||
|
||||
|
||||
@router.post("/api/v1/rooms/{room_id}/owner")
|
||||
def transfer_owner(
|
||||
room_id: UUID,
|
||||
body: OwnerIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
"""The owner hands the room to an active member. The new owner becomes manager."""
|
||||
room = _require_owner(conn, principal.account_id, room_id)
|
||||
target = _membership(conn, room_id, body.subject_id, lock=True)
|
||||
account = conn.execute("SELECT status FROM auth_accounts WHERE id = %s", (body.subject_id,)).fetchone()
|
||||
if target is None or target["status"] != "active" or account is None or account["status"] != "active":
|
||||
raise unprocessable("Der Datenraum geht nur an ein aktives Mitglied.")
|
||||
if account_kind(conn, body.subject_id) != "main":
|
||||
raise unprocessable("Ein Mitarbeiter-Konto kann keinen Datenraum besitzen.")
|
||||
if body.subject_id == room["owner_id"]:
|
||||
raise unprocessable("Diese Person ist bereits Eigentümer.")
|
||||
_set_owner(conn, principal.account_id, room_id, body.subject_id, room["owner_id"])
|
||||
return {"owner_id": str(body.subject_id)}
|
||||
|
||||
|
||||
@router.get("/api/v1/rooms/{room_id}/exposure")
|
||||
def exposure(room_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
"""Own cases and matters: shared with this room (`room`) or filed here but not shared (`private`)."""
|
||||
if room_role(conn, principal.account_id, room_id) is None:
|
||||
raise forbidden()
|
||||
result: dict = {}
|
||||
for table, kind in (("cases", "case"), ("matters", "matter")):
|
||||
row = conn.execute(
|
||||
f"""
|
||||
SELECT
|
||||
count(*) FILTER (WHERE EXISTS (
|
||||
SELECT 1 FROM room_shares s
|
||||
WHERE s.resource_kind = %s AND s.resource_id = t.id AND s.room_id = %s)) AS shared,
|
||||
count(*) FILTER (WHERE t.home_scope_id = %s AND NOT EXISTS (
|
||||
SELECT 1 FROM room_shares s
|
||||
WHERE s.resource_kind = %s AND s.resource_id = t.id AND s.room_id = %s)) AS filed
|
||||
FROM {table} t
|
||||
WHERE t.owner_subject_id = %s AND t.deleted_at IS NULL
|
||||
""",
|
||||
(kind, room_id, room_id, kind, room_id, principal.account_id),
|
||||
).fetchone()
|
||||
result[table] = {"room": row["shared"], "private": row["filed"]}
|
||||
return JSONResponse(result, headers=_NO_STORE)
|
||||
|
||||
|
||||
@router.post("/api/v1/rooms/{room_id}/my-content/visibility")
|
||||
def set_my_content(
|
||||
room_id: UUID,
|
||||
body: VisibilityIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
"""`room`: share every own entry filed in this room with it. `private`: end all own shares to it."""
|
||||
role = room_role(conn, principal.account_id, room_id)
|
||||
if role is None:
|
||||
raise forbidden()
|
||||
changed = 0
|
||||
if body.visibility == "room":
|
||||
if role not in {"member", "manager"}:
|
||||
raise forbidden("Als Leser kannst du nichts mit dem Datenraum teilen.")
|
||||
for table, kind in (("cases", "case"), ("matters", "matter")):
|
||||
rows = conn.execute(
|
||||
f"""
|
||||
INSERT INTO room_shares (resource_kind, resource_id, room_id, access, created_by)
|
||||
SELECT %s, t.id, %s, 'edit', %s FROM {table} t
|
||||
WHERE t.home_scope_id = %s AND t.owner_subject_id = %s AND t.deleted_at IS NULL
|
||||
ON CONFLICT DO NOTHING
|
||||
RETURNING id
|
||||
""",
|
||||
(kind, room_id, principal.account_id, room_id, principal.account_id),
|
||||
).fetchall()
|
||||
changed += len(rows)
|
||||
else:
|
||||
for table, kind in (("cases", "case"), ("matters", "matter")):
|
||||
rows = conn.execute(
|
||||
f"""
|
||||
DELETE FROM room_shares s
|
||||
WHERE s.room_id = %s AND s.resource_kind = %s
|
||||
AND s.resource_id IN (SELECT id FROM {table} WHERE owner_subject_id = %s)
|
||||
RETURNING s.id
|
||||
""",
|
||||
(room_id, kind, principal.account_id),
|
||||
).fetchall()
|
||||
changed += len(rows)
|
||||
if changed:
|
||||
audit(
|
||||
conn,
|
||||
principal.account_id,
|
||||
room_id,
|
||||
"visibility_changed",
|
||||
"room",
|
||||
room_id,
|
||||
detail={"visibility": body.visibility, "count": changed},
|
||||
)
|
||||
return {"changed": changed}
|
||||
|
||||
|
||||
@router.get("/api/v1/rooms/{room_id}/members")
|
||||
def members(room_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
require_room_manager(conn, principal.account_id, room_id)
|
||||
owner_id = _room(conn, room_id)["owner_id"]
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT m.subject_id, m.role, a.email, a.display_name, a.status
|
||||
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()
|
||||
lent = _lent_to(conn, room_id, principal.account_id)
|
||||
return {
|
||||
"items": [
|
||||
{
|
||||
"subject_id": str(row["subject_id"]),
|
||||
"email": row["email"],
|
||||
"display_name": row["display_name"],
|
||||
"role": row["role"],
|
||||
"account_status": row["status"],
|
||||
"is_owner": row["subject_id"] == owner_id,
|
||||
"is_self": row["subject_id"] == principal.account_id,
|
||||
"my_sources": row["subject_id"] in lent,
|
||||
}
|
||||
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_room_manager(conn, principal.account_id, room_id)
|
||||
account = account_by_email(conn, body.email)
|
||||
if account is None or account["status"] != "active":
|
||||
raise not_found()
|
||||
existing = _membership(conn, room_id, account["id"], lock=True)
|
||||
if body.role != "manager":
|
||||
_protect_owner(_room(conn, room_id), account["id"])
|
||||
if existing and existing["status"] == "active" and existing["role"] == "manager" and body.role != "manager":
|
||||
if count_active_managers(conn, room_id, lock=True) <= 1:
|
||||
raise unprocessable("Der letzte Verwalter bleibt Verwalter.")
|
||||
was_active = bool(existing and existing["status"] == "active")
|
||||
if not was_active:
|
||||
ensure_can_add_member(conn, _room(conn, room_id)["owner_id"], room_id)
|
||||
_set_role(conn, principal.account_id, room_id, account["id"], body.role, added=not was_active)
|
||||
return {"subject_id": str(account["id"]), "role": body.role}
|
||||
|
||||
|
||||
@router.patch("/api/v1/rooms/{room_id}/members/{subject_id}")
|
||||
def change_member_role(
|
||||
room_id: UUID,
|
||||
subject_id: UUID,
|
||||
body: MemberRoleIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
require_room_manager(conn, principal.account_id, room_id)
|
||||
count_active_managers(conn, room_id, lock=True)
|
||||
current = _membership(conn, room_id, subject_id, lock=True)
|
||||
if current is None or current["status"] != "active":
|
||||
raise not_found()
|
||||
if current["role"] == body.role:
|
||||
return {"subject_id": str(subject_id), "role": body.role}
|
||||
_protect_owner(_room(conn, room_id), subject_id)
|
||||
if current["role"] == "manager" and count_active_managers(conn, room_id) <= 1:
|
||||
raise unprocessable("Der letzte Verwalter bleibt Verwalter.")
|
||||
_set_role(conn, principal.account_id, room_id, subject_id, body.role, added=False)
|
||||
return {"subject_id": str(subject_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_room_manager(conn, principal.account_id, room_id)
|
||||
count_active_managers(conn, room_id, lock=True)
|
||||
current = _membership(conn, room_id, subject_id, lock=True)
|
||||
if current is None or current["status"] != "active":
|
||||
raise not_found()
|
||||
_protect_owner(_room(conn, room_id), subject_id)
|
||||
if current["role"] == "manager" and count_active_managers(conn, room_id) <= 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),
|
||||
)
|
||||
_drop_shares_of(conn, room_id, subject_id)
|
||||
_drop_source_access_to(conn, room_id, subject_id)
|
||||
# The removed person works in the personal room again; own entries stay visible there.
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE auth_sessions
|
||||
SET scope_kind = 'personal', scope_id = account_id, epoch = epoch + 1
|
||||
WHERE account_id = %s AND scope_id = %s AND revoked_at IS NULL
|
||||
""",
|
||||
(subject_id, room_id),
|
||||
)
|
||||
_audit_membership(conn, principal.account_id, room_id, subject_id, "membership_removed")
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@router.put("/api/v1/rooms/{room_id}/source-access/{subject_id}")
|
||||
def put_source_access(
|
||||
room_id: UUID,
|
||||
subject_id: UUID,
|
||||
body: SourceAccessIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
"""Lend the own connectors to one member for the own entries shared with this room.
|
||||
|
||||
Only the person whose connectors are used decides. That is anyone who may share into the room.
|
||||
"""
|
||||
actor = principal.account_id
|
||||
room = conn.execute(
|
||||
"SELECT id, status FROM data_rooms WHERE id = %s AND kind = 'organization'", (room_id,)
|
||||
).fetchone()
|
||||
if room is None or room_role(conn, actor, room_id) is None:
|
||||
raise not_found()
|
||||
if room["status"] != "active":
|
||||
raise unprocessable("Der Datenraum ist archiviert.")
|
||||
if room_role(conn, actor, room_id) not in {"member", "manager"}:
|
||||
raise forbidden("Quellen gibt frei, wer in diesem Datenraum teilen darf.")
|
||||
if subject_id == actor:
|
||||
raise unprocessable("Die eigenen Zugänge brauchen keine Freigabe.")
|
||||
if room_role(conn, subject_id, room_id) is None:
|
||||
raise not_found()
|
||||
if body.enabled:
|
||||
created = conn.execute(
|
||||
"""
|
||||
INSERT INTO room_source_access (room_id, owner_id, subject_id)
|
||||
VALUES (%s, %s, %s)
|
||||
ON CONFLICT DO NOTHING
|
||||
RETURNING subject_id
|
||||
""",
|
||||
(room_id, actor, subject_id),
|
||||
).fetchone()
|
||||
changed = created is not None
|
||||
else:
|
||||
removed = conn.execute(
|
||||
"""
|
||||
DELETE FROM room_source_access
|
||||
WHERE room_id = %s AND owner_id = %s AND subject_id = %s
|
||||
RETURNING subject_id
|
||||
""",
|
||||
(room_id, actor, subject_id),
|
||||
).fetchone()
|
||||
changed = removed is not None
|
||||
if changed:
|
||||
audit(
|
||||
conn,
|
||||
actor,
|
||||
room_id,
|
||||
"room_source_access_granted" if body.enabled else "room_source_access_revoked",
|
||||
"membership",
|
||||
subject_id,
|
||||
detail={"room_id": str(room_id)},
|
||||
)
|
||||
return {"subject_id": str(subject_id), "enabled": body.enabled}
|
||||
|
||||
|
||||
@router.post("/api/v1/invitations")
|
||||
def invite(
|
||||
body: InvitationIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
# Only the owner, a main user, brings new people in; they become employee accounts.
|
||||
room = _require_owner(conn, principal.account_id, body.room_id)
|
||||
require_main_user(conn, principal.account_id)
|
||||
ensure_can_add_member(conn, room["owner_id"], room["id"])
|
||||
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, role)
|
||||
VALUES (%s, %s, %s, %s, %s, %s)
|
||||
RETURNING id, expires_at
|
||||
""",
|
||||
(email, room["id"], hash_secret(token), principal.account_id, utcnow() + timedelta(days=INVITATION_DAYS), body.role),
|
||||
).fetchone()
|
||||
audit(conn, principal.account_id, room["id"], "invitation_created", "invitation", row["id"], detail={"role": body.role})
|
||||
return _created(
|
||||
f"/api/v1/invitations/{row['id']}",
|
||||
{"id": str(row["id"]), "email": email, "role": body.role, "expires_at": dump_dt(row["expires_at"]), "token": token},
|
||||
)
|
||||
|
||||
|
||||
@router.get("/api/v1/rooms/{room_id}/invitations")
|
||||
def invitations(room_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
require_room_manager(conn, principal.account_id, room_id)
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT id, email, role, expires_at, created_at
|
||||
FROM auth_invitations
|
||||
WHERE room_id = %s AND accepted_at IS NULL AND revoked_at IS NULL AND expires_at > now()
|
||||
ORDER BY created_at DESC, id
|
||||
""",
|
||||
(room_id,),
|
||||
).fetchall()
|
||||
return JSONResponse(
|
||||
{
|
||||
"items": [
|
||||
{
|
||||
"id": str(row["id"]),
|
||||
"email": row["email"],
|
||||
"role": row["role"],
|
||||
"expires_at": dump_dt(row["expires_at"]),
|
||||
"created_at": dump_dt(row["created_at"]),
|
||||
}
|
||||
for row in rows
|
||||
]
|
||||
},
|
||||
headers=_NO_STORE,
|
||||
)
|
||||
|
||||
|
||||
@router.delete("/api/v1/rooms/{room_id}/invitations/{invitation_id}", status_code=204)
|
||||
def revoke_invitation(
|
||||
room_id: UUID,
|
||||
invitation_id: UUID,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
require_room_manager(conn, principal.account_id, room_id)
|
||||
row = conn.execute(
|
||||
"""
|
||||
UPDATE auth_invitations SET revoked_at = now()
|
||||
WHERE id = %s AND room_id = %s AND accepted_at IS NULL AND revoked_at IS NULL
|
||||
RETURNING id
|
||||
""",
|
||||
(invitation_id, room_id),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise not_found()
|
||||
audit(conn, principal.account_id, room_id, "invitation_revoked", "invitation", invitation_id)
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@router.get("/api/v1/admin/rooms")
|
||||
def admin_rooms(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
"""Metadata only: names, state and who manages. No content."""
|
||||
require_operator(conn, principal.account_id)
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT r.id, r.name, r.status, r.created_at,
|
||||
(SELECT o.display_name FROM auth_accounts o WHERE o.id = r.owner_id) AS owner_name,
|
||||
EXISTS (
|
||||
SELECT 1 FROM auth_accounts o
|
||||
JOIN room_memberships om ON om.subject_id = o.id AND om.room_id = r.id AND om.status = 'active'
|
||||
WHERE o.id = r.owner_id AND o.status = 'active'
|
||||
) AS owner_active,
|
||||
(SELECT count(*) FROM room_memberships m WHERE m.room_id = r.id AND m.status = 'active') AS members,
|
||||
COALESCE((
|
||||
SELECT json_agg(a.display_name ORDER BY a.display_name)
|
||||
FROM room_memberships m JOIN auth_accounts a ON a.id = m.subject_id
|
||||
WHERE m.room_id = r.id AND m.status = 'active' AND m.role = 'manager' AND a.status = 'active'
|
||||
), '[]'::json) AS managers
|
||||
FROM data_rooms r
|
||||
WHERE r.kind = 'organization'
|
||||
ORDER BY r.name, r.id
|
||||
"""
|
||||
).fetchall()
|
||||
return {
|
||||
"items": [
|
||||
{
|
||||
"id": str(row["id"]),
|
||||
"name": row["name"],
|
||||
"status": row["status"],
|
||||
"members": row["members"],
|
||||
"owner": row["owner_name"],
|
||||
"owner_active": row["owner_active"],
|
||||
"managers": row["managers"],
|
||||
"has_manager": bool(row["managers"]),
|
||||
"created_at": dump_dt(row["created_at"]),
|
||||
}
|
||||
for row in rows
|
||||
],
|
||||
"next_cursor": None,
|
||||
}
|
||||
|
||||
|
||||
@router.post("/api/v1/admin/rooms/{room_id}/managers")
|
||||
def admin_assign_manager(
|
||||
room_id: UUID,
|
||||
body: OperatorManagerIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
"""Only for a room without an active manager, so it does not stay orphaned."""
|
||||
require_operator(conn, principal.account_id)
|
||||
_room(conn, room_id)
|
||||
if count_active_managers(conn, room_id, lock=True) > 0:
|
||||
raise forbidden("Dieser Datenraum hat bereits einen Verwalter.")
|
||||
account = account_by_email(conn, body.email)
|
||||
if account is None or account["status"] != "active":
|
||||
raise not_found()
|
||||
existing = _membership(conn, room_id, account["id"], lock=True)
|
||||
_set_role(
|
||||
conn,
|
||||
principal.account_id,
|
||||
room_id,
|
||||
account["id"],
|
||||
"manager",
|
||||
added=not (existing and existing["status"] == "active"),
|
||||
)
|
||||
return {"subject_id": str(account["id"]), "role": "manager"}
|
||||
|
||||
|
||||
@router.post("/api/v1/admin/rooms/{room_id}/owner")
|
||||
def admin_set_owner(
|
||||
room_id: UUID,
|
||||
body: OperatorOwnerIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
"""The operator steps in only when the owner can no longer act: disabled or not a member any more."""
|
||||
require_operator(conn, principal.account_id)
|
||||
room = _room(conn, room_id)
|
||||
owner = conn.execute("SELECT status FROM auth_accounts WHERE id = %s", (room["owner_id"],)).fetchone()
|
||||
active_owner = bool(owner and owner["status"] == "active" and room_role(conn, room["owner_id"], room_id))
|
||||
if active_owner:
|
||||
raise forbidden("Der Eigentümer ist aktiv. Er überträgt den Datenraum selbst.")
|
||||
account = account_by_email(conn, body.email)
|
||||
if account is None or account["status"] != "active":
|
||||
raise not_found()
|
||||
if account_kind(conn, account["id"]) != "main":
|
||||
raise unprocessable("Ein Mitarbeiter-Konto kann keinen Datenraum besitzen.")
|
||||
_set_owner(conn, principal.account_id, room_id, account["id"], room["owner_id"])
|
||||
return {"owner_id": str(account["id"])}
|
||||
|
||||
|
||||
_ADMIN_KINDS = ("account", "session", "room", "membership", "invitation")
|
||||
|
||||
|
||||
@router.get("/api/v1/admin/events")
|
||||
def admin_events(
|
||||
cursor: int = 0,
|
||||
limit: int = 50,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
require_operator(conn, principal.account_id)
|
||||
limit = max(1, min(limit, 100))
|
||||
cursor = max(0, cursor)
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT e.id, e.action, e.resource_kind, e.resource_id, e.occurred_at, e.result, e.scope_id,
|
||||
actor.display_name AS actor_name,
|
||||
subject.display_name AS subject_name,
|
||||
room.name AS room_name
|
||||
FROM domain_events e
|
||||
LEFT JOIN auth_accounts actor ON actor.id = e.actor_subject_id
|
||||
LEFT JOIN auth_accounts subject ON subject.id = e.resource_id AND e.resource_kind IN ('account', 'membership')
|
||||
LEFT JOIN data_rooms room ON room.id = COALESCE(e.scope_id, CASE WHEN e.resource_kind = 'room' THEN e.resource_id END)
|
||||
AND room.kind = 'organization'
|
||||
WHERE e.resource_kind = ANY(%s)
|
||||
ORDER BY e.occurred_at DESC, e.id DESC
|
||||
OFFSET %s LIMIT %s
|
||||
""",
|
||||
(list(_ADMIN_KINDS), cursor, limit + 1),
|
||||
).fetchall()
|
||||
page = rows[:limit]
|
||||
return JSONResponse(
|
||||
{
|
||||
"items": [
|
||||
{
|
||||
"id": str(row["id"]),
|
||||
"action": row["action"],
|
||||
"label": LABELS.get(row["action"], "Ereignis"),
|
||||
"resource_kind": row["resource_kind"],
|
||||
"actor": row["actor_name"],
|
||||
"subject": row["subject_name"],
|
||||
"room": row["room_name"],
|
||||
"occurred_at": dump_dt(row["occurred_at"]),
|
||||
"result": row["result"],
|
||||
}
|
||||
for row in page
|
||||
],
|
||||
"next_cursor": cursor + limit if len(rows) > limit else None,
|
||||
},
|
||||
headers=_NO_STORE,
|
||||
)
|
||||
@@ -0,0 +1,145 @@
|
||||
"""Room shares of a case or matter. A room is a team: the owner shares an entry with any of the
|
||||
rooms he is a member of, independent of where the entry is filed."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends, Response
|
||||
from fastapi.responses import JSONResponse
|
||||
from psycopg import Connection
|
||||
|
||||
from app.access.policy import ROOM_RIGHTS, Rights
|
||||
from app.api.deps import Principal, get_conn, get_principal
|
||||
from app.api.schemas import ExclusionIn, RoomShareIn
|
||||
from app.library import room_effect
|
||||
from app.ops import _shareable, set_person_exclusion, share_with_room, unshare_from_room
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
_NO_STORE = {"Cache-Control": "no-store"}
|
||||
|
||||
|
||||
def _capped(role: str, access: str) -> Rights:
|
||||
rights = ROOM_RIGHTS.get(role, Rights())
|
||||
return Rights(read=rights.read) if access == "read" else rights
|
||||
|
||||
|
||||
def _view(conn, actor: UUID, kind: str, resource_id: UUID) -> dict:
|
||||
_shareable(conn, actor, kind, resource_id)
|
||||
shares = conn.execute(
|
||||
"""
|
||||
SELECT s.room_id, s.access, r.name, r.status
|
||||
FROM room_shares s JOIN data_rooms r ON r.id = s.room_id
|
||||
WHERE s.resource_kind = %s AND s.resource_id = %s
|
||||
ORDER BY r.name, r.id
|
||||
""",
|
||||
(kind, resource_id),
|
||||
).fetchall()
|
||||
result = []
|
||||
lent = conn.execute(
|
||||
"SELECT room_id, subject_id FROM room_source_access WHERE owner_id = %s",
|
||||
(actor,),
|
||||
).fetchall()
|
||||
lent_pairs = {(row["room_id"], row["subject_id"]) for row in lent}
|
||||
for share in shares:
|
||||
members = conn.execute(
|
||||
"""
|
||||
SELECT m.subject_id, m.role, a.display_name,
|
||||
EXISTS (
|
||||
SELECT 1 FROM access_grants g
|
||||
WHERE g.is_exception AND g.grantee_subject_id = m.subject_id
|
||||
AND g.resource_kind = %s AND g.resource_id = %s AND g.context_kind IS NULL
|
||||
) AS excluded
|
||||
FROM room_memberships m
|
||||
JOIN auth_accounts a ON a.id = m.subject_id
|
||||
WHERE m.room_id = %s AND m.status = 'active' AND m.subject_id <> %s
|
||||
ORDER BY a.display_name, a.id
|
||||
""",
|
||||
(kind, resource_id, share["room_id"], actor),
|
||||
).fetchall()
|
||||
result.append(
|
||||
{
|
||||
"room_id": str(share["room_id"]),
|
||||
"room_name": share["name"],
|
||||
"archived": share["status"] != "active",
|
||||
"access": share["access"],
|
||||
"members": [
|
||||
{
|
||||
"subject_id": str(row["subject_id"]),
|
||||
"display_name": row["display_name"],
|
||||
"role": row["role"],
|
||||
"excluded": row["excluded"],
|
||||
"sources": (share["room_id"], row["subject_id"]) in lent_pairs,
|
||||
"rights": {
|
||||
"read": _capped(row["role"], share["access"]).read,
|
||||
"edit": _capped(row["role"], share["access"]).edit,
|
||||
},
|
||||
}
|
||||
for row in members
|
||||
],
|
||||
}
|
||||
)
|
||||
shared_ids = {item["room_id"] for item in result}
|
||||
candidates = conn.execute(
|
||||
"""
|
||||
SELECT r.id, r.name, m.role
|
||||
FROM room_memberships m JOIN data_rooms r ON r.id = m.room_id
|
||||
WHERE m.subject_id = %s AND m.status = 'active' AND m.role IN ('member', 'manager')
|
||||
AND r.kind = 'organization' AND r.status = 'active'
|
||||
ORDER BY r.name, r.id
|
||||
""",
|
||||
(actor,),
|
||||
).fetchall()
|
||||
return {
|
||||
"id": str(resource_id),
|
||||
"shares": result,
|
||||
"available": [
|
||||
{"id": str(row["id"]), "name": row["name"]} for row in candidates if str(row["id"]) not in shared_ids
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
def _register(kind: str, plural: str) -> None:
|
||||
base = f"/api/v1/{plural}/{{resource_id}}/room-share"
|
||||
|
||||
@router.get(base, name=f"get_{kind}_room_share")
|
||||
def get_share(resource_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
return JSONResponse(_view(conn, principal.account_id, kind, resource_id), headers=_NO_STORE)
|
||||
|
||||
@router.put(base + "/rooms/{room_id}", name=f"put_{kind}_room_share")
|
||||
def put_share(
|
||||
resource_id: UUID,
|
||||
room_id: UUID,
|
||||
body: RoomShareIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
shared = share_with_room(conn, principal.account_id, kind, resource_id, room_id, body.access)
|
||||
shared["effect"] = room_effect(conn, room_id, principal.account_id, body.access)
|
||||
return shared
|
||||
|
||||
@router.delete(base + "/rooms/{room_id}", status_code=204, name=f"delete_{kind}_room_share")
|
||||
def delete_share(
|
||||
resource_id: UUID,
|
||||
room_id: UUID,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
unshare_from_room(conn, principal.account_id, kind, resource_id, room_id)
|
||||
return Response(status_code=204)
|
||||
|
||||
@router.put(base + "/people/{subject_id}", name=f"put_{kind}_room_share_person")
|
||||
def put_person(
|
||||
resource_id: UUID,
|
||||
subject_id: UUID,
|
||||
body: ExclusionIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
set_person_exclusion(conn, principal.account_id, kind, resource_id, subject_id, body.excluded)
|
||||
return {"subject_id": str(subject_id), "excluded": body.excluded}
|
||||
|
||||
|
||||
_register("case", "cases")
|
||||
_register("matter", "matters")
|
||||
+133
-282
@@ -12,6 +12,7 @@ from psycopg import Connection
|
||||
from app.access.policy import (
|
||||
Ctx,
|
||||
account_by_email,
|
||||
audit,
|
||||
case_rights,
|
||||
deadline_rights,
|
||||
element_rights,
|
||||
@@ -31,10 +32,11 @@ from app.access.policy import (
|
||||
require_matter,
|
||||
task_rights,
|
||||
)
|
||||
from app.access.limits import ensure_can_add_member
|
||||
from app.api.deps import Principal, get_conn, get_principal, get_session
|
||||
from app.api.externals import place_external
|
||||
from app.api.schemas import (
|
||||
AcceptInviteIn,
|
||||
AccountIn,
|
||||
AnnotationIn,
|
||||
BootstrapIn,
|
||||
AssigneeIn,
|
||||
@@ -60,18 +62,15 @@ from app.api.schemas import (
|
||||
ExternalIn,
|
||||
FulfillIn,
|
||||
GrantIn,
|
||||
InvitationIn,
|
||||
LoginIn,
|
||||
MatterIn,
|
||||
MatterPatch,
|
||||
MemberIn,
|
||||
BindingOrderIn,
|
||||
ContentOrderIn,
|
||||
ChapterMoveIn,
|
||||
DatesPatch,
|
||||
NoteIn,
|
||||
NotePatch,
|
||||
RoomIn,
|
||||
ScopeIn,
|
||||
TaskDeadlineIn,
|
||||
ElementReferenceIn,
|
||||
@@ -82,19 +81,31 @@ from app.api.schemas import (
|
||||
TaskIn,
|
||||
TaskPatch,
|
||||
)
|
||||
from app.auth.accounts import create_account, list_rooms, normalize_email, start_session
|
||||
from app.auth.accounts import (
|
||||
clear_login_attempts,
|
||||
create_account,
|
||||
initial_scope,
|
||||
list_rooms,
|
||||
login_blocked,
|
||||
normalize_email,
|
||||
record_failed_login,
|
||||
start_session,
|
||||
)
|
||||
from app.auth.security import (
|
||||
clear_session_cookie,
|
||||
device_label,
|
||||
hash_secret,
|
||||
login_bucket,
|
||||
new_secret,
|
||||
session_expiry,
|
||||
set_session_cookie,
|
||||
verify_password,
|
||||
verify_unknown_account,
|
||||
)
|
||||
from app.core.errors import Problem, forbidden, not_found, too_many, unprocessable
|
||||
from app.core.errors import DOWNLOAD_REFUSED, 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.media.port import read_clear_bytes
|
||||
from app.media.storage import content_disposition
|
||||
from app.ops import (
|
||||
add_annotation,
|
||||
assign_task,
|
||||
@@ -103,7 +114,6 @@ from app.ops import (
|
||||
create_chapter,
|
||||
create_cross_link,
|
||||
create_deadline,
|
||||
create_external,
|
||||
create_file,
|
||||
create_matter,
|
||||
create_note,
|
||||
@@ -157,10 +167,11 @@ from app.present import (
|
||||
note_update_payload,
|
||||
task_payload,
|
||||
)
|
||||
from app.library import case_items, matter_items
|
||||
from app.ops import share_with_room as _share_with_room
|
||||
from app.seed import demo_public
|
||||
|
||||
router = APIRouter()
|
||||
_login_attempts: dict[str, list[datetime]] = {}
|
||||
|
||||
|
||||
def _chosen_home(conn, principal: Principal, requested: UUID | None) -> UUID:
|
||||
@@ -192,7 +203,7 @@ def _chapter_payload(row) -> dict:
|
||||
|
||||
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",
|
||||
"SELECT id, email, display_name, is_superadmin, must_change_password, account_kind 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()
|
||||
@@ -202,6 +213,8 @@ def _session_body(conn, account_id: UUID, scope_kind: str, scope_id: UUID, csrf:
|
||||
"email": account["email"],
|
||||
"display_name": account["display_name"],
|
||||
"is_superadmin": account["is_superadmin"],
|
||||
"must_change_password": account["must_change_password"],
|
||||
"account_kind": account["account_kind"],
|
||||
},
|
||||
"scope": {"kind": scope_kind, "id": str(room["id"]), "name": room["name"]},
|
||||
"rooms": list_rooms(conn, account_id),
|
||||
@@ -210,29 +223,30 @@ def _session_body(conn, account_id: UUID, scope_kind: str, scope_id: UUID, csrf:
|
||||
}
|
||||
|
||||
|
||||
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}")
|
||||
bucket = login_bucket(request.client.host if request.client else "local", email)
|
||||
if login_blocked(conn, bucket):
|
||||
raise too_many()
|
||||
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"]):
|
||||
if account is None or account["status"] != "active":
|
||||
# Same time and same answer as a wrong password.
|
||||
verify_unknown_account(body.password)
|
||||
valid = False
|
||||
else:
|
||||
valid = verify_password(body.password, account["password_hash"])
|
||||
if not valid:
|
||||
record_failed_login(conn, bucket)
|
||||
raise Problem(401, "Anmeldung fehlgeschlagen", "E-Mail oder Passwort ist nicht richtig.", "unauthorized")
|
||||
clear_login_attempts(conn, bucket)
|
||||
settings = request.app.state.settings
|
||||
token, csrf = start_session(conn, settings, account["id"])
|
||||
payload = _session_body(conn, account["id"], "personal", account["id"], csrf, 1)
|
||||
token, csrf = start_session(conn, settings, account["id"], device_label(request.headers.get("user-agent")))
|
||||
scope_kind, scope_id = initial_scope(conn, account["id"])
|
||||
payload = _session_body(conn, account["id"], scope_kind, scope_id, csrf, 1)
|
||||
response = JSONResponse(payload)
|
||||
set_session_cookie(response, request, settings, token)
|
||||
return response
|
||||
@@ -241,6 +255,7 @@ def login(body: LoginIn, request: Request, conn: Connection = Depends(get_conn))
|
||||
@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"],))
|
||||
audit(conn, session["account_id"], None, "session_ended", "session", session["id"])
|
||||
response = Response(status_code=204)
|
||||
clear_session_cookie(response, request, request.app.state.settings)
|
||||
return response
|
||||
@@ -303,99 +318,13 @@ def bootstrap(body: BootstrapIn, request: Request, conn: Connection = Depends(ge
|
||||
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"])
|
||||
token, csrf = start_session(conn, settings, account["id"], device_label(request.headers.get("user-agent")))
|
||||
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,
|
||||
@@ -404,143 +333,46 @@ def accept_invite(
|
||||
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():
|
||||
if (
|
||||
row is None
|
||||
or row["accepted_at"] is not None
|
||||
or row["revoked_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)
|
||||
room = conn.execute("SELECT owner_id FROM data_rooms WHERE id = %s AND status = 'active'", (row["room_id"],)).fetchone()
|
||||
if room is None:
|
||||
raise not_found()
|
||||
ensure_can_add_member(conn, room["owner_id"], row["room_id"])
|
||||
# An invitation creates an employee account. The owner of the room is the sponsor.
|
||||
account = create_account(
|
||||
conn,
|
||||
row["email"],
|
||||
body.display_name,
|
||||
body.password,
|
||||
account_kind="employee",
|
||||
sponsor_id=room["owner_id"],
|
||||
)
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO room_memberships (room_id, subject_id, role)
|
||||
VALUES (%s, %s, 'member')
|
||||
VALUES (%s, %s, %s)
|
||||
""",
|
||||
(row["room_id"], account["id"]),
|
||||
(row["room_id"], account["id"], row["role"]),
|
||||
)
|
||||
conn.execute("UPDATE auth_invitations SET accepted_at = now() WHERE id = %s", (invitation_id,))
|
||||
audit(conn, account["id"], row["room_id"], "invitation_accepted", "invitation", 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)
|
||||
token, csrf = start_session(conn, settings, account["id"], device_label(request.headers.get("user-agent")))
|
||||
scope_kind, scope_id = initial_scope(conn, account["id"])
|
||||
payload = _session_body(conn, account["id"], scope_kind, scope_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)
|
||||
@@ -551,18 +383,7 @@ def find_principal(email: str, principal: Principal = Depends(get_principal), co
|
||||
|
||||
@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}
|
||||
return {"items": case_items(conn, principal.account_id, list_cases(conn, principal.account_id)), "next_cursor": None}
|
||||
|
||||
|
||||
@router.post("/api/v1/cases")
|
||||
@@ -575,6 +396,8 @@ def post_case(body: CaseIn, principal: Principal = Depends(get_principal), conn:
|
||||
body.parent_case_id,
|
||||
body.rights_mode,
|
||||
)
|
||||
if body.share_with_room_id is not None:
|
||||
_share_with_room(conn, principal.account_id, "case", case["id"], body.share_with_room_id, "edit")
|
||||
rights = case_rights(conn, principal.account_id, case)
|
||||
return _created(f"/api/v1/cases/{case['id']}", case_summary(case, rights))
|
||||
|
||||
@@ -659,8 +482,7 @@ def post_case_grant(
|
||||
|
||||
@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}
|
||||
return {"items": matter_items(conn, principal.account_id, list_matters(conn, principal.account_id)), "next_cursor": None}
|
||||
|
||||
|
||||
@router.post("/api/v1/matters")
|
||||
@@ -673,6 +495,8 @@ def post_matter(body: MatterIn, principal: Principal = Depends(get_principal), c
|
||||
body.parent_matter_id,
|
||||
_ctx_model(body.context),
|
||||
)
|
||||
if body.share_with_room_id is not None:
|
||||
_share_with_room(conn, principal.account_id, "matter", matter["id"], body.share_with_room_id, "edit")
|
||||
return _created(f"/api/v1/matters/{matter['id']}", matter_summary(conn, principal.account_id, matter))
|
||||
|
||||
|
||||
@@ -1036,21 +860,7 @@ def post_annotation(
|
||||
|
||||
@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(mode="json", exclude_none=True) if body.detail else None,
|
||||
)
|
||||
element = place_external(conn, principal, body)
|
||||
return _created(f"/api/v1/elements/{element['id']}", {"id": str(element["id"]), "title": element["title"]})
|
||||
|
||||
|
||||
@@ -1108,6 +918,7 @@ def download_file(
|
||||
request: Request,
|
||||
context_kind: str | None = None,
|
||||
context_id: str | None = None,
|
||||
save: bool = False,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
@@ -1118,13 +929,27 @@ def download_file(
|
||||
rights = element_rights(conn, principal.account_id, element, context)
|
||||
if not rights.read:
|
||||
raise not_found()
|
||||
if save and not rights.download:
|
||||
raise forbidden(DOWNLOAD_REFUSED)
|
||||
asset = conn.execute(
|
||||
"SELECT id, original_filename, content_type, status FROM media_assets WHERE element_id = %s",
|
||||
"""
|
||||
SELECT id, original_filename, content_type, sha256, status,
|
||||
storage_instance_id, storage_generation, object_key, protection_profile
|
||||
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"]))
|
||||
payload = read_clear_bytes(
|
||||
conn,
|
||||
instance_id=asset["storage_instance_id"],
|
||||
generation=asset["storage_generation"],
|
||||
object_key=asset["object_key"] or str(asset["id"]),
|
||||
media_root=request.app.state.settings.media_root,
|
||||
protection_profile=asset["protection_profile"],
|
||||
expected_sha256=asset["sha256"],
|
||||
)
|
||||
return Response(
|
||||
content=payload,
|
||||
media_type=asset["content_type"],
|
||||
@@ -1343,37 +1168,61 @@ def post_fulfill(
|
||||
return deadline_payload(conn, principal.account_id, deadline)
|
||||
|
||||
|
||||
VIEW_LIMIT = 200
|
||||
SEARCH_LIMIT = 50
|
||||
SCAN_BATCH = 200
|
||||
SCAN_CAP = 20000
|
||||
|
||||
|
||||
def _scan(conn, sql: str, params: tuple = ()):
|
||||
"""Rows in the order of the query, read in batches.
|
||||
|
||||
The rights are checked per row after reading. A fixed LIMIT in the query would count rows
|
||||
of other people too, so the own ones could fall off the end. The reader stops once it has
|
||||
enough. `SCAN_CAP` bounds the work on very large data sets.
|
||||
"""
|
||||
offset = 0
|
||||
while offset < SCAN_CAP:
|
||||
rows = conn.execute(f"{sql} LIMIT %s OFFSET %s", (*params, SCAN_BATCH, offset)).fetchall()
|
||||
yield from rows
|
||||
if len(rows) < SCAN_BATCH:
|
||||
return
|
||||
offset += SCAN_BATCH
|
||||
|
||||
|
||||
@router.get("/api/v1/views/open-tasks")
|
||||
def open_tasks(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
rows = conn.execute(
|
||||
items = []
|
||||
for task in _scan(
|
||||
conn,
|
||||
"""
|
||||
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))
|
||||
if len(items) >= VIEW_LIMIT:
|
||||
break
|
||||
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(
|
||||
items = []
|
||||
for deadline in _scan(
|
||||
conn,
|
||||
"""
|
||||
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))
|
||||
if len(items) >= VIEW_LIMIT:
|
||||
break
|
||||
return {"items": items, "next_cursor": None}
|
||||
|
||||
|
||||
@@ -1427,19 +1276,21 @@ def search(q: str, principal: Principal = Depends(get_principal), conn: Connecti
|
||||
],
|
||||
}
|
||||
)
|
||||
elements = conn.execute(
|
||||
elements = _scan(
|
||||
conn,
|
||||
"""
|
||||
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
|
||||
ORDER BY e.updated_at DESC, e.id
|
||||
""",
|
||||
(pattern, pattern),
|
||||
).fetchall()
|
||||
)
|
||||
for element in elements:
|
||||
if len(items) >= SEARCH_LIMIT:
|
||||
break
|
||||
from app.access.policy import visible_bindings_for_element
|
||||
|
||||
bindings = visible_bindings_for_element(conn, principal.account_id, element)
|
||||
@@ -1467,7 +1318,7 @@ def search(q: str, principal: Principal = Depends(get_principal), conn: Connecti
|
||||
],
|
||||
}
|
||||
)
|
||||
return {"items": items[:50], "next_cursor": None}
|
||||
return {"items": items[:SEARCH_LIMIT], "next_cursor": None}
|
||||
|
||||
|
||||
@router.patch("/api/v1/cases/{case_id}/content-order")
|
||||
|
||||
+118
-4
@@ -27,9 +27,28 @@ class BootstrapIn(APIModel):
|
||||
|
||||
|
||||
class AccountIn(APIModel):
|
||||
"""Without a password the server generates a one-time password."""
|
||||
|
||||
email: Email
|
||||
display_name: str = Field(min_length=1, max_length=120)
|
||||
password: str = Field(min_length=10, max_length=200)
|
||||
password: str | None = Field(default=None, min_length=10, max_length=200)
|
||||
is_operator: bool = False
|
||||
|
||||
|
||||
class AccountPatchIn(APIModel):
|
||||
display_name: str | None = Field(default=None, min_length=1, max_length=120)
|
||||
is_operator: bool | None = None
|
||||
status: Literal["active", "disabled"] | None = None
|
||||
account_kind: Literal["main"] | None = None
|
||||
|
||||
|
||||
class TeamPatchIn(APIModel):
|
||||
status: Literal["active", "disabled"]
|
||||
|
||||
|
||||
class PasswordChangeIn(APIModel):
|
||||
current_password: str = Field(min_length=1, max_length=200)
|
||||
new_password: str = Field(min_length=10, max_length=200)
|
||||
|
||||
|
||||
class ScopeIn(APIModel):
|
||||
@@ -46,15 +65,65 @@ class AcceptInviteIn(APIModel):
|
||||
class InvitationIn(APIModel):
|
||||
email: Email
|
||||
room_id: UUID
|
||||
role: Literal["member", "manager", "reader"] = "member"
|
||||
|
||||
|
||||
class RoomIn(APIModel):
|
||||
name: str = Field(min_length=1, max_length=160)
|
||||
default_visibility: Literal["private", "room"] = "room"
|
||||
|
||||
|
||||
class VisibilityIn(APIModel):
|
||||
visibility: Literal["private", "room"]
|
||||
|
||||
|
||||
class ShareItemIn(APIModel):
|
||||
kind: Literal["case", "matter"]
|
||||
id: UUID
|
||||
|
||||
|
||||
class BatchShareIn(APIModel):
|
||||
items: list[ShareItemIn] = Field(min_length=1, max_length=200)
|
||||
access: Literal["read", "edit"] = "edit"
|
||||
|
||||
|
||||
class RoomShareIn(APIModel):
|
||||
access: Literal["read", "edit"] = "edit"
|
||||
|
||||
|
||||
class ExclusionIn(APIModel):
|
||||
excluded: bool
|
||||
|
||||
|
||||
class SourceAccessIn(APIModel):
|
||||
enabled: bool
|
||||
|
||||
|
||||
class OwnerIn(APIModel):
|
||||
subject_id: UUID
|
||||
|
||||
|
||||
class OperatorOwnerIn(APIModel):
|
||||
email: Email
|
||||
|
||||
|
||||
class MemberIn(APIModel):
|
||||
email: Email
|
||||
role: Literal["member", "manager"]
|
||||
role: Literal["member", "manager", "reader"]
|
||||
|
||||
|
||||
class MemberRoleIn(APIModel):
|
||||
role: Literal["member", "manager", "reader"]
|
||||
|
||||
|
||||
class RoomPatchIn(APIModel):
|
||||
name: str | None = Field(default=None, min_length=1, max_length=160)
|
||||
status: Literal["active", "archived"] | None = None
|
||||
default_visibility: Literal["private", "room"] | None = None
|
||||
|
||||
|
||||
class OperatorManagerIn(APIModel):
|
||||
email: Email
|
||||
|
||||
|
||||
class ContextIn(APIModel):
|
||||
@@ -67,6 +136,7 @@ class CaseIn(APIModel):
|
||||
parent_case_id: UUID | None = None
|
||||
rights_mode: Literal["inherit_parent", "explicit"] = "inherit_parent"
|
||||
home_scope_id: UUID | None = None
|
||||
share_with_room_id: UUID | None = None
|
||||
|
||||
|
||||
class CasePatch(APIModel):
|
||||
@@ -142,6 +212,7 @@ class MatterIn(APIModel):
|
||||
parent_matter_id: UUID | None = None
|
||||
context: ContextIn | None = None
|
||||
home_scope_id: UUID | None = None
|
||||
share_with_room_id: UUID | None = None
|
||||
|
||||
|
||||
class MatterPatch(APIModel):
|
||||
@@ -278,17 +349,39 @@ class ExternalDetail(APIModel):
|
||||
|
||||
class ExternalIn(APIModel):
|
||||
title: str = Field(min_length=1, max_length=200)
|
||||
source: Literal["paperless", "url", "imap"]
|
||||
source: str = Field(min_length=1, max_length=40)
|
||||
external_id: str = Field(min_length=1, max_length=200)
|
||||
context: ContextIn
|
||||
placement: ContextIn | None = None
|
||||
chapter_id: UUID | None = None
|
||||
dates: DatesIn = DatesIn()
|
||||
detail: ExternalDetail | None = None
|
||||
# "ask": a document that is already present at the account's check level answers 409.
|
||||
# "insert": the user chose to insert it again. `bind_element_id` binds that element instead of creating one.
|
||||
duplicate: Literal["ask", "insert"] = "ask"
|
||||
bind_element_id: UUID | None = None
|
||||
|
||||
|
||||
class ExistingItemIn(APIModel):
|
||||
source: str = Field(min_length=1, max_length=40)
|
||||
external_id: str = Field(min_length=1, max_length=200)
|
||||
connector_id: UUID | None = None
|
||||
|
||||
|
||||
class ExistingIn(APIModel):
|
||||
context: ContextIn
|
||||
placement: ContextIn | None = None
|
||||
items: list[ExistingItemIn] = Field(min_length=1, max_length=100)
|
||||
|
||||
|
||||
class ConnectorIn(APIModel):
|
||||
kind: Literal["paperless", "imap"]
|
||||
"""Kind is checked against the source registry. Source fields stay optional.
|
||||
|
||||
Paperless and IMAP still send their existing fields. A further module
|
||||
uses ``config`` and validates that bag itself.
|
||||
"""
|
||||
|
||||
kind: str = Field(min_length=1, max_length=40)
|
||||
name: str = Field(min_length=1, max_length=120)
|
||||
base_url: str | None = None
|
||||
token: str | None = None
|
||||
@@ -298,6 +391,11 @@ class ConnectorIn(APIModel):
|
||||
password: str | None = None
|
||||
mailbox: str | None = Field(default=None, max_length=200)
|
||||
security: Literal["ssl", "starttls"] | None = None
|
||||
config: dict[str, str | int | None] | None = None
|
||||
|
||||
|
||||
class SourceAssignmentIn(APIModel):
|
||||
connector_id: UUID
|
||||
|
||||
|
||||
class DeleteElementIn(APIModel):
|
||||
@@ -441,3 +539,19 @@ class DispatchCorrectIn(APIModel):
|
||||
clear_sent_on: bool = False
|
||||
counterpart: str | None = Field(default=None, max_length=200)
|
||||
clear_counterpart: bool = False
|
||||
|
||||
|
||||
class PreferenceIn(APIModel):
|
||||
"""`value` replaces the own value; null means: inherit. `team_mode` is for main users and stays as it is when absent."""
|
||||
|
||||
value: str | None = Field(default=None, max_length=40)
|
||||
team_mode: Literal["free", "locked"] | None = None
|
||||
|
||||
|
||||
class DownloadPolicyIn(APIModel):
|
||||
"""Who may save or open the original outside of Tsumugu. `direct` only applies to the account default."""
|
||||
|
||||
manager: bool
|
||||
member: bool
|
||||
reader: bool
|
||||
direct: bool | None = None
|
||||
+262
-68
@@ -4,30 +4,34 @@ from __future__ import annotations
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends
|
||||
from fastapi import APIRouter, Depends, Request
|
||||
from fastapi.responses import JSONResponse, Response
|
||||
from psycopg import Connection
|
||||
|
||||
from app.access.policy import element_rights, get_element, parse_query_context
|
||||
from app.api.deps import Principal, get_conn, get_principal
|
||||
from app.api.routes import _created, _ctx_model
|
||||
from app.api.schemas import ConnectorIn, ExternalIn
|
||||
from app.core.errors import not_found, unprocessable
|
||||
from app.mailpack import parse_mail
|
||||
from app.api.routes import _created
|
||||
from app.api.schemas import ConnectorIn, ExternalIn, SourceAssignmentIn
|
||||
from app.core.errors import DOWNLOAD_REFUSED, forbidden, not_found, unprocessable, unsupported
|
||||
from app.mailpack import _inline_images, parse_mail, sanitize_html
|
||||
from app.remoteimages import RemoteImages
|
||||
from app.media.storage import content_disposition
|
||||
from app.ops import create_external
|
||||
from app.api.externals import place_external
|
||||
from app.retrieval import RetrievalFailure
|
||||
from app.sourcebind import assign_reference
|
||||
from app.sourceport import capability_payload, with_capabilities
|
||||
from app.sourceregistry import get_source, require_source
|
||||
from app.sources import (
|
||||
clean_base_url,
|
||||
connector_detail,
|
||||
delete_connector,
|
||||
imap_mailboxes,
|
||||
imap_messages,
|
||||
imap_preview,
|
||||
list_connectors,
|
||||
paperless_documents,
|
||||
owned_connector,
|
||||
paperless_content,
|
||||
parse_connector,
|
||||
probe,
|
||||
read_linked_mail,
|
||||
read_linked_paperless,
|
||||
save_connector,
|
||||
update_connector,
|
||||
)
|
||||
|
||||
_PRIVATE = {
|
||||
@@ -44,13 +48,38 @@ def get_connectors(principal: Principal = Depends(get_principal), conn: Connecti
|
||||
return {"items": list_connectors(conn, principal.account_id)}
|
||||
|
||||
|
||||
@router.get("/api/v1/sources/capabilities")
|
||||
def source_capabilities(principal: Principal = Depends(get_principal)):
|
||||
del principal
|
||||
return capability_payload()
|
||||
|
||||
|
||||
@router.post("/api/v1/connectors", status_code=201)
|
||||
def post_connector(body: ConnectorIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
name, settings, secret = _connector_parts(body)
|
||||
name, settings, secret = _connector_parts(body, None)
|
||||
row = save_connector(conn, principal.account_id, body.kind, name, settings, secret)
|
||||
return row
|
||||
|
||||
|
||||
@router.get("/api/v1/connectors/{connector_id}")
|
||||
def get_connector(connector_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
return connector_detail(conn, principal.account_id, connector_id)
|
||||
|
||||
|
||||
@router.patch("/api/v1/connectors/{connector_id}")
|
||||
def patch_connector(
|
||||
connector_id: UUID,
|
||||
body: ConnectorIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
current = owned_connector(conn, principal.account_id, connector_id)
|
||||
if current["kind"] != body.kind:
|
||||
raise unprocessable("Der Zugang bleibt bei seiner Quellenart.")
|
||||
name, settings, secret = _connector_parts(body, current)
|
||||
return update_connector(conn, principal.account_id, connector_id, name, settings, secret)
|
||||
|
||||
|
||||
@router.delete("/api/v1/connectors/{connector_id}", status_code=204)
|
||||
def remove_connector(connector_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
delete_connector(conn, principal.account_id, connector_id)
|
||||
@@ -62,24 +91,27 @@ def probe_connector(connector_id: UUID, principal: Principal = Depends(get_princ
|
||||
|
||||
|
||||
@router.get("/api/v1/external-refs/{element_id}/content")
|
||||
def view_paperless(
|
||||
def view_external_content(
|
||||
element_id: UUID,
|
||||
context_kind: str | None = None,
|
||||
context_id: str | None = None,
|
||||
save: bool = False,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
|
||||
if ref is None or ref["source"] != "paperless":
|
||||
raise unprocessable("Nur ein Paperless-Dokument lässt sich hier als Datei ansehen.")
|
||||
data, media_type, filename = read_linked_paperless(conn, principal.account_id, element, context, ref)
|
||||
safe_name = (filename or "dokument.pdf").replace('"', "")
|
||||
if save:
|
||||
_require_download(conn, principal, element, context)
|
||||
module = get_source(ref["source"]) if ref is not None else None
|
||||
if module is None or module.open_original is None:
|
||||
raise unprocessable("Für diese Quelle ist kein Dateiabruf vorgesehen.")
|
||||
data, media_type, filename = module.open_original(conn, principal.account_id, element, context, ref)
|
||||
return Response(
|
||||
content=data,
|
||||
media_type=media_type,
|
||||
headers={
|
||||
**_PRIVATE,
|
||||
"Content-Disposition": f'inline; filename="{safe_name}"',
|
||||
"Content-Disposition": content_disposition(filename or "dokument.pdf").replace("attachment;", "inline;", 1),
|
||||
},
|
||||
)
|
||||
|
||||
@@ -101,14 +133,19 @@ def view_mail(
|
||||
"message_to": parsed.recipient,
|
||||
"message_cc": parsed.copy,
|
||||
"text": parsed.text,
|
||||
"text_truncated": False,
|
||||
"complete": True,
|
||||
"html": parsed.html,
|
||||
"remote_images": len(parsed.remote_images),
|
||||
"text_truncated": parsed.text_truncated,
|
||||
"complete": not parsed.missing,
|
||||
"notices": parsed.notices,
|
||||
"attachments": [
|
||||
{
|
||||
"index": index,
|
||||
"filename": item.filename,
|
||||
"filename": item.display_name or item.filename,
|
||||
"archive_name": item.filename,
|
||||
"content_type": item.media_type,
|
||||
"byte_size": len(item.data),
|
||||
"inline": item.inline,
|
||||
}
|
||||
for index, item in enumerate(parsed.attachments)
|
||||
],
|
||||
@@ -117,6 +154,11 @@ def view_mail(
|
||||
)
|
||||
|
||||
|
||||
def _require_download(conn, principal: Principal, element, context) -> None:
|
||||
if not element_rights(conn, principal.account_id, element, context).download:
|
||||
raise forbidden(DOWNLOAD_REFUSED)
|
||||
|
||||
|
||||
def _opened_ref(conn, principal: Principal, element_id: UUID, context_kind: str | None, context_id: str | None):
|
||||
element = get_element(conn, element_id)
|
||||
if element is None or element["kind"] != "external_ref":
|
||||
@@ -126,14 +168,23 @@ def _opened_ref(conn, principal: Principal, element_id: UUID, context_kind: str
|
||||
if not rights.read:
|
||||
raise not_found()
|
||||
ref = conn.execute(
|
||||
"SELECT source, external_id, detail FROM external_references WHERE element_id = %s",
|
||||
"""
|
||||
SELECT source, external_id, detail, connector_id, resolution
|
||||
FROM external_references WHERE element_id = %s
|
||||
""",
|
||||
(element_id,),
|
||||
).fetchone()
|
||||
return element, context, ref
|
||||
|
||||
|
||||
def _complete_mail(conn, principal: Principal, element, context, ref):
|
||||
raw = read_linked_mail(conn, principal.account_id, element, context, ref)
|
||||
module = get_source(ref["source"]) if ref is not None else None
|
||||
if module is None or module.representation != "email":
|
||||
raise unprocessable("Das ist keine E-Mail.")
|
||||
opened = module.open_original(conn, principal.account_id, element, context, ref)
|
||||
if isinstance(opened, RetrievalFailure):
|
||||
raise unprocessable(opened.message)
|
||||
raw = opened[0] if isinstance(opened, tuple) else opened
|
||||
parsed = parse_mail(raw)
|
||||
if parsed.missing:
|
||||
names = ", ".join(parsed.missing[:5])
|
||||
@@ -141,6 +192,25 @@ def _complete_mail(conn, principal: Principal, element, context, ref):
|
||||
return parsed, raw
|
||||
|
||||
|
||||
@router.get("/api/v1/external-refs/{element_id}/mail/html-with-images")
|
||||
def view_mail_with_images(
|
||||
element_id: UUID,
|
||||
context_kind: str | None = None,
|
||||
context_id: str | None = None,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
"""The formatted mail with its pictures from other servers, loaded by the server on request."""
|
||||
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
|
||||
parsed, _raw = _complete_mail(conn, principal, element, context, ref)
|
||||
loader = RemoteImages()
|
||||
rendered = sanitize_html(parsed.html_source, _inline_images(parsed.attachments), remote=loader) if parsed.html_source else ""
|
||||
return JSONResponse(
|
||||
content={"html": rendered, "loaded": loader.loaded, "failed": loader.failed},
|
||||
headers={"Cache-Control": "private, no-store", "Referrer-Policy": "no-referrer"},
|
||||
)
|
||||
|
||||
|
||||
@router.get("/api/v1/external-refs/{element_id}/mail/original")
|
||||
def download_mail(
|
||||
element_id: UUID,
|
||||
@@ -150,8 +220,9 @@ def download_mail(
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
|
||||
_parsed, raw = _complete_mail(conn, principal, element, context, ref)
|
||||
return _mail_bytes(raw, "message/rfc822", "nachricht.eml")
|
||||
_require_download(conn, principal, element, context)
|
||||
parsed, raw = _complete_mail(conn, principal, element, context, ref)
|
||||
return _mail_bytes(raw, "message/rfc822", f"{parsed.subject or 'nachricht'}.eml")
|
||||
|
||||
|
||||
@router.get("/api/v1/external-refs/{element_id}/mail/attachments/{index}")
|
||||
@@ -160,21 +231,29 @@ def download_mail_attachment(
|
||||
index: int,
|
||||
context_kind: str | None = None,
|
||||
context_id: str | None = None,
|
||||
save: bool = False,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
|
||||
if save:
|
||||
_require_download(conn, principal, element, context)
|
||||
parsed, _raw = _complete_mail(conn, principal, element, context, ref)
|
||||
if index < 0 or index >= len(parsed.attachments):
|
||||
raise not_found()
|
||||
item = parsed.attachments[index]
|
||||
return _mail_bytes(item.data, item.media_type or "application/octet-stream", item.filename, inline=True)
|
||||
name = item.display_name or item.filename or "anlage"
|
||||
media = (item.media_type or "application/octet-stream").split(";", 1)[0].strip()
|
||||
if item.data[:1024].lstrip(b"\xef\xbb\xbf\r\n\t ").startswith(b"%PDF"):
|
||||
media = "application/pdf"
|
||||
if not name.lower().endswith(".pdf"):
|
||||
leaf = name.replace("\\", "/").split("/")[-1]
|
||||
name = name if "." in leaf else f"{name}.pdf"
|
||||
return _mail_bytes(item.data, media or "application/octet-stream", name, inline=True)
|
||||
|
||||
|
||||
def _mail_bytes(data: bytes, media_type: str, filename: str, inline: bool = False) -> Response:
|
||||
disposition = content_disposition(filename)
|
||||
if inline:
|
||||
disposition = disposition.replace("attachment;", "inline;", 1)
|
||||
disposition = content_disposition(filename, inline=inline)
|
||||
return Response(
|
||||
content=data,
|
||||
media_type=media_type,
|
||||
@@ -185,9 +264,66 @@ def _mail_bytes(data: bytes, media_type: str, filename: str, inline: bool = Fals
|
||||
)
|
||||
|
||||
|
||||
# These belong to the route. Every other query parameter is a filter the registered module must declare.
|
||||
_ROUTE_PARAMS = frozenset({"q", "connector_id", "mailbox", "before", "uidvalidity"})
|
||||
|
||||
|
||||
def _filters(request: Request) -> dict:
|
||||
return {name: value for name, value in request.query_params.items() if name not in _ROUTE_PARAMS}
|
||||
|
||||
|
||||
@router.get("/api/v1/sources/paperless/documents")
|
||||
def search_paperless(q: str = "", principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
return {"items": paperless_documents(conn, principal.account_id, q.strip())}
|
||||
def search_paperless(
|
||||
request: Request,
|
||||
q: str = "",
|
||||
connector_id: UUID | None = None,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
return _run_search("paperless", conn, principal.account_id, q.strip(), connector_id, "", None, _filters(request))
|
||||
|
||||
|
||||
@router.get("/api/v1/sources/{kind}/facets")
|
||||
def source_facets(
|
||||
kind: str,
|
||||
connector_id: UUID,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
module = require_source(kind)
|
||||
if module.facets is None:
|
||||
raise unsupported("Diese Quelle hat keine Auswahllisten.")
|
||||
return module.facets(conn, principal.account_id, connector_id)
|
||||
|
||||
|
||||
@router.get("/api/v1/sources/paperless/documents/{document_id}/preview")
|
||||
def preview_paperless_document(
|
||||
document_id: str,
|
||||
connector_id: UUID,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
data, media, name = paperless_content(conn, principal.account_id, document_id, connector_id)
|
||||
return Response(
|
||||
content=data,
|
||||
media_type=media,
|
||||
headers={**_PRIVATE, "Content-Disposition": content_disposition(name).replace("attachment;", "inline;", 1)},
|
||||
)
|
||||
|
||||
|
||||
@router.get("/api/v1/sources/{kind}/thumbnail")
|
||||
def thumbnail_source(
|
||||
kind: str,
|
||||
connector_id: UUID,
|
||||
item: str,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
module = require_source(kind)
|
||||
if not module.capabilities["search"].get("result_preview") or module.thumbnail is None:
|
||||
raise unsupported("Diese Quelle hat keine Vorschaubilder.")
|
||||
data, media = module.thumbnail(conn, principal.account_id, connector_id, item)
|
||||
return Response(content=data, media_type=media, headers=_PRIVATE)
|
||||
|
||||
|
||||
@router.get("/api/v1/sources/imap/mailboxes")
|
||||
@@ -196,21 +332,25 @@ def list_mailboxes(
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
return {"items": imap_mailboxes(conn, principal.account_id, connector_id)}
|
||||
return _run_navigate("imap", conn, principal.account_id, connector_id)
|
||||
|
||||
|
||||
@router.get("/api/v1/sources/imap/messages")
|
||||
def search_mail(
|
||||
request: Request,
|
||||
connector_id: UUID,
|
||||
q: str = "",
|
||||
mailbox: str = "",
|
||||
before: int | None = None,
|
||||
uidvalidity: int | None = None,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
if before is not None and before < 1:
|
||||
raise unprocessable("Die Seitenangabe ist ungültig.")
|
||||
return imap_messages(conn, principal.account_id, connector_id, q.strip(), mailbox.strip(), before)
|
||||
return _run_search(
|
||||
"imap", conn, principal.account_id, q.strip(), connector_id, mailbox.strip(), before, _filters(request), uidvalidity
|
||||
)
|
||||
|
||||
|
||||
@router.get("/api/v1/sources/imap/message")
|
||||
@@ -228,40 +368,94 @@ def read_mail(
|
||||
|
||||
@router.post("/api/v1/sources/link", status_code=201)
|
||||
def link_source(body: ExternalIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
if body.source not in {"paperless", "imap"}:
|
||||
raise unprocessable("Verknüpft werden Paperless-Dokumente und E-Mails.")
|
||||
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(mode="json", exclude_none=True) if body.detail else None,
|
||||
)
|
||||
if get_source(body.source) is None:
|
||||
raise unprocessable("Verknüpft werden registrierte Quellen.")
|
||||
element = place_external(conn, principal, body)
|
||||
return _created(f"/api/v1/elements/{element['id']}", {"id": str(element["id"]), "title": element["title"]})
|
||||
|
||||
|
||||
def _connector_parts(body: ConnectorIn) -> tuple[str, dict, str]:
|
||||
if body.kind == "paperless":
|
||||
if not body.base_url or not body.token or len(body.token.strip()) < 8:
|
||||
raise unprocessable("Paperless braucht eine Adresse und einen API-Schlüssel.")
|
||||
return body.name.strip(), {"base_url": clean_base_url(body.base_url)}, body.token.strip()
|
||||
if not body.host or not body.username or not body.password:
|
||||
raise unprocessable("Ein E-Mail-Konto braucht Server, Benutzername und Passwort.")
|
||||
host = body.host.strip()
|
||||
if " " in host or len(host) > 200:
|
||||
raise unprocessable("Der Mailserver ist ungültig.")
|
||||
return body.name.strip(), {
|
||||
"host": host,
|
||||
"port": body.port or 993,
|
||||
"username": body.username.strip(),
|
||||
"mailbox": (body.mailbox or "INBOX").strip() or "INBOX",
|
||||
"security": body.security or "ssl",
|
||||
}, body.password
|
||||
@router.post("/api/v1/external-refs/{element_id}/assignment")
|
||||
def assign_source(
|
||||
element_id: UUID,
|
||||
body: SourceAssignmentIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
assign_reference(conn, principal.account_id, element_id, body.connector_id)
|
||||
return {"id": str(element_id), "connector_id": str(body.connector_id), "resolution": "bound"}
|
||||
|
||||
|
||||
def _connector_parts(body: ConnectorIn, current: dict | None) -> tuple[str, dict, str]:
|
||||
"""The registered module validates. Flat fields of the first release are folded into ``config``."""
|
||||
flat = body.model_dump(exclude={"kind", "name", "config"})
|
||||
return parse_connector(body.kind, body.name, flat, body.config, current)
|
||||
|
||||
|
||||
def _run_search(kind: str, conn, owner, query: str, connector_id: UUID | None, mailbox: str, before: int | None, filters: dict, uidvalidity: int | None = None) -> dict:
|
||||
module = require_source(kind)
|
||||
search = module.capabilities["search"]
|
||||
refused = [
|
||||
name
|
||||
for name, value in filters.items()
|
||||
if str(value or "").strip() and not search.get(module.search_params.get(name, ""))
|
||||
]
|
||||
if before is not None and not search.get("continuation"):
|
||||
refused.append("before")
|
||||
if refused:
|
||||
raise unsupported("Diese Suche unterstützt den Filter nicht: " + ", ".join(refused) + ".")
|
||||
options = {"mailbox": mailbox, "before": before}
|
||||
if uidvalidity is not None:
|
||||
options["uidvalidity"] = uidvalidity
|
||||
options.update({key: value for key, value in filters.items() if str(value or "").strip()})
|
||||
found = module.find(conn, owner, connector_id, query, options)
|
||||
bound = str(found.get("connector_id") or connector_id or "")
|
||||
return with_capabilities(kind, bound, found)
|
||||
|
||||
|
||||
def _run_navigate(kind: str, conn, owner, connector_id: UUID) -> dict:
|
||||
module = require_source(kind)
|
||||
if not module.capabilities.get("navigate") or module.navigate is None:
|
||||
raise unsupported("Diese Quelle hat keine Fachnavigation.")
|
||||
return {"items": module.navigate(conn, owner, connector_id)}
|
||||
|
||||
|
||||
@router.get("/api/v1/sources/{kind}/search")
|
||||
def search_source(
|
||||
request: Request,
|
||||
kind: str,
|
||||
q: str = "",
|
||||
connector_id: UUID | None = None,
|
||||
mailbox: str = "",
|
||||
before: int | None = None,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
if before is not None and before < 1:
|
||||
raise unprocessable("Die Seitenangabe ist ungültig.")
|
||||
return _run_search(kind, conn, principal.account_id, q.strip(), connector_id, mailbox.strip(), before, _filters(request))
|
||||
|
||||
|
||||
@router.get("/api/v1/sources/{kind}/navigate")
|
||||
def navigate_source(
|
||||
kind: str,
|
||||
connector_id: UUID,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
return _run_navigate(kind, conn, principal.account_id, connector_id)
|
||||
|
||||
|
||||
@router.get("/api/v1/sources/{kind}/preview")
|
||||
def preview_source(
|
||||
kind: str,
|
||||
connector_id: UUID,
|
||||
mailbox: str = "",
|
||||
uid: int = 0,
|
||||
item: str = "",
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
module = require_source(kind)
|
||||
if not module.capabilities.get("read_preview") or module.preview is None:
|
||||
raise unsupported("Diese Quelle hat keine Vorschau vor dem Übernehmen.")
|
||||
return module.preview(conn, principal.account_id, connector_id, {"mailbox": mailbox, "uid": uid, "item": item})
|
||||
@@ -0,0 +1,245 @@
|
||||
"""Team of a main user and the operator's overview of all teams.
|
||||
|
||||
A main user sees the people in the rooms he owns and manages the employees he invited.
|
||||
The operator sees main users with their employees, rooms and roles: accounts and roles, never content.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import csv
|
||||
import io
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends, Response
|
||||
from fastapi.responses import JSONResponse
|
||||
from psycopg import Connection
|
||||
|
||||
from app.access.policy import audit
|
||||
from app.access.roles import require_main_user, require_operator
|
||||
from app.api.deps import Principal, get_conn, get_principal
|
||||
from app.api.rooms import _audit_membership, _drop_shares_of
|
||||
from app.api.schemas import TeamPatchIn
|
||||
from app.auth.accounts import reset_password, set_status
|
||||
from app.core.errors import forbidden
|
||||
from app.core.timeutil import dump_dt
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
_NO_STORE = {"Cache-Control": "no-store"}
|
||||
|
||||
|
||||
def _own_employee(conn, owner_id: UUID, account_id: UUID) -> dict:
|
||||
"""An employee this main user invited. Unknown and foreign accounts answer alike."""
|
||||
row = conn.execute(
|
||||
"SELECT id, status FROM auth_accounts WHERE id = %s AND account_kind = 'employee' AND sponsor_id = %s",
|
||||
(account_id, owner_id),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise forbidden("Das ist keiner deiner Mitarbeiter.")
|
||||
return row
|
||||
|
||||
|
||||
@router.get("/api/v1/team")
|
||||
def team(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
require_main_user(conn, principal.account_id)
|
||||
me = principal.account_id
|
||||
people = conn.execute(
|
||||
"""
|
||||
SELECT DISTINCT a.id, a.display_name, a.email, a.status, a.account_kind, a.last_login_at,
|
||||
(a.sponsor_id = %s) AS mine
|
||||
FROM auth_accounts a
|
||||
WHERE a.id <> %s AND (
|
||||
a.sponsor_id = %s
|
||||
OR EXISTS (
|
||||
SELECT 1 FROM room_memberships m JOIN data_rooms r ON r.id = m.room_id
|
||||
WHERE m.subject_id = a.id AND m.status = 'active'
|
||||
AND r.kind = 'organization' AND r.owner_id = %s
|
||||
)
|
||||
)
|
||||
ORDER BY a.display_name, a.id
|
||||
""",
|
||||
(me, me, me, me),
|
||||
).fetchall()
|
||||
rooms = conn.execute(
|
||||
"""
|
||||
SELECT m.subject_id, r.id AS room_id, r.name, r.status, m.role
|
||||
FROM room_memberships m JOIN data_rooms r ON r.id = m.room_id
|
||||
WHERE m.status = 'active' AND r.kind = 'organization' AND r.owner_id = %s AND m.subject_id <> %s
|
||||
ORDER BY r.name, r.id
|
||||
""",
|
||||
(me, me),
|
||||
).fetchall()
|
||||
by_person: dict = {}
|
||||
for row in rooms:
|
||||
by_person.setdefault(row["subject_id"], []).append(
|
||||
{"room_id": str(row["room_id"]), "name": row["name"], "archived": row["status"] != "active", "role": row["role"]}
|
||||
)
|
||||
return JSONResponse(
|
||||
{
|
||||
"items": [
|
||||
{
|
||||
"id": str(person["id"]),
|
||||
"display_name": person["display_name"],
|
||||
"email": person["email"],
|
||||
"status": person["status"],
|
||||
"account_kind": person["account_kind"],
|
||||
"last_login_at": dump_dt(person["last_login_at"]),
|
||||
"mine": person["mine"],
|
||||
"rooms": by_person.get(person["id"], []),
|
||||
}
|
||||
for person in people
|
||||
]
|
||||
},
|
||||
headers=_NO_STORE,
|
||||
)
|
||||
|
||||
|
||||
@router.patch("/api/v1/team/{account_id}")
|
||||
def patch_team_member(
|
||||
account_id: UUID,
|
||||
body: TeamPatchIn,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
require_main_user(conn, principal.account_id)
|
||||
_own_employee(conn, principal.account_id, account_id)
|
||||
set_status(conn, principal.account_id, account_id, body.status)
|
||||
return {"id": str(account_id), "status": body.status}
|
||||
|
||||
|
||||
@router.post("/api/v1/team/{account_id}/password-reset")
|
||||
def reset_team_password(
|
||||
account_id: UUID,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
require_main_user(conn, principal.account_id)
|
||||
_own_employee(conn, principal.account_id, account_id)
|
||||
password = reset_password(conn, principal.account_id, account_id)
|
||||
audit(conn, principal.account_id, None, "employee_password_reset", "account", account_id)
|
||||
return JSONResponse({"temporary_password": password}, headers=_NO_STORE)
|
||||
|
||||
|
||||
@router.delete("/api/v1/team/{account_id}/memberships", status_code=204)
|
||||
def remove_from_my_rooms(
|
||||
account_id: UUID,
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
"""End the memberships of one person in all rooms this main user owns."""
|
||||
require_main_user(conn, principal.account_id)
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT m.room_id FROM room_memberships m JOIN data_rooms r ON r.id = m.room_id
|
||||
WHERE m.subject_id = %s AND m.status = 'active' AND r.kind = 'organization' AND r.owner_id = %s
|
||||
FOR UPDATE OF m
|
||||
""",
|
||||
(account_id, principal.account_id),
|
||||
).fetchall()
|
||||
if account_id == principal.account_id or not rows:
|
||||
raise forbidden("Diese Person ist in keinem deiner Räume Mitglied.")
|
||||
for row in rows:
|
||||
room_id = row["room_id"]
|
||||
conn.execute(
|
||||
"UPDATE room_memberships SET status = 'removed' WHERE room_id = %s AND subject_id = %s",
|
||||
(room_id, account_id),
|
||||
)
|
||||
_drop_shares_of(conn, room_id, account_id)
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE auth_sessions
|
||||
SET scope_kind = 'personal', scope_id = account_id, epoch = epoch + 1
|
||||
WHERE account_id = %s AND scope_id = %s AND revoked_at IS NULL
|
||||
""",
|
||||
(account_id, room_id),
|
||||
)
|
||||
_audit_membership(conn, principal.account_id, room_id, account_id, "membership_removed")
|
||||
audit(conn, principal.account_id, None, "employee_removed", "account", account_id, detail={"rooms": len(rows)})
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
def _csv_cell(value) -> str:
|
||||
text = "" if value is None else str(value)
|
||||
# A cell that starts like a formula would run in a spreadsheet.
|
||||
return "'" + text if text[:1] in {"=", "+", "-", "@", "\t", "\r"} else text
|
||||
|
||||
|
||||
@router.get("/api/v1/admin/team")
|
||||
def admin_team(
|
||||
format: str = "json",
|
||||
principal: Principal = Depends(get_principal),
|
||||
conn: Connection = Depends(get_conn),
|
||||
):
|
||||
"""Main users with their employees, rooms and roles. Metadata only."""
|
||||
require_operator(conn, principal.account_id)
|
||||
owners = conn.execute(
|
||||
"""
|
||||
SELECT a.id, a.display_name, a.email, a.status
|
||||
FROM auth_accounts a
|
||||
WHERE a.account_kind = 'main'
|
||||
AND (EXISTS (SELECT 1 FROM auth_accounts e WHERE e.sponsor_id = a.id)
|
||||
OR EXISTS (SELECT 1 FROM data_rooms r WHERE r.owner_id = a.id AND r.kind = 'organization'))
|
||||
ORDER BY a.display_name, a.id
|
||||
"""
|
||||
).fetchall()
|
||||
employees = conn.execute(
|
||||
"""
|
||||
SELECT e.id, e.sponsor_id, e.display_name, e.email, e.status, e.last_login_at
|
||||
FROM auth_accounts e WHERE e.account_kind = 'employee'
|
||||
ORDER BY e.display_name, e.id
|
||||
"""
|
||||
).fetchall()
|
||||
memberships = conn.execute(
|
||||
"""
|
||||
SELECT m.subject_id, r.id AS room_id, r.name, r.status, r.owner_id, m.role
|
||||
FROM room_memberships m JOIN data_rooms r ON r.id = m.room_id
|
||||
WHERE m.status = 'active' AND r.kind = 'organization'
|
||||
ORDER BY r.name, r.id
|
||||
"""
|
||||
).fetchall()
|
||||
rooms_of: dict = {}
|
||||
for row in memberships:
|
||||
rooms_of.setdefault(row["subject_id"], []).append(row)
|
||||
result = []
|
||||
for owner in owners:
|
||||
mine = [e for e in employees if e["sponsor_id"] == owner["id"]]
|
||||
result.append(
|
||||
{
|
||||
"id": str(owner["id"]),
|
||||
"display_name": owner["display_name"],
|
||||
"email": owner["email"],
|
||||
"status": owner["status"],
|
||||
"employees": [
|
||||
{
|
||||
"id": str(e["id"]),
|
||||
"display_name": e["display_name"],
|
||||
"email": e["email"],
|
||||
"status": e["status"],
|
||||
"last_login_at": dump_dt(e["last_login_at"]),
|
||||
"rooms": [
|
||||
{"room_id": str(r["room_id"]), "name": r["name"], "archived": r["status"] != "active", "role": r["role"]}
|
||||
for r in rooms_of.get(e["id"], [])
|
||||
],
|
||||
}
|
||||
for e in mine
|
||||
],
|
||||
}
|
||||
)
|
||||
if format == "csv":
|
||||
out = io.StringIO()
|
||||
writer = csv.writer(out)
|
||||
writer.writerow(["Hauptnutzer", "Mitarbeiter", "E-Mail", "Status", "Datenraum", "Rolle"])
|
||||
for owner in result:
|
||||
for e in owner["employees"]:
|
||||
if not e["rooms"]:
|
||||
writer.writerow([_csv_cell(v) for v in (owner["display_name"], e["display_name"], e["email"], e["status"], "", "")])
|
||||
for room in e["rooms"]:
|
||||
writer.writerow(
|
||||
[_csv_cell(v) for v in (owner["display_name"], e["display_name"], e["email"], e["status"], room["name"], room["role"])]
|
||||
)
|
||||
return Response(
|
||||
content=out.getvalue(),
|
||||
media_type="text/csv; charset=utf-8",
|
||||
headers={"Content-Disposition": 'attachment; filename="team-uebersicht.csv"', **_NO_STORE},
|
||||
)
|
||||
return JSONResponse({"items": result}, headers=_NO_STORE)
|
||||
+258
-18
@@ -1,18 +1,42 @@
|
||||
"""Accounts, personal rooms and sessions."""
|
||||
"""Accounts, personal rooms, sessions and the administrative account actions."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import secrets
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from app.auth.security import hash_password, hash_secret, new_secret, session_expiry
|
||||
from app.core.errors import unprocessable
|
||||
from app.access.policy import audit
|
||||
from app.access.roles import count_active_operators
|
||||
from app.auth.security import (
|
||||
hash_password,
|
||||
hash_secret,
|
||||
new_secret,
|
||||
session_expiry,
|
||||
verify_password,
|
||||
)
|
||||
from app.core.errors import not_found, unprocessable
|
||||
from app.core.settings import Settings
|
||||
|
||||
MIN_PASSWORD = 10
|
||||
MAX_PASSWORD_BYTES = 72
|
||||
|
||||
|
||||
def normalize_email(email: str) -> str:
|
||||
return email.strip().lower()
|
||||
|
||||
|
||||
def check_password_policy(password: str) -> None:
|
||||
if len(password) < MIN_PASSWORD:
|
||||
raise unprocessable(f"Das Passwort braucht mindestens {MIN_PASSWORD} Zeichen.")
|
||||
if len(password.encode("utf-8")) > MAX_PASSWORD_BYTES:
|
||||
raise unprocessable("Das Passwort ist zu lang. Erlaubt sind höchstens 72 Byte.")
|
||||
|
||||
|
||||
def generate_password() -> str:
|
||||
"""A one-time password for hand-over. It is shown once and must be changed at the first login."""
|
||||
return secrets.token_urlsafe(12)
|
||||
|
||||
|
||||
def create_account(
|
||||
conn,
|
||||
email: str,
|
||||
@@ -21,50 +45,255 @@ def create_account(
|
||||
*,
|
||||
is_superadmin: bool = False,
|
||||
origin: str = "operator",
|
||||
must_change_password: bool = False,
|
||||
account_kind: str = "main",
|
||||
sponsor_id: UUID | None = None,
|
||||
) -> dict:
|
||||
email = normalize_email(email)
|
||||
display_name = display_name.strip()
|
||||
if origin not in {"operator", "fixture"}:
|
||||
raise unprocessable("Die Kontenherkunft ist ungültig.")
|
||||
if account_kind not in {"main", "employee"} or (account_kind == "employee") != (sponsor_id is not None):
|
||||
raise unprocessable("Die Kontoart ist ungültig.")
|
||||
check_password_policy(password)
|
||||
if conn.execute("SELECT 1 FROM auth_accounts WHERE email = %s", (email,)).fetchone():
|
||||
raise unprocessable("Für diese E-Mail gibt es bereits ein Konto.")
|
||||
account_id = uuid4()
|
||||
password_hash = hash_password(password)
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO auth_accounts (id, email, display_name, password_hash, is_superadmin, origin)
|
||||
VALUES (%s, %s, %s, %s, %s, %s)
|
||||
INSERT INTO auth_accounts (
|
||||
id, email, display_name, password_hash, is_superadmin, origin,
|
||||
must_change_password, password_changed_at, account_kind, sponsor_id
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, now(), %s, %s)
|
||||
""",
|
||||
(account_id, email, display_name, password_hash, is_superadmin, origin),
|
||||
(
|
||||
account_id, email, display_name, password_hash, is_superadmin, origin,
|
||||
must_change_password, account_kind, sponsor_id,
|
||||
),
|
||||
)
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO data_rooms (id, kind, name, created_by)
|
||||
VALUES (%s, 'personal', 'Persönlicher Raum', %s)
|
||||
INSERT INTO data_rooms (id, kind, name, created_by, owner_id)
|
||||
VALUES (%s, 'personal', 'Persönlicher Raum', %s, %s)
|
||||
""",
|
||||
(account_id, account_id),
|
||||
(account_id, account_id, account_id),
|
||||
)
|
||||
return conn.execute(
|
||||
"SELECT id, email, display_name, is_superadmin FROM auth_accounts WHERE id = %s",
|
||||
"""
|
||||
SELECT id, email, display_name, is_superadmin, status, must_change_password, account_kind
|
||||
FROM auth_accounts WHERE id = %s
|
||||
""",
|
||||
(account_id,),
|
||||
).fetchone()
|
||||
|
||||
|
||||
def start_session(conn, settings: Settings, account_id: UUID) -> tuple[str, str]:
|
||||
def promote_to_main(conn, actor: UUID, account_id: UUID) -> None:
|
||||
"""Only the operator turns an employee into a main user."""
|
||||
account = _account(conn, account_id, lock=True)
|
||||
if account["account_kind"] == "main":
|
||||
return
|
||||
conn.execute("UPDATE auth_accounts SET account_kind = 'main', sponsor_id = NULL WHERE id = %s", (account_id,))
|
||||
# A raised kind starts from a fresh login.
|
||||
revoke_sessions(conn, account_id)
|
||||
audit(conn, actor, None, "employee_promoted", "account", account_id)
|
||||
|
||||
|
||||
def initial_scope(conn, account_id: UUID) -> tuple[str, UUID]:
|
||||
"""Where a new session starts: the personal room, or for an employee the first team room."""
|
||||
account = conn.execute("SELECT account_kind FROM auth_accounts WHERE id = %s", (account_id,)).fetchone()
|
||||
if account is not None and account["account_kind"] == "employee":
|
||||
room = conn.execute(
|
||||
"""
|
||||
SELECT r.id FROM room_memberships m JOIN data_rooms r ON r.id = m.room_id
|
||||
WHERE m.subject_id = %s AND m.status = 'active' AND r.kind = 'organization' AND r.status = 'active'
|
||||
ORDER BY r.name, r.id LIMIT 1
|
||||
""",
|
||||
(account_id,),
|
||||
).fetchone()
|
||||
if room is not None:
|
||||
return "organization", room["id"]
|
||||
return "personal", account_id
|
||||
|
||||
|
||||
def start_session(conn, settings: Settings, account_id: UUID, label: str | None = None) -> tuple[str, str]:
|
||||
token = new_secret()
|
||||
csrf = new_secret()
|
||||
conn.execute(
|
||||
scope_kind, scope_id = initial_scope(conn, account_id)
|
||||
session = conn.execute(
|
||||
"""
|
||||
INSERT INTO auth_sessions (
|
||||
account_id, secret_hash, csrf_token, scope_kind, scope_id, expires_at
|
||||
account_id, secret_hash, csrf_token, scope_kind, scope_id, expires_at, label, last_seen_at
|
||||
)
|
||||
VALUES (%s, %s, %s, 'personal', %s, %s)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, now())
|
||||
RETURNING id
|
||||
""",
|
||||
(account_id, hash_secret(token), csrf, account_id, session_expiry(settings)),
|
||||
)
|
||||
(account_id, hash_secret(token), csrf, scope_kind, scope_id, session_expiry(settings), (label or None) and label[:80]),
|
||||
).fetchone()
|
||||
conn.execute("UPDATE auth_accounts SET last_login_at = now() WHERE id = %s", (account_id,))
|
||||
audit(conn, account_id, None, "session_started", "session", session["id"])
|
||||
return token, csrf
|
||||
|
||||
|
||||
def _account(conn, account_id: UUID, *, lock: bool = False) -> dict:
|
||||
suffix = " FOR UPDATE" if lock else ""
|
||||
row = conn.execute(f"SELECT * FROM auth_accounts WHERE id = %s{suffix}", (account_id,)).fetchone()
|
||||
if row is None:
|
||||
raise not_found()
|
||||
return row
|
||||
|
||||
|
||||
def revoke_sessions(conn, account_id: UUID, *, keep: UUID | None = None) -> int:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
UPDATE auth_sessions SET revoked_at = now()
|
||||
WHERE account_id = %s AND revoked_at IS NULL AND (%s::uuid IS NULL OR id <> %s::uuid)
|
||||
RETURNING id
|
||||
""",
|
||||
(account_id, keep, keep),
|
||||
).fetchall()
|
||||
return len(rows)
|
||||
|
||||
|
||||
def set_display_name(conn, actor: UUID, account_id: UUID, display_name: str) -> None:
|
||||
name = " ".join(display_name.split())
|
||||
if not name or len(name) > 120:
|
||||
raise unprocessable("Der Name ist ungültig.")
|
||||
_account(conn, account_id)
|
||||
conn.execute("UPDATE auth_accounts SET display_name = %s WHERE id = %s", (name, account_id))
|
||||
audit(conn, actor, None, "account_renamed", "account", account_id)
|
||||
|
||||
|
||||
def set_status(conn, actor: UUID, account_id: UUID, status: str) -> None:
|
||||
"""Disable or enable. A disabled account keeps its content, owner links and audit trail."""
|
||||
if status not in {"active", "disabled"}:
|
||||
raise unprocessable("Der Kontostatus ist ungültig.")
|
||||
# Lock the operators first so two parallel changes cannot remove the last one.
|
||||
operators = count_active_operators(conn, lock=True)
|
||||
account = _account(conn, account_id, lock=True)
|
||||
if account["status"] == status:
|
||||
return
|
||||
if status == "disabled":
|
||||
if account_id == actor:
|
||||
raise unprocessable("Du kannst dein eigenes Konto nicht deaktivieren.")
|
||||
owned = _owned_shared_rooms(conn, account_id)
|
||||
if owned:
|
||||
raise unprocessable(
|
||||
f"Das Konto ist Eigentümer von {owned} Datenraum(en) mit weiteren Mitgliedern. "
|
||||
"Der Eigentümer überträgt sie zuerst, oder der Betreiber setzt einen neuen Eigentümer ein."
|
||||
)
|
||||
if account["is_superadmin"] and operators <= 1:
|
||||
raise unprocessable("Der letzte Betreiber lässt sich nicht deaktivieren.")
|
||||
conn.execute(
|
||||
"UPDATE auth_accounts SET status = 'disabled', disabled_at = now(), disabled_by = %s WHERE id = %s",
|
||||
(actor, account_id),
|
||||
)
|
||||
revoke_sessions(conn, account_id)
|
||||
audit(conn, actor, None, "account_disabled", "account", account_id)
|
||||
else:
|
||||
conn.execute(
|
||||
"UPDATE auth_accounts SET status = 'active', disabled_at = NULL, disabled_by = NULL WHERE id = %s",
|
||||
(account_id,),
|
||||
)
|
||||
audit(conn, actor, None, "account_enabled", "account", account_id)
|
||||
|
||||
|
||||
def set_operator(conn, actor: UUID, account_id: UUID, value: bool) -> None:
|
||||
operators = count_active_operators(conn, lock=True)
|
||||
account = _account(conn, account_id, lock=True)
|
||||
if bool(account["is_superadmin"]) == value:
|
||||
return
|
||||
if value:
|
||||
if account["status"] != "active":
|
||||
raise unprocessable("Ein deaktiviertes Konto kann nicht Betreiber werden.")
|
||||
conn.execute("UPDATE auth_accounts SET is_superadmin = true WHERE id = %s", (account_id,))
|
||||
# A raised role starts from a fresh login (Auth blueprint).
|
||||
revoke_sessions(conn, account_id)
|
||||
audit(conn, actor, None, "operator_granted", "account", account_id)
|
||||
return
|
||||
if account["status"] == "active" and operators <= 1:
|
||||
raise unprocessable("Der letzte Betreiber lässt sich nicht zurückstufen.")
|
||||
conn.execute("UPDATE auth_accounts SET is_superadmin = false WHERE id = %s", (account_id,))
|
||||
audit(conn, actor, None, "operator_revoked", "account", account_id)
|
||||
|
||||
|
||||
def reset_password(conn, actor: UUID, account_id: UUID) -> str:
|
||||
if account_id == actor:
|
||||
raise unprocessable("Dein eigenes Passwort änderst du unter Mein Konto.")
|
||||
account = _account(conn, account_id, lock=True)
|
||||
if account["status"] != "active":
|
||||
raise unprocessable("Für ein deaktiviertes Konto lässt sich kein Passwort setzen.")
|
||||
password = generate_password()
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE auth_accounts
|
||||
SET password_hash = %s, must_change_password = true, password_changed_at = now()
|
||||
WHERE id = %s
|
||||
""",
|
||||
(hash_password(password), account_id),
|
||||
)
|
||||
revoke_sessions(conn, account_id)
|
||||
audit(conn, actor, None, "password_reset", "account", account_id)
|
||||
return password
|
||||
|
||||
|
||||
def change_own_password(conn, account_id: UUID, session_id: UUID, current: str, new: str) -> None:
|
||||
account = _account(conn, account_id, lock=True)
|
||||
if not verify_password(current, account["password_hash"]):
|
||||
raise unprocessable("Das aktuelle Passwort ist nicht richtig.")
|
||||
check_password_policy(new)
|
||||
if verify_password(new, account["password_hash"]):
|
||||
raise unprocessable("Das neue Passwort muss sich vom bisherigen unterscheiden.")
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE auth_accounts
|
||||
SET password_hash = %s, must_change_password = false, password_changed_at = now()
|
||||
WHERE id = %s
|
||||
""",
|
||||
(hash_password(new), account_id),
|
||||
)
|
||||
revoke_sessions(conn, account_id, keep=session_id)
|
||||
audit(conn, account_id, None, "password_changed", "account", account_id)
|
||||
|
||||
|
||||
def login_blocked(conn, bucket: str, *, limit: int = 8, minutes: int = 10) -> bool:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT count(*) AS n FROM auth_login_attempts
|
||||
WHERE bucket = %s AND attempted_at > now() - make_interval(mins => %s)
|
||||
""",
|
||||
(bucket, minutes),
|
||||
).fetchone()
|
||||
return row["n"] >= limit
|
||||
|
||||
|
||||
def record_failed_login(conn, bucket: str) -> None:
|
||||
"""Committed at once: the failed request rolls back, the count must survive."""
|
||||
conn.execute("DELETE FROM auth_login_attempts WHERE attempted_at < now() - interval '1 day'")
|
||||
conn.execute("INSERT INTO auth_login_attempts (bucket) VALUES (%s)", (bucket,))
|
||||
conn.commit()
|
||||
|
||||
|
||||
def clear_login_attempts(conn, bucket: str) -> None:
|
||||
conn.execute("DELETE FROM auth_login_attempts WHERE bucket = %s", (bucket,))
|
||||
|
||||
|
||||
def _owned_shared_rooms(conn, account_id: UUID) -> int:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT count(*) AS n FROM data_rooms r
|
||||
WHERE r.kind = 'organization' AND r.status = 'active' AND r.owner_id = %s
|
||||
AND EXISTS (
|
||||
SELECT 1 FROM room_memberships m
|
||||
WHERE m.room_id = r.id AND m.status = 'active' AND m.subject_id <> %s
|
||||
)
|
||||
""",
|
||||
(account_id, account_id),
|
||||
).fetchone()
|
||||
return int(row["n"])
|
||||
|
||||
|
||||
def list_rooms(conn, account_id: UUID) -> list[dict]:
|
||||
personal = conn.execute(
|
||||
"SELECT id, kind, name FROM data_rooms WHERE id = %s AND kind = 'personal'",
|
||||
@@ -75,7 +304,8 @@ def list_rooms(conn, account_id: UUID) -> list[dict]:
|
||||
rooms.append({"id": str(personal["id"]), "kind": personal["kind"], "name": personal["name"], "role": "owner"})
|
||||
shared = conn.execute(
|
||||
"""
|
||||
SELECT r.id, r.kind, r.name, m.role
|
||||
SELECT r.id, r.kind, r.name, m.role, r.owner_id, r.default_visibility,
|
||||
(SELECT count(*) FROM room_memberships x WHERE x.room_id = r.id AND x.status = 'active') AS members
|
||||
FROM room_memberships m
|
||||
JOIN data_rooms r ON r.id = m.room_id
|
||||
WHERE m.subject_id = %s AND m.status = 'active' AND r.status = 'active' AND r.kind = 'organization'
|
||||
@@ -84,5 +314,15 @@ def list_rooms(conn, account_id: UUID) -> list[dict]:
|
||||
(account_id,),
|
||||
).fetchall()
|
||||
for room in shared:
|
||||
rooms.append({"id": str(room["id"]), "kind": room["kind"], "name": room["name"], "role": room["role"]})
|
||||
rooms.append(
|
||||
{
|
||||
"id": str(room["id"]),
|
||||
"kind": room["kind"],
|
||||
"name": room["name"],
|
||||
"role": room["role"],
|
||||
"is_owner": room["owner_id"] == account_id,
|
||||
"private": room["members"] <= 1,
|
||||
"default_visibility": room["default_visibility"],
|
||||
}
|
||||
)
|
||||
return rooms
|
||||
@@ -5,6 +5,7 @@ from __future__ import annotations
|
||||
import hashlib
|
||||
import secrets
|
||||
from datetime import timedelta
|
||||
from functools import lru_cache
|
||||
|
||||
import bcrypt
|
||||
from fastapi import Request, Response
|
||||
@@ -27,6 +28,33 @@ def verify_password(password: str, password_hash: str) -> bool:
|
||||
return False
|
||||
|
||||
|
||||
@lru_cache
|
||||
def _dummy_hash() -> str:
|
||||
return hash_password("kein-konto-nur-zeitausgleich")
|
||||
|
||||
|
||||
def verify_unknown_account(password: str) -> None:
|
||||
"""Spend the same time as a real check so the answer time does not reveal an account."""
|
||||
verify_password(password, _dummy_hash())
|
||||
|
||||
|
||||
def login_bucket(host: str, email: str) -> str:
|
||||
"""Rate-limit key. The address is never stored in the clear."""
|
||||
return hashlib.sha256(f"{host}|{email}".encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
_BROWSERS = (("Edg/", "Edge"), ("OPR/", "Opera"), ("Firefox/", "Firefox"), ("Chrome/", "Chrome"), ("Safari/", "Safari"))
|
||||
_SYSTEMS = (("Windows", "Windows"), ("iPhone", "iPhone"), ("iPad", "iPad"), ("Android", "Android"), ("Mac OS", "macOS"), ("Linux", "Linux"))
|
||||
|
||||
|
||||
def device_label(user_agent: str | None) -> str:
|
||||
"""A short, readable hint for the session list. The full user agent is not kept."""
|
||||
agent = user_agent or ""
|
||||
browser = next((name for marker, name in _BROWSERS if marker in agent), "Browser")
|
||||
system = next((name for marker, name in _SYSTEMS if marker in agent), "")
|
||||
return f"{browser} auf {system}" if system else browser
|
||||
|
||||
|
||||
def new_secret() -> str:
|
||||
return secrets.token_urlsafe(32)
|
||||
|
||||
|
||||
@@ -33,6 +33,9 @@ def forbidden(detail: str = "Diese Aktion ist im gewählten Kontext nicht erlaub
|
||||
return Problem(403, "Keine Berechtigung", detail, "forbidden")
|
||||
|
||||
|
||||
DOWNLOAD_REFUSED = "Das Herunterladen ist für dich in diesem Datenraum nicht freigegeben. Du kannst das Dokument in Tsumugu lesen."
|
||||
|
||||
|
||||
def not_found() -> Problem:
|
||||
return Problem(404, "Nicht gefunden", "Der Eintrag ist nicht vorhanden.", "not_found")
|
||||
|
||||
@@ -50,6 +53,28 @@ def unprocessable(detail: str) -> Problem:
|
||||
return Problem(422, "Eingabe ungültig", detail, "unprocessable")
|
||||
|
||||
|
||||
def unsupported(detail: str) -> Problem:
|
||||
return Problem(422, "Nicht unterstützt", detail, "unsupported")
|
||||
|
||||
|
||||
def scope_changed() -> Problem:
|
||||
return Problem(
|
||||
403,
|
||||
"Datenraum gewechselt",
|
||||
"Der gewählte Datenraum entspricht nicht mehr der Sitzung. Die Ansicht wird neu geladen.",
|
||||
"scope_changed",
|
||||
)
|
||||
|
||||
|
||||
def password_change_required() -> Problem:
|
||||
return Problem(
|
||||
403,
|
||||
"Passwortwechsel erforderlich",
|
||||
"Bitte lege zuerst ein eigenes Passwort fest.",
|
||||
"password_change_required",
|
||||
)
|
||||
|
||||
|
||||
def too_many() -> Problem:
|
||||
return Problem(429, "Zu viele Versuche", "Bitte kurz warten und es erneut versuchen.", "too_many_requests")
|
||||
|
||||
|
||||
+281
-65
@@ -26,9 +26,10 @@ from app.access.policy import (
|
||||
require_case,
|
||||
require_matter,
|
||||
)
|
||||
from app.core.errors import conflict, not_found, unprocessable
|
||||
from app.core.errors import Problem, conflict, not_found, unprocessable
|
||||
from app.core.timeutil import dump_date, dump_dt
|
||||
from app.media.storage import asset_path, display_filename, read_bytes, sha256, write_bytes
|
||||
from app.media.port import LEGACY_PROFILE, StoredHandle, adapter_for, instance_for_write, publish, read_clear_bytes, removal_for, stored_path
|
||||
from app.media.storage import display_filename, sha256
|
||||
from app.retrieval import FilePayload, MailPayload, RetrievalFailure, load_external, load_file
|
||||
|
||||
CHANNELS = {"email": "per E-Mail", "post": "per Post", "other": "sonstiger Weg"}
|
||||
@@ -210,11 +211,36 @@ def record_dispatch(
|
||||
raise unprocessable("Dieselbe Anlage ist mehrfach im Versand genannt.")
|
||||
container_row, page, scope = open_container(conn, actor, context, placement, "edit")
|
||||
host = _bound_element(conn, actor, host_id, page, scope)
|
||||
bump_version(conn, "elements", host_id, expected)
|
||||
known = {row["attachment_element_id"] for row in _uses(conn, scope, host_id)}
|
||||
if any(item not in known for item in attachment_ids):
|
||||
raise unprocessable("Mitversendet werden nur Anlagen dieses Schreibens.")
|
||||
counterpart_text = _counterpart(counterpart)
|
||||
edition_plans = []
|
||||
if capture_editions:
|
||||
edition_plans.append(_plan_edition(conn, actor, host, "host", 0, page, historical_gap, media_root, cleanup))
|
||||
ordered = [row for row in _uses(conn, scope, host_id) if row["attachment_element_id"] in set(attachment_ids)]
|
||||
position_of = {item: index for index, item in enumerate(attachment_ids)}
|
||||
ordered.sort(key=lambda row: position_of[row["attachment_element_id"]])
|
||||
for index, row in enumerate(ordered, start=1):
|
||||
element = _readable(conn, actor, row["attachment_element_id"], page)
|
||||
if element is None:
|
||||
raise not_found()
|
||||
edition_plans.append(
|
||||
_plan_edition(conn, actor, element, "attachment", index, page, historical_gap, media_root, cleanup)
|
||||
)
|
||||
evidence_plans = []
|
||||
for item in evidence:
|
||||
element = _readable(conn, actor, item["element_id"], page)
|
||||
if element is None:
|
||||
raise not_found()
|
||||
evidence_plans.append(
|
||||
_plan_evidence(
|
||||
conn, actor, element, item["role"], item.get("fold") or "keep", page, media_root, cleanup, container_row["home_scope_id"]
|
||||
)
|
||||
)
|
||||
container_row, page, scope = open_container(conn, actor, context, placement, "edit")
|
||||
host = _bound_element(conn, actor, host_id, page, scope)
|
||||
bump_version(conn, "elements", host_id, expected)
|
||||
dispatch = conn.execute(
|
||||
"""
|
||||
INSERT INTO dispatches (
|
||||
@@ -236,37 +262,11 @@ def record_dispatch(
|
||||
actor,
|
||||
),
|
||||
).fetchone()
|
||||
states = []
|
||||
if capture_editions:
|
||||
states.append(_capture_item(conn, actor, dispatch, host, "host", 0, page, historical_gap, media_root, cleanup))
|
||||
ordered = [row for row in _uses(conn, scope, host_id) if row["attachment_element_id"] in set(attachment_ids)]
|
||||
position_of = {item: index for index, item in enumerate(attachment_ids)}
|
||||
ordered.sort(key=lambda row: position_of[row["attachment_element_id"]])
|
||||
for index, row in enumerate(ordered, start=1):
|
||||
element = _readable(conn, actor, row["attachment_element_id"], page)
|
||||
if element is None:
|
||||
raise not_found()
|
||||
states.append(
|
||||
_capture_item(conn, actor, dispatch, element, "attachment", index, page, historical_gap, media_root, cleanup)
|
||||
)
|
||||
evidence_rows = []
|
||||
for item in evidence:
|
||||
evidence_rows.append(
|
||||
_add_evidence(
|
||||
conn,
|
||||
actor,
|
||||
container_row,
|
||||
page,
|
||||
scope,
|
||||
dispatch,
|
||||
item["element_id"],
|
||||
item["role"],
|
||||
item.get("fold") or "keep",
|
||||
media_root,
|
||||
cleanup,
|
||||
log=False,
|
||||
)
|
||||
)
|
||||
states = [_write_edition(conn, dispatch, plan) for plan in edition_plans]
|
||||
evidence_rows = [
|
||||
_write_evidence(conn, actor, container_row, page, scope, dispatch, plan, log=False)
|
||||
for plan in evidence_plans
|
||||
]
|
||||
completeness = _completeness(states) if capture_editions else "secured"
|
||||
conn.execute(
|
||||
"UPDATE dispatches SET completeness = %s, updated_at = now() WHERE id = %s",
|
||||
@@ -291,11 +291,16 @@ def add_dispatch_evidence(
|
||||
) -> dict:
|
||||
container_row, page, scope = open_container(conn, actor, context, placement, "edit")
|
||||
dispatch = _dispatch_in(conn, dispatch_id, scope)
|
||||
_bump_dispatch(conn, dispatch_id, expected)
|
||||
row = _add_evidence(
|
||||
conn, actor, container_row, page, scope, dispatch, element_id, role, fold, media_root, cleanup, log=True
|
||||
element = _readable(conn, actor, element_id, page)
|
||||
if element is None:
|
||||
raise not_found()
|
||||
plan = _plan_evidence(
|
||||
conn, actor, element, role, fold, page, media_root, cleanup, container_row["home_scope_id"], dispatch_id
|
||||
)
|
||||
return row
|
||||
container_row, page, scope = open_container(conn, actor, context, placement, "edit")
|
||||
dispatch = _dispatch_in(conn, dispatch_id, scope)
|
||||
_bump_dispatch(conn, dispatch_id, expected)
|
||||
return _write_evidence(conn, actor, container_row, page, scope, dispatch, plan, log=True)
|
||||
|
||||
|
||||
def detach_dispatch_evidence(
|
||||
@@ -415,9 +420,25 @@ def load_snapshot_file(conn, snapshot_id: UUID, media_root: str) -> FilePayload
|
||||
row = conn.execute("SELECT * FROM dispatch_snapshots WHERE id = %s", (snapshot_id,)).fetchone()
|
||||
if row is None:
|
||||
return RetrievalFailure("missing", "Die gesicherte Fassung ist nicht mehr vorhanden.")
|
||||
profile = row["protection_profile"] or "legacy-plaintext"
|
||||
if profile != "legacy-plaintext":
|
||||
return RetrievalFailure(
|
||||
"unsupported",
|
||||
"Dieser Inhalt ist geschützt und kann hier nicht im Klartext gelesen werden.",
|
||||
)
|
||||
try:
|
||||
data = read_bytes(_snapshot_path(media_root, row["id"]))
|
||||
except Exception:
|
||||
data = read_clear_bytes(
|
||||
conn,
|
||||
instance_id=row["storage_instance_id"],
|
||||
generation=row["storage_generation"],
|
||||
object_key=row["object_key"] or f"dispatch/{row['id']}",
|
||||
media_root=media_root,
|
||||
protection_profile=profile,
|
||||
expected_sha256=row["sha256"],
|
||||
)
|
||||
except Problem as exc:
|
||||
if exc.code == "processing":
|
||||
return RetrievalFailure("missing", "Die gesicherte Fassung lässt sich nicht unverändert lesen.")
|
||||
return RetrievalFailure("missing", "Die gesicherte Fassung ist nicht mehr vorhanden.")
|
||||
if sha256(data) != row["sha256"]:
|
||||
return RetrievalFailure("missing", "Die gesicherte Fassung lässt sich nicht unverändert lesen.")
|
||||
@@ -573,7 +594,7 @@ def purge_element_dispatch_files(conn, element_id: UUID, media_root: str) -> lis
|
||||
(item_id,),
|
||||
).fetchone()
|
||||
if snap is not None:
|
||||
paths.append(_snapshot_path(media_root, snap["id"]))
|
||||
paths.append(_snapshot_disk(conn, snap["id"], media_root))
|
||||
conn.execute("DELETE FROM dispatch_snapshots WHERE id = %s", (snap["id"],))
|
||||
conn.execute(
|
||||
"""
|
||||
@@ -596,7 +617,7 @@ def purge_element_dispatch_files(conn, element_id: UUID, media_root: str) -> lis
|
||||
(evidence_id,),
|
||||
).fetchone()
|
||||
if snap is not None:
|
||||
paths.append(_snapshot_path(media_root, snap["id"]))
|
||||
paths.append(_snapshot_disk(conn, snap["id"], media_root))
|
||||
conn.execute("DELETE FROM dispatch_snapshots WHERE id = %s", (snap["id"],))
|
||||
conn.execute(
|
||||
"""
|
||||
@@ -743,7 +764,7 @@ def _identify_evidence(conn, actor, dispatch, element, page, media_root, cleanup
|
||||
if isinstance(loaded, RetrievalFailure):
|
||||
return False, loaded.message, None, None, [], None
|
||||
if isinstance(loaded, MailPayload):
|
||||
comparisons = _compare_mail(conn, actor, dispatch["id"], page, loaded)
|
||||
comparisons = _compare_mail(conn, actor, dispatch["id"], page, loaded) if dispatch is not None else []
|
||||
payload = FilePayload("nachweis.eml", "message/rfc822", loaded.raw, sha256(loaded.raw))
|
||||
return True, None, loaded.parsed.message_id or None, payload.sha256, comparisons, payload
|
||||
payload = FilePayload(loaded.filename, loaded.media_type, loaded.data, sha256(loaded.data))
|
||||
@@ -914,22 +935,191 @@ def _working_bytes(conn, actor, element, media_root: str):
|
||||
return None, "Für diesen Inhalt ist keine sicherbare Fassung vorgesehen.", None, None, None
|
||||
|
||||
|
||||
def _store_snapshot(conn, scope_id, actor, payload: FilePayload, media_root: str, cleanup: list[Path], dispatch_item_id: UUID | None = None, evidence_id: UUID | None = None) -> UUID:
|
||||
def _stage_snapshot(conn, media_root: str, data: bytes, cleanup: list) -> dict:
|
||||
"""Publish bytes only while the domain transaction is idle. The row comes later."""
|
||||
from app.sourceaccess import release_for_external
|
||||
|
||||
instance = instance_for_write(conn, media_root)
|
||||
snapshot_id = uuid4()
|
||||
path = _snapshot_path(media_root, snapshot_id)
|
||||
write_bytes(path, payload.data)
|
||||
cleanup.append(path)
|
||||
digest = sha256(payload.data)
|
||||
object_key = f"dispatch/{snapshot_id}"
|
||||
adapter = adapter_for(instance)
|
||||
release_for_external(conn)
|
||||
publish(adapter, object_key, data)
|
||||
cleanup.append(StoredHandle(adapter, object_key))
|
||||
return {
|
||||
"id": snapshot_id,
|
||||
"instance": instance,
|
||||
"object_key": object_key,
|
||||
"content_revision": str(uuid4()),
|
||||
}
|
||||
|
||||
|
||||
def _plan_edition(conn, actor, element, role, position, page, historical_gap, media_root, cleanup) -> dict:
|
||||
dates = _dates(conn, element["id"])
|
||||
payload = None
|
||||
gap_reason = None
|
||||
note_document = None
|
||||
external_source = None
|
||||
external_id = None
|
||||
if historical_gap:
|
||||
state = "gap"
|
||||
gap_reason = _HISTORICAL_GAP
|
||||
else:
|
||||
payload, gap_reason, note_document, external_source, external_id = _working_bytes(
|
||||
conn, actor, element, media_root
|
||||
)
|
||||
state = "snapshot" if payload is not None else "gap"
|
||||
staged = _stage_snapshot(conn, media_root, payload.data, cleanup) if payload is not None else None
|
||||
return {
|
||||
"element": element,
|
||||
"role": role,
|
||||
"position": position,
|
||||
"dates": dates,
|
||||
"state": state,
|
||||
"payload": payload,
|
||||
"gap_reason": gap_reason,
|
||||
"note_document": note_document,
|
||||
"external_source": external_source,
|
||||
"external_id": external_id,
|
||||
"staged": staged,
|
||||
}
|
||||
|
||||
|
||||
def _write_edition(conn, dispatch, plan: dict) -> str:
|
||||
payload = plan["payload"]
|
||||
filename = payload.filename if payload is not None else None
|
||||
content_type = payload.media_type if payload is not None else None
|
||||
digest = sha256(payload.data) if payload is not None else None
|
||||
byte_size = len(payload.data) if payload is not None else None
|
||||
item = conn.execute(
|
||||
"""
|
||||
INSERT INTO dispatch_items (
|
||||
dispatch_id, role, position, element_id, title, document_on, filename,
|
||||
content_type, byte_size, content_sha256, source_state, gap_reason,
|
||||
note_document, external_source, external_id
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
RETURNING id
|
||||
""",
|
||||
(
|
||||
dispatch["id"],
|
||||
plan["role"],
|
||||
plan["position"],
|
||||
plan["element"]["id"],
|
||||
plan["element"]["title"],
|
||||
plan["dates"]["document_on"],
|
||||
filename,
|
||||
content_type,
|
||||
byte_size,
|
||||
digest,
|
||||
plan["state"],
|
||||
plan["gap_reason"],
|
||||
Json(plan["note_document"]) if plan["note_document"] is not None else None,
|
||||
plan["external_source"],
|
||||
plan["external_id"],
|
||||
),
|
||||
).fetchone()
|
||||
if plan["staged"] is not None and payload is not None:
|
||||
_record_snapshot(conn, dispatch["home_scope_id"], dispatch["recorded_by"], payload, plan["staged"], dispatch_item_id=item["id"])
|
||||
return plan["state"]
|
||||
|
||||
|
||||
def _plan_evidence(conn, actor, element, role, fold, page, media_root, cleanup, scope_id, dispatch_id=None) -> dict:
|
||||
if role not in EVIDENCE_ROLES:
|
||||
raise unprocessable("Die Rolle des Nachweises ist nicht vorgesehen.")
|
||||
if fold not in {"keep", "evidence"}:
|
||||
raise unprocessable("Die Darstellung des Nachweises ist nicht festgelegt.")
|
||||
if dispatch_id is not None and conn.execute(
|
||||
"SELECT id FROM dispatch_evidence WHERE dispatch_id = %s AND element_id = %s",
|
||||
(dispatch_id, element["id"]),
|
||||
).fetchone():
|
||||
raise unprocessable("Dieser Nachweis ist dem Versand bereits zugeordnet.")
|
||||
dispatch = {"id": dispatch_id} if dispatch_id is not None else None
|
||||
identified, gap_reason, message_id, digest, comparisons, snapshot = _identify_evidence(
|
||||
conn, actor, dispatch, element, page, media_root, cleanup, scope_id
|
||||
)
|
||||
staged = _stage_snapshot(conn, media_root, snapshot.data, cleanup) if snapshot is not None else None
|
||||
return {
|
||||
"element": element,
|
||||
"role": role,
|
||||
"fold": fold,
|
||||
"identified": identified,
|
||||
"gap_reason": gap_reason,
|
||||
"message_id": message_id,
|
||||
"digest": digest,
|
||||
"comparisons": comparisons,
|
||||
"snapshot": snapshot,
|
||||
"staged": staged,
|
||||
}
|
||||
|
||||
|
||||
def _write_evidence(conn, actor, container_row, page, scope, dispatch, plan: dict, log: bool) -> dict:
|
||||
snapshot = plan["snapshot"]
|
||||
comparisons = plan["comparisons"]
|
||||
if snapshot is not None and snapshot.media_type == "message/rfc822":
|
||||
from app.mailpack import parse_mail
|
||||
|
||||
comparisons = _compare_mail(conn, actor, dispatch["id"], page, MailPayload(snapshot.data, parse_mail(snapshot.data)))
|
||||
proof = conn.execute(
|
||||
"""
|
||||
INSERT INTO dispatch_evidence (
|
||||
dispatch_id, element_id, role, source_state, gap_reason, message_id,
|
||||
identity_sha256, comparisons, manual, created_by
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, true, %s)
|
||||
RETURNING *
|
||||
""",
|
||||
(
|
||||
dispatch["id"],
|
||||
plan["element"]["id"],
|
||||
plan["role"],
|
||||
"identified" if plan["identified"] else "gap",
|
||||
plan["gap_reason"],
|
||||
plan["message_id"],
|
||||
plan["digest"],
|
||||
Json(comparisons),
|
||||
actor,
|
||||
),
|
||||
).fetchone()
|
||||
if plan["staged"] is not None and snapshot is not None:
|
||||
_record_snapshot(
|
||||
conn,
|
||||
container_row["home_scope_id"],
|
||||
actor,
|
||||
snapshot,
|
||||
plan["staged"],
|
||||
evidence_id=proof["id"],
|
||||
)
|
||||
if plan["fold"] == "evidence":
|
||||
_set_binding_fold(conn, scope, plan["element"]["id"], "evidence")
|
||||
if log:
|
||||
_log(conn, dispatch["id"], actor, f"Nachweis ergänzt: {EVIDENCE_ROLES[plan['role']]}")
|
||||
audit(conn, actor, container_row["home_scope_id"], "dispatch_evidence", "element", plan["element"]["id"], page)
|
||||
return {
|
||||
"id": str(proof["id"]),
|
||||
"element_id": str(plan["element"]["id"]),
|
||||
"role": plan["role"],
|
||||
"role_label": EVIDENCE_ROLES[plan["role"]],
|
||||
"source_state": proof["source_state"],
|
||||
"gap_reason": plan["gap_reason"],
|
||||
"manual": True,
|
||||
"comparisons": comparisons,
|
||||
}
|
||||
|
||||
|
||||
def _record_snapshot(conn, scope_id, actor, payload: FilePayload, staged: dict, dispatch_item_id=None, evidence_id=None) -> UUID:
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO dispatch_snapshots (
|
||||
id, dispatch_item_id, evidence_id, home_scope_id, owner_subject_id,
|
||||
original_filename, content_type, byte_size, sha256
|
||||
original_filename, content_type, byte_size, sha256,
|
||||
storage_instance_id, storage_generation, object_key, content_revision,
|
||||
protection_profile, key_responsibility
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'none')
|
||||
""",
|
||||
(
|
||||
snapshot_id,
|
||||
staged["id"],
|
||||
dispatch_item_id,
|
||||
evidence_id,
|
||||
scope_id,
|
||||
@@ -937,10 +1127,20 @@ def _store_snapshot(conn, scope_id, actor, payload: FilePayload, media_root: str
|
||||
display_filename(payload.filename),
|
||||
payload.media_type or "application/octet-stream",
|
||||
len(payload.data),
|
||||
digest,
|
||||
sha256(payload.data),
|
||||
staged["instance"]["id"],
|
||||
staged["instance"]["generation"],
|
||||
staged["object_key"],
|
||||
staged["content_revision"],
|
||||
LEGACY_PROFILE,
|
||||
),
|
||||
)
|
||||
return snapshot_id
|
||||
return staged["id"]
|
||||
|
||||
|
||||
def _store_snapshot(conn, scope_id, actor, payload: FilePayload, media_root: str, cleanup: list[Path], dispatch_item_id: UUID | None = None, evidence_id: UUID | None = None) -> UUID:
|
||||
staged = _stage_snapshot(conn, media_root, payload.data, cleanup)
|
||||
return _record_snapshot(conn, scope_id, actor, payload, staged, dispatch_item_id, evidence_id)
|
||||
|
||||
|
||||
def _snapshot_file(conn, media_root: str, dispatch_item_id: UUID | None = None, evidence_id: UUID | None = None) -> FilePayload:
|
||||
@@ -956,20 +1156,36 @@ def _snapshot_file(conn, media_root: str, dispatch_item_id: UUID | None = None,
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise not_found()
|
||||
data = read_bytes(_snapshot_path(media_root, row["id"]))
|
||||
if sha256(data) != row["sha256"]:
|
||||
raise not_found()
|
||||
profile = row["protection_profile"] or "legacy-plaintext"
|
||||
data = read_clear_bytes(
|
||||
conn,
|
||||
instance_id=row["storage_instance_id"],
|
||||
generation=row["storage_generation"],
|
||||
object_key=row["object_key"] or f"dispatch/{row['id']}",
|
||||
media_root=media_root,
|
||||
protection_profile=profile,
|
||||
expected_sha256=row["sha256"],
|
||||
)
|
||||
return FilePayload(row["original_filename"], row["content_type"], data, row["sha256"])
|
||||
|
||||
|
||||
def _snapshot_path(media_root: str, snapshot_id: UUID) -> Path:
|
||||
root = Path(media_root).resolve()
|
||||
folder = (root / "dispatch").resolve()
|
||||
folder.mkdir(parents=True, exist_ok=True)
|
||||
target = (folder / str(snapshot_id)).resolve()
|
||||
if target.parent != folder:
|
||||
raise unprocessable("Ungültiger Speicherpfad.")
|
||||
return target
|
||||
def _snapshot_disk(conn, snapshot_id: UUID, media_root: str) -> Path:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT id, storage_instance_id, storage_generation, object_key
|
||||
FROM dispatch_snapshots WHERE id = %s
|
||||
""",
|
||||
(snapshot_id,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return removal_for(conn, None, "legacy-local-1", f"dispatch/{snapshot_id}", media_root)
|
||||
return removal_for(
|
||||
conn,
|
||||
row["storage_instance_id"],
|
||||
row["storage_generation"],
|
||||
row["object_key"] or f"dispatch/{row['id']}",
|
||||
media_root,
|
||||
)
|
||||
|
||||
|
||||
def _snapshot_id(conn, dispatch_item_id: UUID | None = None, evidence_id: UUID | None = None) -> str | None:
|
||||
@@ -1416,5 +1632,5 @@ def _delete_dispatch_files(conn, dispatch_id: UUID, media_root: str) -> list[Pat
|
||||
(dispatch_id, dispatch_id),
|
||||
).fetchall()
|
||||
for row in rows:
|
||||
paths.append(_snapshot_path(media_root, row["id"]))
|
||||
paths.append(_snapshot_disk(conn, row["id"], media_root))
|
||||
return paths
|
||||
@@ -49,9 +49,26 @@ def migrate(settings: Settings | None = None) -> list[str]:
|
||||
)
|
||||
applied.append(version)
|
||||
_ensure_runtime_role(conn, settings)
|
||||
_prepare_source_storage(settings)
|
||||
return applied
|
||||
|
||||
|
||||
def _prepare_source_storage(settings: Settings) -> None:
|
||||
from psycopg.rows import dict_row
|
||||
|
||||
from app.media.port import ensure_legacy_instance
|
||||
from app.sourcebind import backfill_source_bindings
|
||||
from app.sources import _install_sources
|
||||
|
||||
# The process that migrates has not imported the application yet.
|
||||
# Without the modules, a legacy reference would stay unresolved.
|
||||
_install_sources()
|
||||
with psycopg.connect(settings.dsn(), row_factory=dict_row) as conn:
|
||||
backfill_source_bindings(conn)
|
||||
ensure_legacy_instance(conn, settings.media_root)
|
||||
conn.commit()
|
||||
|
||||
|
||||
def _ensure_runtime_role(conn: psycopg.Connection, settings: Settings) -> None:
|
||||
role = sql.Identifier(settings.db_runtime_user)
|
||||
database = sql.Identifier(settings.db_name)
|
||||
|
||||
@@ -0,0 +1,166 @@
|
||||
"""Documents of a source that are inserted into a container again.
|
||||
|
||||
The same document in different Vorgänge stays allowed. This module only finds where a document is
|
||||
already present around the target, so the dialog can warn and the user can decide. Levels (account
|
||||
preference `duplicate_check`):
|
||||
|
||||
- here: bound directly to the target.
|
||||
- inside: also what the target shows: Teilvorgänge of a Vorgang, the linked Vorgänge of an Akte.
|
||||
- around: also where the target lies: its Vorgang, the Akten it is linked to, the parent Akte.
|
||||
|
||||
Only elements the actor may read are reported. A hit outside the actor's rights does not exist here.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
from app.access.policy import (
|
||||
Ctx,
|
||||
case_rights,
|
||||
element_rights,
|
||||
get_case,
|
||||
get_matter,
|
||||
matter_rights,
|
||||
)
|
||||
from app.core.errors import Problem
|
||||
|
||||
LEVELS = {"off": (), "here": ("here",), "inside": ("here", "inside"), "around": ("here", "inside", "around")}
|
||||
_ORDER = {"here": 0, "inside": 1, "around": 2}
|
||||
|
||||
|
||||
def _stored_connector(row: dict) -> str | None:
|
||||
if row["connector_id"] is not None:
|
||||
return str(row["connector_id"])
|
||||
stored = (row["detail"] or {}).get("connector_id")
|
||||
return str(stored) if stored else None
|
||||
|
||||
|
||||
def _candidates(conn, source: str, external_id: str, connector_id: str | None) -> list[dict]:
|
||||
"""Elements for the same document. `certain` is False when only one side knows the connection."""
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT e.id, e.title, e.owner_subject_id, er.connector_id, er.detail
|
||||
FROM external_references er
|
||||
JOIN elements e ON e.id = er.element_id
|
||||
WHERE er.source = %s AND er.external_id = %s AND e.deleted_at IS NULL
|
||||
""",
|
||||
(source, external_id.strip()[:200]),
|
||||
).fetchall()
|
||||
found = []
|
||||
for row in rows:
|
||||
stored = _stored_connector(row)
|
||||
if stored is not None and connector_id is not None and stored != connector_id:
|
||||
continue
|
||||
found.append(row | {"certain": stored == connector_id})
|
||||
return found
|
||||
|
||||
|
||||
def _children(conn, matter_id: UUID) -> list[UUID]:
|
||||
rows = conn.execute("SELECT id FROM matters WHERE parent_matter_id = %s AND deleted_at IS NULL", (matter_id,)).fetchall()
|
||||
return [row["id"] for row in rows]
|
||||
|
||||
|
||||
def _zones(conn, target: Ctx) -> dict[str, list[Ctx]]:
|
||||
inside: list[Ctx] = []
|
||||
around: list[Ctx] = []
|
||||
if target.kind == "matter":
|
||||
inside = [Ctx("matter", child) for child in _children(conn, target.id)]
|
||||
matter = get_matter(conn, target.id)
|
||||
anchors = [target.id]
|
||||
if matter is not None and matter["parent_matter_id"] is not None:
|
||||
around.append(Ctx("matter", matter["parent_matter_id"]))
|
||||
anchors.append(matter["parent_matter_id"])
|
||||
links = conn.execute("SELECT DISTINCT case_id FROM matter_case_links WHERE matter_id = ANY(%s)", (anchors,)).fetchall()
|
||||
around += [Ctx("case", row["case_id"]) for row in links]
|
||||
else:
|
||||
links = conn.execute("SELECT matter_id FROM matter_case_links WHERE case_id = %s", (target.id,)).fetchall()
|
||||
for row in links:
|
||||
inside.append(Ctx("matter", row["matter_id"]))
|
||||
inside += [Ctx("matter", child) for child in _children(conn, row["matter_id"])]
|
||||
case = get_case(conn, target.id)
|
||||
if case is not None and case["parent_case_id"] is not None:
|
||||
around.append(Ctx("case", case["parent_case_id"]))
|
||||
return {"here": [target], "inside": inside, "around": around}
|
||||
|
||||
|
||||
def _blocked(conn, case_id: UUID, element_id: UUID) -> bool:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT 1 FROM case_link_blocks b JOIN matter_case_links l ON l.id = b.link_id
|
||||
WHERE l.case_id = %s AND b.element_id = %s
|
||||
""",
|
||||
(case_id, element_id),
|
||||
).fetchone()
|
||||
return row is not None
|
||||
|
||||
|
||||
def _title_if_readable(conn, actor: UUID, container: Ctx) -> str | None:
|
||||
if container.kind == "case":
|
||||
case = get_case(conn, container.id)
|
||||
return case["title"] if case is not None and case_rights(conn, actor, case).read else None
|
||||
matter = get_matter(conn, container.id)
|
||||
return matter["title"] if matter is not None and matter_rights(conn, actor, matter, None).read else None
|
||||
|
||||
|
||||
def find_existing(
|
||||
conn,
|
||||
actor: UUID,
|
||||
source: str,
|
||||
external_id: str,
|
||||
connector_id: str | None,
|
||||
target: Ctx,
|
||||
rights_context: Ctx | None,
|
||||
level: str,
|
||||
) -> list[dict]:
|
||||
"""Matches of one document at the chosen level, readable by the actor, nearest zone first."""
|
||||
zones = LEVELS.get(level, ())
|
||||
if not zones:
|
||||
return []
|
||||
candidates = _candidates(conn, source, external_id, connector_id)
|
||||
if not candidates:
|
||||
return []
|
||||
layout = _zones(conn, target)
|
||||
by_element: dict[UUID, dict] = {}
|
||||
for candidate in candidates:
|
||||
bindings = conn.execute(
|
||||
"SELECT b.context_kind, b.context_id, c.title AS chapter FROM bindings b LEFT JOIN chapters c ON c.id = b.chapter_id WHERE b.element_id = %s",
|
||||
(candidate["id"],),
|
||||
).fetchall()
|
||||
for zone in zones:
|
||||
for container in layout[zone]:
|
||||
hit = next((b for b in bindings if b["context_kind"] == container.kind and b["context_id"] == container.id), None)
|
||||
if hit is None:
|
||||
continue
|
||||
if target.kind == "case" and zone == "inside" and _blocked(conn, target.id, candidate["id"]):
|
||||
continue
|
||||
seen_in = [container] if zone == "around" else [c for c in (target, rights_context) if c is not None]
|
||||
rights = [element_rights(conn, actor, candidate, ctx) for ctx in seen_in]
|
||||
if not any(r.read for r in rights):
|
||||
continue
|
||||
match = {
|
||||
"element_id": str(candidate["id"]),
|
||||
"title": candidate["title"],
|
||||
"where": zone,
|
||||
"certain": candidate["certain"],
|
||||
"chapter": hit["chapter"] if zone == "here" else None,
|
||||
"container": {
|
||||
"kind": container.kind,
|
||||
"title": _title_if_readable(conn, actor, container) if zone != "here" else None,
|
||||
},
|
||||
"can_bind": any(r.share for r in rights),
|
||||
}
|
||||
known = by_element.get(candidate["id"])
|
||||
if known is None or _ORDER[zone] < _ORDER[known["where"]]:
|
||||
by_element[candidate["id"]] = match
|
||||
return sorted(by_element.values(), key=lambda item: (_ORDER[item["where"]], item["title"]))
|
||||
|
||||
|
||||
def already_present(matches: list[dict]) -> Problem:
|
||||
where = {"here": "hier", "inside": "in diesem Bestand", "around": "im Umfeld"}[matches[0]["where"]]
|
||||
return Problem(
|
||||
409,
|
||||
"Bereits vorhanden",
|
||||
f"Dieses Dokument ist {where} schon vorhanden. Füge es nur dann erneut ein, wenn das gewollt ist.",
|
||||
"already_present",
|
||||
)
|
||||
+44
-10
@@ -39,6 +39,7 @@ _KIND_LABEL = {
|
||||
"file": "Datei",
|
||||
"email": "E-Mail",
|
||||
"paperless": "Paperless",
|
||||
"source": "Quelle",
|
||||
"url": "Webadresse",
|
||||
"annotation": "Anmerkung",
|
||||
"chapter": "Kapitel",
|
||||
@@ -233,7 +234,7 @@ def _plan(conn, actor, matter_id, context, selected, assignments, media_root) ->
|
||||
continue
|
||||
if node.content_kind == "file":
|
||||
result = load_file(conn, UUID(node.element_id), media_root)
|
||||
elif node.content_kind in {"email", "paperless", "url"}:
|
||||
elif node.content_kind in {"email", "paperless", "url", "source"}:
|
||||
result = load_external(conn, actor, UUID(node.element_id), assignments.get(node.id))
|
||||
else:
|
||||
result = RetrievalFailure("capability", "Für diesen Inhalt ist kein Originalabruf vorgesehen.")
|
||||
@@ -461,13 +462,16 @@ def _content_kind(element: dict) -> str:
|
||||
if element["kind"] == "file":
|
||||
return "file"
|
||||
source = (element.get("external") or {}).get("source")
|
||||
if source == "imap":
|
||||
return "email"
|
||||
if source == "paperless":
|
||||
return "paperless"
|
||||
if source == "url":
|
||||
return "url"
|
||||
return element["kind"]
|
||||
from app.sourceregistry import get_source
|
||||
|
||||
module = get_source(source) if source else None
|
||||
if module is None:
|
||||
return "source"
|
||||
if module.representation == "email":
|
||||
return "email"
|
||||
return "source"
|
||||
|
||||
|
||||
def _chosen(root: ExportNode, selected: list[str]) -> set[str]:
|
||||
@@ -492,8 +496,8 @@ def _note_text(conn, element_id: UUID) -> str:
|
||||
parts = []
|
||||
for block in document.get("blocks") or []:
|
||||
if isinstance(block, dict):
|
||||
text = str(block.get("text") or "").strip()
|
||||
if text:
|
||||
text = str(block.get("text") or "")
|
||||
if text.strip():
|
||||
parts.append(text)
|
||||
return "\n\n".join(parts)
|
||||
|
||||
@@ -691,9 +695,18 @@ def _emit_one(node, prefix, add, entries, loaded, notice_for, generated: str) ->
|
||||
links = [("EML-Original", eml)]
|
||||
try:
|
||||
parsed = payload.parsed if isinstance(payload, MailPayload) else parse_mail(raw)
|
||||
reading = _mail_reading_html(parsed)
|
||||
if reading is not None:
|
||||
reading_path = add(prefix + ["lesefassung.html"], reading)
|
||||
links.append(("Formatierte Lesefassung", reading_path))
|
||||
else:
|
||||
notice = "\n".join(part for part in [notice, "Eine formatierte Lesefassung liegt für diese Nachricht nicht vor. Die vereinfachte Textfassung steht in der Übersicht."] if part)
|
||||
for attachment in parsed.attachments:
|
||||
label = attachment.display_name or attachment.filename
|
||||
path = add(prefix + ["anlagen", attachment.filename], attachment.data)
|
||||
links.append((attachment.filename, path))
|
||||
links.append((label, path))
|
||||
if parsed.notices:
|
||||
notice = "\n".join(part for part in [notice, *parsed.notices] if part)
|
||||
except Exception:
|
||||
links.append(("Hinweis", eml))
|
||||
entries.append(_entry(node, eml, links, notice or None))
|
||||
@@ -1219,6 +1232,21 @@ def _note_markdown(node: ExportNode, body: str, generated: str) -> str:
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def _mail_reading_html(parsed) -> bytes | None:
|
||||
if not getattr(parsed, "html", ""):
|
||||
return None
|
||||
page = (
|
||||
"<!DOCTYPE html><html lang=\"de\"><head><meta charset=\"utf-8\">"
|
||||
"<meta http-equiv=\"Content-Security-Policy\" content=\"default-src 'none'; img-src data:; style-src 'none'; script-src 'none'\">"
|
||||
"<title>Lesefassung</title></head><body>"
|
||||
f"{parsed.html}"
|
||||
"<p>Vereinfachte Textfassung und das unveränderte EML-Original stehen daneben. "
|
||||
"Die Ansicht ist nicht pixelgleich zur Postfachdarstellung.</p>"
|
||||
"</body></html>"
|
||||
)
|
||||
return page.encode("utf-8")
|
||||
|
||||
|
||||
def _mail_markdown(node, mail: MailPayload, text_path: str, eml_path: str, attachments, notice: str, generated: str) -> str:
|
||||
parsed = mail.parsed
|
||||
lines = [f"# {node.title}", "", "Lesefassung. Das unveränderte Original ist die EML-Datei.", ""]
|
||||
@@ -1230,7 +1258,13 @@ def _mail_markdown(node, mail: MailPayload, text_path: str, eml_path: str, attac
|
||||
if parsed.copy:
|
||||
lines.append(f"- Kopie: {parsed.copy}")
|
||||
lines.append(f"- [EML-Original]({_href(_relative(text_path, eml_path))})")
|
||||
lines.extend(["", parsed.text or "Der Text steht im EML-Original.", ""])
|
||||
lines.extend([
|
||||
"",
|
||||
"Vereinfachte Textfassung. Sie ist nicht die formatierte Ansicht und nicht das EML-Original.",
|
||||
"",
|
||||
parsed.text or "Der Text steht im EML-Original.",
|
||||
"",
|
||||
])
|
||||
if attachments:
|
||||
lines.append("## Anlagen")
|
||||
lines.append("")
|
||||
|
||||
@@ -0,0 +1,170 @@
|
||||
"""Overviews for the library: cases and matters as tiles, and what lies in a room.
|
||||
|
||||
A room is a virtual folder. Cases and matters stay where they are; a share puts them into a room.
|
||||
Counts only include what the person may read. Hidden entries are neither named nor counted.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from collections import Counter
|
||||
from uuid import UUID
|
||||
|
||||
from app.access.policy import (
|
||||
ROOM_RIGHTS,
|
||||
Ctx,
|
||||
Rights,
|
||||
case_rights,
|
||||
get_case,
|
||||
list_cases,
|
||||
list_matters,
|
||||
matter_rights,
|
||||
room_name,
|
||||
)
|
||||
from app.present import _chapters, _matter_tree, case_summary, matter_summary
|
||||
|
||||
|
||||
def shared_rooms(conn, kind: str, resource_id: UUID) -> list[dict]:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT r.id, r.name, s.access FROM room_shares s JOIN data_rooms r ON r.id = s.room_id
|
||||
WHERE s.resource_kind = %s AND s.resource_id = %s
|
||||
ORDER BY r.name, r.id
|
||||
""",
|
||||
(kind, resource_id),
|
||||
).fetchall()
|
||||
return [{"id": str(row["id"]), "name": row["name"], "access": row["access"]} for row in rows]
|
||||
|
||||
|
||||
def readable_matter_count(conn, actor: UUID, case: dict) -> int:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT m.* FROM matter_case_links l JOIN matters m ON m.id = l.matter_id
|
||||
WHERE l.case_id = %s AND m.deleted_at IS NULL AND m.parent_matter_id IS NULL
|
||||
""",
|
||||
(case["id"],),
|
||||
).fetchall()
|
||||
context = Ctx("case", case["id"])
|
||||
return sum(1 for matter in rows if matter_rights(conn, actor, matter, context).read)
|
||||
|
||||
|
||||
def case_items(conn, actor: UUID, visible: list[tuple[dict, Rights]]) -> list[dict]:
|
||||
children = Counter(case["parent_case_id"] for case, _ in visible if case["parent_case_id"])
|
||||
items = []
|
||||
for case, rights in visible:
|
||||
summary = case_summary(case, rights)
|
||||
owner = case["owner_subject_id"] == actor
|
||||
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
|
||||
summary["is_owner"] = owner
|
||||
summary["shared_with"] = shared_rooms(conn, "case", case["id"]) if owner else []
|
||||
summary["child_cases"] = children.get(case["id"], 0)
|
||||
summary["matter_count"] = readable_matter_count(conn, actor, case)
|
||||
if case["parent_case_id"]:
|
||||
parent = get_case(conn, case["parent_case_id"])
|
||||
if parent is not None and case_rights(conn, actor, parent).read:
|
||||
summary["parent_title"] = parent["title"]
|
||||
items.append(summary)
|
||||
return items
|
||||
|
||||
|
||||
def matter_items(conn, actor: UUID, visible: list[tuple[dict, list[dict]]]) -> list[dict]:
|
||||
children = Counter(matter["parent_matter_id"] for matter, _ in visible if matter["parent_matter_id"])
|
||||
items = []
|
||||
for matter, _contexts in visible:
|
||||
summary = matter_summary(conn, actor, matter)
|
||||
summary["child_matters"] = children.get(matter["id"], 0)
|
||||
items.append(summary)
|
||||
return items
|
||||
|
||||
|
||||
def room_contents(conn, actor: UUID, room_id: UUID) -> tuple[list[tuple[dict, Rights]], list[tuple[dict, list[dict]]]]:
|
||||
"""Cases and matters shared with the room that the person may read, with their readable sub-entries."""
|
||||
rows = conn.execute(
|
||||
"SELECT resource_kind, resource_id FROM room_shares WHERE room_id = %s",
|
||||
(room_id,),
|
||||
).fetchall()
|
||||
case_ids = {row["resource_id"] for row in rows if row["resource_kind"] == "case"}
|
||||
matter_ids = {row["resource_id"] for row in rows if row["resource_kind"] == "matter"}
|
||||
cases = [
|
||||
(case, rights)
|
||||
for case, rights in list_cases(conn, actor)
|
||||
if case["id"] in case_ids
|
||||
or (case["rights_mode"] == "inherit_parent" and case["parent_case_id"] in case_ids)
|
||||
]
|
||||
matters = [
|
||||
(matter, contexts)
|
||||
for matter, contexts in list_matters(conn, actor)
|
||||
if matter["id"] in matter_ids or matter["parent_matter_id"] in matter_ids
|
||||
]
|
||||
return cases, matters
|
||||
|
||||
|
||||
def room_effect(conn, room_id: UUID, actor: UUID, access: str) -> list[dict]:
|
||||
"""Who gets which rights through a share with this room."""
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT m.subject_id, m.role, 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' AND a.status = 'active' AND m.subject_id <> %s
|
||||
ORDER BY a.display_name, a.id
|
||||
""",
|
||||
(room_id, actor),
|
||||
).fetchall()
|
||||
effect = []
|
||||
for row in rows:
|
||||
rights = ROOM_RIGHTS.get(row["role"], Rights())
|
||||
if access == "read":
|
||||
rights = Rights(read=rights.read)
|
||||
effect.append(
|
||||
{
|
||||
"display_name": row["display_name"],
|
||||
"role": row["role"],
|
||||
"rights": {"read": rights.read, "edit": rights.edit},
|
||||
}
|
||||
)
|
||||
return effect
|
||||
|
||||
|
||||
def case_outline(conn, actor: UUID, case: dict) -> dict:
|
||||
"""What the navigation tree shows below a case. Only readable entries; no bindings or texts."""
|
||||
chapters = _chapters(conn, "case", case["id"], case.get("content_order") or "position", case.get("content_order_dir") or "asc")
|
||||
subcases = []
|
||||
for row in conn.execute(
|
||||
"SELECT * FROM cases WHERE parent_case_id = %s AND deleted_at IS NULL ORDER BY title, id",
|
||||
(case["id"],),
|
||||
).fetchall():
|
||||
if case_rights(conn, actor, row).read:
|
||||
subcases.append({"id": str(row["id"]), "title": row["title"], "status": row["record_status"]})
|
||||
linked = []
|
||||
for link in conn.execute(
|
||||
"""
|
||||
SELECT m.* FROM matter_case_links l JOIN matters m ON m.id = l.matter_id
|
||||
WHERE l.case_id = %s AND m.deleted_at IS NULL ORDER BY m.title, m.id
|
||||
""",
|
||||
(case["id"],),
|
||||
).fetchall():
|
||||
if matter_rights(conn, actor, link, Ctx("case", case["id"])).read:
|
||||
linked.append(link)
|
||||
return {
|
||||
"kind": "case",
|
||||
"id": str(case["id"]),
|
||||
"chapters": chapters,
|
||||
"subcases": subcases,
|
||||
"matters": _matter_tree(conn, actor, case["id"], linked),
|
||||
}
|
||||
|
||||
|
||||
def matter_outline(conn, actor: UUID, matter: dict, context: Ctx | None) -> dict:
|
||||
"""What the navigation tree shows below a matter: its chapters and its readable Teilvorgänge."""
|
||||
chapters = _chapters(
|
||||
conn, "matter", matter["id"], matter.get("content_order") or "position", matter.get("content_order_dir") or "asc"
|
||||
)
|
||||
children = []
|
||||
for row in conn.execute(
|
||||
"SELECT * FROM matters WHERE parent_matter_id = %s AND deleted_at IS NULL ORDER BY title, id",
|
||||
(matter["id"],),
|
||||
).fetchall():
|
||||
if matter_rights(conn, actor, row, context).read:
|
||||
children.append({"id": str(row["id"]), "title": row["title"], "status": row["record_status"]})
|
||||
return {"kind": "matter", "id": str(matter["id"]), "chapters": chapters, "submatters": children}
|
||||
+409
-66
@@ -1,16 +1,46 @@
|
||||
"""Pure mail identity and attachment extraction for a complete export.
|
||||
|
||||
A preview cutoff does not belong here. Duplicate attachment names stay distinct.
|
||||
The same tree feeds preview, reading, attachment download and export.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import html
|
||||
import re
|
||||
from dataclasses import dataclass, field
|
||||
from email import policy
|
||||
from email.header import decode_header, make_header
|
||||
from email.message import EmailMessage
|
||||
from email.parser import BytesParser
|
||||
from email.utils import parsedate_to_datetime
|
||||
from html.parser import HTMLParser
|
||||
|
||||
_UID_PREFIX = "uid:"
|
||||
_POLICY = policy.default
|
||||
_ALLOWED_TAGS = {
|
||||
"a", "p", "br", "div", "span", "strong", "em", "b", "i", "u",
|
||||
"ul", "ol", "li", "table", "thead", "tbody", "tr", "th", "td",
|
||||
"blockquote", "pre", "code", "h1", "h2", "h3", "h4", "h5", "h6", "img",
|
||||
"font", "center", "hr", "small", "sub", "sup", "s", "strike", "caption", "tfoot", "section", "article",
|
||||
}
|
||||
_VOID_TAGS = {"br", "img", "hr"}
|
||||
# Formatting a mail may keep. Nothing here loads anything, positions an element or runs code.
|
||||
_STYLE_PROPS = {
|
||||
"color", "background-color", "font-family", "font-size", "font-weight", "font-style", "text-align",
|
||||
"text-decoration", "line-height", "vertical-align", "white-space", "letter-spacing",
|
||||
"margin", "margin-top", "margin-bottom", "margin-left", "margin-right",
|
||||
"padding", "padding-top", "padding-bottom", "padding-left", "padding-right",
|
||||
"border", "border-top", "border-bottom", "border-left", "border-right", "border-color", "border-width",
|
||||
"border-style", "border-collapse", "width", "max-width", "height", "text-indent", "list-style-type",
|
||||
}
|
||||
_STYLE_VALUE = re.compile(r"^[#%a-z0-9 .,()\-+'\"]{1,100}$", re.IGNORECASE)
|
||||
_STYLE_DENIED = re.compile(r"url|expression|var\(|attr\(|image|@|javascript|behavior|\\", re.IGNORECASE)
|
||||
_COLOR = re.compile(r"^(#[0-9a-f]{3,8}|[a-z]{3,20}|rgb\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}\s*\))$", re.IGNORECASE)
|
||||
_SAFE_LINK = re.compile(r"^(https?://|mailto:)", re.IGNORECASE)
|
||||
_DATA_IMAGE = re.compile(r"^data:image/(?:png|jpeg|gif|webp);base64,[a-z0-9+/=\s]+$", re.IGNORECASE)
|
||||
|
||||
|
||||
class MailIdentityError(Exception):
|
||||
@@ -25,6 +55,9 @@ class AttachmentBytes:
|
||||
media_type: str
|
||||
data: bytes
|
||||
sha256: str
|
||||
display_name: str = ""
|
||||
content_id: str = ""
|
||||
inline: bool = False
|
||||
|
||||
|
||||
@dataclass
|
||||
@@ -37,10 +70,16 @@ class ParsedMail:
|
||||
text: str
|
||||
attachments: list[AttachmentBytes] = field(default_factory=list)
|
||||
missing: list[str] = field(default_factory=list)
|
||||
html: str = ""
|
||||
html_source: str = ""
|
||||
remote_images: list[str] = field(default_factory=list)
|
||||
notices: list[str] = field(default_factory=list)
|
||||
text_truncated: bool = False
|
||||
document_on: str | None = None
|
||||
|
||||
|
||||
def header_message_id(raw: bytes) -> str:
|
||||
message = BytesParser().parsebytes(raw)
|
||||
message = BytesParser(policy=_POLICY).parsebytes(raw)
|
||||
return str(message.get("Message-ID") or "").strip()
|
||||
|
||||
|
||||
@@ -69,67 +108,404 @@ def choose_message(candidate: bytes | None, alternates: list[bytes], expected: s
|
||||
raise MailIdentityError("Die gespeicherte Nachricht lässt sich nicht eindeutig wiederfinden.")
|
||||
|
||||
|
||||
def header_text(value) -> str:
|
||||
"""Decode encoded-words. A raw MIME header is not a display name."""
|
||||
if value is None:
|
||||
return ""
|
||||
raw = str(value).replace("\r", " ").replace("\n", " ")
|
||||
try:
|
||||
text = str(make_header(decode_header(raw)))
|
||||
except (UnicodeError, LookupError, ValueError):
|
||||
text = raw
|
||||
return re.sub(r"\s+", " ", text).strip()
|
||||
|
||||
|
||||
def parse_mail(raw: bytes) -> ParsedMail:
|
||||
message = BytesParser().parsebytes(raw)
|
||||
message = BytesParser(policy=_POLICY).parsebytes(raw)
|
||||
attachments: list[AttachmentBytes] = []
|
||||
missing: list[str] = []
|
||||
notices: list[str] = []
|
||||
used: set[str] = set()
|
||||
plain: list[str] = []
|
||||
html_parts: list[str] = []
|
||||
index = 0
|
||||
for part in message.walk():
|
||||
if part.is_multipart():
|
||||
for kind, part in _walk(message):
|
||||
if kind == "message":
|
||||
index += 1
|
||||
label = header_text(part.get_filename()) or f"nachricht-{index}.eml"
|
||||
data = _message_bytes(part)
|
||||
if data is None:
|
||||
missing.append(label)
|
||||
notices.append(f"Die angehängte Nachricht {label} ließ sich nicht vollständig lesen.")
|
||||
continue
|
||||
name = _unique_filename(label, used)
|
||||
attachments.append(_attachment(part, name, label, data, inline=False))
|
||||
continue
|
||||
filename = part.get_filename()
|
||||
disposition = (part.get_content_disposition() or "").lower()
|
||||
if not filename and disposition != "attachment":
|
||||
media = part.get_content_type()
|
||||
filename = part.get_filename()
|
||||
content_id = _content_id(part)
|
||||
body = media in {"text/plain", "text/html"} and disposition != "attachment" and not filename
|
||||
if body:
|
||||
text = _decoded_text(part)
|
||||
if text is None:
|
||||
notices.append("Ein Textteil ließ sich nicht sicher dekodieren.")
|
||||
continue
|
||||
if media == "text/plain":
|
||||
plain.append(text)
|
||||
else:
|
||||
html_parts.append(text)
|
||||
continue
|
||||
if not filename and disposition != "attachment" and not content_id:
|
||||
continue
|
||||
index += 1
|
||||
label = _header_text(filename) if filename else f"anlage-{index}.bin"
|
||||
payload = part.get_payload(decode=True)
|
||||
if not isinstance(payload, (bytes, bytearray)):
|
||||
label = header_text(filename) if filename else f"anlage-{index}.bin"
|
||||
data = _leaf_bytes(part)
|
||||
if data is None:
|
||||
missing.append(label or f"Anlage {index}")
|
||||
notices.append(f"Die Anlage {label or index} ließ sich nicht vollständig lesen.")
|
||||
continue
|
||||
data = _unwrap_pdf_payload(data, media, label)
|
||||
if _is_pdf(data):
|
||||
media = "application/pdf"
|
||||
label = _pdf_filename(label)
|
||||
name = _unique_filename(label or f"anlage-{index}.bin", used)
|
||||
data = bytes(payload)
|
||||
attachments.append(
|
||||
AttachmentBytes(
|
||||
filename=name,
|
||||
media_type=(part.get_content_type() or "application/octet-stream")[:120],
|
||||
data=data,
|
||||
sha256=hashlib.sha256(data).hexdigest(),
|
||||
)
|
||||
)
|
||||
text = _body_text(message)
|
||||
inline = disposition == "inline" or bool(content_id)
|
||||
attachments.append(_attachment(part, name, label or name, data, inline=inline, media=media))
|
||||
simplified = "\n".join(chunk for chunk in plain if chunk).strip()
|
||||
rendered = ""
|
||||
if html_parts:
|
||||
source = "\n".join(html_parts)
|
||||
remote_found: list[str] = []
|
||||
rendered = sanitize_html(source, _inline_images(attachments), found=remote_found)
|
||||
if not simplified:
|
||||
simplified = simplified_text("\n".join(html_parts))
|
||||
if missing:
|
||||
notices.append("Mindestens eine Anlage fehlt in der Aufbereitung.")
|
||||
return ParsedMail(
|
||||
message_id=str(message.get("Message-ID") or "").strip(),
|
||||
subject=_header_text(message.get("Subject")) or "(ohne Betreff)",
|
||||
sender=_header_text(message.get("From")),
|
||||
recipient=_header_text(message.get("To")),
|
||||
copy=_header_text(message.get("Cc")),
|
||||
text=text,
|
||||
subject=header_text(message.get("Subject")) or "(ohne Betreff)",
|
||||
sender=header_text(message.get("From")),
|
||||
recipient=header_text(message.get("To")),
|
||||
copy=header_text(message.get("Cc")),
|
||||
text=simplified,
|
||||
attachments=attachments,
|
||||
missing=missing,
|
||||
html=rendered,
|
||||
html_source=source if html_parts else "",
|
||||
remote_images=remote_found if html_parts else [],
|
||||
notices=notices,
|
||||
document_on=_message_date(message.get("Date")),
|
||||
)
|
||||
|
||||
|
||||
def decode_transfer(payload: bytes, charset: str | None) -> str:
|
||||
return bytes(payload).decode(charset or "utf-8", errors="replace")
|
||||
|
||||
|
||||
def simplified_text(value: str) -> str:
|
||||
"""A recognizable plain reading. It is not the formatted view."""
|
||||
class Collector(HTMLParser):
|
||||
def __init__(self) -> None:
|
||||
super().__init__(convert_charrefs=True)
|
||||
self.parts: list[str] = []
|
||||
self.skip = 0
|
||||
|
||||
def handle_starttag(self, tag, attrs):
|
||||
name = tag.lower()
|
||||
if name in {"script", "style"}:
|
||||
self.skip += 1
|
||||
return
|
||||
if name in {"br", "p", "div", "tr", "li", "h1", "h2", "h3", "h4", "h5", "h6", "blockquote"}:
|
||||
self.parts.append("\n")
|
||||
elif name in {"td", "th"}:
|
||||
self.parts.append("\t")
|
||||
|
||||
def handle_endtag(self, tag):
|
||||
name = tag.lower()
|
||||
if name in {"script", "style"} and self.skip:
|
||||
self.skip -= 1
|
||||
return
|
||||
if name in {"p", "div", "tr", "li", "table", "h1", "h2", "h3", "h4", "h5", "h6"}:
|
||||
self.parts.append("\n")
|
||||
|
||||
def handle_data(self, data):
|
||||
if not self.skip:
|
||||
self.parts.append(data)
|
||||
|
||||
collector = Collector()
|
||||
try:
|
||||
collector.feed(value)
|
||||
collector.close()
|
||||
except Exception:
|
||||
return ""
|
||||
text = "".join(collector.parts)
|
||||
text = text.replace("\r", "")
|
||||
text = re.sub(r"[ \t]+\n", "\n", text)
|
||||
text = re.sub(r"\n{3,}", "\n\n", text)
|
||||
return text.strip()
|
||||
|
||||
|
||||
def sanitize_html(value: str, images: dict[str, str] | None = None, *, remote=None, found: list[str] | None = None) -> str:
|
||||
"""Keep a formatted reading. Scripts and active content stay out.
|
||||
|
||||
Pictures from other servers stay out too, unless `remote` turns an address into an inline picture.
|
||||
`found` collects the addresses that were met."""
|
||||
images = images or {}
|
||||
|
||||
class Cleaner(HTMLParser):
|
||||
def __init__(self) -> None:
|
||||
super().__init__(convert_charrefs=True)
|
||||
self.parts: list[str] = []
|
||||
self.skip = 0
|
||||
|
||||
def handle_starttag(self, tag, attrs):
|
||||
name = tag.lower()
|
||||
if name in {"script", "style", "iframe", "object", "embed", "form", "link", "meta"}:
|
||||
self.skip += 1
|
||||
return
|
||||
if self.skip or name not in _ALLOWED_TAGS:
|
||||
return
|
||||
rendered = _clean_attrs(name, attrs, images, remote, found)
|
||||
if rendered is None:
|
||||
return
|
||||
self.parts.append(f"<{name}{rendered}>")
|
||||
|
||||
def handle_endtag(self, tag):
|
||||
name = tag.lower()
|
||||
if name in {"script", "style", "iframe", "object", "embed", "form", "link", "meta"}:
|
||||
if self.skip:
|
||||
self.skip -= 1
|
||||
return
|
||||
if self.skip or name not in _ALLOWED_TAGS or name in _VOID_TAGS:
|
||||
return
|
||||
self.parts.append(f"</{name}>")
|
||||
|
||||
def handle_data(self, data):
|
||||
if not self.skip:
|
||||
self.parts.append(html.escape(data))
|
||||
|
||||
def handle_entityref(self, name):
|
||||
if not self.skip:
|
||||
self.parts.append(f"&{name};")
|
||||
|
||||
def handle_charref(self, name):
|
||||
if not self.skip:
|
||||
self.parts.append(f"&#{name};")
|
||||
|
||||
cleaner = Cleaner()
|
||||
try:
|
||||
cleaner.feed(value)
|
||||
cleaner.close()
|
||||
except Exception:
|
||||
return ""
|
||||
return "".join(cleaner.parts).strip()
|
||||
|
||||
|
||||
def _safe_style(value: str) -> str:
|
||||
kept = []
|
||||
for declaration in (value or "").split(";"):
|
||||
prop, _, raw = declaration.partition(":")
|
||||
prop, raw = prop.strip().lower(), raw.strip().replace("!important", "").strip()
|
||||
if prop not in _STYLE_PROPS or not raw or _STYLE_DENIED.search(raw) or not _STYLE_VALUE.match(raw):
|
||||
continue
|
||||
kept.append(f"{prop}: {raw}")
|
||||
return "; ".join(kept)
|
||||
|
||||
|
||||
def _clean_attrs(tag: str, attrs, images: dict[str, str], remote=None, found: list[str] | None = None) -> str | None:
|
||||
kept: list[str] = []
|
||||
for key, value in attrs:
|
||||
name = (key or "").lower()
|
||||
if name.startswith("on") or name == "srcset":
|
||||
continue
|
||||
if name == "style":
|
||||
style = _safe_style(value or "")
|
||||
if style:
|
||||
kept.append(f' style="{html.escape(style, quote=True)}"')
|
||||
continue
|
||||
if name in {"bgcolor", "color"} and _COLOR.match((value or "").strip()):
|
||||
kept.append(f' {name}="{html.escape(value.strip(), quote=True)}"')
|
||||
continue
|
||||
if name in {"width", "height"} and re.fullmatch(r"\d{1,4}%?", (value or "").strip()):
|
||||
kept.append(f' {name}="{value.strip()}"')
|
||||
continue
|
||||
if name in {"border", "cellpadding", "cellspacing", "size"} and str(value or "").strip().isdigit():
|
||||
kept.append(f' {name}="{int(value)}"')
|
||||
continue
|
||||
if name in {"align", "valign"} and (value or "").strip().lower() in {"left", "right", "center", "justify", "top", "middle", "bottom"}:
|
||||
kept.append(f' {name}="{value.strip().lower()}"')
|
||||
continue
|
||||
if tag == "a" and name == "href":
|
||||
target = (value or "").strip()
|
||||
if not _SAFE_LINK.match(target):
|
||||
continue
|
||||
kept.append(f' href="{html.escape(target, quote=True)}" title="{html.escape(target, quote=True)}"')
|
||||
elif tag == "img" and name == "src":
|
||||
source = (value or "").strip()
|
||||
if source.lower().startswith("cid:"):
|
||||
token = source[4:].strip().strip("<>")
|
||||
source = images.get(token.casefold(), "")
|
||||
elif re.match(r"https://", source, re.IGNORECASE):
|
||||
if found is not None and source not in found:
|
||||
found.append(source)
|
||||
source = remote(source) if remote is not None else ""
|
||||
if not _DATA_IMAGE.match(source):
|
||||
continue
|
||||
kept.append(f' src="{source}"')
|
||||
elif tag == "img" and name == "alt":
|
||||
kept.append(f' alt="{html.escape(value or "", quote=True)}"')
|
||||
elif name in {"colspan", "rowspan"} and str(value or "").isdigit():
|
||||
kept.append(f" {name}=\"{int(value)}\"")
|
||||
if tag == "img" and not any(item.startswith(" src=") for item in kept):
|
||||
return None
|
||||
if tag == "a":
|
||||
kept.append(' rel="noreferrer noopener" target="_blank"')
|
||||
return "".join(kept)
|
||||
|
||||
|
||||
def _walk(message: EmailMessage):
|
||||
if message.get_content_maintype() == "message" and message.get_content_subtype() == "rfc822":
|
||||
yield "message", message
|
||||
return
|
||||
if message.is_multipart():
|
||||
for child in message.iter_parts():
|
||||
yield from _walk(child)
|
||||
return
|
||||
yield "leaf", message
|
||||
|
||||
|
||||
def _decoded_text(part: EmailMessage) -> str | None:
|
||||
try:
|
||||
payload = part.get_payload(decode=True)
|
||||
except Exception:
|
||||
return None
|
||||
if not isinstance(payload, (bytes, bytearray)):
|
||||
raw = part.get_payload()
|
||||
return raw.strip() if isinstance(raw, str) else None
|
||||
charset = part.get_content_charset() or "utf-8"
|
||||
try:
|
||||
return decode_transfer(bytes(payload), charset).strip()
|
||||
except LookupError:
|
||||
return decode_transfer(bytes(payload), "utf-8").strip()
|
||||
|
||||
|
||||
def _leaf_bytes(part: EmailMessage) -> bytes | None:
|
||||
try:
|
||||
payload = part.get_payload(decode=True)
|
||||
except Exception:
|
||||
return None
|
||||
if isinstance(payload, (bytes, bytearray)):
|
||||
return bytes(payload)
|
||||
return None
|
||||
|
||||
|
||||
def _message_bytes(part: EmailMessage) -> bytes | None:
|
||||
payload = part.get_payload()
|
||||
if isinstance(payload, list) and payload:
|
||||
inner = payload[0]
|
||||
if isinstance(inner, EmailMessage):
|
||||
return inner.as_bytes()
|
||||
data = _leaf_bytes(part)
|
||||
return data or None
|
||||
|
||||
|
||||
def _content_id(part: EmailMessage) -> str:
|
||||
token = str(part.get("Content-ID") or "").strip().strip("<>").strip()
|
||||
return token
|
||||
|
||||
|
||||
def _is_pdf(data: bytes) -> bool:
|
||||
return data[:1024].lstrip(b"\xef\xbb\xbf\r\n\t ").startswith(b"%PDF")
|
||||
|
||||
|
||||
def _unwrap_pdf_payload(data: bytes, media: str, name: str) -> bytes:
|
||||
"""A PDF that arrived as undecoded Base64 is still the PDF, not the transfer text."""
|
||||
if _is_pdf(data):
|
||||
return data
|
||||
declared = (media or "").split(";", 1)[0].strip().lower()
|
||||
hinted = "pdf" in declared or (name or "").lower().endswith(".pdf") or declared in {
|
||||
"application/octet-stream",
|
||||
"application/x-octet-stream",
|
||||
"binary/octet-stream",
|
||||
}
|
||||
if not hinted:
|
||||
return data
|
||||
stripped = b"".join(data.split())
|
||||
if len(stripped) < 16 or re.fullmatch(rb"[A-Za-z0-9+/=]+", stripped) is None:
|
||||
return data
|
||||
try:
|
||||
decoded = base64.b64decode(stripped, validate=True)
|
||||
except Exception:
|
||||
return data
|
||||
return decoded if _is_pdf(decoded) else data
|
||||
|
||||
|
||||
def _pdf_filename(name: str) -> str:
|
||||
text = (name or "").strip() or "anlage"
|
||||
if text.lower().endswith(".pdf"):
|
||||
return text
|
||||
if text.lower().endswith(".bin"):
|
||||
text = text[:-4].rstrip(" .") or "anlage"
|
||||
leaf = text.replace("\\", "/").split("/")[-1]
|
||||
if "." in leaf:
|
||||
return text
|
||||
return f"{text}.pdf"
|
||||
|
||||
|
||||
def _attachment(part: EmailMessage, filename: str, label: str, data: bytes, inline: bool, media: str | None = None) -> AttachmentBytes:
|
||||
resolved = (media or part.get_content_type() or "application/octet-stream").split(";", 1)[0].strip()
|
||||
return AttachmentBytes(
|
||||
filename=filename,
|
||||
media_type=(resolved or "application/octet-stream")[:120],
|
||||
data=data,
|
||||
sha256=hashlib.sha256(data).hexdigest(),
|
||||
display_name=label or filename,
|
||||
content_id=_content_id(part),
|
||||
inline=inline,
|
||||
)
|
||||
|
||||
|
||||
def _inline_images(attachments: list[AttachmentBytes]) -> dict[str, str]:
|
||||
import base64
|
||||
|
||||
images: dict[str, str] = {}
|
||||
for item in attachments:
|
||||
if not item.content_id or not item.media_type.startswith("image/"):
|
||||
continue
|
||||
if len(item.data) > 1_500_000:
|
||||
continue
|
||||
subtype = item.media_type.split("/", 1)[1].split(";", 1)[0].lower()
|
||||
if subtype == "jpg":
|
||||
subtype = "jpeg"
|
||||
if subtype not in {"png", "jpeg", "gif", "webp"}:
|
||||
continue
|
||||
encoded = base64.b64encode(item.data).decode("ascii")
|
||||
images[item.content_id.casefold()] = f"data:image/{subtype};base64,{encoded}"
|
||||
return images
|
||||
|
||||
|
||||
def _message_date(value) -> str | None:
|
||||
if not value:
|
||||
return None
|
||||
try:
|
||||
return parsedate_to_datetime(str(value)).date().isoformat()
|
||||
except (TypeError, ValueError, OverflowError):
|
||||
return None
|
||||
|
||||
|
||||
def _bare(value: str) -> str:
|
||||
return value.strip().strip("<>").strip().casefold()
|
||||
|
||||
|
||||
def _header_text(value) -> str:
|
||||
if value is None:
|
||||
return ""
|
||||
text = str(value).replace("\r", " ").replace("\n", " ")
|
||||
return re.sub(r"\s+", " ", text).strip()
|
||||
|
||||
|
||||
def _unique_filename(name: str, used: set[str]) -> str:
|
||||
cleaned = name.replace("\\", "/").split("/")[-1].strip() or "anlage.bin"
|
||||
cleaned = cleaned[:180]
|
||||
cleaned = re.sub(r"[\r\n\x00]", "", cleaned)[:180] or "anlage.bin"
|
||||
if cleaned not in used:
|
||||
used.add(cleaned)
|
||||
return cleaned
|
||||
stem, dot, ext = cleaned.rpartition(".")
|
||||
if not dot:
|
||||
if not dot or not stem:
|
||||
stem, ext = cleaned, ""
|
||||
else:
|
||||
ext = f".{ext}"
|
||||
@@ -140,36 +516,3 @@ def _unique_filename(name: str, used: set[str]) -> str:
|
||||
used.add(candidate)
|
||||
return candidate
|
||||
number += 1
|
||||
|
||||
|
||||
def _body_text(message) -> str:
|
||||
plain: list[str] = []
|
||||
html: list[str] = []
|
||||
parts = message.walk() if message.is_multipart() else [message]
|
||||
for part in parts:
|
||||
if part.is_multipart() or part.get_content_disposition() == "attachment" or part.get_filename():
|
||||
continue
|
||||
kind = part.get_content_type()
|
||||
payload = part.get_payload(decode=True)
|
||||
if isinstance(payload, (bytes, bytearray)):
|
||||
charset = part.get_content_charset() or "utf-8"
|
||||
text = bytes(payload).decode(charset, errors="replace").strip()
|
||||
else:
|
||||
raw = part.get_payload()
|
||||
text = raw.strip() if isinstance(raw, str) else ""
|
||||
if kind == "text/plain":
|
||||
plain.append(text)
|
||||
elif kind == "text/html":
|
||||
html.append(_html_text(text))
|
||||
body = "\n".join(chunk for chunk in plain if chunk).strip()
|
||||
if not body:
|
||||
body = "\n".join(chunk for chunk in html if chunk).strip()
|
||||
return body
|
||||
|
||||
|
||||
def _html_text(value: str) -> str:
|
||||
text = re.sub(r"(?is)<(script|style)\b.*?>.*?</\1>", " ", value)
|
||||
text = re.sub(r"(?i)<br\s*/?>", "\n", text)
|
||||
text = re.sub(r"(?i)</p>", "\n", text)
|
||||
text = re.sub(r"<[^>]+>", " ", text)
|
||||
return re.sub(r"[ \t]{2,}", " ", text).strip()
|
||||
@@ -9,8 +9,16 @@ from fastapi import FastAPI, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
from app.api.accounts import router as accounts_router
|
||||
from app.api.correspondence import router as correspondence_router
|
||||
from app.api.downloads import router as downloads_router
|
||||
from app.api.export import router as export_router
|
||||
from app.api.externals import router as externals_router
|
||||
from app.api.library import router as library_router
|
||||
from app.api.preferences import router as preferences_router
|
||||
from app.api.rooms import router as rooms_router
|
||||
from app.api.roomshare import router as roomshare_router
|
||||
from app.api.team import router as team_router
|
||||
from app.api.routes import router
|
||||
from app.api.sources import router as sources_router
|
||||
from app.core.errors import Problem, problem_response
|
||||
@@ -116,8 +124,16 @@ def create_app() -> FastAPI:
|
||||
)
|
||||
|
||||
app.include_router(router)
|
||||
app.include_router(accounts_router)
|
||||
app.include_router(library_router)
|
||||
app.include_router(rooms_router)
|
||||
app.include_router(roomshare_router)
|
||||
app.include_router(team_router)
|
||||
app.include_router(sources_router)
|
||||
app.include_router(export_router)
|
||||
app.include_router(downloads_router)
|
||||
app.include_router(preferences_router)
|
||||
app.include_router(externals_router)
|
||||
app.include_router(correspondence_router)
|
||||
return app
|
||||
|
||||
|
||||
@@ -0,0 +1,295 @@
|
||||
"""Opaque storage port. The adapter stores bytes and does not decide who may read them.
|
||||
|
||||
Cleartext for a reader goes through require_cleartext. Locked profiles stay
|
||||
bytes on disk and are not decrypted here. No new cryptography is implemented.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
from pathlib import Path
|
||||
from uuid import UUID
|
||||
|
||||
from app.core.errors import Problem, storage_unavailable, unprocessable
|
||||
from app.media.storage import read_bytes, sha256, write_bytes
|
||||
|
||||
LEGACY_GENERATION = "legacy-local-1"
|
||||
LEGACY_PROFILE = "legacy-plaintext"
|
||||
LOCKED_PROFILES = frozenset({"managed-encrypted", "client-encrypted"})
|
||||
PROFILES = frozenset({LEGACY_PROFILE, *LOCKED_PROFILES})
|
||||
|
||||
|
||||
def require_cleartext(profile: str | None) -> None:
|
||||
name = profile or LEGACY_PROFILE
|
||||
if name == LEGACY_PROFILE:
|
||||
return
|
||||
if name in LOCKED_PROFILES:
|
||||
raise Problem(
|
||||
422,
|
||||
"Geschützter Inhalt",
|
||||
"Dieser Inhalt ist geschützt. Ein Klartextabruf ist in dieser Lieferung nicht möglich.",
|
||||
"unsupported",
|
||||
)
|
||||
raise Problem(
|
||||
422,
|
||||
"Nicht unterstützt",
|
||||
"Dieses Schutzprofil wird nicht unterstützt.",
|
||||
"unsupported",
|
||||
)
|
||||
|
||||
|
||||
def check_object_key(object_key: str) -> str:
|
||||
key = (object_key or "").replace("\\", "/").strip()
|
||||
parts = key.split("/")
|
||||
if not key or key.startswith("/") or any(part in {"", ".", ".."} for part in parts):
|
||||
raise unprocessable("Ungültiger Speicherpfad.")
|
||||
try:
|
||||
if len(parts) == 1:
|
||||
UUID(parts[0])
|
||||
elif len(parts) == 2 and parts[0] == "dispatch":
|
||||
UUID(parts[1])
|
||||
else:
|
||||
raise ValueError
|
||||
except ValueError:
|
||||
raise unprocessable("Ungültiger Speicherpfad.") from None
|
||||
return key
|
||||
|
||||
|
||||
def object_path(root: Path, object_key: str) -> Path:
|
||||
key = check_object_key(object_key)
|
||||
base = Path(root).resolve()
|
||||
base.mkdir(parents=True, exist_ok=True)
|
||||
target = (base / key).resolve()
|
||||
if base != target and base not in target.parents:
|
||||
raise unprocessable("Ungültiger Speicherpfad.")
|
||||
return target
|
||||
|
||||
|
||||
class LocalAdapter:
|
||||
"""Files stay under one recorded root. A client path is not an address."""
|
||||
|
||||
def __init__(self, root: str | Path) -> None:
|
||||
self.root = Path(root)
|
||||
|
||||
def put(self, object_key: str, data: bytes) -> None:
|
||||
path = object_path(self.root, object_key)
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
write_bytes(path, data)
|
||||
|
||||
def open(self, object_key: str) -> bytes:
|
||||
return read_bytes(object_path(self.root, object_key))
|
||||
|
||||
def delete(self, object_key: str) -> None:
|
||||
path = object_path(self.root, object_key)
|
||||
try:
|
||||
path.unlink(missing_ok=True)
|
||||
except OSError as exc:
|
||||
raise storage_unavailable() from exc
|
||||
|
||||
def describe(self, object_key: str) -> dict:
|
||||
path = object_path(self.root, object_key)
|
||||
try:
|
||||
if not path.is_file():
|
||||
raise storage_unavailable()
|
||||
return {"byte_size": path.stat().st_size, "object_key": object_key}
|
||||
except OSError as exc:
|
||||
raise storage_unavailable() from exc
|
||||
|
||||
|
||||
class MemoryAdapter:
|
||||
"""In-memory stand-in for the same port. It is not a second product store."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._items: dict[str, bytes] = {}
|
||||
self.fail_put = False
|
||||
|
||||
def put(self, object_key: str, data: bytes) -> None:
|
||||
if self.fail_put:
|
||||
raise storage_unavailable()
|
||||
key = check_object_key(object_key)
|
||||
self._items[key] = bytes(data)
|
||||
|
||||
def open(self, object_key: str) -> bytes:
|
||||
key = check_object_key(object_key)
|
||||
try:
|
||||
return self._items[key]
|
||||
except KeyError as exc:
|
||||
raise storage_unavailable() from exc
|
||||
|
||||
def delete(self, object_key: str) -> None:
|
||||
key = check_object_key(object_key)
|
||||
self._items.pop(key, None)
|
||||
|
||||
def describe(self, object_key: str) -> dict:
|
||||
data = self.open(object_key)
|
||||
return {"byte_size": len(data), "object_key": object_key}
|
||||
|
||||
|
||||
def publish(adapter, object_key: str, data: bytes) -> None:
|
||||
"""Make bytes readable only after a checked roundtrip. A failed put leaves nothing published."""
|
||||
adapter.put(object_key, data)
|
||||
try:
|
||||
opened = adapter.open(object_key)
|
||||
except Problem:
|
||||
adapter.delete(object_key)
|
||||
raise
|
||||
if opened != data:
|
||||
adapter.delete(object_key)
|
||||
raise storage_unavailable()
|
||||
|
||||
|
||||
def ensure_legacy_instance(conn, media_root: str) -> dict:
|
||||
"""Bind the legacy generation to the current root once. Later roots do not retarget it."""
|
||||
root = str(Path(media_root).resolve())
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO storage_instances (kind, generation, root_path)
|
||||
VALUES ('local', %s, %s)
|
||||
ON CONFLICT (generation) DO NOTHING
|
||||
""",
|
||||
(LEGACY_GENERATION, root),
|
||||
)
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE storage_instances
|
||||
SET root_path = %s
|
||||
WHERE generation = %s AND root_path IS NULL
|
||||
""",
|
||||
(root, LEGACY_GENERATION),
|
||||
)
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT id, kind, generation, root_path
|
||||
FROM storage_instances
|
||||
WHERE generation = %s
|
||||
""",
|
||||
(LEGACY_GENERATION,),
|
||||
).fetchone()
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE media_assets
|
||||
SET storage_instance_id = %s
|
||||
WHERE storage_generation = %s AND storage_instance_id IS NULL
|
||||
""",
|
||||
(row["id"], LEGACY_GENERATION),
|
||||
)
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE dispatch_snapshots
|
||||
SET storage_instance_id = %s
|
||||
WHERE storage_generation = %s AND storage_instance_id IS NULL
|
||||
""",
|
||||
(row["id"], LEGACY_GENERATION),
|
||||
)
|
||||
return row
|
||||
|
||||
|
||||
def instance_for_write(conn, media_root: str) -> dict:
|
||||
legacy = ensure_legacy_instance(conn, media_root)
|
||||
root = str(Path(media_root).resolve())
|
||||
if legacy["root_path"] == root:
|
||||
return legacy
|
||||
generation = "local-" + hashlib.sha256(root.encode("utf-8")).hexdigest()[:16]
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO storage_instances (kind, generation, root_path)
|
||||
VALUES ('local', %s, %s)
|
||||
ON CONFLICT (generation) DO NOTHING
|
||||
""",
|
||||
(generation, root),
|
||||
)
|
||||
return conn.execute(
|
||||
"""
|
||||
SELECT id, kind, generation, root_path
|
||||
FROM storage_instances
|
||||
WHERE generation = %s
|
||||
""",
|
||||
(generation,),
|
||||
).fetchone()
|
||||
|
||||
|
||||
class StoredHandle:
|
||||
"""Rollback and delete go through the adapter that owns the bytes."""
|
||||
|
||||
def __init__(self, adapter: StoragePort, object_key: str):
|
||||
self._adapter = adapter
|
||||
self._key = object_key
|
||||
|
||||
def discard(self) -> None:
|
||||
self._adapter.delete(self._key)
|
||||
|
||||
|
||||
_FACTORIES: dict[str, callable] = {}
|
||||
|
||||
|
||||
def _local_factory(row: dict) -> StoragePort:
|
||||
return LocalAdapter(row["root_path"])
|
||||
|
||||
|
||||
_FACTORIES["local"] = _local_factory
|
||||
|
||||
|
||||
def adapter_for(row: dict) -> StoragePort:
|
||||
factory = _FACTORIES.get(row["kind"])
|
||||
if factory is None or not row.get("root_path") and row["kind"] == "local":
|
||||
raise storage_unavailable()
|
||||
return factory(row)
|
||||
|
||||
|
||||
def removal_for(conn, instance_id, generation: str | None, object_key: str, media_root: str) -> StoredHandle:
|
||||
row = None
|
||||
if instance_id is not None:
|
||||
row = conn.execute(
|
||||
"SELECT id, kind, generation, root_path FROM storage_instances WHERE id = %s",
|
||||
(instance_id,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
root = resolve_root(conn, instance_id, generation, media_root)
|
||||
return StoredHandle(LocalAdapter(root), object_key)
|
||||
return StoredHandle(adapter_for(row), object_key)
|
||||
|
||||
|
||||
def resolve_root(conn, instance_id, generation: str | None, media_root: str) -> str:
|
||||
if instance_id is not None:
|
||||
row = conn.execute(
|
||||
"SELECT root_path FROM storage_instances WHERE id = %s",
|
||||
(instance_id,),
|
||||
).fetchone()
|
||||
if row is not None and row["root_path"]:
|
||||
return row["root_path"]
|
||||
if generation in {None, LEGACY_GENERATION}:
|
||||
return ensure_legacy_instance(conn, media_root)["root_path"]
|
||||
return str(Path(media_root).resolve())
|
||||
|
||||
|
||||
def stored_path(conn, instance_id, generation: str | None, object_key: str, media_root: str) -> Path:
|
||||
return object_path(Path(resolve_root(conn, instance_id, generation, media_root)), object_key)
|
||||
|
||||
|
||||
def read_clear_bytes(
|
||||
conn,
|
||||
*,
|
||||
instance_id,
|
||||
generation: str | None,
|
||||
object_key: str,
|
||||
media_root: str,
|
||||
protection_profile: str | None,
|
||||
expected_sha256: str | None,
|
||||
) -> bytes:
|
||||
require_cleartext(protection_profile)
|
||||
row = None
|
||||
if instance_id is not None:
|
||||
row = conn.execute(
|
||||
"SELECT id, kind, generation, root_path FROM storage_instances WHERE id = %s",
|
||||
(instance_id,),
|
||||
).fetchone()
|
||||
adapter = adapter_for(row) if row is not None else LocalAdapter(resolve_root(conn, instance_id, generation, media_root))
|
||||
data = adapter.open(object_key)
|
||||
if expected_sha256 and sha256(data) != expected_sha256:
|
||||
raise Problem(
|
||||
422,
|
||||
"Inhalt nicht geprüft",
|
||||
"Die gespeicherte Datei stimmt nicht mit dem erfassten Stand überein.",
|
||||
"processing",
|
||||
)
|
||||
return data
|
||||
@@ -4,6 +4,7 @@ from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
from pathlib import Path
|
||||
from urllib.parse import quote
|
||||
from uuid import UUID
|
||||
|
||||
from app.core.errors import storage_unavailable, unprocessable
|
||||
@@ -66,6 +67,17 @@ def display_filename(name: str) -> str:
|
||||
return text[:240]
|
||||
|
||||
|
||||
def content_disposition(filename: str) -> str:
|
||||
safe = display_filename(filename).replace('"', "")
|
||||
return f'attachment; filename="{safe}"'
|
||||
def content_disposition(filename: str, *, inline: bool = False) -> str:
|
||||
"""The real name goes along in UTF-8 (RFC 5987), with a plain ASCII fallback for old clients."""
|
||||
name = display_filename(filename)
|
||||
kind = "inline" if inline else "attachment"
|
||||
suffix = ""
|
||||
leaf = name.rsplit(".", 1)
|
||||
if len(leaf) == 2 and leaf[1].isascii() and leaf[1].isalnum():
|
||||
suffix = f".{leaf[1]}"
|
||||
fallback = name.encode("ascii", "replace").decode("ascii").replace("?", "_").replace('"', "").replace("\\", "_").replace(";", "_")
|
||||
fallback = " ".join(fallback.split())
|
||||
if suffix and not fallback.lower().endswith(suffix.lower()):
|
||||
fallback = f"{fallback}{suffix}".strip()
|
||||
fallback = fallback or f"datei{suffix}"
|
||||
return f"{kind}; filename=\"{fallback}\"; filename*=UTF-8''{quote(name, safe='')}"
|
||||
+249
-16
@@ -8,6 +8,7 @@ from uuid import UUID, uuid4
|
||||
|
||||
from psycopg.types.json import Json
|
||||
|
||||
from app.access.roles import ensure_can_create, room_role
|
||||
from app.access.policy import (
|
||||
Ctx,
|
||||
Rights,
|
||||
@@ -33,9 +34,12 @@ from app.access.policy import (
|
||||
task_rights,
|
||||
)
|
||||
from app.content.documents import clean_document
|
||||
from app.core.errors import forbidden, not_found, unprocessable
|
||||
from app.core.errors import forbidden, not_found, unprocessable, unsupported
|
||||
from app.core.timeutil import utcnow
|
||||
from app.media.storage import asset_path, display_filename, sha256, sniff, write_bytes
|
||||
from app.preferences import effective_preference
|
||||
from app.duplicates import already_present, find_existing
|
||||
from app.media.port import LEGACY_PROFILE, StoredHandle, adapter_for, instance_for_write, publish, removal_for
|
||||
from app.media.storage import display_filename, sha256, sniff
|
||||
|
||||
MAX_CHAPTER_DEPTH = 32
|
||||
|
||||
@@ -72,7 +76,135 @@ def _placement(context: Ctx, placement: Ctx | None) -> tuple[Ctx, Ctx]:
|
||||
return target, context if context.kind == "case" or placement is not None else None
|
||||
|
||||
|
||||
def default_visibility(conn, scope_id: UUID) -> str:
|
||||
"""Whether new cases and matters are shared with their room at once. The personal room never is."""
|
||||
room = conn.execute("SELECT kind, default_visibility FROM data_rooms WHERE id = %s", (scope_id,)).fetchone()
|
||||
if room is not None and room["kind"] == "organization" and room["default_visibility"] == "room":
|
||||
return "room"
|
||||
return "private"
|
||||
|
||||
|
||||
def _auto_share(conn, actor: UUID, kind: str, resource: dict) -> None:
|
||||
if default_visibility(conn, resource["home_scope_id"]) == "room":
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO room_shares (resource_kind, resource_id, room_id, access, created_by)
|
||||
VALUES (%s, %s, %s, 'edit', %s)
|
||||
ON CONFLICT DO NOTHING
|
||||
""",
|
||||
(kind, resource["id"], resource["home_scope_id"], actor),
|
||||
)
|
||||
|
||||
|
||||
def _shareable(conn, actor: UUID, kind: str, resource_id: UUID) -> dict:
|
||||
"""The own case or matter. Only the owner decides which rooms it is shared with."""
|
||||
if kind == "case":
|
||||
resource = get_case(conn, resource_id)
|
||||
elif kind == "matter":
|
||||
resource = get_matter(conn, resource_id)
|
||||
else:
|
||||
raise unprocessable("Die Raumfreigabe gilt für Akten und Vorgänge.")
|
||||
if resource is None or resource["owner_subject_id"] != actor:
|
||||
raise not_found()
|
||||
return resource
|
||||
|
||||
|
||||
def _target_room(conn, actor: UUID, room_id: UUID) -> dict:
|
||||
room = conn.execute("SELECT id, kind, status FROM data_rooms WHERE id = %s", (room_id,)).fetchone()
|
||||
if room is None or room["kind"] != "organization" or room["status"] != "active":
|
||||
raise not_found()
|
||||
if room_role(conn, actor, room_id) not in {"member", "manager"}:
|
||||
raise forbidden("Du kannst nur mit Datenräumen teilen, in denen du Mitglied oder Verwalter bist.")
|
||||
return room
|
||||
|
||||
|
||||
def share_with_room(conn, actor: UUID, kind: str, resource_id: UUID, room_id: UUID, access: str) -> dict:
|
||||
if access not in {"read", "edit"}:
|
||||
raise unprocessable("Die Freigabeart ist ungültig.")
|
||||
resource = _shareable(conn, actor, kind, resource_id)
|
||||
_target_room(conn, actor, room_id)
|
||||
existing = conn.execute(
|
||||
"SELECT access FROM room_shares WHERE resource_kind = %s AND resource_id = %s AND room_id = %s",
|
||||
(kind, resource_id, room_id),
|
||||
).fetchone()
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO room_shares (resource_kind, resource_id, room_id, access, created_by)
|
||||
VALUES (%s, %s, %s, %s, %s)
|
||||
ON CONFLICT (resource_kind, resource_id, room_id) DO UPDATE SET access = EXCLUDED.access
|
||||
""",
|
||||
(kind, resource_id, room_id, access, actor),
|
||||
)
|
||||
if existing is None or existing["access"] != access:
|
||||
audit(
|
||||
conn,
|
||||
actor,
|
||||
resource["home_scope_id"],
|
||||
"room_shared" if existing is None else "room_share_changed",
|
||||
kind,
|
||||
resource_id,
|
||||
detail={"room_id": str(room_id), "access": access},
|
||||
)
|
||||
return {"room_id": str(room_id), "access": access}
|
||||
|
||||
|
||||
def unshare_from_room(conn, actor: UUID, kind: str, resource_id: UUID, room_id: UUID) -> None:
|
||||
resource = _shareable(conn, actor, kind, resource_id)
|
||||
row = conn.execute(
|
||||
"DELETE FROM room_shares WHERE resource_kind = %s AND resource_id = %s AND room_id = %s RETURNING id",
|
||||
(kind, resource_id, room_id),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise not_found()
|
||||
audit(conn, actor, resource["home_scope_id"], "room_unshared", kind, resource_id, detail={"room_id": str(room_id)})
|
||||
|
||||
|
||||
def set_person_exclusion(conn, actor: UUID, kind: str, resource_id: UUID, subject_id: UUID, excluded: bool) -> None:
|
||||
"""Take one person out of the room shares of an own case or matter."""
|
||||
resource = _shareable(conn, actor, kind, resource_id)
|
||||
if subject_id == actor:
|
||||
raise unprocessable("Du kannst dich nicht selbst ausnehmen.")
|
||||
member = conn.execute(
|
||||
"""
|
||||
SELECT 1 FROM room_shares s
|
||||
JOIN room_memberships m ON m.room_id = s.room_id AND m.subject_id = %s AND m.status = 'active'
|
||||
WHERE s.resource_kind = %s AND s.resource_id = %s
|
||||
""",
|
||||
(subject_id, kind, resource_id),
|
||||
).fetchone()
|
||||
if member is None:
|
||||
raise not_found()
|
||||
conn.execute(
|
||||
"""
|
||||
DELETE FROM access_grants
|
||||
WHERE is_exception AND grantee_subject_id = %s AND resource_kind = %s AND resource_id = %s
|
||||
AND context_kind IS NULL
|
||||
""",
|
||||
(subject_id, kind, resource_id),
|
||||
)
|
||||
if excluded:
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO access_grants (
|
||||
grantee_subject_id, resource_kind, resource_id,
|
||||
can_read, can_edit, can_share, can_delete, is_exception, created_by
|
||||
)
|
||||
VALUES (%s, %s, %s, true, true, true, true, true, %s)
|
||||
""",
|
||||
(subject_id, kind, resource_id, actor),
|
||||
)
|
||||
audit(
|
||||
conn,
|
||||
actor,
|
||||
resource["home_scope_id"],
|
||||
"person_excluded" if excluded else "person_included",
|
||||
kind,
|
||||
resource_id,
|
||||
)
|
||||
|
||||
|
||||
def create_case(conn, actor: UUID, scope_id: UUID, title: str, parent_case_id: UUID | None, rights_mode: str) -> dict:
|
||||
ensure_can_create(conn, actor, scope_id)
|
||||
title = title.strip()
|
||||
if parent_case_id is None:
|
||||
row = conn.execute(
|
||||
@@ -103,6 +235,7 @@ def create_case(conn, actor: UUID, scope_id: UUID, title: str, parent_case_id: U
|
||||
""",
|
||||
(parent["home_scope_id"], actor, actor, title, parent["id"], rights_mode),
|
||||
).fetchone()
|
||||
_auto_share(conn, actor, "case", row)
|
||||
audit(conn, actor, row["home_scope_id"], "case_created", "case", row["id"])
|
||||
return row
|
||||
|
||||
@@ -338,6 +471,7 @@ def set_chapter_date(
|
||||
|
||||
|
||||
def create_matter(conn, actor: UUID, scope_id: UUID, title: str, parent_matter_id: UUID | None, context: Ctx | None) -> dict:
|
||||
ensure_can_create(conn, actor, scope_id)
|
||||
title = title.strip()
|
||||
if parent_matter_id is None:
|
||||
row = conn.execute(
|
||||
@@ -363,6 +497,7 @@ def create_matter(conn, actor: UUID, scope_id: UUID, title: str, parent_matter_i
|
||||
""",
|
||||
(parent["home_scope_id"], actor, actor, title, parent["id"]),
|
||||
).fetchone()
|
||||
_auto_share(conn, actor, "matter", row)
|
||||
audit(conn, actor, row["home_scope_id"], "matter_created", "matter", row["id"], context)
|
||||
return row
|
||||
|
||||
@@ -516,8 +651,9 @@ def move_bindings_chapter(
|
||||
|
||||
|
||||
def delete_case(conn, actor: UUID, case_id: UUID, expected: int) -> None:
|
||||
case, rights = require_case(conn, actor, case_id, "edit")
|
||||
if not rights.edit:
|
||||
case, rights = require_case(conn, actor, case_id, "read")
|
||||
# Deleting the container is the owner's right. Editing, also through the room share, is not enough.
|
||||
if case["owner_subject_id"] != actor and not rights.delete:
|
||||
raise forbidden()
|
||||
children = conn.execute(
|
||||
"SELECT id FROM cases WHERE parent_case_id = %s AND deleted_at IS NULL",
|
||||
@@ -532,7 +668,9 @@ def delete_case(conn, actor: UUID, case_id: UUID, expected: int) -> None:
|
||||
|
||||
|
||||
def delete_matter(conn, actor: UUID, matter_id: UUID, expected: int, context: Ctx | None) -> None:
|
||||
matter, _rights = require_matter(conn, actor, matter_id, context, "edit")
|
||||
matter, rights = require_matter(conn, actor, matter_id, context, "read")
|
||||
if matter["owner_subject_id"] != actor and not rights.delete:
|
||||
raise forbidden()
|
||||
children = conn.execute(
|
||||
"SELECT id FROM matters WHERE parent_matter_id = %s AND deleted_at IS NULL",
|
||||
(matter_id,),
|
||||
@@ -701,6 +839,12 @@ def _actor_rights_for(conn, actor: UUID, kind: str, resource_id: UUID, context:
|
||||
return rights
|
||||
|
||||
|
||||
def _is_reader_of_home(conn, account_id: UUID, home_scope_id: UUID) -> bool:
|
||||
from app.access.roles import room_role
|
||||
|
||||
return room_role(conn, account_id, home_scope_id) == "reader"
|
||||
|
||||
|
||||
def grant_access(
|
||||
conn,
|
||||
actor: UUID,
|
||||
@@ -740,6 +884,8 @@ def grant_access(
|
||||
).fetchone()
|
||||
if account is None:
|
||||
raise not_found()
|
||||
if (can_edit or can_share) and _is_reader_of_home(conn, grantee_id, resource["home_scope_id"]):
|
||||
raise unprocessable("Diese Person ist in dem Datenraum der Akte nur Leser und kann nicht bearbeiten oder freigeben.")
|
||||
existing = conn.execute(
|
||||
"""
|
||||
SELECT id, use_owner_sources FROM access_grants
|
||||
@@ -908,6 +1054,7 @@ def create_note(
|
||||
received_on: date | None = None,
|
||||
communication_direction: str | None = None,
|
||||
) -> dict:
|
||||
ensure_can_create(conn, actor, scope_id)
|
||||
document = clean_document(document)
|
||||
target, rights_context = _placement(context, placement)
|
||||
require_container_edit(conn, actor, target, rights_context)
|
||||
@@ -929,7 +1076,7 @@ def update_note(conn, actor: UUID, element_id: UUID, expected: int, document: di
|
||||
document = clean_document(document)
|
||||
element, rights = require_element(conn, actor, element_id, context, "edit")
|
||||
if element["kind"] != "note":
|
||||
raise not_found()
|
||||
raise unsupported("Diese Fassung lässt sich nicht als Notiz bearbeiten.")
|
||||
if not rights.edit:
|
||||
raise forbidden()
|
||||
version = bump_version(conn, "elements", element_id, expected)
|
||||
@@ -997,16 +1144,31 @@ def add_annotation(conn, actor: UUID, binding_id: UUID, body: str, context: Ctx
|
||||
return row
|
||||
|
||||
|
||||
def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str, external_id: str, context: Ctx, placement: Ctx | None, chapter_id: UUID | None, document_on, sent_on, received_on, detail: dict | None = None, communication_direction: str | None = None) -> dict:
|
||||
def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str, external_id: str, context: Ctx, placement: Ctx | None, chapter_id: UUID | None, document_on, sent_on, received_on, detail: dict | None = None, communication_direction: str | None = None, duplicate: str = "insert") -> dict:
|
||||
ensure_can_create(conn, actor, scope_id)
|
||||
from app.sourceregistry import accepts_reference
|
||||
|
||||
if not accepts_reference(source):
|
||||
raise unprocessable("Diese Quelle ist nicht registriert.")
|
||||
target, rights_context = _placement(context, placement)
|
||||
require_container_edit(conn, actor, target, rights_context)
|
||||
if duplicate == "ask":
|
||||
# The level is the account's choice. Only a certain match warns: an unclear connection never blocks.
|
||||
connector = (detail or {}).get("connector_id")
|
||||
level = effective_preference(conn, actor, "duplicate_check")
|
||||
found = [item for item in find_existing(conn, actor, source, external_id, str(connector) if connector else None, target, rights_context, level) if item["certain"]]
|
||||
if found:
|
||||
raise already_present(found)
|
||||
element = _new_element(conn, actor, scope_id, title, "external_ref")
|
||||
conn.execute(
|
||||
"INSERT INTO external_references (element_id, source, external_id, detail) VALUES (%s, %s, %s, %s)",
|
||||
(element["id"], source, external_id.strip()[:200], Json(detail or {})),
|
||||
)
|
||||
from app.sourcebind import attach_new_reference
|
||||
|
||||
attach_new_reference(conn, element["id"])
|
||||
binding = insert_binding(conn, element["id"], target.kind, target.id, chapter_id, actor)
|
||||
adopted = (detail or {}).get("direction") if source == "imap" else None
|
||||
adopted = (detail or {}).get("direction")
|
||||
chosen = chosen_direction(communication_direction) or (adopted if adopted in ("in", "out") else None)
|
||||
store_direction(conn, binding["id"], chosen, chosen is not None)
|
||||
record_dates(conn, actor, scope_id, element["id"], rights_context or target, document_on, sent_on, received_on)
|
||||
@@ -1014,24 +1176,80 @@ def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str,
|
||||
return element | {"binding_id": binding["id"]}
|
||||
|
||||
|
||||
def existing_externals(conn, actor: UUID, context: Ctx, placement: Ctx | None, items: list[dict]) -> dict:
|
||||
"""For each document: where it is already present around the target, at the account's check level."""
|
||||
target, rights_context = _placement(context, placement)
|
||||
require_container_edit(conn, actor, target, rights_context)
|
||||
level = effective_preference(conn, actor, "duplicate_check")
|
||||
return {
|
||||
"level": level,
|
||||
"items": [
|
||||
item
|
||||
| {"matches": find_existing(conn, actor, item["source"], item["external_id"], item.get("connector_id"), target, rights_context, level)}
|
||||
for item in items
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
def bind_existing_external(conn, actor: UUID, scope_id: UUID, element_id: UUID, context: Ctx, placement: Ctx | None, chapter_id: UUID | None) -> dict:
|
||||
"""Bind an element that already holds the document into a further container: one element, one more binding.
|
||||
|
||||
The element must be a certain match around the target, readable for the actor, and the actor may share it
|
||||
there. Nothing is copied and nothing is handed over: rights stay those of each context.
|
||||
"""
|
||||
ensure_can_create(conn, actor, scope_id)
|
||||
target, rights_context = _placement(context, placement)
|
||||
require_container_edit(conn, actor, target, rights_context)
|
||||
ref = conn.execute(
|
||||
"SELECT source, external_id, connector_id, detail FROM external_references WHERE element_id = %s",
|
||||
(element_id,),
|
||||
).fetchone()
|
||||
if ref is None:
|
||||
raise not_found()
|
||||
connector = ref["connector_id"] or (ref["detail"] or {}).get("connector_id")
|
||||
matches = find_existing(conn, actor, ref["source"], ref["external_id"], str(connector) if connector else None, target, rights_context, "around")
|
||||
match = next((item for item in matches if item["element_id"] == str(element_id) and item["certain"]), None)
|
||||
if match is None:
|
||||
raise not_found()
|
||||
if match["where"] == "here":
|
||||
raise unprocessable("Das Dokument ist hier bereits eingebunden.")
|
||||
if not match["can_bind"]:
|
||||
raise forbidden("Du darfst dieses Element nicht in einen weiteren Zusammenhang einbinden.")
|
||||
element = get_element(conn, element_id)
|
||||
binding = insert_binding(conn, element_id, target.kind, target.id, chapter_id, actor)
|
||||
audit(conn, actor, scope_id, "external_ref_bound", "element", element_id, rights_context or target)
|
||||
return element | {"binding_id": binding["id"]}
|
||||
|
||||
|
||||
def create_file(conn, actor: UUID, scope_id: UUID, title: str, filename: str, data: bytes, context: Ctx, placement: Ctx | None, chapter_id: UUID | None, document_on, sent_on, received_on, media_root: str, max_bytes: int, rollback_files: list[Path], communication_direction: str | None = None) -> dict:
|
||||
ensure_can_create(conn, actor, scope_id)
|
||||
if not data or len(data) > max_bytes:
|
||||
raise unprocessable("Die Datei ist leer oder zu groß.")
|
||||
content_type = sniff(data)
|
||||
target, rights_context = _placement(context, placement)
|
||||
require_container_edit(conn, actor, target, rights_context)
|
||||
element = _new_element(conn, actor, scope_id, title, "file")
|
||||
asset_id = uuid4()
|
||||
path = asset_path(media_root, asset_id)
|
||||
write_bytes(path, data)
|
||||
rollback_files.append(path)
|
||||
content_revision = str(uuid4())
|
||||
instance = instance_for_write(conn, media_root)
|
||||
object_key = str(asset_id)
|
||||
adapter = adapter_for(instance)
|
||||
from app.sourceaccess import release_for_external
|
||||
|
||||
release_for_external(conn)
|
||||
publish(adapter, object_key, data)
|
||||
rollback_files.append(StoredHandle(adapter, object_key))
|
||||
require_container_edit(conn, actor, target, rights_context)
|
||||
element = _new_element(conn, actor, scope_id, title, "file")
|
||||
digest = sha256(data)
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO media_assets (
|
||||
id, element_id, owner_subject_id, home_scope_id, original_filename,
|
||||
content_type, byte_size, sha256, status
|
||||
content_type, byte_size, sha256, status, storage_instance_id,
|
||||
storage_generation, object_key, content_revision, protection_profile,
|
||||
key_responsibility
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, 'active')
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, 'active', %s, %s, %s, %s, %s, 'none')
|
||||
""",
|
||||
(
|
||||
asset_id,
|
||||
@@ -1041,7 +1259,12 @@ def create_file(conn, actor: UUID, scope_id: UUID, title: str, filename: str, da
|
||||
display_filename(filename),
|
||||
content_type,
|
||||
len(data),
|
||||
sha256(data),
|
||||
digest,
|
||||
instance["id"],
|
||||
instance["generation"],
|
||||
object_key,
|
||||
content_revision,
|
||||
LEGACY_PROFILE,
|
||||
),
|
||||
)
|
||||
conn.execute(
|
||||
@@ -1075,12 +1298,21 @@ def delete_element(conn, actor: UUID, element_id: UUID, expected: int, media_roo
|
||||
)
|
||||
if asset is not None and asset["status"] == "active":
|
||||
conn.execute("UPDATE media_assets SET status = 'purging' WHERE id = %s", (asset["id"],))
|
||||
delete_after.append(asset_path(media_root, asset["id"]))
|
||||
delete_after.append(
|
||||
removal_for(
|
||||
conn,
|
||||
asset["storage_instance_id"],
|
||||
asset["storage_generation"],
|
||||
asset["object_key"] or str(asset["id"]),
|
||||
media_root,
|
||||
)
|
||||
)
|
||||
conn.execute("UPDATE media_assets SET status = 'purged' WHERE id = %s", (asset["id"],))
|
||||
audit(conn, actor, element["home_scope_id"], "element_deleted", "element", element_id)
|
||||
|
||||
|
||||
def create_task(conn, actor: UUID, scope_id: UUID, title: str, due_on: date | None, matter_id: UUID | None, context: Ctx | None) -> dict:
|
||||
ensure_can_create(conn, actor, scope_id)
|
||||
if matter_id is not None:
|
||||
require_matter(conn, actor, matter_id, context, "edit")
|
||||
row = conn.execute(
|
||||
@@ -1186,6 +1418,7 @@ def assign_task(conn, actor: UUID, task_id: UUID, assignee_id: UUID | None, cont
|
||||
|
||||
|
||||
def create_deadline(conn, actor: UUID, scope_id: UUID, title: str, due_on: date, matter_id: UUID | None, context: Ctx | None) -> dict:
|
||||
ensure_can_create(conn, actor, scope_id)
|
||||
if matter_id is not None:
|
||||
require_matter(conn, actor, matter_id, context, "edit")
|
||||
row = conn.execute(
|
||||
|
||||
@@ -0,0 +1,112 @@
|
||||
"""Account preferences with inheritance.
|
||||
|
||||
An employee inherits the value of the main user who sponsors the account and may change it,
|
||||
unless the main user made the preference binding for the team. A binding value overrides an own
|
||||
value without deleting it: it applies again once the binding is lifted.
|
||||
Allowed values, default and lockability of each key are fixed here.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from uuid import UUID
|
||||
|
||||
from psycopg.types.json import Json
|
||||
|
||||
from app.core.errors import forbidden, not_found, unprocessable
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Preference:
|
||||
default: str
|
||||
allowed: tuple[str, ...]
|
||||
team_lockable: bool = True
|
||||
|
||||
|
||||
PREFERENCES: dict[str, Preference] = {
|
||||
# Where an element that is inserted again counts as already present.
|
||||
"duplicate_check": Preference("here", ("off", "here", "inside", "around")),
|
||||
}
|
||||
|
||||
|
||||
def spec(key: str) -> Preference:
|
||||
found = PREFERENCES.get(key)
|
||||
if found is None:
|
||||
raise not_found()
|
||||
return found
|
||||
|
||||
|
||||
def _valid(wanted: Preference, value) -> str | None:
|
||||
return value if isinstance(value, str) and value in wanted.allowed else None
|
||||
|
||||
|
||||
def preference_state(conn, account_id: UUID, key: str) -> dict:
|
||||
"""The effective value and where it comes from: locked, own, team or default."""
|
||||
wanted = spec(key)
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT a.account_kind,
|
||||
own.value AS own_value, own.team_mode AS own_mode,
|
||||
sp.value AS team_value, sp.team_mode AS team_mode
|
||||
FROM auth_accounts a
|
||||
LEFT JOIN account_preferences own ON own.account_id = a.id AND own.key = %s
|
||||
LEFT JOIN account_preferences sp ON sp.account_id = a.sponsor_id AND sp.key = %s
|
||||
WHERE a.id = %s
|
||||
""",
|
||||
(key, key, account_id),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise not_found()
|
||||
employee = row["account_kind"] == "employee"
|
||||
own = _valid(wanted, row["own_value"])
|
||||
team = _valid(wanted, row["team_value"]) if employee else None
|
||||
locked = employee and wanted.team_lockable and row["team_mode"] == "locked"
|
||||
inherited = team or wanted.default
|
||||
if locked:
|
||||
value, source = inherited, "locked"
|
||||
elif own is not None:
|
||||
value, source = own, "own"
|
||||
elif team is not None:
|
||||
value, source = team, "team"
|
||||
else:
|
||||
value, source = wanted.default, "default"
|
||||
return {
|
||||
"key": key,
|
||||
"value": value,
|
||||
"source": source,
|
||||
"own": own,
|
||||
"inherited": inherited,
|
||||
"locked": locked,
|
||||
"allowed": list(wanted.allowed),
|
||||
"default": wanted.default,
|
||||
"can_lock": row["account_kind"] == "main" and wanted.team_lockable,
|
||||
"team_mode": row["own_mode"] if row["own_mode"] and not employee else "free",
|
||||
}
|
||||
|
||||
|
||||
def effective_preference(conn, account_id: UUID, key: str) -> str:
|
||||
return preference_state(conn, account_id, key)["value"]
|
||||
|
||||
|
||||
def store_preference(conn, account_id: UUID, key: str, value: str | None, team_mode: str | None) -> dict:
|
||||
"""Own value (None: inherit) and, for a main user, the binding for the team."""
|
||||
wanted = spec(key)
|
||||
state = preference_state(conn, account_id, key)
|
||||
if value is not None and value not in wanted.allowed:
|
||||
raise unprocessable("Dieser Wert ist für die Einstellung nicht vorgesehen.")
|
||||
if team_mode is not None and not state["can_lock"]:
|
||||
raise forbidden("Nur der Hauptnutzer kann eine Einstellung für das Team verbindlich setzen.")
|
||||
if state["locked"]:
|
||||
raise forbidden("Der Hauptnutzer hat diese Einstellung für das Team vorgegeben.")
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO account_preferences (account_id, key, value, team_mode)
|
||||
VALUES (%s, %s, %s, COALESCE(%s, 'free'))
|
||||
ON CONFLICT (account_id, key) DO UPDATE
|
||||
SET value = EXCLUDED.value,
|
||||
team_mode = COALESCE(%s, account_preferences.team_mode),
|
||||
updated_at = now()
|
||||
""",
|
||||
(account_id, key, Json(value) if value is not None else None, team_mode, team_mode),
|
||||
)
|
||||
return preference_state(conn, account_id, key)
|
||||
+94
-11
@@ -117,10 +117,16 @@ def _preview_meta(kind: str, content_type: str | None, source: str | None) -> di
|
||||
return {"available": True, "media": "image", "source": "file"}
|
||||
if kind == "file" and media == "application/pdf":
|
||||
return {"available": True, "media": "pdf", "source": "file"}
|
||||
if kind == "external_ref" and source == "paperless":
|
||||
return {"available": True, "media": "paperless", "source": "paperless"}
|
||||
if kind == "external_ref" and source == "imap":
|
||||
return {"available": True, "media": "email", "source": "imap"}
|
||||
if kind == "external_ref" and source:
|
||||
from app.sourceregistry import get_source
|
||||
|
||||
module = get_source(source)
|
||||
if module is not None:
|
||||
return {
|
||||
"available": bool(module.capabilities.get("read_preview")),
|
||||
"media": module.representation,
|
||||
"source": source,
|
||||
}
|
||||
if kind == "file":
|
||||
return {"available": False, "media": "file", "source": "file"}
|
||||
return {"available": False, "media": "none", "source": source}
|
||||
@@ -175,35 +181,57 @@ def _element_body(conn, actor: UUID, element: dict) -> dict:
|
||||
elif element["kind"] == "file":
|
||||
asset = conn.execute(
|
||||
"""
|
||||
SELECT original_filename, content_type, byte_size, status
|
||||
SELECT original_filename, content_type, byte_size, status, protection_profile
|
||||
FROM media_assets WHERE element_id = %s
|
||||
""",
|
||||
(element["id"],),
|
||||
).fetchone()
|
||||
if asset is not None:
|
||||
profile = asset["protection_profile"] or "legacy-plaintext"
|
||||
payload["file"] = {
|
||||
"filename": asset["original_filename"],
|
||||
"content_type": asset["content_type"],
|
||||
"byte_size": asset["byte_size"],
|
||||
"status": asset["status"],
|
||||
"protection_profile": profile,
|
||||
}
|
||||
payload["preview"] = _preview_meta("file", asset["content_type"], "file")
|
||||
if profile != "legacy-plaintext":
|
||||
payload["preview"] = {"available": False, "media": "locked", "source": "file"}
|
||||
else:
|
||||
payload["preview"] = _preview_meta("file", asset["content_type"], "file")
|
||||
elif element["kind"] == "external_ref":
|
||||
ref = conn.execute(
|
||||
"SELECT source, external_id, detail FROM external_references WHERE element_id = %s",
|
||||
"""
|
||||
SELECT source, external_id, detail, connector_id, resolution
|
||||
FROM external_references WHERE element_id = %s
|
||||
""",
|
||||
(element["id"],),
|
||||
).fetchone()
|
||||
if ref is not None:
|
||||
detail = dict(ref["detail"] or {})
|
||||
connector_owner = _connector_owner(conn, detail.get("connector_id"))
|
||||
connector_owner = _connector_owner(conn, ref["connector_id"] or detail.get("connector_id"))
|
||||
revealed = actor == element["owner_subject_id"] or (connector_owner is not None and actor == connector_owner)
|
||||
if not revealed:
|
||||
detail = {key: value for key, value in detail.items() if key not in _HIDDEN_SOURCE_FIELDS}
|
||||
external = {"source": ref["source"], "detail": detail}
|
||||
resolution = ref["resolution"] or "unresolved"
|
||||
external = {"source": ref["source"], "detail": detail, "resolution": resolution}
|
||||
if revealed:
|
||||
external["external_id"] = ref["external_id"]
|
||||
payload["external"] = external
|
||||
payload["preview"] = _preview_meta("external_ref", None, ref["source"])
|
||||
from app.sourcebind import resolve_for_read
|
||||
from app.sourceregistry import get_source
|
||||
|
||||
module = get_source(ref["source"])
|
||||
if module is None:
|
||||
payload["preview"] = _preview_meta("external_ref", None, ref["source"])
|
||||
else:
|
||||
resolved = resolve_for_read(conn, element["owner_subject_id"], ref["source"], ref, None)
|
||||
if resolved.code == "ok":
|
||||
payload["preview"] = _preview_meta("external_ref", None, ref["source"])
|
||||
elif actor == element["owner_subject_id"]:
|
||||
payload["preview"] = {"available": False, "media": "unassigned", "source": ref["source"]}
|
||||
else:
|
||||
payload["preview"] = {"available": False, "media": "none", "source": ref["source"]}
|
||||
return payload
|
||||
|
||||
|
||||
@@ -237,7 +265,7 @@ def communication_from_row(conn, binding: dict, element: dict) -> dict:
|
||||
"SELECT source, detail FROM external_references WHERE element_id = %s",
|
||||
(element["id"],),
|
||||
).fetchone()
|
||||
detail = (ref["detail"] or {}) if ref is not None and ref["source"] == "imap" else {}
|
||||
detail = (ref["detail"] or {}) if ref is not None else {}
|
||||
if detail.get("direction") in ("in", "out"):
|
||||
source = detail["direction"]
|
||||
return {"direction": source, "explicit": False}
|
||||
@@ -719,8 +747,23 @@ def matter_contexts(conn, actor: UUID, matter: dict) -> list[dict]:
|
||||
return contexts
|
||||
|
||||
|
||||
def _shared_rooms(conn, kind: str, resource_id: UUID) -> list[dict]:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT r.id, r.name, s.access FROM room_shares s JOIN data_rooms r ON r.id = s.room_id
|
||||
WHERE s.resource_kind = %s AND s.resource_id = %s
|
||||
ORDER BY r.name, r.id
|
||||
""",
|
||||
(kind, resource_id),
|
||||
).fetchall()
|
||||
return [{"id": str(row["id"]), "name": row["name"], "access": row["access"]} for row in rows]
|
||||
|
||||
|
||||
def matter_summary(conn, actor: UUID, matter: dict) -> dict:
|
||||
owner = matter["owner_subject_id"] == actor
|
||||
return {
|
||||
"is_owner": owner,
|
||||
"shared_with": _shared_rooms(conn, "matter", matter["id"]) if owner else [],
|
||||
"id": str(matter["id"]),
|
||||
"title": matter["title"],
|
||||
"status": matter["record_status"],
|
||||
@@ -1003,4 +1046,44 @@ LABELS = {
|
||||
"chapter_moved": "Kapitel umgehängt",
|
||||
"content_order": "Ordnungsart geändert",
|
||||
"content_reordered": "Eigene Reihenfolge geändert",
|
||||
"account_created": "Konto angelegt",
|
||||
"account_renamed": "Kontoname geändert",
|
||||
"account_disabled": "Konto deaktiviert",
|
||||
"account_enabled": "Konto aktiviert",
|
||||
"operator_granted": "Betreiberrolle vergeben",
|
||||
"operator_revoked": "Betreiberrolle entzogen",
|
||||
"password_reset": "Passwort zurückgesetzt",
|
||||
"password_changed": "Passwort geändert",
|
||||
"sessions_revoked": "Sitzungen beendet",
|
||||
"session_started": "Angemeldet",
|
||||
"session_ended": "Abgemeldet",
|
||||
"room_created": "Datenraum angelegt",
|
||||
"room_renamed": "Datenraum umbenannt",
|
||||
"room_archived": "Datenraum archiviert",
|
||||
"room_restored": "Datenraum wieder aktiviert",
|
||||
"membership_added": "Mitglied hinzugefügt",
|
||||
"membership_role_changed": "Raumrolle geändert",
|
||||
"membership_removed": "Mitglied entfernt",
|
||||
"invitation_created": "Einladung erstellt",
|
||||
"invitation_revoked": "Einladung widerrufen",
|
||||
"invitation_accepted": "Einladung angenommen",
|
||||
"visibility_changed": "Raumfreigabe geändert",
|
||||
"employee_promoted": "Mitarbeiter zum Hauptnutzer gemacht",
|
||||
"employee_disabled": "Mitarbeiter-Konto deaktiviert",
|
||||
"employee_enabled": "Mitarbeiter-Konto aktiviert",
|
||||
"employee_password_reset": "Passwort eines Mitarbeiters zurückgesetzt",
|
||||
"employee_removed": "Mitarbeiter aus allen Räumen entfernt",
|
||||
"room_shared": "Mit Datenraum geteilt",
|
||||
"room_share_changed": "Freigabe an Datenraum geändert",
|
||||
"room_unshared": "Freigabe an Datenraum beendet",
|
||||
"person_excluded": "Person von der Raumfreigabe ausgenommen",
|
||||
"person_included": "Person wieder in die Raumfreigabe aufgenommen",
|
||||
"room_source_access_granted": "Originale über eigene Zugänge im Datenraum freigegeben",
|
||||
"room_source_access_revoked": "Originale über eigene Zugänge im Datenraum entzogen",
|
||||
"room_owner_changed": "Eigentümer des Datenraums gewechselt",
|
||||
"room_default_changed": "Voreinstellung des Datenraums geändert",
|
||||
"room_download_policy_changed": "Download-Regel des Datenraums geändert",
|
||||
"download_defaults_changed": "Standard für Downloads geändert",
|
||||
"preference_changed": "Einstellung des Kontos geändert",
|
||||
"external_ref_bound": "Vorhandene Referenz zusätzlich eingebunden",
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
"""Fetching the pictures a mail refers to, on the server and only on request.
|
||||
|
||||
The browser never contacts the sender: the server loads each picture, checks that it really is
|
||||
a PNG, JPEG, GIF or WebP, and hands it over inline. This hides the reader's address and device.
|
||||
It cannot hide that the mail was opened, because the sender sees the request.
|
||||
|
||||
Only public https addresses are fetched. The address is resolved once, every result must be a
|
||||
public one, and the connection goes to exactly that address, so a changing DNS answer cannot
|
||||
lead to an internal host. Redirects are followed a few times with the same checks.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import http.client
|
||||
import ipaddress
|
||||
import socket
|
||||
import ssl
|
||||
from urllib.parse import urljoin, urlsplit
|
||||
|
||||
MAX_IMAGE_BYTES = 1_500_000
|
||||
MAX_REDIRECTS = 3
|
||||
TIMEOUT_SECONDS = 5
|
||||
MAX_IMAGES = 12
|
||||
MAX_TOTAL_BYTES = 6_000_000
|
||||
|
||||
_SIGNATURES = (
|
||||
(b"\x89PNG\r\n\x1a\n", "png"),
|
||||
(b"\xff\xd8\xff", "jpeg"),
|
||||
(b"GIF87a", "gif"),
|
||||
(b"GIF89a", "gif"),
|
||||
)
|
||||
|
||||
|
||||
class _Pinned(http.client.HTTPSConnection):
|
||||
"""An https connection that goes to a fixed, already checked address."""
|
||||
|
||||
def __init__(self, host: str, address: str, port: int) -> None:
|
||||
super().__init__(host, port, timeout=TIMEOUT_SECONDS, context=ssl.create_default_context())
|
||||
self._address = address
|
||||
|
||||
def connect(self) -> None:
|
||||
sock = socket.create_connection((self._address, self.port), self.timeout)
|
||||
self.sock = self._context.wrap_socket(sock, server_hostname=self.host)
|
||||
|
||||
|
||||
def is_public(address: str) -> bool:
|
||||
try:
|
||||
ip = ipaddress.ip_address(address)
|
||||
except ValueError:
|
||||
return False
|
||||
return ip.is_global and not ip.is_multicast
|
||||
|
||||
|
||||
def _public_address(host: str, port: int) -> str | None:
|
||||
try:
|
||||
found = {item[4][0] for item in socket.getaddrinfo(host, port, type=socket.SOCK_STREAM)}
|
||||
except OSError:
|
||||
return None
|
||||
if not found or not all(is_public(address) for address in found):
|
||||
return None
|
||||
return sorted(found)[0]
|
||||
|
||||
|
||||
def _kind(data: bytes) -> str | None:
|
||||
for signature, kind in _SIGNATURES:
|
||||
if data.startswith(signature):
|
||||
return kind
|
||||
if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
|
||||
return "webp"
|
||||
return None
|
||||
|
||||
|
||||
def fetch_image(url: str) -> bytes | None:
|
||||
"""The bytes of a picture, or None when anything about it is not safe."""
|
||||
for _ in range(MAX_REDIRECTS + 1):
|
||||
parts = urlsplit(url)
|
||||
if parts.scheme != "https" or not parts.hostname or parts.username or parts.password:
|
||||
return None
|
||||
port = parts.port or 443
|
||||
if port != 443:
|
||||
return None
|
||||
address = _public_address(parts.hostname, port)
|
||||
if address is None:
|
||||
return None
|
||||
target = (parts.path or "/") + (f"?{parts.query}" if parts.query else "")
|
||||
connection = _Pinned(parts.hostname, address, port)
|
||||
try:
|
||||
connection.request("GET", target, headers={"User-Agent": "Mozilla/5.0", "Accept": "image/png,image/jpeg,image/gif,image/webp", "Connection": "close"})
|
||||
response = connection.getresponse()
|
||||
if response.status in {301, 302, 303, 307, 308}:
|
||||
location = response.getheader("Location")
|
||||
if not location:
|
||||
return None
|
||||
url = urljoin(url, location)
|
||||
continue
|
||||
if response.status != 200:
|
||||
return None
|
||||
data = response.read(MAX_IMAGE_BYTES + 1)
|
||||
except (OSError, http.client.HTTPException, ssl.SSLError):
|
||||
return None
|
||||
finally:
|
||||
connection.close()
|
||||
if len(data) > MAX_IMAGE_BYTES or _kind(data) is None:
|
||||
return None
|
||||
return data
|
||||
return None
|
||||
|
||||
|
||||
class RemoteImages:
|
||||
"""Loads the pictures of one mail within a budget and remembers each address once."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.cache: dict[str, str] = {}
|
||||
self.total = 0
|
||||
self.loaded = 0
|
||||
self.failed = 0
|
||||
|
||||
def __call__(self, url: str) -> str:
|
||||
if url in self.cache:
|
||||
return self.cache[url]
|
||||
result = ""
|
||||
if len(self.cache) < MAX_IMAGES and self.total < MAX_TOTAL_BYTES:
|
||||
data = fetch_image(url)
|
||||
if data is not None:
|
||||
self.total += len(data)
|
||||
result = f"data:image/{_kind(data)};base64,{base64.b64encode(data).decode('ascii')}"
|
||||
self.cache[url] = result
|
||||
if result:
|
||||
self.loaded += 1
|
||||
else:
|
||||
self.failed += 1
|
||||
return result
|
||||
+33
-111
@@ -10,17 +10,12 @@ from dataclasses import dataclass, field
|
||||
from uuid import UUID
|
||||
|
||||
from app.core.errors import Problem
|
||||
from app.mailpack import ParsedMail, identities_match, parse_mail
|
||||
from app.media.storage import asset_path, read_bytes
|
||||
from app.sources import COMPLETE_MAIL_LIMIT, pull_paperless_original, pull_rfc822
|
||||
from app.mailpack import ParsedMail
|
||||
from app.media.port import read_clear_bytes
|
||||
from app.sources import COMPLETE_MAIL_LIMIT
|
||||
|
||||
EXPORT_BYTE_LIMIT = COMPLETE_MAIL_LIMIT
|
||||
|
||||
_TOO_LARGE = (
|
||||
"Die vollständige Nachricht überschreitet die Exportgrenze. "
|
||||
"Eine gekürzte Vorschau wird nicht als Original übernommen."
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class RetrievalFailure:
|
||||
@@ -45,132 +40,59 @@ class MailPayload:
|
||||
|
||||
|
||||
def load_external(conn, actor_id: UUID, element_id: UUID, assigned: UUID | None) -> FilePayload | MailPayload | RetrievalFailure:
|
||||
from app.sourceregistry import get_source
|
||||
|
||||
ref = conn.execute(
|
||||
"SELECT source, external_id, detail FROM external_references WHERE element_id = %s",
|
||||
"""
|
||||
SELECT element_id, source, external_id, detail, connector_id, resolution
|
||||
FROM external_references WHERE element_id = %s
|
||||
""",
|
||||
(element_id,),
|
||||
).fetchone()
|
||||
if ref is None:
|
||||
return RetrievalFailure("missing", "Die Quellenreferenz fehlt.")
|
||||
source = ref["source"]
|
||||
detail = ref["detail"] or {}
|
||||
if source == "paperless":
|
||||
return _load_paperless(conn, actor_id, ref["external_id"], detail, assigned)
|
||||
if source == "imap":
|
||||
return _load_imap(conn, actor_id, ref["external_id"], detail, assigned)
|
||||
if source == "url":
|
||||
return RetrievalFailure("capability", "Für eine Webadresse ist kein Originalabruf vorgesehen.")
|
||||
return RetrievalFailure("capability", "Für diese Quelle ist kein Originalabruf vorgesehen.")
|
||||
module = get_source(ref["source"])
|
||||
if module is None or module.export_original is None:
|
||||
return RetrievalFailure("capability", "Für diese Quelle ist kein Originalabruf vorgesehen.")
|
||||
return module.export_original(conn, actor_id, ref["external_id"], ref["detail"] or {}, assigned, ref)
|
||||
|
||||
|
||||
def load_file(conn, element_id: UUID, media_root: str) -> FilePayload | RetrievalFailure:
|
||||
asset = conn.execute(
|
||||
"""
|
||||
SELECT id, original_filename, content_type, sha256, status
|
||||
SELECT id, original_filename, content_type, sha256, status,
|
||||
storage_instance_id, storage_generation, object_key, protection_profile
|
||||
FROM media_assets WHERE element_id = %s
|
||||
""",
|
||||
(element_id,),
|
||||
).fetchone()
|
||||
if asset is None or asset["status"] != "active":
|
||||
return RetrievalFailure("missing", "Die Originaldatei ist nicht mehr vorhanden.")
|
||||
if (asset["protection_profile"] or "legacy-plaintext") != "legacy-plaintext":
|
||||
return RetrievalFailure(
|
||||
"unsupported",
|
||||
"Dieser Inhalt ist geschützt und kann hier nicht im Klartext gelesen werden.",
|
||||
)
|
||||
try:
|
||||
data = read_bytes(asset_path(media_root, asset["id"]))
|
||||
except Problem:
|
||||
data = read_clear_bytes(
|
||||
conn,
|
||||
instance_id=asset["storage_instance_id"],
|
||||
generation=asset["storage_generation"],
|
||||
object_key=asset["object_key"] or str(asset["id"]),
|
||||
media_root=media_root,
|
||||
protection_profile=asset["protection_profile"],
|
||||
expected_sha256=asset["sha256"],
|
||||
)
|
||||
except Problem as exc:
|
||||
if exc.code == "unsupported":
|
||||
return RetrievalFailure("unsupported", exc.detail)
|
||||
return RetrievalFailure("missing", "Die Originaldatei ist nicht mehr vorhanden.")
|
||||
if len(data) > EXPORT_BYTE_LIMIT:
|
||||
return RetrievalFailure("too_large", "Die Originaldatei ist für den Export zu groß.")
|
||||
return FilePayload(asset["original_filename"], asset["content_type"], data, asset["sha256"])
|
||||
|
||||
|
||||
def _load_paperless(conn, actor_id: UUID, external_id: str, detail: dict, assigned: UUID | None):
|
||||
stored = _uuid(detail.get("connector_id"))
|
||||
resolved = _resolve_connector(conn, actor_id, "paperless", stored, assigned)
|
||||
if isinstance(resolved, RetrievalFailure):
|
||||
return resolved
|
||||
try:
|
||||
data, media, name = pull_paperless_original(
|
||||
resolved["settings"]["base_url"].rstrip("/"),
|
||||
resolved["secret"],
|
||||
str(external_id),
|
||||
EXPORT_BYTE_LIMIT,
|
||||
)
|
||||
except Problem as exc:
|
||||
return _from_problem(exc)
|
||||
if len(data) > EXPORT_BYTE_LIMIT:
|
||||
return RetrievalFailure("too_large", "Die Originaldatei ist für den Export zu groß.")
|
||||
return FilePayload(name or f"paperless-{external_id}", media, data, "")
|
||||
|
||||
|
||||
def _load_imap(conn, actor_id: UUID, external_id: str, detail: dict, assigned: UUID | None):
|
||||
stored = _uuid(detail.get("connector_id"))
|
||||
resolved = _resolve_connector(conn, actor_id, "imap", stored, assigned)
|
||||
if isinstance(resolved, RetrievalFailure):
|
||||
return resolved
|
||||
mailbox = str(detail.get("mailbox") or "").strip()
|
||||
uid = detail.get("uid")
|
||||
if isinstance(uid, str) and uid.isdigit():
|
||||
uid = int(uid)
|
||||
if not mailbox or isinstance(uid, bool) or not isinstance(uid, int) or uid < 1:
|
||||
return RetrievalFailure("identity", "Für diese E-Mail fehlt die Zuordnung zu Fach und Nachricht.")
|
||||
try:
|
||||
raw = pull_rfc822(resolved["settings"], resolved["secret"], mailbox, uid, str(external_id), EXPORT_BYTE_LIMIT)
|
||||
except Problem as exc:
|
||||
return _from_problem(exc)
|
||||
if len(raw) > EXPORT_BYTE_LIMIT:
|
||||
return RetrievalFailure("too_large", _TOO_LARGE)
|
||||
parsed = parse_mail(raw)
|
||||
if not identities_match(parsed.message_id, str(external_id)):
|
||||
return RetrievalFailure("identity", "Die gefundene Nachricht ist nicht die referenzierte E-Mail.")
|
||||
if parsed.missing:
|
||||
names = ", ".join(parsed.missing[:5])
|
||||
return RetrievalFailure("attachment", f"Eine Anlage der E-Mail ließ sich nicht vollständig lesen: {names}.")
|
||||
return MailPayload(raw, parsed)
|
||||
|
||||
|
||||
def _resolve_connector(conn, actor_id: UUID, kind: str, stored: UUID | None, assigned: UUID | None):
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT id, kind, name, settings, secret
|
||||
FROM connectors
|
||||
WHERE owner_id = %s AND kind = %s
|
||||
ORDER BY name, id
|
||||
""",
|
||||
(actor_id, kind),
|
||||
).fetchall()
|
||||
if stored is not None and assigned is None:
|
||||
match = next((row for row in rows if row["id"] == stored), None)
|
||||
if match is None:
|
||||
return RetrievalFailure("missing", "Der gespeicherte Zugang für diese Quelle ist nicht mehr vorhanden.")
|
||||
return match
|
||||
chosen = assigned or stored
|
||||
if chosen is not None:
|
||||
match = next((row for row in rows if row["id"] == chosen), None)
|
||||
if match is None:
|
||||
return RetrievalFailure(
|
||||
"assignment",
|
||||
"Der gewählte Zugang gehört nicht zu diesem Konto oder passt nicht zur Quelle.",
|
||||
)
|
||||
return match
|
||||
if len(rows) == 1:
|
||||
return rows[0]
|
||||
if not rows:
|
||||
return RetrievalFailure("missing", "Für diese Quelle ist kein Zugang vorhanden.")
|
||||
return RetrievalFailure(
|
||||
"ambiguous",
|
||||
"Für diese Quelle ist kein eindeutiger Zugang zugeordnet. Die Zuordnung muss bewusst gewählt werden.",
|
||||
tuple({"id": str(row["id"]), "name": row["name"]} for row in rows),
|
||||
)
|
||||
|
||||
|
||||
def _uuid(value) -> UUID | None:
|
||||
if not value:
|
||||
return None
|
||||
try:
|
||||
return UUID(str(value))
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def _from_problem(exc: Problem) -> RetrievalFailure:
|
||||
def failure_from_problem(exc: Problem) -> RetrievalFailure:
|
||||
text = exc.detail
|
||||
lowered = text.casefold()
|
||||
if "exportgrenze" in lowered or "zu groß" in lowered:
|
||||
|
||||
+3
-3
@@ -87,11 +87,11 @@ def seed_demo(settings: Settings | None = None) -> bool:
|
||||
ben = create_account(conn, BEN_EMAIL, "Ben Beispiel", BEN_PASSWORD, origin="fixture")
|
||||
room = conn.execute(
|
||||
"""
|
||||
INSERT INTO data_rooms (id, kind, name, created_by)
|
||||
VALUES (gen_random_uuid(), 'organization', 'Haushalt Musterstraße', %s)
|
||||
INSERT INTO data_rooms (id, kind, name, created_by, owner_id)
|
||||
VALUES (gen_random_uuid(), 'organization', 'Haushalt Musterstraße', %s, %s)
|
||||
RETURNING id
|
||||
""",
|
||||
(ada["id"],),
|
||||
(ada["id"], ada["id"]),
|
||||
).fetchone()
|
||||
conn.execute(
|
||||
"INSERT INTO room_memberships (room_id, subject_id, role) VALUES (%s, %s, 'manager'), (%s, %s, 'member')",
|
||||
|
||||
@@ -0,0 +1,138 @@
|
||||
"""Rights stay in one place. A source module only fetches its own bytes."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from uuid import UUID
|
||||
|
||||
import psycopg
|
||||
|
||||
from app.access.policy import Ctx, audit, mediated_source_owner
|
||||
from app.core.errors import Problem, not_found, unprocessable
|
||||
from app.sourcebind import resolve_for_read
|
||||
|
||||
ORIGINAL_UNAVAILABLE = "Das Original ist über die Freigabe nicht abrufbar."
|
||||
|
||||
|
||||
@dataclass
|
||||
class BorrowedOriginal:
|
||||
row: dict
|
||||
external_id: str
|
||||
mediated: bool
|
||||
actor_id: UUID
|
||||
owner_id: UUID
|
||||
element: dict
|
||||
context: Ctx | None
|
||||
kind: str
|
||||
|
||||
|
||||
def release_for_external(conn) -> None:
|
||||
"""External calls must not sit inside an open domain transaction."""
|
||||
if conn.info.transaction_status != psycopg.pq.TransactionStatus.IDLE:
|
||||
conn.commit()
|
||||
|
||||
|
||||
def connector_owner(conn, connector_id: UUID | None) -> UUID | None:
|
||||
if connector_id is None:
|
||||
return None
|
||||
row = conn.execute("SELECT owner_id FROM connectors WHERE id = %s", (connector_id,)).fetchone()
|
||||
return row["owner_id"] if row else None
|
||||
|
||||
|
||||
def assert_still_owned(conn, connector_id, owner_id: UUID) -> None:
|
||||
row = conn.execute(
|
||||
"SELECT id FROM connectors WHERE id = %s AND owner_id = %s",
|
||||
(connector_id, owner_id),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise not_found()
|
||||
|
||||
|
||||
def audit_mediated(conn, actor_id: UUID, element: dict, context: Ctx | None, source: str, connector_id, outcome: str) -> None:
|
||||
audit(
|
||||
conn,
|
||||
actor_id,
|
||||
element["home_scope_id"],
|
||||
"source_read_mediated",
|
||||
"element",
|
||||
element["id"],
|
||||
context,
|
||||
result="ok" if outcome == "ok" else "unavailable",
|
||||
detail={
|
||||
"source": source,
|
||||
"connector_id": str(connector_id) if connector_id else None,
|
||||
"outcome": outcome,
|
||||
},
|
||||
)
|
||||
if outcome != "ok":
|
||||
conn.commit()
|
||||
|
||||
|
||||
def _uuid(value) -> UUID | None:
|
||||
if isinstance(value, UUID):
|
||||
return value
|
||||
try:
|
||||
return UUID(str(value))
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def borrow_original(conn, actor_id: UUID, element: dict, context: Ctx | None, ref, kind: str) -> BorrowedOriginal:
|
||||
"""Resolve the owner's connector. A grantee never supplies another account's connector."""
|
||||
detail = (ref or {}).get("detail") or {}
|
||||
external_id = str((ref or {}).get("external_id") or "")
|
||||
stored = _uuid(detail.get("connector_id")) or _uuid((ref or {}).get("connector_id"))
|
||||
stored_owner = connector_owner(conn, stored)
|
||||
mediated = not (element["owner_subject_id"] == actor_id or stored_owner == actor_id)
|
||||
if mediated:
|
||||
owner_id = mediated_source_owner(conn, actor_id, element, context)
|
||||
if owner_id is None:
|
||||
raise unprocessable(ORIGINAL_UNAVAILABLE)
|
||||
else:
|
||||
owner_id = actor_id
|
||||
result = resolve_for_read(conn, owner_id, kind, ref, None)
|
||||
if result.row is None:
|
||||
if mediated:
|
||||
audit_mediated(conn, actor_id, element, context, kind, stored, "unavailable")
|
||||
raise unprocessable(ORIGINAL_UNAVAILABLE)
|
||||
raise unprocessable(result.message)
|
||||
return BorrowedOriginal(
|
||||
row=result.row,
|
||||
external_id=external_id,
|
||||
mediated=mediated,
|
||||
actor_id=actor_id,
|
||||
owner_id=owner_id,
|
||||
element=element,
|
||||
context=context,
|
||||
kind=kind,
|
||||
)
|
||||
|
||||
|
||||
def _recheck(conn, borrowed: BorrowedOriginal) -> None:
|
||||
if borrowed.mediated:
|
||||
owner_id = mediated_source_owner(conn, borrowed.actor_id, borrowed.element, borrowed.context)
|
||||
if owner_id != borrowed.owner_id:
|
||||
audit_mediated(conn, borrowed.actor_id, borrowed.element, borrowed.context, borrowed.kind, borrowed.row["id"], "unavailable")
|
||||
raise unprocessable(ORIGINAL_UNAVAILABLE)
|
||||
row = conn.execute("SELECT owner_id FROM connectors WHERE id = %s", (borrowed.row["id"],)).fetchone()
|
||||
if row is None or row["owner_id"] != borrowed.owner_id:
|
||||
if borrowed.mediated:
|
||||
audit_mediated(conn, borrowed.actor_id, borrowed.element, borrowed.context, borrowed.kind, borrowed.row["id"], "unavailable")
|
||||
raise unprocessable(ORIGINAL_UNAVAILABLE)
|
||||
raise not_found()
|
||||
|
||||
|
||||
def complete_borrow(conn, borrowed: BorrowedOriginal, fetch):
|
||||
"""Run the adapter fetch outside the open transaction, then check the grant again."""
|
||||
release_for_external(conn)
|
||||
try:
|
||||
value = fetch(borrowed.row)
|
||||
except Problem:
|
||||
if borrowed.mediated:
|
||||
audit_mediated(conn, borrowed.actor_id, borrowed.element, borrowed.context, borrowed.kind, borrowed.row["id"], "unavailable")
|
||||
raise unprocessable(ORIGINAL_UNAVAILABLE) from None
|
||||
raise
|
||||
_recheck(conn, borrowed)
|
||||
if borrowed.mediated:
|
||||
audit_mediated(conn, borrowed.actor_id, borrowed.element, borrowed.context, borrowed.kind, borrowed.row["id"], "ok")
|
||||
return value
|
||||
@@ -0,0 +1,258 @@
|
||||
"""Bind a reference to one connector instance.
|
||||
|
||||
The newest connection is never a fallback. A stored id that no longer
|
||||
exists stays missing. Ambiguous stock waits for an explicit assignment.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from uuid import UUID
|
||||
|
||||
from psycopg.types.json import Json
|
||||
|
||||
from app.access.policy import get_element
|
||||
from app.core.errors import not_found, unprocessable
|
||||
from app.sourceregistry import get_source
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ResolveResult:
|
||||
row: dict | None
|
||||
code: str
|
||||
message: str
|
||||
choices: tuple[dict, ...] = ()
|
||||
|
||||
|
||||
def _uuid(value) -> UUID | None:
|
||||
if isinstance(value, UUID):
|
||||
return value
|
||||
if not value:
|
||||
return None
|
||||
try:
|
||||
return UUID(str(value))
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def stored_id(ref) -> UUID | None:
|
||||
if not ref:
|
||||
return None
|
||||
detail = ref["detail"] if "detail" in ref.keys() else None
|
||||
detail = detail or {}
|
||||
return _uuid(detail.get("connector_id")) or _uuid(ref["connector_id"] if "connector_id" in ref.keys() else None)
|
||||
|
||||
|
||||
def _connectors(conn, owner_id: UUID, kind: str) -> list[dict]:
|
||||
return conn.execute(
|
||||
"""
|
||||
SELECT id, owner_id, kind, name, settings, secret
|
||||
FROM connectors
|
||||
WHERE owner_id = %s AND kind = %s
|
||||
ORDER BY name, id
|
||||
""",
|
||||
(owner_id, kind),
|
||||
).fetchall()
|
||||
|
||||
|
||||
def resolve_for_read(conn, owner_id: UUID, kind: str, ref, assigned: UUID | None) -> ResolveResult:
|
||||
"""Resolve one access. Assignment applies only when the reference has no stored id."""
|
||||
stored = stored_id(ref)
|
||||
resolution = (ref["resolution"] if ref and "resolution" in ref.keys() and ref["resolution"] else None) or "unresolved"
|
||||
rows = _connectors(conn, owner_id, kind)
|
||||
if stored is not None:
|
||||
match = next((row for row in rows if row["id"] == stored), None)
|
||||
if match is None:
|
||||
return ResolveResult(None, "missing", "Der gespeicherte Zugang für diese Quelle ist nicht mehr vorhanden.")
|
||||
return ResolveResult(match, "ok", "")
|
||||
if assigned is not None:
|
||||
match = next((row for row in rows if row["id"] == assigned), None)
|
||||
if match is None:
|
||||
return ResolveResult(
|
||||
None,
|
||||
"assignment",
|
||||
"Der gewählte Zugang gehört nicht zu diesem Konto oder passt nicht zur Quelle.",
|
||||
)
|
||||
return ResolveResult(match, "ok", "")
|
||||
if resolution == "ambiguous" or len(rows) != 1:
|
||||
if not rows:
|
||||
return ResolveResult(None, "missing", "Für diese Quelle ist kein Zugang vorhanden.")
|
||||
return ResolveResult(
|
||||
None,
|
||||
"ambiguous",
|
||||
"Für diese Quelle ist kein eindeutiger Zugang zugeordnet. Die Zuordnung muss bewusst gewählt werden.",
|
||||
tuple({"id": str(row["id"]), "name": row["name"]} for row in rows),
|
||||
)
|
||||
return ResolveResult(rows[0], "ok", "")
|
||||
|
||||
|
||||
def _set_binding(conn, element_id: UUID, connector_id: UUID | None, resolution: str, detail: dict | None = None) -> None:
|
||||
if detail is None:
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE external_references
|
||||
SET connector_id = %s, resolution = %s
|
||||
WHERE element_id = %s
|
||||
""",
|
||||
(connector_id, resolution, element_id),
|
||||
)
|
||||
return
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE external_references
|
||||
SET connector_id = %s, resolution = %s, detail = %s
|
||||
WHERE element_id = %s
|
||||
""",
|
||||
(connector_id, resolution, Json(detail), element_id),
|
||||
)
|
||||
|
||||
|
||||
def attach_new_reference(conn, element_id: UUID) -> None:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT er.source, er.detail, e.owner_subject_id
|
||||
FROM external_references er
|
||||
JOIN elements e ON e.id = er.element_id
|
||||
WHERE er.element_id = %s
|
||||
""",
|
||||
(element_id,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return
|
||||
if get_source(row["source"]) is None:
|
||||
_set_binding(conn, element_id, None, "none")
|
||||
return
|
||||
detail = dict(row["detail"] or {})
|
||||
stored = _uuid(detail.get("connector_id"))
|
||||
if stored is not None:
|
||||
match = conn.execute(
|
||||
"""
|
||||
SELECT id FROM connectors
|
||||
WHERE id = %s AND owner_id = %s AND kind = %s
|
||||
""",
|
||||
(stored, row["owner_subject_id"], row["source"]),
|
||||
).fetchone()
|
||||
_set_binding(conn, element_id, stored, "bound" if match else "unresolved")
|
||||
return
|
||||
rows = _connectors(conn, row["owner_subject_id"], row["source"])
|
||||
if len(rows) == 1:
|
||||
detail["connector_id"] = str(rows[0]["id"])
|
||||
_set_binding(conn, element_id, rows[0]["id"], "bound", detail)
|
||||
return
|
||||
if len(rows) > 1:
|
||||
_set_binding(conn, element_id, None, "ambiguous")
|
||||
return
|
||||
_set_binding(conn, element_id, None, "unresolved")
|
||||
|
||||
|
||||
def backfill_source_bindings(conn) -> None:
|
||||
"""Idempotent. Unique stock is bound once. A stored id is never retargeted.
|
||||
|
||||
Startup calls this before the application has imported the connector
|
||||
modules. Register them first, otherwise every existing reference stays
|
||||
unresolved and the case or matter can no longer open its originals.
|
||||
"""
|
||||
from app.sources import _install_sources
|
||||
|
||||
_install_sources()
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE external_references
|
||||
SET resolution = 'none'
|
||||
WHERE source = 'url' AND resolution = 'unresolved'
|
||||
"""
|
||||
)
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT er.element_id, er.source, er.detail, e.owner_subject_id
|
||||
FROM external_references er
|
||||
JOIN elements e ON e.id = er.element_id
|
||||
WHERE er.source <> 'url'
|
||||
AND er.resolution IN ('unresolved', 'ambiguous')
|
||||
AND er.connector_id IS NULL
|
||||
"""
|
||||
).fetchall()
|
||||
for row in rows:
|
||||
if get_source(row["source"]) is None:
|
||||
continue
|
||||
detail = dict(row["detail"] or {})
|
||||
stored = _uuid(detail.get("connector_id"))
|
||||
if stored is not None:
|
||||
match = conn.execute(
|
||||
"""
|
||||
SELECT id FROM connectors
|
||||
WHERE id = %s AND owner_id = %s AND kind = %s
|
||||
""",
|
||||
(stored, row["owner_subject_id"], row["source"]),
|
||||
).fetchone()
|
||||
_set_binding(conn, row["element_id"], stored, "bound" if match else "unresolved")
|
||||
continue
|
||||
found = _connectors(conn, row["owner_subject_id"], row["source"])
|
||||
if len(found) == 1:
|
||||
detail["connector_id"] = str(found[0]["id"])
|
||||
_set_binding(conn, row["element_id"], found[0]["id"], "bound", detail)
|
||||
elif len(found) > 1:
|
||||
_set_binding(conn, row["element_id"], None, "ambiguous")
|
||||
|
||||
|
||||
def assign_reference(conn, actor_id: UUID, element_id: UUID, connector_id: UUID) -> None:
|
||||
element = get_element(conn, element_id)
|
||||
if element is None or element["kind"] != "external_ref" or element["owner_subject_id"] != actor_id:
|
||||
raise not_found()
|
||||
ref = conn.execute(
|
||||
"SELECT source, detail FROM external_references WHERE element_id = %s",
|
||||
(element_id,),
|
||||
).fetchone()
|
||||
if ref is None or get_source(ref["source"]) is None:
|
||||
raise unprocessable("Diese Referenz hat keinen Quellzugang.")
|
||||
connector = conn.execute(
|
||||
"""
|
||||
SELECT id, kind FROM connectors
|
||||
WHERE id = %s AND owner_id = %s
|
||||
""",
|
||||
(connector_id, actor_id),
|
||||
).fetchone()
|
||||
if connector is None or connector["kind"] != ref["source"]:
|
||||
raise unprocessable("Der Zugang gehört nicht zu diesem Konto oder passt nicht zur Quelle.")
|
||||
detail = dict(ref["detail"] or {})
|
||||
detail["connector_id"] = str(connector_id)
|
||||
_set_binding(conn, element_id, connector_id, "bound", detail)
|
||||
|
||||
|
||||
def remember_imap_location(
|
||||
conn,
|
||||
element_id: UUID,
|
||||
external_id: str,
|
||||
previous_mailbox: str,
|
||||
previous_uid: int,
|
||||
mailbox: str,
|
||||
uid: int,
|
||||
) -> None:
|
||||
"""Store the folder and UID of a message found at a new place.
|
||||
|
||||
Only the previous place is replaced. The message identity, the connector
|
||||
and an adopted direction stay as they were.
|
||||
"""
|
||||
if (
|
||||
not mailbox
|
||||
or any(char in mailbox for char in "\r\n\x00")
|
||||
or uid < 1
|
||||
or (mailbox == previous_mailbox and uid == previous_uid)
|
||||
):
|
||||
return
|
||||
conn.execute(
|
||||
"""
|
||||
UPDATE external_references
|
||||
SET detail = jsonb_set(
|
||||
jsonb_set(detail, '{mailbox}', to_jsonb(%s::text)),
|
||||
'{uid}',
|
||||
to_jsonb(%s::bigint)
|
||||
)
|
||||
WHERE element_id = %s
|
||||
AND source = 'imap'
|
||||
AND external_id = %s
|
||||
AND detail->>'mailbox' = %s
|
||||
AND detail->>'uid' = %s
|
||||
""",
|
||||
(mailbox, uid, element_id, external_id, previous_mailbox, str(previous_uid)),
|
||||
)
|
||||
@@ -0,0 +1,50 @@
|
||||
"""Declared editor capabilities and the payloads that carry them.
|
||||
|
||||
The capabilities of a source belong to its module. A filter is offered only when that module implements it.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
EDITORS = {
|
||||
"note": True,
|
||||
"markdown_file": False,
|
||||
}
|
||||
|
||||
|
||||
def capability_payload() -> dict:
|
||||
from app.sourceregistry import registered_sources
|
||||
|
||||
return {
|
||||
"sources": [module.capabilities for module in registered_sources()],
|
||||
"modules": [
|
||||
{
|
||||
"kind": module.kind,
|
||||
"label": module.label,
|
||||
"representation": module.representation,
|
||||
"config_fields": [item.public() for item in module.config_fields],
|
||||
}
|
||||
for module in registered_sources()
|
||||
],
|
||||
"editors": EDITORS,
|
||||
"protection_profiles": {
|
||||
"legacy-plaintext": "cleartext",
|
||||
"managed-encrypted": "locked",
|
||||
"client-encrypted": "locked",
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def with_capabilities(kind: str, connector_id: str, payload: dict) -> dict:
|
||||
from app.sourceregistry import require_source
|
||||
|
||||
body = dict(payload)
|
||||
spec = require_source(kind).capabilities
|
||||
body["connector_id"] = connector_id
|
||||
body["capabilities"] = spec
|
||||
body["unsupported"] = [name for name, enabled in spec["search"].items() if not enabled]
|
||||
if spec["search"].get("continuation"):
|
||||
body["continuation"] = body.get("next_before") if body.get("next_before") is not None else body.get("next_page")
|
||||
else:
|
||||
body["continuation"] = None
|
||||
body["incomplete"] = bool(body.get("incomplete"))
|
||||
return body
|
||||
@@ -0,0 +1,167 @@
|
||||
"""Registered source modules. Unknown kinds are rejected, not guessed."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Callable
|
||||
|
||||
from app.core.errors import unprocessable
|
||||
|
||||
FIELD_TYPES = ("text", "url", "number", "password", "select")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ConfigField:
|
||||
"""One configuration field a module declares for its connector instances.
|
||||
|
||||
At most one field per module is a secret. Its value is stored apart from
|
||||
the settings and is never handed out again.
|
||||
"""
|
||||
|
||||
key: str
|
||||
label: str
|
||||
type: str = "text"
|
||||
required: bool = False
|
||||
secret: bool = False
|
||||
default: str | int | None = None
|
||||
options: tuple[tuple[str, str], ...] = ()
|
||||
help: str = ""
|
||||
placeholder: str = ""
|
||||
minimum: int | None = None
|
||||
maximum: int | None = None
|
||||
max_length: int = 200
|
||||
|
||||
def public(self) -> dict:
|
||||
return {
|
||||
"key": self.key,
|
||||
"label": self.label,
|
||||
"type": self.type,
|
||||
"required": self.required,
|
||||
"secret": self.secret,
|
||||
"default": self.default,
|
||||
"options": [{"value": value, "label": label} for value, label in self.options],
|
||||
"help": self.help,
|
||||
"placeholder": self.placeholder,
|
||||
"minimum": self.minimum,
|
||||
"maximum": self.maximum,
|
||||
"max_length": self.max_length,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class SourceModule:
|
||||
kind: str
|
||||
label: str
|
||||
representation: str
|
||||
capabilities: dict
|
||||
probe: Callable
|
||||
find: Callable
|
||||
open_original: Callable
|
||||
export_original: Callable
|
||||
# A module either declares fields (generic validation) or parses the payload itself.
|
||||
parse_config: Callable[[dict], tuple[str, dict, str]] | None = None
|
||||
config_fields: tuple[ConfigField, ...] = ()
|
||||
normalize_config: Callable[[dict, str], dict] | None = None
|
||||
navigate: Callable | None = None
|
||||
preview: Callable | None = None
|
||||
facets: Callable | None = None
|
||||
# Query parameter of a search, mapped to the capability flag that must be true for it.
|
||||
# The module owns its filter names. Anything not declared here is refused.
|
||||
search_params: dict[str, str] = field(default_factory=dict)
|
||||
# thumbnail(conn, owner_id, connector_id, item) -> (bytes, media type), when the module declares it.
|
||||
thumbnail: Callable | None = None
|
||||
|
||||
|
||||
_MODULES: dict[str, SourceModule] = {}
|
||||
|
||||
|
||||
def register_source(module: SourceModule) -> None:
|
||||
if module.parse_config is None and not module.config_fields:
|
||||
raise ValueError(f"Quelle {module.kind} braucht Konfigurationsfelder oder parse_config.")
|
||||
if sum(1 for item in module.config_fields if item.secret) > 1:
|
||||
raise ValueError(f"Quelle {module.kind} darf höchstens ein Geheimnisfeld haben.")
|
||||
for item in module.config_fields:
|
||||
if item.type not in FIELD_TYPES:
|
||||
raise ValueError(f"Feldtyp {item.type} ist unbekannt.")
|
||||
_MODULES[module.kind] = module
|
||||
|
||||
|
||||
def unregister_source(kind: str) -> None:
|
||||
_MODULES.pop(kind, None)
|
||||
|
||||
|
||||
def registered_sources() -> list[SourceModule]:
|
||||
return list(_MODULES.values())
|
||||
|
||||
|
||||
def get_source(kind: str) -> SourceModule | None:
|
||||
return _MODULES.get(kind)
|
||||
|
||||
|
||||
def require_source(kind: str) -> SourceModule:
|
||||
module = _MODULES.get(kind)
|
||||
if module is None:
|
||||
raise unprocessable("Diese Quelle ist nicht registriert.")
|
||||
return module
|
||||
|
||||
|
||||
def accepts_reference(source: str) -> bool:
|
||||
return source == "url" or source in _MODULES
|
||||
|
||||
|
||||
def _blank(value) -> bool:
|
||||
return value is None or (isinstance(value, str) and not value.strip())
|
||||
|
||||
|
||||
def _coerce(field: ConfigField, value):
|
||||
if field.type == "number":
|
||||
try:
|
||||
number = int(str(value).strip())
|
||||
except (TypeError, ValueError):
|
||||
raise unprocessable(f"{field.label} muss eine ganze Zahl sein.") from None
|
||||
if field.minimum is not None and number < field.minimum:
|
||||
raise unprocessable(f"{field.label} ist zu klein.")
|
||||
if field.maximum is not None and number > field.maximum:
|
||||
raise unprocessable(f"{field.label} ist zu groß.")
|
||||
return number
|
||||
text = str(value) if field.secret else str(value).strip()
|
||||
if len(text) > field.max_length:
|
||||
raise unprocessable(f"{field.label} ist zu lang.")
|
||||
if field.type == "select" and text not in {option for option, _label in field.options}:
|
||||
raise unprocessable(f"{field.label} ist keine zulässige Auswahl.")
|
||||
return text
|
||||
|
||||
|
||||
def parse_fields(
|
||||
fields: tuple[ConfigField, ...],
|
||||
values: dict,
|
||||
current_settings: dict | None = None,
|
||||
current_secret: str = "",
|
||||
) -> tuple[dict, str]:
|
||||
"""Validate declared fields. Unknown keys are refused, a blank secret keeps the stored one."""
|
||||
known = {item.key for item in fields}
|
||||
extra = sorted(key for key, value in values.items() if key not in known and not _blank(value))
|
||||
if extra:
|
||||
raise unprocessable("Unbekanntes Konfigurationsfeld: " + ", ".join(extra[:3]) + ".")
|
||||
current_settings = current_settings or {}
|
||||
settings: dict = {}
|
||||
secret = current_secret
|
||||
for item in fields:
|
||||
raw = values.get(item.key)
|
||||
if item.secret:
|
||||
if _blank(raw):
|
||||
if not current_secret and item.required:
|
||||
raise unprocessable(f"{item.label} fehlt.")
|
||||
continue
|
||||
secret = _coerce(item, raw)
|
||||
continue
|
||||
if _blank(raw):
|
||||
raw = current_settings.get(item.key)
|
||||
if _blank(raw):
|
||||
raw = item.default
|
||||
if _blank(raw):
|
||||
if item.required:
|
||||
raise unprocessable(f"{item.label} fehlt.")
|
||||
continue
|
||||
settings[item.key] = _coerce(item, raw)
|
||||
return settings, secret
|
||||
+1446
-222
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,66 @@
|
||||
-- Source instance binding and opaque storage generation.
|
||||
-- Connector ids are not a foreign key: deleting an access must not
|
||||
-- retarget or remove an existing reference.
|
||||
-- The legacy root path is bound in the migrator, not in this file.
|
||||
|
||||
CREATE TABLE storage_instances (
|
||||
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
kind text NOT NULL,
|
||||
generation text NOT NULL,
|
||||
root_path text,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
CONSTRAINT storage_instances_kind CHECK (kind IN ('local')),
|
||||
CONSTRAINT storage_instances_generation UNIQUE (generation),
|
||||
CONSTRAINT storage_instances_generation_len CHECK (char_length(generation) BETWEEN 1 AND 80)
|
||||
);
|
||||
|
||||
ALTER TABLE media_assets
|
||||
ADD COLUMN storage_instance_id uuid REFERENCES storage_instances (id),
|
||||
ADD COLUMN storage_generation text,
|
||||
ADD COLUMN object_key text,
|
||||
ADD COLUMN content_revision text,
|
||||
ADD COLUMN protection_profile text NOT NULL DEFAULT 'legacy-plaintext',
|
||||
ADD COLUMN key_responsibility text NOT NULL DEFAULT 'none',
|
||||
ADD CONSTRAINT media_assets_protection CHECK (
|
||||
protection_profile IN ('legacy-plaintext', 'managed-encrypted', 'client-encrypted')
|
||||
),
|
||||
ADD CONSTRAINT media_assets_key_responsibility CHECK (
|
||||
key_responsibility IN ('none', 'operator', 'client')
|
||||
);
|
||||
|
||||
ALTER TABLE dispatch_snapshots
|
||||
ADD COLUMN storage_instance_id uuid REFERENCES storage_instances (id),
|
||||
ADD COLUMN storage_generation text,
|
||||
ADD COLUMN object_key text,
|
||||
ADD COLUMN content_revision text,
|
||||
ADD COLUMN protection_profile text NOT NULL DEFAULT 'legacy-plaintext',
|
||||
ADD COLUMN key_responsibility text NOT NULL DEFAULT 'none',
|
||||
ADD CONSTRAINT dispatch_snapshots_protection CHECK (
|
||||
protection_profile IN ('legacy-plaintext', 'managed-encrypted', 'client-encrypted')
|
||||
),
|
||||
ADD CONSTRAINT dispatch_snapshots_key_responsibility CHECK (
|
||||
key_responsibility IN ('none', 'operator', 'client')
|
||||
);
|
||||
|
||||
UPDATE media_assets
|
||||
SET storage_generation = 'legacy-local-1',
|
||||
object_key = id::text,
|
||||
content_revision = id::text,
|
||||
protection_profile = 'legacy-plaintext',
|
||||
key_responsibility = 'none'
|
||||
WHERE object_key IS NULL;
|
||||
|
||||
UPDATE dispatch_snapshots
|
||||
SET storage_generation = 'legacy-local-1',
|
||||
object_key = 'dispatch/' || id::text,
|
||||
content_revision = id::text,
|
||||
protection_profile = 'legacy-plaintext',
|
||||
key_responsibility = 'none'
|
||||
WHERE object_key IS NULL;
|
||||
|
||||
ALTER TABLE external_references
|
||||
ADD COLUMN connector_id uuid,
|
||||
ADD COLUMN resolution text NOT NULL DEFAULT 'unresolved',
|
||||
ADD CONSTRAINT external_references_resolution CHECK (
|
||||
resolution IN ('bound', 'ambiguous', 'unresolved', 'none')
|
||||
);
|
||||
@@ -0,0 +1,5 @@
|
||||
-- Connector kinds are validated by the registered source modules.
|
||||
-- A database checklist must not grow for every additional source.
|
||||
|
||||
ALTER TABLE connectors DROP CONSTRAINT IF EXISTS connectors_kind;
|
||||
ALTER TABLE external_references DROP CONSTRAINT IF EXISTS external_references_source;
|
||||
@@ -0,0 +1,8 @@
|
||||
-- Last connection check per connector instance. Display only: it grants nothing
|
||||
-- and carries no secret.
|
||||
|
||||
ALTER TABLE connectors
|
||||
ADD COLUMN last_probe_at timestamptz,
|
||||
ADD COLUMN last_probe_ok boolean,
|
||||
ADD COLUMN last_probe_detail text,
|
||||
ADD CONSTRAINT connectors_probe_detail_len CHECK (last_probe_detail IS NULL OR char_length(last_probe_detail) <= 300);
|
||||
@@ -0,0 +1,31 @@
|
||||
-- Benutzerverwaltung: Kontostatus, Sitzungsübersicht, persistente Login-Begrenzung,
|
||||
-- Raumrolle "Leser" und Rollen in Einladungen. Bestehende Zeilen bleiben gültig.
|
||||
|
||||
ALTER TABLE auth_accounts
|
||||
ADD COLUMN must_change_password boolean NOT NULL DEFAULT false,
|
||||
ADD COLUMN password_changed_at timestamptz,
|
||||
ADD COLUMN last_login_at timestamptz,
|
||||
ADD COLUMN disabled_at timestamptz,
|
||||
ADD COLUMN disabled_by uuid REFERENCES auth_accounts (id);
|
||||
|
||||
ALTER TABLE auth_sessions
|
||||
ADD COLUMN last_seen_at timestamptz,
|
||||
ADD COLUMN label text,
|
||||
ADD CONSTRAINT auth_sessions_label_len CHECK (label IS NULL OR char_length(label) <= 80);
|
||||
|
||||
-- Der Bucket ist ein Hash aus Adresse und E-Mail. Die Roh-E-Mail wird nie gespeichert.
|
||||
CREATE TABLE auth_login_attempts (
|
||||
bucket text NOT NULL,
|
||||
attempted_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE INDEX auth_login_attempts_bucket ON auth_login_attempts (bucket, attempted_at);
|
||||
|
||||
ALTER TABLE room_memberships DROP CONSTRAINT room_memberships_role;
|
||||
ALTER TABLE room_memberships
|
||||
ADD CONSTRAINT room_memberships_role CHECK (role IN ('member', 'manager', 'reader'));
|
||||
|
||||
ALTER TABLE auth_invitations
|
||||
ADD COLUMN role text NOT NULL DEFAULT 'member',
|
||||
ADD COLUMN revoked_at timestamptz,
|
||||
ADD CONSTRAINT auth_invitations_role CHECK (role IN ('member', 'manager', 'reader'));
|
||||
@@ -0,0 +1,21 @@
|
||||
-- Raum-Eigentümer und Raumfreigabe. Bestehende Akten und Vorgänge bleiben privat.
|
||||
|
||||
ALTER TABLE data_rooms
|
||||
ADD COLUMN owner_id uuid REFERENCES auth_accounts (id),
|
||||
ADD COLUMN default_visibility text NOT NULL DEFAULT 'private',
|
||||
ADD CONSTRAINT data_rooms_default_visibility CHECK (default_visibility IN ('private', 'room'));
|
||||
|
||||
UPDATE data_rooms SET owner_id = created_by;
|
||||
|
||||
ALTER TABLE data_rooms
|
||||
ADD CONSTRAINT data_rooms_owner CHECK (kind = 'personal' OR owner_id IS NOT NULL);
|
||||
|
||||
CREATE INDEX data_rooms_owner ON data_rooms (owner_id) WHERE kind = 'organization';
|
||||
|
||||
ALTER TABLE cases
|
||||
ADD COLUMN visibility text NOT NULL DEFAULT 'private',
|
||||
ADD CONSTRAINT cases_visibility CHECK (visibility IN ('private', 'room'));
|
||||
|
||||
ALTER TABLE matters
|
||||
ADD COLUMN visibility text NOT NULL DEFAULT 'private',
|
||||
ADD CONSTRAINT matters_visibility CHECK (visibility IN ('private', 'room'));
|
||||
@@ -0,0 +1,32 @@
|
||||
-- Raum als Team: Eine Akte oder ein Vorgang wird mit beliebigen Datenräumen geteilt,
|
||||
-- unabhängig vom Heimatraum. Der Heimatraum bleibt Ablage. Die Freigabe zum Heimatraum
|
||||
-- aus 20261021T090000Z_room_access.sql wird übernommen, danach entfallen die Spalten.
|
||||
|
||||
CREATE TABLE room_shares (
|
||||
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
resource_kind text NOT NULL,
|
||||
resource_id uuid NOT NULL,
|
||||
room_id uuid NOT NULL REFERENCES data_rooms (id),
|
||||
-- Obergrenze der Freigabe: 'edit' = Rechte nach Raumrolle, 'read' = höchstens Lesen.
|
||||
access text NOT NULL DEFAULT 'edit',
|
||||
created_by uuid NOT NULL REFERENCES auth_accounts (id),
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
CONSTRAINT room_shares_kind CHECK (resource_kind IN ('case', 'matter')),
|
||||
CONSTRAINT room_shares_access CHECK (access IN ('read', 'edit')),
|
||||
UNIQUE (resource_kind, resource_id, room_id)
|
||||
);
|
||||
|
||||
CREATE INDEX room_shares_room ON room_shares (room_id);
|
||||
|
||||
INSERT INTO room_shares (resource_kind, resource_id, room_id, access, created_by)
|
||||
SELECT 'case', c.id, c.home_scope_id, 'edit', c.owner_subject_id
|
||||
FROM cases c
|
||||
WHERE c.visibility = 'room';
|
||||
|
||||
INSERT INTO room_shares (resource_kind, resource_id, room_id, access, created_by)
|
||||
SELECT 'matter', m.id, m.home_scope_id, 'edit', m.owner_subject_id
|
||||
FROM matters m
|
||||
WHERE m.visibility = 'room';
|
||||
|
||||
ALTER TABLE cases DROP CONSTRAINT cases_visibility, DROP COLUMN visibility;
|
||||
ALTER TABLE matters DROP CONSTRAINT matters_visibility, DROP COLUMN visibility;
|
||||
@@ -0,0 +1,13 @@
|
||||
-- Hauptnutzer und Mitarbeiter. Alle bestehenden Konten sind Hauptnutzer.
|
||||
-- Ein Mitarbeiter-Konto entsteht durch eine Einladung und hat den einladenden Eigentümer als Förderer.
|
||||
|
||||
ALTER TABLE auth_accounts
|
||||
ADD COLUMN account_kind text NOT NULL DEFAULT 'main',
|
||||
ADD COLUMN sponsor_id uuid REFERENCES auth_accounts (id),
|
||||
ADD CONSTRAINT auth_accounts_kind CHECK (account_kind IN ('main', 'employee')),
|
||||
ADD CONSTRAINT auth_accounts_sponsor CHECK (
|
||||
(account_kind = 'employee' AND sponsor_id IS NOT NULL)
|
||||
OR (account_kind = 'main' AND sponsor_id IS NULL)
|
||||
);
|
||||
|
||||
CREATE INDEX auth_accounts_sponsor ON auth_accounts (sponsor_id) WHERE sponsor_id IS NOT NULL;
|
||||
@@ -0,0 +1,11 @@
|
||||
-- Herunterladen des Originals: je Rolle steuerbar. Voreinstellung am Konto des Hauptnutzers,
|
||||
-- Übernahme beim Anlegen eines Raums, danach je Raum änderbar. "direct" gilt für Personen,
|
||||
-- die einen Eintrag direkt erhalten haben (ohne Raum). Bestehende Daten bleiben erlaubt.
|
||||
|
||||
ALTER TABLE auth_accounts
|
||||
ADD COLUMN download_defaults jsonb NOT NULL
|
||||
DEFAULT '{"manager": true, "member": true, "reader": true, "direct": true}'::jsonb;
|
||||
|
||||
ALTER TABLE data_rooms
|
||||
ADD COLUMN download_roles jsonb NOT NULL
|
||||
DEFAULT '{"manager": true, "member": true, "reader": true}'::jsonb;
|
||||
@@ -0,0 +1,18 @@
|
||||
-- Einstellungen je Konto. Ein Mitarbeiter erbt den Wert seines Hauptnutzers und kann ihn ändern,
|
||||
-- solange der Hauptnutzer die Einstellung nicht für das Team verbindlich gesetzt hat (team_mode).
|
||||
-- Erlaubte Werte, Standard und Verbindlichkeit je Schlüssel stehen im Code (app/preferences.py).
|
||||
-- value NULL: kein eigener Wert, es gilt die Erbung bzw. der Standard.
|
||||
|
||||
CREATE TABLE account_preferences (
|
||||
account_id uuid NOT NULL REFERENCES auth_accounts (id) ON DELETE CASCADE,
|
||||
key text NOT NULL,
|
||||
value jsonb,
|
||||
team_mode text NOT NULL DEFAULT 'free',
|
||||
updated_at timestamptz NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (account_id, key),
|
||||
CONSTRAINT account_preferences_key_len CHECK (char_length(key) BETWEEN 1 AND 60),
|
||||
CONSTRAINT account_preferences_team_mode CHECK (team_mode IN ('free', 'locked'))
|
||||
);
|
||||
|
||||
-- Dieselbe Quelle und Kennung: Suche nach bereits eingefügten Dokumenten (app/duplicates.py).
|
||||
CREATE INDEX external_references_identity ON external_references (source, external_id);
|
||||
@@ -0,0 +1,14 @@
|
||||
-- Quellenfreigabe im Raum: Eine Person erlaubt einem Mitglied, die verknüpften Originale
|
||||
-- ihrer mit diesem Raum geteilten Akten und Vorgänge über ihre eigenen Zugänge zu lesen.
|
||||
-- Die Freigabe gilt je Raum, je verleihender Person und je Mitglied. Sie entsteht nur ausdrücklich.
|
||||
|
||||
CREATE TABLE room_source_access (
|
||||
room_id uuid NOT NULL REFERENCES data_rooms (id),
|
||||
owner_id uuid NOT NULL REFERENCES auth_accounts (id),
|
||||
subject_id uuid NOT NULL REFERENCES auth_accounts (id),
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (room_id, owner_id, subject_id),
|
||||
CONSTRAINT room_source_access_other CHECK (owner_id <> subject_id)
|
||||
);
|
||||
|
||||
CREATE INDEX room_source_access_subject ON room_source_access (subject_id, room_id);
|
||||
@@ -43,6 +43,7 @@ def _reset(settings) -> None:
|
||||
TRUNCATE TABLE
|
||||
media_operations,
|
||||
domain_events,
|
||||
auth_login_attempts,
|
||||
auth_accounts,
|
||||
data_rooms
|
||||
RESTART IDENTITY CASCADE
|
||||
@@ -86,13 +87,9 @@ def client(database):
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def clean(database, client):
|
||||
from app.api import routes
|
||||
|
||||
routes._login_attempts.clear()
|
||||
client.cookies.clear()
|
||||
_reset(database)
|
||||
yield
|
||||
routes._login_attempts.clear()
|
||||
client.cookies.clear()
|
||||
_reset(database)
|
||||
|
||||
|
||||
@@ -0,0 +1,165 @@
|
||||
"""Third source used only to prove that registration is enough.
|
||||
|
||||
This module is not a product connector and is not imported by the application.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
from app.core.errors import not_found, unprocessable
|
||||
from app.retrieval import FilePayload, RetrievalFailure
|
||||
from app.sourcebind import resolve_for_read
|
||||
from app.sourceregistry import ConfigField, SourceModule, register_source, unregister_source
|
||||
from app.sourceaccess import borrow_original, complete_borrow
|
||||
|
||||
KIND = "sample"
|
||||
|
||||
CATALOG = {
|
||||
"alpha": {
|
||||
"brief": {
|
||||
"id": "brief",
|
||||
"title": "Probenbrief",
|
||||
"text": "Der Probenbrief bleibt lesbar.",
|
||||
},
|
||||
"notiz": {
|
||||
"id": "notiz",
|
||||
"title": "Randnotiz",
|
||||
"text": "Die Randnotiz bleibt in der Quelle.",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
CAPABILITIES = {
|
||||
"kind": KIND,
|
||||
"navigate": False,
|
||||
"read_original": True,
|
||||
"read_preview": True,
|
||||
"read_attachment": False,
|
||||
"edit_content": False,
|
||||
"edit_metadata": False,
|
||||
"search": {
|
||||
"query": True,
|
||||
"title": False,
|
||||
"correspondent": False,
|
||||
"document_type": False,
|
||||
"tags": False,
|
||||
"document_range": False,
|
||||
"sort": False,
|
||||
"continuation": False,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
CONFIG_FIELDS = (
|
||||
ConfigField("catalog", "Katalog", required=True, default="alpha", help="Name des Beispielkatalogs."),
|
||||
)
|
||||
|
||||
|
||||
def normalize_config(settings: dict, secret: str) -> dict:
|
||||
del secret
|
||||
if settings["catalog"] not in CATALOG:
|
||||
raise unprocessable("Der Katalog dieser Beispielquelle ist unbekannt.")
|
||||
return settings
|
||||
|
||||
|
||||
def probe(row) -> dict:
|
||||
items = _items(row)
|
||||
return {"ok": True, "detail": f"Beispielquelle antwortet. {len(items)} Einträge sichtbar."}
|
||||
|
||||
|
||||
def find(conn, owner_id: UUID, connector_id: UUID | None, query: str, options: dict) -> dict:
|
||||
del options
|
||||
row = _connector(conn, owner_id, connector_id)
|
||||
needle = query.casefold()
|
||||
items = list(_items(row).values())
|
||||
if needle:
|
||||
items = [
|
||||
item for item in items
|
||||
if needle in item["title"].casefold() or needle in item["text"].casefold()
|
||||
]
|
||||
return {"items": items, "connector_id": str(row["id"])}
|
||||
|
||||
|
||||
def preview(conn, owner_id: UUID, connector_id: UUID, options: dict) -> dict:
|
||||
row = _connector(conn, owner_id, connector_id)
|
||||
item = _items(row).get(str(options.get("item") or ""))
|
||||
if item is None:
|
||||
raise unprocessable("Dieser Eintrag ist in der Beispielquelle nicht vorhanden.")
|
||||
return {"id": item["id"], "title": item["title"], "text": item["text"], "media": "text"}
|
||||
|
||||
|
||||
def open_original(conn, actor_id: UUID, element: dict, context, ref) -> tuple[bytes, str, str]:
|
||||
borrowed = borrow_original(conn, actor_id, element, context, ref, KIND)
|
||||
return complete_borrow(conn, borrowed, lambda row: _bytes(row, borrowed.external_id))
|
||||
|
||||
|
||||
def export_original(conn, actor_id: UUID, external_id: str, detail: dict, assigned, ref):
|
||||
del detail
|
||||
result = resolve_for_read(conn, actor_id, KIND, ref, assigned)
|
||||
if result.row is None:
|
||||
return RetrievalFailure(result.code, result.message, result.choices)
|
||||
try:
|
||||
data, media, name = _bytes(result.row, str(external_id))
|
||||
except Exception as exc:
|
||||
return RetrievalFailure("missing", str(getattr(exc, "detail", exc)))
|
||||
return FilePayload(name, media, data, "")
|
||||
|
||||
|
||||
def install_sample_source() -> None:
|
||||
register_source(SourceModule(
|
||||
kind=KIND,
|
||||
label="Beispielquelle",
|
||||
representation="text",
|
||||
capabilities=CAPABILITIES,
|
||||
config_fields=CONFIG_FIELDS,
|
||||
normalize_config=normalize_config,
|
||||
probe=probe,
|
||||
find=find,
|
||||
open_original=open_original,
|
||||
export_original=export_original,
|
||||
navigate=None,
|
||||
preview=preview,
|
||||
))
|
||||
|
||||
|
||||
def remove_sample_source() -> None:
|
||||
unregister_source(KIND)
|
||||
|
||||
|
||||
def _connector(conn, owner_id: UUID, connector_id: UUID | None):
|
||||
if connector_id is not None:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT id, owner_id, kind, name, settings, secret
|
||||
FROM connectors WHERE id = %s AND owner_id = %s
|
||||
""",
|
||||
(connector_id, owner_id),
|
||||
).fetchone()
|
||||
if row is None or row["kind"] != KIND:
|
||||
raise not_found()
|
||||
return row
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT id, owner_id, kind, name, settings, secret
|
||||
FROM connectors
|
||||
WHERE owner_id = %s AND kind = %s
|
||||
ORDER BY name, id
|
||||
""",
|
||||
(owner_id, KIND),
|
||||
).fetchall()
|
||||
if len(rows) != 1:
|
||||
raise unprocessable("Für diese Quelle ist kein eindeutiger Zugang zugeordnet.")
|
||||
return rows[0]
|
||||
|
||||
|
||||
def _items(row) -> dict:
|
||||
catalog = (row["settings"] or {}).get("catalog")
|
||||
return CATALOG.get(catalog) or {}
|
||||
|
||||
|
||||
def _bytes(row, external_id: str) -> tuple[bytes, str, str]:
|
||||
item = _items(row).get(external_id)
|
||||
if item is None:
|
||||
raise unprocessable("Dieser Eintrag ist in der Beispielquelle nicht vorhanden.")
|
||||
return item["text"].encode("utf-8"), "text/plain", f"{item['id']}.txt"
|
||||
@@ -35,7 +35,8 @@ def test_bootstrap_once_then_superadmin_creates_users(client):
|
||||
status=201,
|
||||
)
|
||||
assert created["is_superadmin"] is False
|
||||
assert "password" not in created
|
||||
assert created["must_change_password"] is True
|
||||
assert "password" not in created and "temporary_password" not in created
|
||||
listed = owner.request("GET", "/api/v1/accounts")
|
||||
assert {item["email"] for item in listed["items"]} == {"betreiber@example.test", "mitglied@example.test"}
|
||||
assert all("password_hash" not in item and "password" not in item for item in listed["items"])
|
||||
|
||||
@@ -0,0 +1,539 @@
|
||||
"""Section A: source binding and the storage port, with today's behaviour kept."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
|
||||
from app.core.errors import Problem
|
||||
from app.media.port import (
|
||||
LEGACY_GENERATION,
|
||||
LocalAdapter,
|
||||
MemoryAdapter,
|
||||
check_object_key,
|
||||
instance_for_write,
|
||||
publish,
|
||||
read_clear_bytes,
|
||||
)
|
||||
from app.sourcebind import backfill_source_bindings
|
||||
from tests.support import ORIGIN, Actor, register
|
||||
|
||||
PDF = b"%PDF-1.4\n1 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\n"
|
||||
|
||||
|
||||
def _raw(actor: Actor, path: str):
|
||||
return actor.client.get(
|
||||
path,
|
||||
headers={
|
||||
"Origin": ORIGIN,
|
||||
"X-CSRF-Token": actor.csrf,
|
||||
"X-Scope-Kind": actor.scope["kind"],
|
||||
"X-Scope-Id": actor.scope["id"],
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def _case(actor: Actor) -> dict:
|
||||
return actor.request("POST", "/api/v1/cases", json={"title": "Bestand"}, status=201)
|
||||
|
||||
|
||||
def _paperless(actor: Actor, name: str, token: str) -> str:
|
||||
row = actor.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={"kind": "paperless", "name": name, "base_url": "https://paper.example.test", "token": token},
|
||||
status=201,
|
||||
)
|
||||
return row["id"]
|
||||
|
||||
|
||||
def _link(actor: Actor, case_id: str, connector_id: str | None, external_id: str, title: str) -> str:
|
||||
body = {
|
||||
"title": title,
|
||||
"source": "paperless",
|
||||
"external_id": external_id,
|
||||
"context": {"kind": "case", "id": case_id},
|
||||
}
|
||||
if connector_id:
|
||||
body["detail"] = {"connector_id": connector_id}
|
||||
created = actor.request("POST", "/api/v1/external-refs", json=body, status=201)
|
||||
return created["id"]
|
||||
|
||||
|
||||
def test_storage_adapters_roundtrip_and_reject_escape(tmp_path):
|
||||
payload = b"opaque-bytes"
|
||||
key = str(uuid4())
|
||||
revision = "rev-1"
|
||||
for adapter in (LocalAdapter(tmp_path), MemoryAdapter()):
|
||||
publish(adapter, key, payload)
|
||||
assert adapter.open(key) == payload
|
||||
assert adapter.describe(key)["byte_size"] == len(payload)
|
||||
assert adapter.open(key) == payload
|
||||
assert revision == "rev-1"
|
||||
memory = MemoryAdapter()
|
||||
memory.fail_put = True
|
||||
with pytest.raises(Problem) as failed:
|
||||
publish(memory, str(uuid4()), payload)
|
||||
assert failed.value.code == "storage_unavailable"
|
||||
assert memory._items == {}
|
||||
with pytest.raises(Problem):
|
||||
check_object_key("../secret")
|
||||
with pytest.raises(Problem):
|
||||
check_object_key("/etc/passwd")
|
||||
with pytest.raises(Problem):
|
||||
LocalAdapter(tmp_path).open("dispatch/../../" + str(uuid4()))
|
||||
|
||||
|
||||
def test_changed_root_does_not_retarget_legacy(db, database):
|
||||
legacy = db.execute(
|
||||
"SELECT id, root_path FROM storage_instances WHERE generation = %s",
|
||||
(LEGACY_GENERATION,),
|
||||
).fetchone()
|
||||
key = str(uuid4())
|
||||
original = b"%PDF-legacy-root"
|
||||
publish(LocalAdapter(legacy["root_path"]), key, original)
|
||||
other = Path(database.media_root).parent / f"other-root-{uuid4().hex}"
|
||||
other.mkdir()
|
||||
moved = instance_for_write(db, str(other))
|
||||
assert moved["id"] != legacy["id"]
|
||||
assert moved["generation"] != LEGACY_GENERATION
|
||||
publish(LocalAdapter(moved["root_path"]), key, b"%PDF-other-root")
|
||||
seen = read_clear_bytes(
|
||||
db,
|
||||
instance_id=legacy["id"],
|
||||
generation=LEGACY_GENERATION,
|
||||
object_key=key,
|
||||
media_root=str(other),
|
||||
protection_profile="legacy-plaintext",
|
||||
expected_sha256=None,
|
||||
)
|
||||
assert seen == original
|
||||
db.rollback()
|
||||
|
||||
|
||||
def test_existing_file_keeps_id_bytes_and_revision(client, db):
|
||||
register(db, "ada-file@example.test", "Ada File")
|
||||
ada = Actor(client, "ada-file@example.test", "Ada File")
|
||||
ada.login()
|
||||
case = _case(ada)
|
||||
upload = ada.request(
|
||||
"POST",
|
||||
"/api/v1/files",
|
||||
data={"title": "Scan", "context_kind": "case", "context_id": case["id"]},
|
||||
files={"upload": ("scan.pdf", PDF, "application/pdf")},
|
||||
status=201,
|
||||
)
|
||||
stored = db.execute(
|
||||
"""
|
||||
SELECT a.id, a.object_key, a.content_revision, a.storage_generation, a.protection_profile,
|
||||
s.root_path
|
||||
FROM media_assets a
|
||||
JOIN storage_instances s ON s.id = a.storage_instance_id
|
||||
WHERE a.element_id = %s
|
||||
""",
|
||||
(upload["id"],),
|
||||
).fetchone()
|
||||
assert stored["protection_profile"] == "legacy-plaintext"
|
||||
assert stored["object_key"] == str(stored["id"])
|
||||
assert Path(stored["root_path"]) == Path(client.app.state.settings.media_root).resolve()
|
||||
assert stored["storage_generation"]
|
||||
first = stored["content_revision"]
|
||||
opened = _raw(ada, f"/api/v1/files/{upload['id']}/content")
|
||||
assert opened.status_code == 200
|
||||
assert opened.content == PDF
|
||||
again = db.execute(
|
||||
"SELECT content_revision FROM media_assets WHERE element_id = %s",
|
||||
(upload["id"],),
|
||||
).fetchone()
|
||||
assert again["content_revision"] == first
|
||||
refused = ada.client.patch(
|
||||
f"/api/v1/notes/{upload['id']}",
|
||||
json={"expected_version": 1, "document": {"version": 1, "blocks": [{"type": "paragraph", "text": "nein"}]}},
|
||||
headers={
|
||||
"Origin": ORIGIN,
|
||||
"X-CSRF-Token": ada.csrf,
|
||||
"X-Scope-Kind": ada.scope["kind"],
|
||||
"X-Scope-Id": ada.scope["id"],
|
||||
},
|
||||
)
|
||||
assert refused.status_code == 422
|
||||
assert refused.json()["code"] == "unsupported"
|
||||
|
||||
|
||||
def test_two_paperless_instances_stay_bound_when_order_changes(client, db, monkeypatch):
|
||||
register(db, "ada-two@example.test", "Ada Two")
|
||||
ada = Actor(client, "ada-two@example.test", "Ada Two")
|
||||
ada.login()
|
||||
case = _case(ada)
|
||||
older = _paperless(ada, "Zweitens", "token-older")
|
||||
newer = _paperless(ada, "Erstens", "token-newer")
|
||||
assert older != newer
|
||||
|
||||
def fake_bytes(row, document_id):
|
||||
return f"%PDF-{row['secret']}-{document_id}\n".encode(), "application/pdf", "dokument.pdf"
|
||||
|
||||
monkeypatch.setattr("app.sources._paperless_bytes", fake_bytes)
|
||||
left = _link(ada, case["id"], older, "15", "Altbestand")
|
||||
right = _link(ada, case["id"], newer, "15", "Zweiter Bestand")
|
||||
db.execute("UPDATE connectors SET created_at = now() - interval '2 days' WHERE id = %s", (newer,))
|
||||
db.execute("UPDATE connectors SET created_at = now() WHERE id = %s", (older,))
|
||||
db.commit()
|
||||
assert _raw(ada, f"/api/v1/external-refs/{left}/content").content.startswith(b"%PDF-token-older-15")
|
||||
assert _raw(ada, f"/api/v1/external-refs/{right}/content").content.startswith(b"%PDF-token-newer-15")
|
||||
calls = []
|
||||
|
||||
def fake_get(*args, **kwargs):
|
||||
calls.append(args)
|
||||
return {"results": [{"id": 15, "title": "Treffer", "created": "2024-01-02"}]}
|
||||
|
||||
monkeypatch.setattr("app.sources._paperless_get", fake_get)
|
||||
headers = {
|
||||
"Origin": ORIGIN,
|
||||
"X-CSRF-Token": ada.csrf,
|
||||
"X-Scope-Kind": ada.scope["kind"],
|
||||
"X-Scope-Id": ada.scope["id"],
|
||||
}
|
||||
refused = ada.client.get("/api/v1/sources/paperless/documents", params={"q": "Treffer"}, headers=headers)
|
||||
assert refused.status_code == 422
|
||||
assert calls == []
|
||||
found = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={"q": "Treffer", "connector_id": older},
|
||||
)
|
||||
assert found["items"][0]["title"] == "Treffer"
|
||||
assert found["connector_id"] == older
|
||||
assert found["capabilities"]["search"]["correspondent"] is True
|
||||
assert "correspondent" not in found["unsupported"]
|
||||
filtered = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={"q": "Treffer", "connector_id": older, "correspondent": "4"},
|
||||
)
|
||||
assert filtered["items"][0]["title"] == "Treffer"
|
||||
assert calls[-1][3]["correspondent__id"] == "4"
|
||||
assert calls[-1][3]["title_content"] == "Treffer"
|
||||
|
||||
|
||||
def test_ambiguous_legacy_stays_until_assignment(client, db, monkeypatch):
|
||||
register(db, "ada-old@example.test", "Ada Old")
|
||||
ada = Actor(client, "ada-old@example.test", "Ada Old")
|
||||
ada.login()
|
||||
case = _case(ada)
|
||||
loose = _link(ada, case["id"], None, "15", "Ohne Instanz")
|
||||
_paperless(ada, "Alpha", "token-alpha")
|
||||
second = _paperless(ada, "Beta", "token-beta")
|
||||
db.execute(
|
||||
"""
|
||||
UPDATE external_references
|
||||
SET connector_id = NULL, resolution = 'unresolved', detail = '{}'::jsonb
|
||||
WHERE element_id = %s
|
||||
""",
|
||||
(loose,),
|
||||
)
|
||||
backfill_source_bindings(db)
|
||||
state = db.execute(
|
||||
"SELECT connector_id, resolution FROM external_references WHERE element_id = %s",
|
||||
(loose,),
|
||||
).fetchone()
|
||||
db.commit()
|
||||
assert state["resolution"] == "ambiguous"
|
||||
assert state["connector_id"] is None
|
||||
opened = ada.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
assert opened["bindings"][0]["element"]["id"] == loose
|
||||
assert opened["bindings"][0]["element"]["preview"]["media"] == "unassigned"
|
||||
blocked = _raw(ada, f"/api/v1/external-refs/{loose}/content")
|
||||
assert blocked.status_code == 422
|
||||
assert "eindeutiger Zugang" in blocked.json()["detail"]
|
||||
|
||||
def fake_bytes(row, document_id):
|
||||
del document_id
|
||||
return f"%PDF-{row['secret']}\n".encode(), "application/pdf", "dokument.pdf"
|
||||
|
||||
monkeypatch.setattr("app.sources._paperless_bytes", fake_bytes)
|
||||
ada.request(
|
||||
"POST",
|
||||
f"/api/v1/external-refs/{loose}/assignment",
|
||||
json={"connector_id": second},
|
||||
)
|
||||
_paperless(ada, "Gamma", "token-gamma")
|
||||
assert _raw(ada, f"/api/v1/external-refs/{loose}/content").content.startswith(b"%PDF-token-beta")
|
||||
|
||||
|
||||
def test_legacy_stock_rebinds_and_case_and_matter_open(client, db, monkeypatch):
|
||||
from app.sourceregistry import get_source, unregister_source
|
||||
|
||||
register(db, "ada-keep@example.test", "Ada Keep")
|
||||
ada = Actor(client, "ada-keep@example.test", "Ada Keep")
|
||||
ada.login()
|
||||
case = _case(ada)
|
||||
matter = ada.request("POST", "/api/v1/matters", json={"title": "Bestand"}, status=201)
|
||||
kept = _paperless(ada, "Archiv", "token-kept")
|
||||
case_ref = _link(ada, case["id"], None, "15", "Vertragsakte")
|
||||
matter_ref = ada.request(
|
||||
"POST",
|
||||
"/api/v1/external-refs",
|
||||
json={
|
||||
"title": "Vertragsvorgang",
|
||||
"source": "paperless",
|
||||
"external_id": "16",
|
||||
"context": {"kind": "matter", "id": matter["id"]},
|
||||
},
|
||||
status=201,
|
||||
)["id"]
|
||||
db.execute(
|
||||
"""
|
||||
UPDATE external_references
|
||||
SET connector_id = NULL, resolution = 'unresolved', detail = '{}'::jsonb
|
||||
WHERE element_id IN (%s, %s)
|
||||
""",
|
||||
(case_ref, matter_ref),
|
||||
)
|
||||
db.commit()
|
||||
unregister_source("paperless")
|
||||
unregister_source("imap")
|
||||
assert get_source("paperless") is None
|
||||
try:
|
||||
backfill_source_bindings(db)
|
||||
db.commit()
|
||||
for element_id in (case_ref, matter_ref):
|
||||
state = db.execute(
|
||||
"SELECT connector_id::text AS connector_id, resolution FROM external_references WHERE element_id = %s",
|
||||
(element_id,),
|
||||
).fetchone()
|
||||
assert state["resolution"] == "bound"
|
||||
assert state["connector_id"] == kept
|
||||
assert get_source("paperless") is not None
|
||||
case_page = ada.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
matter_page = ada.request("GET", f"/api/v1/matters/{matter['id']}")
|
||||
assert case_page["bindings"][0]["element"]["preview"]["available"] is True
|
||||
assert case_page["bindings"][0]["element"]["preview"]["media"] == "pdf"
|
||||
assert matter_page["bindings"][0]["element"]["preview"]["available"] is True
|
||||
monkeypatch.setattr(
|
||||
"app.sources._paperless_bytes",
|
||||
lambda row, document_id: (f"%PDF-{row['secret']}-{document_id}\n".encode(), "application/pdf", "dokument.pdf"),
|
||||
)
|
||||
assert _raw(ada, f"/api/v1/external-refs/{case_ref}/content").content.startswith(b"%PDF-token-kept-15")
|
||||
assert _raw(ada, f"/api/v1/external-refs/{matter_ref}/content").content.startswith(b"%PDF-token-kept-16")
|
||||
finally:
|
||||
from app.sources import _install_sources
|
||||
|
||||
_install_sources()
|
||||
|
||||
|
||||
def test_connectors_remain_with_their_account(client, db, monkeypatch):
|
||||
calls = []
|
||||
monkeypatch.setattr(
|
||||
"app.sources._paperless_get",
|
||||
lambda *args, **kwargs: calls.append(args) or {"results": []},
|
||||
)
|
||||
register(db, "ada-own@example.test", "Ada Own")
|
||||
register(db, "ben-own@example.test", "Ben Own")
|
||||
ada = Actor(client, "ada-own@example.test", "Ada Own")
|
||||
ben = Actor(client, "ben-own@example.test", "Ben Own")
|
||||
ada.login()
|
||||
ada_paper = _paperless(ada, "Ada Archiv", "token-ada")
|
||||
ben.login()
|
||||
ben_paper = _paperless(ben, "Ben Archiv", "token-ben")
|
||||
listed = ben.request("GET", "/api/v1/connectors")
|
||||
ids = {item["id"] for item in listed["items"]}
|
||||
assert ben_paper in ids
|
||||
assert ada_paper not in ids
|
||||
assert all(item["name"] != "Ada Archiv" for item in listed["items"])
|
||||
ben.request("POST", f"/api/v1/connectors/{ada_paper}/probe", status=404)
|
||||
ben.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={"q": "fremd", "connector_id": ada_paper},
|
||||
status=404,
|
||||
)
|
||||
assert calls == []
|
||||
ada.login()
|
||||
own = {item["id"] for item in ada.request("GET", "/api/v1/connectors")["items"]}
|
||||
assert ada_paper in own
|
||||
assert ben_paper not in own
|
||||
|
||||
|
||||
def test_locked_profile_serves_metadata_not_cleartext(client, db):
|
||||
register(db, "ada-lock@example.test", "Ada Lock")
|
||||
ada = Actor(client, "ada-lock@example.test", "Ada Lock")
|
||||
ada.login()
|
||||
case = _case(ada)
|
||||
upload = ada.request(
|
||||
"POST",
|
||||
"/api/v1/files",
|
||||
data={"title": "Geschuetzt", "context_kind": "case", "context_id": case["id"]},
|
||||
files={"upload": ("geheim.pdf", PDF, "application/pdf")},
|
||||
status=201,
|
||||
)
|
||||
dummy = b"cipher-dummy-not-clear"
|
||||
asset = db.execute(
|
||||
"SELECT id, object_key, storage_instance_id FROM media_assets WHERE element_id = %s",
|
||||
(upload["id"],),
|
||||
).fetchone()
|
||||
root = db.execute(
|
||||
"SELECT root_path FROM storage_instances WHERE id = %s",
|
||||
(asset["storage_instance_id"],),
|
||||
).fetchone()["root_path"]
|
||||
path = Path(root) / asset["object_key"]
|
||||
path.write_bytes(dummy)
|
||||
db.execute(
|
||||
"""
|
||||
UPDATE media_assets
|
||||
SET protection_profile = 'client-encrypted',
|
||||
key_responsibility = 'client',
|
||||
sha256 = %s
|
||||
WHERE element_id = %s
|
||||
""",
|
||||
(hashlib.sha256(dummy).hexdigest(), upload["id"]),
|
||||
)
|
||||
db.commit()
|
||||
detail = ada.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
rendered = json.dumps(detail)
|
||||
assert "client-encrypted" in rendered
|
||||
assert "Geschuetzt" in rendered
|
||||
assert dummy.decode() not in rendered
|
||||
opened = _raw(ada, f"/api/v1/files/{upload['id']}/content")
|
||||
assert opened.status_code == 422
|
||||
assert opened.json()["code"] == "unsupported"
|
||||
assert path.read_bytes() == dummy
|
||||
|
||||
|
||||
def test_credential_update_keeps_the_instance(client, db):
|
||||
register(db, "ada-key@example.test", "Ada Key")
|
||||
ada = Actor(client, "ada-key@example.test", "Ada Key")
|
||||
ada.login()
|
||||
first = _paperless(ada, "Archiv", "token-first-1")
|
||||
second = _paperless(ada, "Anderes Archiv", "token-second-2")
|
||||
renewed = ada.request(
|
||||
"PATCH",
|
||||
f"/api/v1/connectors/{first}",
|
||||
json={"kind": "paperless", "name": "Archiv", "base_url": "https://paper.example.test", "token": "token-renewed"},
|
||||
)
|
||||
assert renewed["id"] == first
|
||||
secrets = {
|
||||
str(row["id"]): row["secret"]
|
||||
for row in db.execute("SELECT id, secret FROM connectors").fetchall()
|
||||
}
|
||||
assert secrets[first] == "token-renewed"
|
||||
assert secrets[second] == "token-second-2"
|
||||
caps = ada.request("GET", "/api/v1/sources/capabilities")
|
||||
assert caps["editors"]["note"] is True
|
||||
assert caps["editors"]["markdown_file"] is False
|
||||
assert caps["protection_profiles"]["client-encrypted"] == "locked"
|
||||
paperless = next(item for item in caps["sources"] if item["kind"] == "paperless")
|
||||
assert paperless["search"]["query"] is True
|
||||
assert paperless["edit_content"] is False
|
||||
|
||||
|
||||
def test_legacy_reference_stays_bound_and_foreign_connectors_stay_hidden(client, db, database, monkeypatch):
|
||||
"""A startup without loaded modules must still keep the one existing connection."""
|
||||
from app.db.migrate import _prepare_source_storage
|
||||
from app.sourceregistry import unregister_source
|
||||
from app.sources import _install_sources
|
||||
|
||||
def fake_bytes(row, document_id):
|
||||
del document_id
|
||||
return f"%PDF-{row['secret']}\n".encode(), "application/pdf", "dokument.pdf"
|
||||
|
||||
monkeypatch.setattr("app.sources._paperless_bytes", fake_bytes)
|
||||
register(db, "ada-legacy@example.test", "Ada Legacy")
|
||||
register(db, "ben-legacy@example.test", "Ben Legacy")
|
||||
ada = Actor(client, "ada-legacy@example.test", "Ada Legacy")
|
||||
ben = Actor(client, "ben-legacy@example.test", "Ben Legacy")
|
||||
ada.login()
|
||||
case = _case(ada)
|
||||
matter = ada.request("POST", "/api/v1/matters", json={"title": "Altbestand"}, status=201)
|
||||
connector = _paperless(ada, "Archiv", "token-legacy")
|
||||
case_ref = _link(ada, case["id"], None, "15", "Akte")
|
||||
matter_ref = ada.request(
|
||||
"POST",
|
||||
"/api/v1/external-refs",
|
||||
json={
|
||||
"title": "Vorgang",
|
||||
"source": "paperless",
|
||||
"external_id": "16",
|
||||
"context": {"kind": "matter", "id": matter["id"]},
|
||||
},
|
||||
status=201,
|
||||
)["id"]
|
||||
db.execute(
|
||||
"""
|
||||
UPDATE external_references
|
||||
SET connector_id = NULL, resolution = 'unresolved', detail = '{}'::jsonb
|
||||
WHERE element_id IN (%s, %s)
|
||||
""",
|
||||
(case_ref, matter_ref),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
opened = ada.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
shown = next(item["element"] for item in opened["bindings"] if item["element"]["id"] == case_ref)
|
||||
assert shown["preview"]["media"] == "pdf"
|
||||
assert shown["preview"]["available"] is True
|
||||
assert _raw(ada, f"/api/v1/external-refs/{case_ref}/content?context_kind=case&context_id={case['id']}").content.startswith(
|
||||
b"%PDF-token-legacy"
|
||||
)
|
||||
matter_view = ada.request("GET", f"/api/v1/matters/{matter['id']}")
|
||||
matter_element = next(item["element"] for item in matter_view["bindings"] if item["element"]["id"] == matter_ref)
|
||||
assert matter_element["preview"]["media"] == "pdf"
|
||||
|
||||
unregister_source("paperless")
|
||||
unregister_source("imap")
|
||||
try:
|
||||
_prepare_source_storage(database)
|
||||
finally:
|
||||
_install_sources()
|
||||
state = db.execute(
|
||||
"SELECT connector_id::text AS connector_id, resolution FROM external_references WHERE element_id = %s",
|
||||
(case_ref,),
|
||||
).fetchone()
|
||||
assert state["connector_id"] == connector
|
||||
assert state["resolution"] == "bound"
|
||||
|
||||
ben.login()
|
||||
own = _paperless(ben, "Bens Archiv", "token-ben")
|
||||
listed = {item["id"] for item in ben.request("GET", "/api/v1/connectors")["items"]}
|
||||
assert listed == {own}
|
||||
ben.request("POST", f"/api/v1/connectors/{connector}/probe", status=404)
|
||||
ben.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={"q": "Alt", "connector_id": connector},
|
||||
status=404,
|
||||
)
|
||||
ada.login()
|
||||
ada.request(
|
||||
"POST",
|
||||
f"/api/v1/matters/{matter['id']}/grants",
|
||||
json={"email": ben.email, "can_read": True, "can_edit": False, "can_share": False, "use_owner_sources": False},
|
||||
status=201,
|
||||
)
|
||||
ben.login()
|
||||
shared = ben.request("GET", f"/api/v1/matters/{matter['id']}")
|
||||
shared_element = next(item["element"] for item in shared["bindings"] if item["element"]["id"] == matter_ref)
|
||||
assert "connector_id" not in shared_element["external"]["detail"]
|
||||
assert "external_id" not in shared_element["external"]
|
||||
blocked = _raw(
|
||||
ben,
|
||||
f"/api/v1/external-refs/{matter_ref}/content?context_kind=matter&context_id={matter['id']}",
|
||||
)
|
||||
assert blocked.status_code == 422
|
||||
ada.login()
|
||||
ada.request(
|
||||
"POST",
|
||||
f"/api/v1/matters/{matter['id']}/grants",
|
||||
json={"email": ben.email, "can_read": True, "can_edit": False, "can_share": False, "use_owner_sources": True},
|
||||
status=201,
|
||||
)
|
||||
ben.login()
|
||||
allowed = _raw(
|
||||
ben,
|
||||
f"/api/v1/external-refs/{matter_ref}/content?context_kind=matter&context_id={matter['id']}",
|
||||
)
|
||||
assert allowed.status_code == 200
|
||||
assert allowed.content.startswith(b"%PDF-token-legacy")
|
||||
@@ -0,0 +1,215 @@
|
||||
"""Connector configuration: fields come from the module, secrets never leave the server."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
|
||||
from app.core.errors import Problem
|
||||
from app.sourceregistry import ConfigField, parse_fields
|
||||
from tests.sample_source import install_sample_source, remove_sample_source
|
||||
from tests.support import Actor, register
|
||||
|
||||
SECRET_WORDS = ("secret", "token-geheim-1234", "passwort-geheim")
|
||||
|
||||
PAPERLESS = {"kind": "paperless", "name": "Archiv", "base_url": "https://paper.example.test", "token": "token-geheim-1234"}
|
||||
IMAP = {
|
||||
"kind": "imap",
|
||||
"name": "Postfach",
|
||||
"host": "imap.example.test",
|
||||
"port": 993,
|
||||
"username": "ada",
|
||||
"password": "passwort-geheim",
|
||||
"security": "ssl",
|
||||
}
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_source():
|
||||
install_sample_source()
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
remove_sample_source()
|
||||
|
||||
|
||||
def _ada(client, db) -> Actor:
|
||||
ada = Actor(client, "ada-config@example.test", "Ada Konfig")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
return ada
|
||||
|
||||
|
||||
def _stored(db, connector_id: str) -> dict:
|
||||
return db.execute("SELECT settings, secret FROM connectors WHERE id = %s", (connector_id,)).fetchone()
|
||||
|
||||
|
||||
def test_parse_fields_checks_types_and_refuses_unknown_keys():
|
||||
fields = (
|
||||
ConfigField("host", "Server", required=True),
|
||||
ConfigField("port", "Port", type="number", default=993, minimum=1, maximum=65535),
|
||||
ConfigField("mode", "Modus", type="select", default="a", options=(("a", "A"), ("b", "B"))),
|
||||
ConfigField("key", "Schlüssel", type="password", required=True, secret=True),
|
||||
)
|
||||
settings, secret = parse_fields(fields, {"host": " h ", "key": "k"})
|
||||
assert settings == {"host": "h", "port": 993, "mode": "a"}
|
||||
assert secret == "k"
|
||||
for bad in (
|
||||
{"host": "h", "key": "k", "port": "abc"},
|
||||
{"host": "h", "key": "k", "port": 0},
|
||||
{"host": "h", "key": "k", "mode": "c"},
|
||||
{"host": "h", "key": "k", "fremd": "x"},
|
||||
{"key": "k"},
|
||||
{"host": "h"},
|
||||
):
|
||||
with pytest.raises(Problem) as caught:
|
||||
parse_fields(fields, bad)
|
||||
assert caught.value.status == 422
|
||||
kept_settings, kept_secret = parse_fields(fields, {"host": "neu", "key": ""}, {"host": "alt", "port": 143}, "bleibt")
|
||||
assert kept_settings["host"] == "neu" and kept_settings["port"] == 143
|
||||
assert kept_secret == "bleibt"
|
||||
|
||||
|
||||
def test_capabilities_list_the_fields_of_each_module(client, db):
|
||||
ada = _ada(client, db)
|
||||
modules = {item["kind"]: item for item in ada.request("GET", "/api/v1/sources/capabilities")["modules"]}
|
||||
assert {"paperless", "imap"} <= set(modules)
|
||||
paperless = {item["key"]: item for item in modules["paperless"]["config_fields"]}
|
||||
assert paperless["token"]["secret"] is True and paperless["base_url"]["required"] is True
|
||||
imap = {item["key"]: item for item in modules["imap"]["config_fields"]}
|
||||
assert imap["password"]["secret"] is True
|
||||
assert imap["port"]["type"] == "number" and imap["port"]["default"] == 993
|
||||
assert [option["value"] for option in imap["security"]["options"]] == ["ssl", "starttls"]
|
||||
assert imap["mailbox"]["default"] == "INBOX"
|
||||
|
||||
|
||||
def test_create_with_config_and_flat_fields_gives_the_same_stored_result(client, db):
|
||||
ada = _ada(client, db)
|
||||
flat = ada.request("POST", "/api/v1/connectors", json=PAPERLESS, status=201)
|
||||
config = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={
|
||||
"kind": "paperless",
|
||||
"name": "Zweites Archiv",
|
||||
"config": {"base_url": "https://paper.example.test/", "token": "token-geheim-1234"},
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
assert _stored(db, flat["id"]) == _stored(db, config["id"])
|
||||
assert _stored(db, flat["id"])["settings"] == {"base_url": "https://paper.example.test"}
|
||||
|
||||
|
||||
def test_secrets_never_leave_the_server(client, db):
|
||||
ada = _ada(client, db)
|
||||
created = ada.request("POST", "/api/v1/connectors", json=IMAP, status=201)
|
||||
detail = ada.request("GET", f"/api/v1/connectors/{created['id']}")
|
||||
listed = ada.request("GET", "/api/v1/connectors")
|
||||
for body in (created, detail, listed):
|
||||
text = str(body)
|
||||
assert not any(word in text for word in SECRET_WORDS if word != "secret"), text
|
||||
assert "'secret'" not in text and "'password'" not in text and "'token'" not in text
|
||||
assert detail["has_secret"] is True
|
||||
assert detail["settings"]["mailbox"] == "INBOX"
|
||||
assert detail["settings"]["port"] == 993
|
||||
assert detail["protection_profile"] == "legacy-plaintext"
|
||||
assert detail["references"] == 0
|
||||
assert detail["probe"] is None
|
||||
|
||||
|
||||
def test_change_without_secret_keeps_the_stored_one_and_the_instance(client, db):
|
||||
ada = _ada(client, db)
|
||||
created = ada.request("POST", "/api/v1/connectors", json=IMAP, status=201)
|
||||
changed = ada.request(
|
||||
"PATCH",
|
||||
f"/api/v1/connectors/{created['id']}",
|
||||
json={"kind": "imap", "name": "Umbenannt", "config": {"host": "mail.example.test", "port": "143", "security": "starttls"}},
|
||||
)
|
||||
assert changed["id"] == created["id"]
|
||||
assert changed["name"] == "Umbenannt"
|
||||
stored = _stored(db, created["id"])
|
||||
assert stored["secret"] == "passwort-geheim"
|
||||
assert stored["settings"]["host"] == "mail.example.test"
|
||||
assert stored["settings"]["port"] == 143
|
||||
assert stored["settings"]["security"] == "starttls"
|
||||
assert stored["settings"]["username"] == "ada"
|
||||
renewed = ada.request(
|
||||
"PATCH",
|
||||
f"/api/v1/connectors/{created['id']}",
|
||||
json={"kind": "imap", "name": "Umbenannt", "config": {"password": "neues-passwort"}},
|
||||
)
|
||||
assert renewed["id"] == created["id"]
|
||||
assert _stored(db, created["id"])["secret"] == "neues-passwort"
|
||||
|
||||
|
||||
def test_module_validation_refuses_bad_input(client, db):
|
||||
ada = _ada(client, db)
|
||||
ada.request("POST", "/api/v1/connectors", json={**PAPERLESS, "base_url": "ftp://paper.example.test"}, status=422)
|
||||
ada.request("POST", "/api/v1/connectors", json={**PAPERLESS, "token": "kurz"}, status=422)
|
||||
ada.request("POST", "/api/v1/connectors", json={**IMAP, "host": "mail server"}, status=422)
|
||||
ada.request("POST", "/api/v1/connectors", json={**IMAP, "port": 70000}, status=422)
|
||||
ada.request("POST", "/api/v1/connectors", json={**IMAP, "password": None}, status=422)
|
||||
ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={"kind": "paperless", "name": "Fremdfeld", "config": {"base_url": "https://paper.example.test", "token": "token-geheim-1234", "host": "x"}},
|
||||
status=422,
|
||||
)
|
||||
created = ada.request("POST", "/api/v1/connectors", json=PAPERLESS, status=201)
|
||||
ada.request(
|
||||
"PATCH",
|
||||
f"/api/v1/connectors/{created['id']}",
|
||||
json={**PAPERLESS, "kind": "imap"},
|
||||
status=422,
|
||||
)
|
||||
assert _stored(db, created["id"])["settings"] == {"base_url": "https://paper.example.test"}
|
||||
|
||||
|
||||
def test_a_foreign_instance_is_not_found(client, db):
|
||||
ada = _ada(client, db)
|
||||
ben = Actor(client, "ben-config@example.test", "Ben Konfig")
|
||||
register(db, ben.email, ben.name)
|
||||
created = ada.request("POST", "/api/v1/connectors", json=PAPERLESS, status=201)
|
||||
ben.login()
|
||||
ben.request("GET", f"/api/v1/connectors/{created['id']}", status=404)
|
||||
ben.request("PATCH", f"/api/v1/connectors/{created['id']}", json=PAPERLESS, status=404)
|
||||
ben.request("DELETE", f"/api/v1/connectors/{created['id']}", status=404)
|
||||
|
||||
|
||||
def test_probe_result_is_kept_for_display(client, db, sample_source):
|
||||
del sample_source
|
||||
ada = _ada(client, db)
|
||||
created = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={"kind": "sample", "name": "Katalog", "config": {"catalog": "alpha"}},
|
||||
status=201,
|
||||
)
|
||||
probed = ada.request("POST", f"/api/v1/connectors/{created['id']}/probe")
|
||||
detail = ada.request("GET", f"/api/v1/connectors/{created['id']}")
|
||||
assert detail["probe"]["ok"] is True
|
||||
assert detail["probe"]["detail"] == probed["detail"]
|
||||
ada.request(
|
||||
"PATCH",
|
||||
f"/api/v1/connectors/{created['id']}",
|
||||
json={"kind": "sample", "name": "Katalog", "config": {"catalog": "alpha"}},
|
||||
)
|
||||
assert ada.request("GET", f"/api/v1/connectors/{created['id']}")["probe"] is None
|
||||
|
||||
|
||||
def test_a_module_with_fields_needs_no_central_schema(client, db, sample_source):
|
||||
del sample_source
|
||||
ada = _ada(client, db)
|
||||
modules = {item["kind"]: item for item in ada.request("GET", "/api/v1/sources/capabilities")["modules"]}
|
||||
assert [item["key"] for item in modules["sample"]["config_fields"]] == ["catalog"]
|
||||
ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={"kind": "sample", "name": "Ohne Wert", "config": {}},
|
||||
status=201,
|
||||
)
|
||||
ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={"kind": "sample", "name": "Falsch", "config": {"catalog": "kein-katalog"}},
|
||||
status=422,
|
||||
)
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,503 @@
|
||||
"""Corrections K1–K3 and K7. Synthetic only; no live mailbox or Paperless."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import imaplib
|
||||
|
||||
import psycopg
|
||||
import pytest
|
||||
from email.message import EmailMessage
|
||||
|
||||
import app.sources as sources
|
||||
from app.core.errors import unprocessable
|
||||
from app.mailpack import parse_mail
|
||||
from tests.support import Actor, register
|
||||
|
||||
|
||||
def test_mailbox_names_are_quoted_protocol_strings():
|
||||
client = imaplib.IMAP4.__new__(imaplib.IMAP4)
|
||||
client.sent = []
|
||||
client.state = "AUTH"
|
||||
client._encoding = "ascii"
|
||||
client.tagpre = b"T"
|
||||
client.tagnum = 1
|
||||
client.tagged_commands = {}
|
||||
client.untagged_responses = {}
|
||||
client.is_readonly = True
|
||||
client.literal = None
|
||||
client.debug = 0
|
||||
client._mesg = lambda *args: None
|
||||
client._log = lambda *args: None
|
||||
client.send = lambda data: client.sent.append(data)
|
||||
|
||||
value = "Sent Items"
|
||||
client._command("EXAMINE", sources._mailbox_argument(value))
|
||||
assert client.sent[-1] == b'T1 EXAMINE "Sent Items"\r\n'
|
||||
value = 'Ordner "A"\\B'
|
||||
client._command("EXAMINE", sources._mailbox_argument(value))
|
||||
assert client.sent[-1] == b'T2 EXAMINE "Ordner \\"A\\"\\\\B"\r\n'
|
||||
assert sources._mailbox_argument("INBOX") == "INBOX"
|
||||
with pytest.raises(Exception):
|
||||
sources._mailbox_argument("Sent\nItems")
|
||||
|
||||
|
||||
def test_parse_mail_keeps_names_html_and_attached_messages():
|
||||
inner = EmailMessage()
|
||||
inner["Subject"] = "Innen"
|
||||
inner.set_content("innen bleibt drin")
|
||||
inner.add_attachment(b"innen-pdf", maintype="application", subtype="pdf", filename="innen.pdf")
|
||||
outer = EmailMessage()
|
||||
outer["From"] = "Ada <ada@example.test>"
|
||||
outer["To"] = "Ben <ben@example.test>"
|
||||
outer["Subject"] = "=?utf-8?q?Aussen?="
|
||||
outer.set_content("aussen bleibt aussen")
|
||||
outer.add_attachment(b"%PDF-same", maintype="application", subtype="pdf", filename="lage.pdf")
|
||||
outer.add_attachment(b"%PDF-other", maintype="application", subtype="pdf", filename="lage.pdf")
|
||||
outer.add_attachment(inner, subtype="rfc822", filename="weitergeleitet.eml")
|
||||
html = (
|
||||
"<p>A & B</p><table><tr><td>Zelle</td><td>Zwei</td></tr></table>"
|
||||
"<script>alert(1)</script><img src=\"https://evil.test/a.png\">"
|
||||
"<a href=\"javascript:alert(1)\">x</a><img src=\"cid:logo@x\">"
|
||||
)
|
||||
mixed = EmailMessage()
|
||||
mixed["Subject"] = "HTML"
|
||||
mixed.set_content("nur text")
|
||||
mixed.add_alternative(html, subtype="html")
|
||||
logo = b"\x89PNG\r\n"
|
||||
mixed.add_attachment(logo, maintype="image", subtype="png", filename="logo.png", cid="<logo@x>")
|
||||
encoded = EmailMessage()
|
||||
encoded["Subject"] = "Namen"
|
||||
encoded.set_content("datei")
|
||||
encoded.add_attachment(
|
||||
b"pdf",
|
||||
maintype="application",
|
||||
subtype="pdf",
|
||||
filename="=?utf-8?q?Buero_Uebergabe=2Epdf?=",
|
||||
)
|
||||
|
||||
parsed = parse_mail(outer.as_bytes())
|
||||
assert parsed.subject == "Aussen"
|
||||
assert parsed.text == "aussen bleibt aussen"
|
||||
assert "innen" not in parsed.text
|
||||
names = [item.display_name for item in parsed.attachments]
|
||||
assert "weitergeleitet.eml" in names
|
||||
assert names.count("lage.pdf") == 2
|
||||
archives = [item.filename for item in parsed.attachments]
|
||||
assert len(set(archives)) == len(archives)
|
||||
attached = next(item for item in parsed.attachments if item.display_name == "weitergeleitet.eml")
|
||||
assert b"innen bleibt drin" in attached.data or b"Innen" in attached.data
|
||||
assert attached.sha256 == hashlib.sha256(attached.data).hexdigest()
|
||||
|
||||
view = parse_mail(mixed.as_bytes())
|
||||
assert "<table>" in view.html
|
||||
assert "<script" not in view.html
|
||||
assert "https://evil.test" not in view.html
|
||||
assert "javascript:" not in view.html
|
||||
assert "data:image/png;base64," in view.html
|
||||
assert "A & B" in view.html or "A & B" in view.html
|
||||
assert "Zelle" in view.html
|
||||
|
||||
named = parse_mail(encoded.as_bytes())
|
||||
assert named.attachments[0].display_name == "Buero Uebergabe.pdf"
|
||||
assert "=?utf-8?" not in named.attachments[0].display_name
|
||||
assert named.attachments[0].data == b"pdf"
|
||||
|
||||
|
||||
def test_an_undecoded_pdf_stays_a_named_pdf():
|
||||
import base64
|
||||
from app.media.storage import content_disposition
|
||||
|
||||
pdf = b"%PDF-1.4\n1 0 obj\n<<>>\nendobj\ntrailer\n<<>>\n%%EOF\n"
|
||||
raw = (
|
||||
b"Subject: Scan\r\n"
|
||||
b"MIME-Version: 1.0\r\n"
|
||||
b"Content-Type: multipart/mixed; boundary=bound\r\n"
|
||||
b"\r\n"
|
||||
b"--bound\r\n"
|
||||
b"Content-Type: text/plain; charset=utf-8\r\n"
|
||||
b"\r\n"
|
||||
b"text\r\n"
|
||||
b"--bound\r\n"
|
||||
b"Content-Type: application/octet-stream\r\n"
|
||||
b"Content-Transfer-Encoding: 8bit\r\n"
|
||||
b"Content-Disposition: attachment; filename=\"scan-7f3a9c\"\r\n"
|
||||
b"\r\n"
|
||||
+ base64.b64encode(pdf) + b"\r\n"
|
||||
b"--bound--\r\n"
|
||||
)
|
||||
item = parse_mail(raw).attachments[0]
|
||||
assert item.data.startswith(b"%PDF")
|
||||
assert item.media_type == "application/pdf"
|
||||
assert item.display_name == "scan-7f3a9c.pdf"
|
||||
header = content_disposition("\u00dcbergabe.pdf", inline=True)
|
||||
assert header.startswith("inline;")
|
||||
header.encode("ascii")
|
||||
assert ".pdf" in header
|
||||
assert "filename*=UTF-8''" in header
|
||||
assert "%C3%9Cbergabe.pdf" in header
|
||||
|
||||
|
||||
class QuotedIMAP:
|
||||
def __init__(self, *args, **kwargs):
|
||||
self.untagged_responses = {}
|
||||
|
||||
def login(self, username, secret):
|
||||
return "OK", [b"logged"]
|
||||
|
||||
def list(self):
|
||||
return "OK", [b'(\\HasNoChildren) "/" "Sent Items"']
|
||||
|
||||
def select(self, mailbox, readonly=False):
|
||||
assert readonly is True
|
||||
assert mailbox == '"Sent Items"'
|
||||
self.untagged_responses = {
|
||||
"EXISTS": [b"4200"],
|
||||
"UIDVALIDITY": [b"8"],
|
||||
"UIDNEXT": [b"2"],
|
||||
}
|
||||
return "OK", [b"4200"]
|
||||
|
||||
def uid(self, command, *args):
|
||||
if command == "SEARCH":
|
||||
return "OK", [b""]
|
||||
header = b"From: Ada <ada@example.test>\r\nSubject: Leer\r\nDate: Thu, 02 May 2024 08:00:00 +0000\r\n"
|
||||
return "OK", [(b"body", header), b")"]
|
||||
|
||||
def logout(self):
|
||||
return "BYE", [b""]
|
||||
|
||||
|
||||
def test_a_filled_folder_with_spaces_is_not_reported_empty(client, db, monkeypatch):
|
||||
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", QuotedIMAP)
|
||||
ada = Actor(client, "ada-sent@example.test", "Ada Gesendet")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
account = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={
|
||||
"kind": "imap",
|
||||
"name": "Post",
|
||||
"host": "imap.example.test",
|
||||
"port": 993,
|
||||
"username": "ada@example.test",
|
||||
"password": "Postfach-Geheim",
|
||||
"security": "ssl",
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
page = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/imap/messages",
|
||||
params={"connector_id": account["id"], "mailbox": "Sent Items"},
|
||||
)
|
||||
assert page["items"] == []
|
||||
assert page["contradictory"] is True
|
||||
assert page["exists"] == 4200
|
||||
assert "leer" not in str(page).casefold()
|
||||
|
||||
|
||||
def _multipart(text: str, name: str, payload: bytes) -> bytes:
|
||||
message = EmailMessage()
|
||||
message["From"] = "Ada <ada@example.test>"
|
||||
message["To"] = "Ben <ben@example.test>"
|
||||
message["Subject"] = "Grenze"
|
||||
message["Message-ID"] = "<grenze@example.test>"
|
||||
message.set_content(text)
|
||||
message.add_attachment(payload, maintype="application", subtype="pdf", filename=name)
|
||||
return message.as_bytes()
|
||||
|
||||
|
||||
class LimitIMAP:
|
||||
raw = b""
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
self.untagged_responses = {}
|
||||
|
||||
def login(self, username, secret):
|
||||
return "OK", [b"ok"]
|
||||
|
||||
def list(self):
|
||||
return "OK", [b'(\\HasNoChildren) "/" "INBOX"']
|
||||
|
||||
def select(self, mailbox, readonly=False):
|
||||
self.untagged_responses = {"UIDVALIDITY": [b"1"], "UIDNEXT": [b"3"], "EXISTS": [b"1"]}
|
||||
return "OK", [b"1"]
|
||||
|
||||
def uid(self, command, *args):
|
||||
spec = " ".join(str(part) for part in args[1:])
|
||||
if "BODY.PEEK[]" in spec and "<" not in spec:
|
||||
return "OK", [(b"rfc822", type(self).raw)]
|
||||
if "BODYSTRUCTURE" in spec:
|
||||
structure = (
|
||||
b'(("TEXT" "PLAIN" ("CHARSET" "utf-8") NIL NIL "7BIT" 12 1 NIL NIL NIL NIL)'
|
||||
b'("APPLICATION" "PDF" NIL NIL NIL "BASE64" 20 NIL '
|
||||
b'("ATTACHMENT" ("FILENAME" "=?utf-8?q?Buero_Uebergabe=2Epdf?=")) NIL NIL)'
|
||||
b' "MIXED" ("BOUNDARY" "b") NIL NIL NIL)'
|
||||
)
|
||||
return "OK", [(b"body", structure)]
|
||||
if "BODY.PEEK[1]" in spec:
|
||||
return "OK", [(b"part", b"gleicher text")]
|
||||
if "BODY.PEEK[2]" in spec:
|
||||
return "OK", [(b"part", b"nicht text")]
|
||||
header = (
|
||||
b"From: Ada <ada@example.test>\r\nTo: Ben <ben@example.test>\r\n"
|
||||
b"Subject: Grenze\r\nDate: Thu, 02 May 2024 08:00:00 +0000\r\n"
|
||||
)
|
||||
return "OK", [(b"body", header), b")"]
|
||||
|
||||
def logout(self):
|
||||
return "BYE", [b""]
|
||||
|
||||
|
||||
def test_preview_below_and_above_the_limit_uses_the_same_parts(client, db, monkeypatch):
|
||||
payload = b"%PDF-plan"
|
||||
small = _multipart("gleicher text", "Buero Uebergabe.pdf", payload)
|
||||
LimitIMAP.raw = small + b"X" * 50
|
||||
monkeypatch.setattr(sources, "PREVIEW_BYTE_LIMIT", len(small))
|
||||
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", LimitIMAP)
|
||||
ada = Actor(client, "ada-limit@example.test", "Ada Grenze")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
account = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={
|
||||
"kind": "imap",
|
||||
"name": "Post",
|
||||
"host": "imap.example.test",
|
||||
"port": 993,
|
||||
"username": "ada@example.test",
|
||||
"password": "Postfach-Geheim",
|
||||
"security": "ssl",
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
under = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/imap/message",
|
||||
params={"connector_id": account["id"], "mailbox": "INBOX", "uid": 1},
|
||||
)
|
||||
LimitIMAP.raw = small + b"Y"
|
||||
over = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/imap/message",
|
||||
params={"connector_id": account["id"], "mailbox": "INBOX", "uid": 1},
|
||||
)
|
||||
assert "gleicher text" in under["text"]
|
||||
assert "gleicher text" in over["text"]
|
||||
assert under["attachments"][0]["filename"] == "Buero Uebergabe.pdf"
|
||||
assert over["attachments"][0]["filename"] == "Buero Uebergabe.pdf"
|
||||
assert "Content-Transfer-Encoding" not in over["text"]
|
||||
assert "BASE64" not in over["text"].upper()
|
||||
assert over["preview_limited"] is True
|
||||
|
||||
|
||||
def test_upload_and_mail_fetch_leave_the_domain_transaction(client, db, monkeypatch):
|
||||
seen = []
|
||||
|
||||
import app.api.routes as routes
|
||||
import app.ops as ops
|
||||
from app.media.port import publish as real_publish
|
||||
|
||||
def watching(adapter, key, data):
|
||||
seen.append(("publish", ops_conn[0].info.transaction_status))
|
||||
return real_publish(adapter, key, data)
|
||||
|
||||
ops_conn = [None]
|
||||
real_create = ops.create_file
|
||||
|
||||
def wrapped_create(conn, *args, **kwargs):
|
||||
ops_conn[0] = conn
|
||||
return real_create(conn, *args, **kwargs)
|
||||
|
||||
monkeypatch.setattr(ops, "publish", watching)
|
||||
monkeypatch.setattr(routes, "create_file", wrapped_create)
|
||||
ada = Actor(client, "ada-idle@example.test", "Ada Leerlauf")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Ablage"}, status=201)
|
||||
ada.request(
|
||||
"POST",
|
||||
"/api/v1/files",
|
||||
data={"title": "Scan", "context_kind": "case", "context_id": case["id"]},
|
||||
files={"upload": ("scan.pdf", b"%PDF-1.4\n", "application/pdf")},
|
||||
status=201,
|
||||
)
|
||||
assert seen[0][1] == psycopg.pq.TransactionStatus.IDLE
|
||||
|
||||
import app.sourceaccess as sourceaccess
|
||||
|
||||
phase = {"external": False, "status": None}
|
||||
real_release = sourceaccess.release_for_external
|
||||
|
||||
def spy_release(conn):
|
||||
real_release(conn)
|
||||
phase["external"] = True
|
||||
phase["status"] = conn.info.transaction_status
|
||||
|
||||
def spy_owned(*args, **kwargs):
|
||||
if phase["external"]:
|
||||
raise AssertionError("Datenbankzugriff im externen Abschnitt")
|
||||
return real_owned(*args, **kwargs)
|
||||
|
||||
def spy_pull(*args, **kwargs):
|
||||
assert phase["status"] == psycopg.pq.TransactionStatus.IDLE
|
||||
return _multipart("brief", "a.pdf", b"%PDF")
|
||||
|
||||
real_owned = sources._owned
|
||||
monkeypatch.setattr(sourceaccess, "release_for_external", spy_release)
|
||||
monkeypatch.setattr(sources, "_owned", spy_owned)
|
||||
monkeypatch.setattr(sources, "pull_rfc822", spy_pull)
|
||||
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", QuotedIMAP)
|
||||
account = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={
|
||||
"kind": "imap",
|
||||
"name": "Post",
|
||||
"host": "imap.example.test",
|
||||
"port": 993,
|
||||
"username": "ada@example.test",
|
||||
"password": "Postfach-Geheim",
|
||||
"security": "ssl",
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
matter = ada.request("POST", "/api/v1/matters", json={"title": "Post"}, status=201)
|
||||
linked = ada.request(
|
||||
"POST",
|
||||
"/api/v1/external-refs",
|
||||
json={
|
||||
"title": "Brief",
|
||||
"source": "imap",
|
||||
"external_id": "<grenze@example.test>",
|
||||
"context": {"kind": "matter", "id": matter["id"]},
|
||||
"detail": {"connector_id": account["id"], "mailbox": "Sent Items", "uid": 4},
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
opened = ada.request("GET", f"/api/v1/external-refs/{linked['id']}/mail")
|
||||
assert opened["text"]
|
||||
assert phase["status"] == psycopg.pq.TransactionStatus.IDLE
|
||||
|
||||
|
||||
def test_failed_conclusion_keeps_no_partial_file(client, db, monkeypatch):
|
||||
import app.ops as ops
|
||||
|
||||
def fail(*args, **kwargs):
|
||||
raise unprocessable("Abschluss fehlgeschlagen")
|
||||
|
||||
monkeypatch.setattr(ops, "_new_element", fail)
|
||||
ada = Actor(client, "ada-fail@example.test", "Ada Abschluss")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Ablage"}, status=201)
|
||||
ada.request(
|
||||
"POST",
|
||||
"/api/v1/files",
|
||||
data={"title": "Scan", "context_kind": "case", "context_id": case["id"]},
|
||||
files={"upload": ("scan.pdf", b"%PDF-FAIL-CONCLUSION\n", "application/pdf")},
|
||||
status=422,
|
||||
)
|
||||
stored = db.execute("SELECT count(*) AS n FROM elements WHERE title = 'Scan'").fetchone()
|
||||
assert stored["n"] == 0
|
||||
from pathlib import Path
|
||||
from app.core.settings import get_settings
|
||||
|
||||
root = Path(get_settings().media_root)
|
||||
left = [path for path in root.rglob("*") if path.is_file() and b"PDF-FAIL-CONCLUSION" in path.read_bytes()]
|
||||
assert left == []
|
||||
|
||||
|
||||
def test_paperless_filters_change_the_hits(client, db, monkeypatch):
|
||||
catalog = []
|
||||
for number in range(1, 46):
|
||||
catalog.append({
|
||||
"id": number,
|
||||
"title": "Vertrag" if number % 5 == 0 else f"Schrift {number}",
|
||||
"content": "nurinhalt" if number == 41 else f"text {number}",
|
||||
"correspondent": 4 if number % 2 == 0 else 9,
|
||||
"document_type": 8 if number < 30 else 1,
|
||||
"tags": [2, 5] if number % 3 == 0 else [2],
|
||||
"created": "2024-06-01" if number > 20 else "2023-01-01",
|
||||
})
|
||||
|
||||
def fake_get(base, token, path, params):
|
||||
if path != "/api/documents/":
|
||||
return {"count": 1, "results": [{"id": 4, "name": "Haus"}]}
|
||||
matched = []
|
||||
for item in catalog:
|
||||
query = params.get("title_content") or params.get("query") or ""
|
||||
title = params.get("title__icontains") or ""
|
||||
if query and query.casefold() not in f"{item['title']} {item['content']}".casefold():
|
||||
continue
|
||||
if title and title.casefold() not in item["title"].casefold():
|
||||
continue
|
||||
if params.get("correspondent__id") and str(item["correspondent"]) != params["correspondent__id"]:
|
||||
continue
|
||||
if params.get("document_type__id") and str(item["document_type"]) != params["document_type__id"]:
|
||||
continue
|
||||
if params.get("tags__id__all"):
|
||||
needed = {int(part) for part in params["tags__id__all"].split(",") if part}
|
||||
if not needed.issubset(set(item["tags"])):
|
||||
continue
|
||||
start = params.get("created__date__gte")
|
||||
end = params.get("created__date__lte")
|
||||
if start and item["created"] < start:
|
||||
continue
|
||||
if end and item["created"] > end:
|
||||
continue
|
||||
matched.append(item)
|
||||
page = int(params.get("page") or 1)
|
||||
start_at = (page - 1) * 20
|
||||
rows = matched[start_at:start_at + 20]
|
||||
return {
|
||||
"count": len(matched),
|
||||
"results": [{"id": item["id"], "title": item["title"], "created": item["created"]} for item in rows],
|
||||
}
|
||||
|
||||
monkeypatch.setattr(sources, "_paperless_get", fake_get)
|
||||
ada = Actor(client, "ada-sense@example.test", "Ada Sinn")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
account = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={"kind": "paperless", "name": "Archiv", "base_url": "https://paper.example.test", "token": "token-alpha"},
|
||||
status=201,
|
||||
)
|
||||
content = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={"connector_id": account["id"], "q": "nurinhalt"},
|
||||
)
|
||||
assert [item["id"] for item in content["items"]] == ["41"]
|
||||
title = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={"connector_id": account["id"], "title": "Vertrag"},
|
||||
)
|
||||
assert title["items"]
|
||||
assert all("Vertrag" in item["title"] for item in title["items"])
|
||||
assert all(item["id"] != "41" for item in title["items"])
|
||||
combined = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={
|
||||
"connector_id": account["id"],
|
||||
"correspondent": "4",
|
||||
"document_type": "8",
|
||||
"tag": "2,5",
|
||||
"document_from": "2023-01-01",
|
||||
"document_to": "2024-12-31",
|
||||
},
|
||||
)
|
||||
plain = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={"connector_id": account["id"], "cursor": "2"},
|
||||
)
|
||||
assert [item["id"] for item in combined["items"]] == ["6", "12", "18", "24"]
|
||||
assert [item["id"] for item in plain["items"]][0] == "21"
|
||||
@@ -230,7 +230,7 @@ def test_dispatch_keeps_the_secured_stand_and_distinct_mail_parts(client, db, mo
|
||||
"Fachlicher Zusatz: die Frist bleibt der 1. Juni.",
|
||||
[("rechnung.pdf", PDF_A), ("lage.pdf", PDF_B), ("konto.pdf", PDF_C), ("lage.pdf", PDF_D)],
|
||||
)
|
||||
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
|
||||
monkeypatch.setattr("app.sources.pull_rfc822", lambda *args, **kwargs: raw)
|
||||
ada = Actor(client, "ada-versand@example.test", "Ada Versand")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
"""Bereits eingefügte Quelldokumente: Vorabfrage, Warnung (409), erneutes Einfügen und zusätzliches Einbinden."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
|
||||
from tests.support import matter_of
|
||||
from tests.test_team import _main
|
||||
|
||||
PREF = "/api/v1/auth/preferences/duplicate_check"
|
||||
EXISTING = "/api/v1/external-refs/existing"
|
||||
CONNECTOR = str(uuid4())
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def ada(client, db):
|
||||
return _main(client, db, "ada", main=True)
|
||||
|
||||
|
||||
def _ref(actor, kind, container, external_id="41", connector=CONNECTOR, status=201, **extra):
|
||||
body = {
|
||||
"title": f"Dokument {external_id}",
|
||||
"source": "paperless",
|
||||
"external_id": external_id,
|
||||
"context": {"kind": kind, "id": container},
|
||||
"detail": {"connector_id": connector},
|
||||
**extra,
|
||||
}
|
||||
return actor.request("POST", "/api/v1/external-refs", json=body, status=status)
|
||||
|
||||
|
||||
def _ask(actor, kind, container, external_id="41", connector=CONNECTOR):
|
||||
body = {
|
||||
"context": {"kind": kind, "id": container},
|
||||
"items": [{"source": "paperless", "external_id": external_id, "connector_id": connector}],
|
||||
}
|
||||
return actor.request("POST", EXISTING, json=body)["items"][0]["matches"]
|
||||
|
||||
|
||||
def _level(actor, value):
|
||||
actor.request("PUT", PREF, json={"value": value})
|
||||
|
||||
|
||||
def test_a_document_in_the_same_container_warns_and_can_be_inserted_anyway(ada):
|
||||
matter = matter_of(ada, "Mietminderung")["id"]
|
||||
first = _ref(ada, "matter", matter)
|
||||
found = _ask(ada, "matter", matter)
|
||||
assert [(m["element_id"], m["where"], m["certain"]) for m in found] == [(first["id"], "here", True)]
|
||||
|
||||
refused = _ref(ada, "matter", matter, status=409)
|
||||
assert refused["code"] == "already_present"
|
||||
# A deliberate second insert goes through. Another document or another connection is no duplicate.
|
||||
_ref(ada, "matter", matter, duplicate="insert")
|
||||
_ref(ada, "matter", matter, external_id="42")
|
||||
_ref(ada, "matter", matter, connector=str(uuid4()))
|
||||
assert _ask(ada, "matter", matter, external_id="42")[0]["where"] == "here"
|
||||
|
||||
|
||||
def test_the_same_document_in_another_vorgang_is_no_duplicate(ada):
|
||||
one = matter_of(ada, "Eins")["id"]
|
||||
two = matter_of(ada, "Zwei")["id"]
|
||||
_ref(ada, "matter", one)
|
||||
assert _ask(ada, "matter", two) == []
|
||||
_ref(ada, "matter", two)
|
||||
|
||||
|
||||
def test_the_check_can_be_switched_off(ada):
|
||||
matter = matter_of(ada, "Mietminderung")["id"]
|
||||
_ref(ada, "matter", matter)
|
||||
_level(ada, "off")
|
||||
assert _ask(ada, "matter", matter) == []
|
||||
_ref(ada, "matter", matter)
|
||||
|
||||
|
||||
def test_levels_reach_into_teilvorgang_vorgang_and_akte(ada):
|
||||
parent = matter_of(ada, "Hauptvorgang")["id"]
|
||||
child = ada.request("POST", "/api/v1/matters", json={"title": "Teil", "parent_matter_id": parent}, status=201)["id"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Akte"}, status=201)["id"]
|
||||
ada.request("POST", f"/api/v1/matters/{parent}/case-links", json={"case_id": case}, status=201)
|
||||
_ref(ada, "matter", child, external_id="1")
|
||||
_ref(ada, "matter", parent, external_id="2")
|
||||
_ref(ada, "case", case, external_id="3")
|
||||
|
||||
def where(kind, container, external_id):
|
||||
return [m["where"] for m in _ask(ada, kind, container, external_id)]
|
||||
|
||||
# Standard: only what sits directly in the target.
|
||||
assert where("matter", parent, "1") == []
|
||||
_level(ada, "inside")
|
||||
assert where("matter", parent, "1") == ["inside"]
|
||||
assert where("matter", child, "2") == []
|
||||
assert where("case", case, "2") == ["inside"]
|
||||
assert where("case", case, "3") == ["here"]
|
||||
_level(ada, "around")
|
||||
assert where("matter", child, "2") == ["around"]
|
||||
assert where("matter", parent, "3") == ["around"]
|
||||
assert where("matter", child, "3") == ["around"]
|
||||
# The server warns at the same level.
|
||||
_ref(ada, "matter", child, external_id="3", status=409)
|
||||
|
||||
|
||||
def test_an_existing_element_can_be_bound_instead_of_a_new_one(ada):
|
||||
parent = matter_of(ada, "Hauptvorgang")["id"]
|
||||
child = ada.request("POST", "/api/v1/matters", json={"title": "Teil", "parent_matter_id": parent}, status=201)["id"]
|
||||
original = _ref(ada, "matter", child)
|
||||
_level(ada, "inside")
|
||||
assert _ask(ada, "matter", parent)[0]["can_bind"] is True
|
||||
|
||||
bound = _ref(ada, "matter", parent, bind_element_id=original["id"])
|
||||
assert bound["id"] == original["id"]
|
||||
assert [m["where"] for m in _ask(ada, "matter", parent)] == ["here"]
|
||||
refused = _ref(ada, "matter", parent, bind_element_id=original["id"], status=422)
|
||||
assert "bereits" in refused["detail"]
|
||||
|
||||
|
||||
def test_a_stranger_neither_sees_nor_binds_my_element(client, db, ada):
|
||||
mine = matter_of(ada, "Mein Vorgang")["id"]
|
||||
element = _ref(ada, "matter", mine)
|
||||
ben = _main(client, db, "ben")
|
||||
theirs = matter_of(ben, "Ihr Vorgang")["id"]
|
||||
_level(ben, "around")
|
||||
assert _ask(ben, "matter", theirs) == []
|
||||
_ref(ben, "matter", theirs)
|
||||
_ref(ben, "matter", theirs, bind_element_id=element["id"], status=404)
|
||||
@@ -141,9 +141,9 @@ def test_handover_package_follows_the_confirmed_selection(client, db, monkeypatc
|
||||
"Der vollständige Brieftext bleibt erhalten.",
|
||||
[("lage.pdf", PDF_A), ("lage.pdf", PDF_B)],
|
||||
)
|
||||
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
|
||||
monkeypatch.setattr("app.sources.pull_rfc822", lambda *args, **kwargs: raw)
|
||||
monkeypatch.setattr(
|
||||
"app.retrieval.pull_paperless_original",
|
||||
"app.sources.pull_paperless_original",
|
||||
lambda *args, **kwargs: (PDF_B, "application/pdf", "archiv.pdf"),
|
||||
)
|
||||
ada = Actor(client, "ada-export@example.test", "Ada Export")
|
||||
@@ -491,7 +491,7 @@ def test_export_names_gaps_and_hides_unreadable_counterparts(client, db, monkeyp
|
||||
calls.append(args)
|
||||
return _eml("<stored@example.test>", "darf nicht ersatzweise kommen", [])
|
||||
|
||||
monkeypatch.setattr("app.retrieval.pull_rfc822", pull)
|
||||
monkeypatch.setattr("app.sources.pull_rfc822", pull)
|
||||
context = {"kind": "case", "id": case["id"]}
|
||||
tree = ada.request(
|
||||
"GET",
|
||||
@@ -547,7 +547,7 @@ def test_export_names_gaps_and_hides_unreadable_counterparts(client, db, monkeyp
|
||||
assert {item["name"] for item in pending["issues"][0]["choices"]} == {"Neu", "Weiter"}
|
||||
monkeypatch.setattr("app.retrieval.EXPORT_BYTE_LIMIT", 40)
|
||||
huge = _eml("<offen@example.test>", "GEKÜRZT-VERBOTEN " * 20, [])
|
||||
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: huge)
|
||||
monkeypatch.setattr("app.sources.pull_rfc822", lambda *args, **kwargs: huge)
|
||||
assigned = ada.request(
|
||||
"POST",
|
||||
f"/api/v1/matters/{matter['id']}/export/review",
|
||||
@@ -557,7 +557,7 @@ def test_export_names_gaps_and_hides_unreadable_counterparts(client, db, monkeyp
|
||||
assert "GEKÜRZT-VERBOTEN" not in json.dumps(assigned)
|
||||
wrong = _eml("<andere@example.test>", "FALSCHE-NACHRICHT", [])
|
||||
monkeypatch.setattr("app.retrieval.EXPORT_BYTE_LIMIT", 80 * 1024 * 1024)
|
||||
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: wrong)
|
||||
monkeypatch.setattr("app.sources.pull_rfc822", lambda *args, **kwargs: wrong)
|
||||
identity = ada.request(
|
||||
"POST",
|
||||
f"/api/v1/matters/{matter['id']}/export/review",
|
||||
@@ -609,7 +609,7 @@ def test_nested_chapter_export_keeps_path_and_complete_mail(client, db, monkeypa
|
||||
"Die Antwort bleibt vollständig.",
|
||||
[("lage.pdf", PDF_A), ("konto.pdf", PDF_B)],
|
||||
)
|
||||
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
|
||||
monkeypatch.setattr("app.sources.pull_rfc822", lambda *args, **kwargs: raw)
|
||||
ada = Actor(client, "ada-nested-export@example.test", "Ada Verschachtelt")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
@@ -844,7 +844,7 @@ def test_chapter_entries_share_one_numbering_sequence(client, db, monkeypatch):
|
||||
files={"upload": ("drittes.pdf", PDF_C, "application/pdf")},
|
||||
status=201,
|
||||
)
|
||||
monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
|
||||
monkeypatch.setattr("app.sources.pull_rfc822", lambda *args, **kwargs: raw)
|
||||
tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]
|
||||
exportable = {"binding", "annotation", "attachment", "dispatch_item", "evidence"}
|
||||
selected = [node["id"] for node in _walk(tree) if node["exportable"] and node["kind"] in exportable]
|
||||
|
||||
@@ -0,0 +1,273 @@
|
||||
"""Bibliothek: Zähler nur aus Lesbarem, Rauminhalt, Raumübersicht und Teilen im Stapel."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.auth.accounts import create_account
|
||||
from tests.support import PASSWORD, Actor, matter_of
|
||||
|
||||
|
||||
def _second_client():
|
||||
from app.main import app
|
||||
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _actor(client, db, key: str, *, main: bool = False) -> Actor:
|
||||
actor = Actor(client if main else _second_client(), f"{key}-bib@example.test", key.title())
|
||||
create_account(db, actor.email, actor.name, PASSWORD)
|
||||
db.commit()
|
||||
actor.login()
|
||||
return actor
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def world(client, db):
|
||||
ada = _actor(client, db, "ada", main=True)
|
||||
ben = _actor(client, db, "ben")
|
||||
cem = _actor(client, db, "cem")
|
||||
dan = _actor(client, db, "dan")
|
||||
room = ada.request("POST", "/api/v1/rooms", json={"name": "Werkstatt", "default_visibility": "private"}, status=201)["id"]
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "member"})
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": cem.email, "role": "reader"})
|
||||
return {"ada": ada, "ben": ben, "cem": cem, "dan": dan, "room": room}
|
||||
|
||||
|
||||
def _share(actor, plural, resource_id, room, status=200):
|
||||
return actor.request("PUT", f"/api/v1/{plural}/{resource_id}/room-share/rooms/{room}", json={"access": "edit"}, status=status)
|
||||
|
||||
|
||||
def _link(actor, matter, case):
|
||||
actor.request("POST", f"/api/v1/matters/{matter}/case-links", json={"case_id": case}, status=201)
|
||||
|
||||
|
||||
def test_counts_include_only_what_the_person_may_read(world):
|
||||
ada, ben, room = world["ada"], world["ben"], world["room"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Vermietung"}, status=201)
|
||||
child = ada.request(
|
||||
"POST", "/api/v1/cases",
|
||||
json={"title": "Nebenkosten", "parent_case_id": case["id"], "rights_mode": "inherit_parent"}, status=201,
|
||||
)
|
||||
one = matter_of(ada, "Mietminderung")
|
||||
two = matter_of(ada, "Eigenbedarf intern")
|
||||
_link(ada, one["id"], case["id"])
|
||||
_link(ada, two["id"], case["id"])
|
||||
_share(ada, "cases", case["id"], room)
|
||||
|
||||
mine = next(i for i in ada.request("GET", "/api/v1/cases")["items"] if i["id"] == case["id"])
|
||||
assert (mine["child_cases"], mine["matter_count"]) == (1, 2)
|
||||
assert [s["name"] for s in mine["shared_with"]] == ["Werkstatt"]
|
||||
|
||||
# One matter is withheld from the room members in this case.
|
||||
ada.request(
|
||||
"PUT", "/api/v1/exceptions",
|
||||
json={"resource_kind": "matter", "resource_id": two["id"], "context": {"kind": "case", "id": case["id"]}, "remove_read": True},
|
||||
)
|
||||
seen = next(i for i in ben.request("GET", "/api/v1/cases")["items"] if i["id"] == case["id"])
|
||||
assert seen["matter_count"] == 1 and seen["shared_with"] == [] and seen["is_owner"] is False
|
||||
assert child["title"] == "Nebenkosten"
|
||||
|
||||
|
||||
def test_a_room_shows_its_contents_to_members_only(world):
|
||||
ada, ben, cem, dan, room = world["ada"], world["ben"], world["cem"], world["dan"], world["room"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Im Raum"}, status=201)
|
||||
sub = ada.request(
|
||||
"POST", "/api/v1/cases",
|
||||
json={"title": "Unter der Akte", "parent_case_id": case["id"], "rights_mode": "inherit_parent"}, status=201,
|
||||
)
|
||||
ada.request("POST", "/api/v1/cases", json={"title": "Bleibt privat"}, status=201)
|
||||
matter = matter_of(ada, "Vorgang im Raum")
|
||||
_share(ada, "cases", case["id"], room)
|
||||
_share(ada, "matters", matter["id"], room)
|
||||
|
||||
for member in (ada, ben, cem):
|
||||
found = member.request("GET", f"/api/v1/rooms/{room}/contents")
|
||||
assert {c["title"] for c in found["cases"]} == {"Im Raum", "Unter der Akte"}
|
||||
assert [m["title"] for m in found["matters"]] == ["Vorgang im Raum"]
|
||||
dan.request("GET", f"/api/v1/rooms/{room}/contents", status=403)
|
||||
# A person who is excluded does not see the entry in the room either.
|
||||
ada.request("PUT", f"/api/v1/cases/{case['id']}/room-share/people/{_id(ada, ben)}", json={"excluded": True})
|
||||
titles = {c["title"] for c in ben.request("GET", f"/api/v1/rooms/{room}/contents")["cases"]}
|
||||
assert "Im Raum" not in titles
|
||||
assert sub["title"] == "Unter der Akte"
|
||||
|
||||
|
||||
def test_the_room_overview_names_members_only_to_managers(world):
|
||||
ada, ben, room = world["ada"], world["ben"], world["room"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Gezählt"}, status=201)
|
||||
_share(ada, "cases", case["id"], room)
|
||||
mine = next(r for r in ada.request("GET", "/api/v1/rooms/overview")["items"] if r["id"] == room)
|
||||
assert mine["is_owner"] is True and mine["role"] == "manager" and mine["member_count"] == 3
|
||||
assert mine["case_count"] == 1 and mine["matter_count"] == 0
|
||||
assert set(mine["members"]) == {"Ada", "Ben", "Cem"}
|
||||
theirs = next(r for r in ben.request("GET", "/api/v1/rooms/overview")["items"] if r["id"] == room)
|
||||
assert theirs["members"] == [] and theirs["member_count"] == 3 and theirs["is_owner"] is False
|
||||
assert world["dan"].request("GET", "/api/v1/rooms/overview")["items"] == []
|
||||
|
||||
|
||||
def test_several_entries_are_shared_at_once_or_not_at_all(world):
|
||||
ada, ben, room = world["ada"], world["ben"], world["room"]
|
||||
a = ada.request("POST", "/api/v1/cases", json={"title": "Eins"}, status=201)
|
||||
b = ada.request("POST", "/api/v1/cases", json={"title": "Zwei"}, status=201)
|
||||
m = matter_of(ada, "Drei")
|
||||
done = ada.request(
|
||||
"POST", f"/api/v1/rooms/{room}/shares",
|
||||
json={"items": [{"kind": "case", "id": a["id"]}, {"kind": "case", "id": b["id"]}, {"kind": "matter", "id": m["id"]}], "access": "read"},
|
||||
)
|
||||
assert done["shared"] == 3
|
||||
assert {(e["display_name"], e["role"], e["rights"]["edit"]) for e in done["effect"]} == {("Ben", "member", False), ("Cem", "reader", False)}
|
||||
assert ben.request("GET", f"/api/v1/cases/{a['id']}")["rights"]["edit"] is False
|
||||
|
||||
foreign = ben.request("POST", "/api/v1/cases", json={"title": "Von Ben"}, status=201)
|
||||
c = ada.request("POST", "/api/v1/cases", json={"title": "Vier"}, status=201)
|
||||
ada.request(
|
||||
"POST", f"/api/v1/rooms/{room}/shares",
|
||||
json={"items": [{"kind": "case", "id": c["id"]}, {"kind": "case", "id": foreign["id"]}]}, status=404,
|
||||
)
|
||||
assert room not in [s["room_id"] for s in ada.request("GET", f"/api/v1/cases/{c['id']}/room-share")["shares"]]
|
||||
# An outsider cannot put his own entry into the room, and nobody shares an entry of someone else.
|
||||
own = world["dan"].request("POST", "/api/v1/cases", json={"title": "Von Dan"}, status=201)
|
||||
world["dan"].request("POST", f"/api/v1/rooms/{room}/shares", json={"items": [{"kind": "case", "id": own["id"]}]}, status=403)
|
||||
world["cem"].request("POST", f"/api/v1/rooms/{room}/shares", json={"items": [{"kind": "case", "id": c["id"]}]}, status=404)
|
||||
|
||||
|
||||
def test_creating_an_entry_can_put_it_into_a_room_and_reports_the_effect(world):
|
||||
ada, ben, room = world["ada"], world["ben"], world["room"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Gleich im Raum", "share_with_room_id": room}, status=201)
|
||||
matter = ada.request("POST", "/api/v1/matters", json={"title": "Vorgang im Raum", "share_with_room_id": room}, status=201)
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
ben.request("GET", f"/api/v1/matters/{matter['id']}")
|
||||
other = ada.request("POST", "/api/v1/cases", json={"title": "Ohne Raum"}, status=201)
|
||||
ben.request("GET", f"/api/v1/cases/{other['id']}", status=404)
|
||||
answer = _share(ada, "cases", other["id"], room)
|
||||
assert {e["display_name"] for e in answer["effect"]} == {"Ben", "Cem"}
|
||||
world["dan"].request("POST", "/api/v1/cases", json={"title": "Fremd", "share_with_room_id": room}, status=403)
|
||||
|
||||
|
||||
def _id(owner: Actor, person: Actor) -> str:
|
||||
from app.core.settings import get_settings
|
||||
import psycopg
|
||||
|
||||
with psycopg.connect(get_settings().dsn(), row_factory=psycopg.rows.dict_row) as conn:
|
||||
return str(conn.execute("SELECT id FROM auth_accounts WHERE email = %s", (person.email,)).fetchone()["id"])
|
||||
|
||||
|
||||
def test_the_outline_lists_only_what_the_person_may_read(world):
|
||||
ada, ben, cem, dan, room = world["ada"], world["ben"], world["cem"], world["dan"], world["room"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Gliederung"}, status=201)
|
||||
ada.request("POST", f"/api/v1/cases/{case['id']}/chapters", json={"title": "Schriftverkehr"}, status=201)
|
||||
sub = ada.request(
|
||||
"POST", "/api/v1/cases",
|
||||
json={"title": "Unterakte", "parent_case_id": case["id"], "rights_mode": "inherit_parent"}, status=201,
|
||||
)
|
||||
open_matter = matter_of(ada, "Offener Vorgang")
|
||||
hidden_matter = matter_of(ada, "Verborgener Vorgang")
|
||||
child = ada.request("POST", "/api/v1/matters", json={"title": "Teilvorgang", "parent_matter_id": open_matter["id"]}, status=201)
|
||||
ada.request("POST", f"/api/v1/matters/{open_matter['id']}/chapters", json={"title": "Belege"}, status=201)
|
||||
_link(ada, open_matter["id"], case["id"])
|
||||
_link(ada, hidden_matter["id"], case["id"])
|
||||
_share(ada, "cases", case["id"], room)
|
||||
ada.request(
|
||||
"PUT", "/api/v1/exceptions",
|
||||
json={"resource_kind": "matter", "resource_id": hidden_matter["id"], "context": {"kind": "case", "id": case["id"]}, "remove_read": True},
|
||||
)
|
||||
|
||||
mine = ada.request("GET", f"/api/v1/cases/{case['id']}/outline")
|
||||
assert [c["title"] for c in mine["chapters"]] == ["Schriftverkehr"]
|
||||
assert [c["title"] for c in mine["subcases"]] == ["Unterakte"]
|
||||
# An exception in the case context hides the matter there for everyone, the owner included.
|
||||
assert {m["title"] for m in mine["matters"]} == {"Offener Vorgang"}
|
||||
seen = ben.request("GET", f"/api/v1/cases/{case['id']}/outline")
|
||||
assert {m["title"] for m in seen["matters"]} == {"Offener Vorgang"}
|
||||
assert [c["title"] for c in seen["matters"][0]["children"]] == ["Teilvorgang"]
|
||||
assert sub["id"] in [c["id"] for c in seen["subcases"]]
|
||||
|
||||
matter = ada.request("GET", f"/api/v1/matters/{open_matter['id']}/outline")
|
||||
assert [c["title"] for c in matter["chapters"]] == ["Belege"]
|
||||
assert [c["title"] for c in matter["submatters"]] == ["Teilvorgang"]
|
||||
in_case = ben.request(
|
||||
"GET", f"/api/v1/matters/{open_matter['id']}/outline",
|
||||
params={"context_kind": "case", "context_id": case["id"]},
|
||||
)
|
||||
assert [c["title"] for c in in_case["submatters"]] == ["Teilvorgang"]
|
||||
ben.request("GET", f"/api/v1/matters/{open_matter['id']}/outline", status=404)
|
||||
assert child["title"] == "Teilvorgang"
|
||||
|
||||
unknown = "00000000-0000-4000-8000-000000000000"
|
||||
seen_status = dan.request("GET", f"/api/v1/cases/{case['id']}/outline", status=404)
|
||||
missing = dan.request("GET", f"/api/v1/cases/{unknown}/outline", status=404)
|
||||
assert seen_status["detail"] == missing["detail"]
|
||||
dan.request("GET", f"/api/v1/matters/{open_matter['id']}/outline", status=404)
|
||||
assert cem.request("GET", f"/api/v1/cases/{case['id']}/outline")["id"] == case["id"]
|
||||
|
||||
|
||||
def test_unlinking_keeps_the_matter_and_its_other_cases(world):
|
||||
ada, ben = world["ada"], world["ben"]
|
||||
first = ada.request("POST", "/api/v1/cases", json={"title": "Vermietung"}, status=201)["id"]
|
||||
second = ada.request("POST", "/api/v1/cases", json={"title": "Steuer"}, status=201)["id"]
|
||||
matter = matter_of(ada, "Nebenkosten")["id"]
|
||||
ada.request("POST", f"/api/v1/matters/{matter}/case-links", json={"case_id": first}, status=201)
|
||||
ada.request("POST", f"/api/v1/matters/{matter}/case-links", json={"case_id": second}, status=201)
|
||||
links = ada.request("GET", f"/api/v1/matters/{matter}")["case_links"]
|
||||
assert {item["case_id"] for item in links} == {first, second}
|
||||
link = next(item for item in links if item["case_id"] == first)
|
||||
|
||||
# A stranger cannot detach it and learns nothing about it.
|
||||
ben.request("DELETE", f"/api/v1/matter-case-links/{link['id']}", status=404)
|
||||
|
||||
ada.request("DELETE", f"/api/v1/matter-case-links/{link['id']}", status=204)
|
||||
opened = ada.request("GET", f"/api/v1/matters/{matter}")
|
||||
assert [item["case_id"] for item in opened["case_links"]] == [second]
|
||||
assert opened["title"] == "Nebenkosten"
|
||||
assert matter in {item["id"] for item in ada.request("GET", "/api/v1/matters")["items"]}
|
||||
ada.request("DELETE", f"/api/v1/matter-case-links/{link['id']}", status=404)
|
||||
|
||||
|
||||
def test_download_policy_follows_the_room_role(world):
|
||||
ada, ben, cem, dan, room = world["ada"], world["ben"], world["cem"], world["dan"], world["room"]
|
||||
matter = matter_of(ada, "Nebenkosten")["id"]
|
||||
file = ada.request(
|
||||
"POST",
|
||||
"/api/v1/files",
|
||||
data={"title": "Vertrag", "context_kind": "matter", "context_id": matter},
|
||||
files={"upload": ("vertrag.pdf", b"%PDF-1.4\n1 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\n", "application/pdf")},
|
||||
status=201,
|
||||
)["id"]
|
||||
_share(ada, "matters", matter, room)
|
||||
path = f"/api/v1/files/{file}/content"
|
||||
query = {"context_kind": "matter", "context_id": matter}
|
||||
|
||||
def fetch(person, **extra):
|
||||
from tests.support import ORIGIN
|
||||
|
||||
headers = {"Origin": ORIGIN, "X-CSRF-Token": person.csrf}
|
||||
if person.scope is not None:
|
||||
headers["X-Scope-Kind"], headers["X-Scope-Id"] = person.scope["kind"], person.scope["id"]
|
||||
return person.client.get(path, params={**query, **extra}, headers=headers)
|
||||
|
||||
# By default every role may save the original.
|
||||
for person in (ben, cem):
|
||||
assert fetch(person, save="true").status_code == 200
|
||||
seen = ben.request("GET", f"/api/v1/matters/{matter}")
|
||||
assert seen["rights"]["download"] is True
|
||||
|
||||
# The owner turns it off for readers. Reading stays possible, saving does not.
|
||||
assert cem.request("GET", f"/api/v1/rooms/{room}/download-policy")["can_change"] is False
|
||||
cem.request("PUT", f"/api/v1/rooms/{room}/download-policy", json={"manager": True, "member": True, "reader": False}, status=403)
|
||||
ada.request("PUT", f"/api/v1/rooms/{room}/download-policy", json={"manager": True, "member": True, "reader": False})
|
||||
assert fetch(cem).status_code == 200
|
||||
refused = fetch(cem, save="true")
|
||||
assert refused.status_code == 403
|
||||
assert "freigegeben" in refused.json()["detail"]
|
||||
assert cem.request("GET", f"/api/v1/matters/{matter}")["rights"]["download"] is False
|
||||
assert fetch(ben, save="true").status_code == 200
|
||||
# A stranger learns nothing about the policy of the room.
|
||||
dan.request("GET", f"/api/v1/rooms/{room}/download-policy", status=404)
|
||||
|
||||
# The owner's default is copied into a new room.
|
||||
ada.request("PUT", "/api/v1/auth/download-defaults", json={"manager": True, "member": False, "reader": False, "direct": True})
|
||||
fresh = ada.request("POST", "/api/v1/rooms", json={"name": "Neu", "default_visibility": "private"}, status=201)["id"]
|
||||
assert ada.request("GET", f"/api/v1/rooms/{fresh}/download-policy")["roles"] == {"manager": True, "member": False, "reader": False}
|
||||
assert ada.request("GET", f"/api/v1/rooms/{room}/download-policy")["roles"]["member"] is True
|
||||
@@ -0,0 +1,81 @@
|
||||
"""HTML mail: formatting stays, everything active or loading from outside is removed."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from app.mailpack import sanitize_html
|
||||
|
||||
|
||||
def test_formatting_stays_and_active_content_goes():
|
||||
cleaned = sanitize_html(
|
||||
'<div style="color:#333;font-size:14px" onclick="steal()"><font color="red" size="3">Hallo</font>'
|
||||
'<table bgcolor="#eee" width="100%"><tr><td align="center">x</td></tr></table><hr>'
|
||||
'<script>alert(1)</script><iframe src="http://x"></iframe><form action="http://x"><input></form></div>'
|
||||
)
|
||||
assert 'style="color: #333; font-size: 14px"' in cleaned
|
||||
assert '<font color="red" size="3">' in cleaned
|
||||
assert 'bgcolor="#eee"' in cleaned and "<hr>" in cleaned
|
||||
for forbidden in ("onclick", "script", "iframe", "<form", "<input", "alert"):
|
||||
assert forbidden not in cleaned
|
||||
|
||||
|
||||
def test_styles_cannot_load_or_position():
|
||||
cleaned = sanitize_html(
|
||||
'<p style="background:url(http://track/p.png);position:fixed;width:expression(alert(1));'
|
||||
'color:red;behavior:url(x.htc);margin:4px">Text</p>'
|
||||
)
|
||||
assert "url" not in cleaned and "position" not in cleaned and "expression" not in cleaned and "behavior" not in cleaned
|
||||
assert "color: red" in cleaned and "margin: 4px" in cleaned
|
||||
|
||||
|
||||
def test_links_and_images_are_limited():
|
||||
cleaned = sanitize_html(
|
||||
'<a href="javascript:alert(1)">a</a><a href="https://ok.example/x">b</a><a href="data:text/html,x">c</a>'
|
||||
'<img src="http://track/p.gif"><img src="data:image/png;base64,AAAA" alt="logo"><img src="data:image/svg+xml;base64,AAAA">'
|
||||
)
|
||||
assert "javascript" not in cleaned and "data:text" not in cleaned and "track" not in cleaned and "svg" not in cleaned
|
||||
assert 'href="https://ok.example/x"' in cleaned
|
||||
assert 'rel="noreferrer noopener"' in cleaned and 'target="_blank"' in cleaned
|
||||
assert 'src="data:image/png;base64,AAAA"' in cleaned
|
||||
|
||||
|
||||
def test_remote_pictures_stay_out_unless_the_server_loads_them():
|
||||
source = '<img src="https://cdn.example/a.png" alt="a"><img src="http://plain.example/b.png"><p>Text</p>'
|
||||
found: list[str] = []
|
||||
assert "<img" not in sanitize_html(source, found=found)
|
||||
assert found == ["https://cdn.example/a.png"]
|
||||
loaded = sanitize_html(source, remote=lambda url: "data:image/png;base64,AAAA" if "cdn" in url else "")
|
||||
assert loaded.count("<img") == 1 and 'src="data:image/png;base64,AAAA"' in loaded
|
||||
|
||||
|
||||
def test_the_server_never_fetches_internal_or_odd_addresses():
|
||||
from app.remoteimages import RemoteImages, fetch_image, is_public
|
||||
|
||||
for address in ("127.0.0.1", "10.0.0.5", "192.168.1.1", "169.254.169.254", "::1", "fd00::1", "224.0.0.1", "not-an-ip"):
|
||||
assert is_public(address) is False
|
||||
assert is_public("93.184.216.34") is True
|
||||
for url in (
|
||||
"http://example.org/a.png",
|
||||
"https://127.0.0.1/a.png",
|
||||
"https://localhost/a.png",
|
||||
"https://[::1]/a.png",
|
||||
"https://example.org:8443/a.png",
|
||||
"https://user:pw@example.org/a.png",
|
||||
"file:///etc/passwd",
|
||||
"https:///a.png",
|
||||
):
|
||||
assert fetch_image(url) is None
|
||||
assert RemoteImages()("https://127.0.0.1/a.png") == ""
|
||||
|
||||
|
||||
def test_remote_pictures_are_checked_by_content_and_limited(monkeypatch):
|
||||
import app.remoteimages as module
|
||||
|
||||
png = b"\x89PNG\r\n\x1a\n" + b"0" * 20
|
||||
monkeypatch.setattr(module, "fetch_image", lambda url: png if url.endswith(".png") else None)
|
||||
loader = module.RemoteImages()
|
||||
assert loader("https://a.example/1.png").startswith("data:image/png;base64,")
|
||||
assert loader("https://a.example/1.png").startswith("data:image/png")
|
||||
assert loader("https://a.example/1.svg") == ""
|
||||
assert (loader.loaded, loader.failed) == (1, 1)
|
||||
assert module._kind(b"<svg xmlns='http://www.w3.org/2000/svg'></svg>") is None
|
||||
assert module._kind(b"RIFF\x00\x00\x00\x00WEBPVP8 ") == "webp"
|
||||
@@ -180,9 +180,12 @@ def test_foreign_mailbox_stays_hidden(client, db, monkeypatch):
|
||||
class HugeIMAP(FakeIMAP):
|
||||
def uid(self, command, *args):
|
||||
spec = " ".join(str(part) for part in args[1:]) if len(args) > 1 else ""
|
||||
if command == "FETCH" and "BODY.PEEK[]" in spec:
|
||||
if command == "FETCH" and "BODY.PEEK[]" in spec and "<" not in spec:
|
||||
return "OK", [(b"rfc822", b"x" * 8_000_001)]
|
||||
if "BODY.PEEK[TEXT]" in spec:
|
||||
if "BODYSTRUCTURE" in spec:
|
||||
structure = b'("TEXT" "PLAIN" ("CHARSET" "utf-8") NIL NIL "7BIT" 40 1 NIL NIL NIL NIL)'
|
||||
return "OK", [(b"body", structure)]
|
||||
if "BODY.PEEK[1]" in spec:
|
||||
return "OK", [(b"text", "Kurzer Auszug der grossen Nachricht.".encode())]
|
||||
return super().uid(command, *args)
|
||||
|
||||
@@ -282,3 +285,195 @@ def test_an_adopted_message_loads_in_full_with_its_attachment(client, db, monkey
|
||||
ada.request("GET", f"/api/v1/external-refs/{wrong['element']['id']}/mail", status=422)
|
||||
ben.login()
|
||||
ben.request("GET", f"/api/v1/external-refs/{created['id']}/mail", status=404)
|
||||
|
||||
|
||||
def _letter(message_id: str, body: str) -> bytes:
|
||||
return (
|
||||
f"From: Ada Beispiel <ada@example.test>\r\n"
|
||||
f"To: Gegenseite <gegen@example.test>\r\n"
|
||||
f"Subject: Verschoben\r\n"
|
||||
f"Date: Thu, 02 May 2024 08:00:00 +0000\r\n"
|
||||
f"Message-ID: {message_id}\r\n"
|
||||
f"MIME-Version: 1.0\r\n"
|
||||
f"Content-Type: text/plain; charset=utf-8\r\n"
|
||||
f"\r\n"
|
||||
f"{body}\r\n"
|
||||
).encode()
|
||||
|
||||
|
||||
class RelocatingIMAP:
|
||||
"""The saved UID holds another message. The Message-ID lives in Archiv."""
|
||||
|
||||
log: list[tuple] = []
|
||||
copies: dict[tuple[str, int], bytes] = {}
|
||||
header_uids: dict[str, bytes] | None = None
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
self.selected = ""
|
||||
|
||||
def login(self, username, secret):
|
||||
assert secret == "Postfach-Geheim"
|
||||
return "OK", [b"logged"]
|
||||
|
||||
def list(self):
|
||||
return "OK", [
|
||||
b'(\\HasNoChildren) "/" "INBOX"',
|
||||
b'(\\HasNoChildren) "/" "Archiv"',
|
||||
]
|
||||
|
||||
def select(self, mailbox, readonly=False):
|
||||
assert readonly is True
|
||||
self.selected = mailbox
|
||||
RelocatingIMAP.log.append(("select", mailbox))
|
||||
return "OK", [b"2"]
|
||||
|
||||
def uid(self, command, *args):
|
||||
if command == "SEARCH":
|
||||
if args and args[0] == "HEADER":
|
||||
RelocatingIMAP.log.append(("header", self.selected))
|
||||
override = (RelocatingIMAP.header_uids or {}).get(self.selected)
|
||||
if override is not None:
|
||||
return "OK", [override]
|
||||
found = [
|
||||
str(uid)
|
||||
for (folder, uid), raw in RelocatingIMAP.copies.items()
|
||||
if folder == self.selected and b"Message-ID: <moved@example.test>" in raw
|
||||
]
|
||||
return "OK", [" ".join(found).encode()]
|
||||
return "OK", [b""]
|
||||
uid = int(args[0])
|
||||
spec = " ".join(str(part) for part in args[1:])
|
||||
if "BODY.PEEK[]" in spec:
|
||||
RelocatingIMAP.log.append(("fetch", self.selected, uid))
|
||||
raw = RelocatingIMAP.copies.get((self.selected, uid))
|
||||
if raw is None:
|
||||
return "OK", [None]
|
||||
return "OK", [(b"rfc822", raw)]
|
||||
return "OK", [None]
|
||||
|
||||
def logout(self):
|
||||
return "BYE", [b""]
|
||||
|
||||
|
||||
def _stored_mail(db, element_id: str) -> dict:
|
||||
row = db.execute(
|
||||
"SELECT detail FROM external_references WHERE element_id = %s",
|
||||
(element_id,),
|
||||
).fetchone()
|
||||
return dict(row["detail"])
|
||||
|
||||
|
||||
def _linked_mail(actor: Actor, account: str, matter_id: str) -> dict:
|
||||
return actor.request(
|
||||
"POST",
|
||||
"/api/v1/external-refs",
|
||||
json={
|
||||
"title": "Verschoben",
|
||||
"source": "imap",
|
||||
"external_id": "<moved@example.test>",
|
||||
"context": {"kind": "matter", "id": matter_id},
|
||||
"detail": {
|
||||
"connector_id": account,
|
||||
"mailbox": "INBOX",
|
||||
"uid": 2,
|
||||
"direction": "in",
|
||||
},
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
|
||||
|
||||
def test_a_moved_message_remembers_its_new_folder(client, db, monkeypatch):
|
||||
from uuid import UUID
|
||||
|
||||
from app.retrieval import MailPayload, load_external
|
||||
|
||||
ada = Actor(client, "ada-move@example.test", "Ada Umzug")
|
||||
account_row = register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
RelocatingIMAP.log = []
|
||||
RelocatingIMAP.header_uids = None
|
||||
RelocatingIMAP.copies = {
|
||||
("INBOX", 2): _letter("<other@example.test>", "Eine andere Nachricht."),
|
||||
("Archiv", 9): _letter("<moved@example.test>", "Der Brief liegt jetzt im Archiv."),
|
||||
}
|
||||
account = _account(monkeypatch, ada)
|
||||
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", RelocatingIMAP)
|
||||
matter = matter_of(ada, "Ablage")
|
||||
created = _linked_mail(ada, account, matter["id"])
|
||||
|
||||
opened = ada.request("GET", f"/api/v1/external-refs/{created['id']}/mail")
|
||||
assert "Archiv" in opened["text"]
|
||||
stored = _stored_mail(db, created["id"])
|
||||
assert stored["mailbox"] == "Archiv"
|
||||
assert stored["uid"] == 9
|
||||
assert stored["direction"] == "in"
|
||||
assert stored["connector_id"] == account
|
||||
assert any(item[0] == "header" for item in RelocatingIMAP.log)
|
||||
|
||||
RelocatingIMAP.log = []
|
||||
again = ada.request("GET", f"/api/v1/external-refs/{created['id']}/mail")
|
||||
assert again["text"] == opened["text"]
|
||||
assert ("fetch", "Archiv", 9) in RelocatingIMAP.log
|
||||
assert not any(item[0] == "header" for item in RelocatingIMAP.log)
|
||||
assert _stored_mail(db, created["id"])["uid"] == 9
|
||||
|
||||
db.execute(
|
||||
"""
|
||||
UPDATE external_references
|
||||
SET detail = jsonb_set(
|
||||
jsonb_set(detail, '{mailbox}', to_jsonb('INBOX'::text)),
|
||||
'{uid}',
|
||||
to_jsonb(2)
|
||||
)
|
||||
WHERE element_id = %s
|
||||
""",
|
||||
(created["id"],),
|
||||
)
|
||||
db.commit()
|
||||
RelocatingIMAP.log = []
|
||||
loaded = load_external(db, account_row["id"], UUID(created["id"]), None)
|
||||
assert isinstance(loaded, MailPayload)
|
||||
assert "Archiv" in loaded.parsed.text
|
||||
exported = _stored_mail(db, created["id"])
|
||||
assert exported["mailbox"] == "Archiv"
|
||||
assert exported["uid"] == 9
|
||||
assert exported["direction"] == "in"
|
||||
assert any(item[0] == "header" for item in RelocatingIMAP.log)
|
||||
|
||||
|
||||
def test_an_ambiguous_or_truncated_move_does_not_replace_the_stored_place(client, db, monkeypatch):
|
||||
ada = Actor(client, "ada-ambiguous@example.test", "Ada Zweifach")
|
||||
register(db, ada.email, ada.name)
|
||||
ada.login()
|
||||
RelocatingIMAP.header_uids = None
|
||||
RelocatingIMAP.copies = {
|
||||
("INBOX", 2): _letter("<other@example.test>", "Altbestand."),
|
||||
("INBOX", 4): _letter("<moved@example.test>", "Erste Kopie."),
|
||||
("Archiv", 9): _letter("<moved@example.test>", "Zweite Kopie."),
|
||||
}
|
||||
account = _account(monkeypatch, ada)
|
||||
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", RelocatingIMAP)
|
||||
matter = matter_of(ada, "Zweifach")
|
||||
created = _linked_mail(ada, account, matter["id"])
|
||||
ada.request("GET", f"/api/v1/external-refs/{created['id']}/mail", status=422)
|
||||
assert _stored_mail(db, created["id"])["mailbox"] == "INBOX"
|
||||
assert _stored_mail(db, created["id"])["uid"] == 2
|
||||
|
||||
RelocatingIMAP.copies = {
|
||||
("INBOX", 2): _letter("<other@example.test>", "Altbestand."),
|
||||
("INBOX", 11): _letter("<moved@example.test>", "Treffer in der abgebrochenen Suche."),
|
||||
("INBOX", 12): _letter("<a@example.test>", "a"),
|
||||
("INBOX", 13): _letter("<b@example.test>", "b"),
|
||||
("INBOX", 14): _letter("<c@example.test>", "c"),
|
||||
("INBOX", 15): _letter("<d@example.test>", "d"),
|
||||
("INBOX", 16): _letter("<e@example.test>", "e"),
|
||||
("Archiv", 9): _letter("<moved@example.test>", "Eigentlich auch hier."),
|
||||
}
|
||||
RelocatingIMAP.header_uids = {"INBOX": b"11 12 13 14 15 16"}
|
||||
RelocatingIMAP.log = []
|
||||
opened = ada.request("GET", f"/api/v1/external-refs/{created['id']}/mail")
|
||||
assert "abgebrochenen Suche" in opened["text"]
|
||||
assert not any(item == ("header", "Archiv") for item in RelocatingIMAP.log)
|
||||
assert _stored_mail(db, created["id"])["mailbox"] == "INBOX"
|
||||
assert _stored_mail(db, created["id"])["uid"] == 2
|
||||
@@ -294,6 +294,16 @@ def test_grantee_reads_linked_originals_only_through_the_owner(client, db, monke
|
||||
assert opened.headers["referrer-policy"] == "no-referrer"
|
||||
assert calls == [{"token": OWNER_TOKEN, "path": "/api/documents/15/preview/"}]
|
||||
assert GRANTEE_TOKEN not in json.dumps(calls)
|
||||
own_connectors = {item["id"] for item in ben.request("GET", "/api/v1/connectors")["items"]}
|
||||
assert paper not in own_connectors
|
||||
assert mailbox not in own_connectors
|
||||
ben.request("POST", f"/api/v1/connectors/{paper}/probe", status=404)
|
||||
ben.request(
|
||||
"GET",
|
||||
"/api/v1/sources/paperless/documents",
|
||||
params={"q": "Geheim", "connector_id": paper},
|
||||
status=404,
|
||||
)
|
||||
search = ben.request("GET", "/api/v1/sources/paperless/documents", params={"q": "Geheim"})
|
||||
assert "Geheimes Archivdokument" not in json.dumps(search)
|
||||
assert all(item["token"] != OWNER_TOKEN for item in calls if "query" in item)
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
"""Einstellungen je Konto: Erbung vom Hauptnutzer, eigener Wert, Verbindlichkeit für das Team."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
|
||||
from tests.test_team import _invite, _main
|
||||
|
||||
PATH = "/api/v1/auth/preferences/duplicate_check"
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def world(client, db):
|
||||
ada = _main(client, db, "ada", main=True)
|
||||
room = ada.request("POST", "/api/v1/rooms", json={"name": "Kanzlei"}, status=201)["id"]
|
||||
ada.use_room(room)
|
||||
emp = _invite(ada, room, "emp-pref@example.test", name="Eva")
|
||||
return {"ada": ada, "emp": emp}
|
||||
|
||||
|
||||
def test_the_default_applies_without_any_choice(world):
|
||||
for person in (world["ada"], world["emp"]):
|
||||
state = person.request("GET", PATH)
|
||||
assert (state["value"], state["source"]) == ("here", "default")
|
||||
assert world["ada"].request("GET", PATH)["can_lock"] is True
|
||||
assert world["emp"].request("GET", PATH)["can_lock"] is False
|
||||
|
||||
|
||||
def test_an_employee_inherits_the_main_user_and_may_override(world):
|
||||
ada, emp = world["ada"], world["emp"]
|
||||
ada.request("PUT", PATH, json={"value": "inside"})
|
||||
inherited = emp.request("GET", PATH)
|
||||
assert (inherited["value"], inherited["source"]) == ("inside", "team")
|
||||
|
||||
own = emp.request("PUT", PATH, json={"value": "off"})
|
||||
assert (own["value"], own["source"]) == ("off", "own")
|
||||
# The main user's change does not touch an own choice.
|
||||
ada.request("PUT", PATH, json={"value": "around"})
|
||||
assert emp.request("GET", PATH)["value"] == "off"
|
||||
assert ada.request("GET", PATH)["value"] == "around"
|
||||
|
||||
# Inheriting again.
|
||||
back = emp.request("PUT", PATH, json={"value": None})
|
||||
assert (back["value"], back["source"]) == ("around", "team")
|
||||
|
||||
|
||||
def test_a_binding_overrides_an_own_value_without_deleting_it(world):
|
||||
ada, emp = world["ada"], world["emp"]
|
||||
emp.request("PUT", PATH, json={"value": "off"})
|
||||
ada.request("PUT", PATH, json={"value": "inside", "team_mode": "locked"})
|
||||
|
||||
locked = emp.request("GET", PATH)
|
||||
assert (locked["value"], locked["source"], locked["locked"]) == ("inside", "locked", True)
|
||||
refused = emp.request("PUT", PATH, json={"value": "here"}, status=403)
|
||||
assert "vorgegeben" in refused["detail"]
|
||||
|
||||
# The main user is not bound by the own binding.
|
||||
assert ada.request("PUT", PATH, json={"value": "here"})["value"] == "here"
|
||||
assert ada.request("GET", PATH)["team_mode"] == "locked"
|
||||
assert emp.request("GET", PATH)["value"] == "here"
|
||||
|
||||
ada.request("PUT", PATH, json={"value": "here", "team_mode": "free"})
|
||||
again = emp.request("GET", PATH)
|
||||
assert (again["value"], again["source"]) == ("off", "own")
|
||||
|
||||
|
||||
def test_only_the_main_user_binds_and_values_are_checked(world):
|
||||
ada, emp = world["ada"], world["emp"]
|
||||
emp.request("PUT", PATH, json={"value": "off", "team_mode": "locked"}, status=403)
|
||||
assert emp.request("GET", PATH)["source"] == "default"
|
||||
ada.request("PUT", PATH, json={"value": "everywhere"}, status=422)
|
||||
ada.request("GET", "/api/v1/auth/preferences/unknown", status=404)
|
||||
ada.request("PUT", "/api/v1/auth/preferences/unknown", json={"value": "off"}, status=404)
|
||||
|
||||
|
||||
def test_a_binding_of_a_stranger_does_not_reach_my_employee(client, db, world):
|
||||
ben = _main(client, db, "ben")
|
||||
ben.request("PUT", PATH, json={"value": "off", "team_mode": "locked"})
|
||||
assert world["emp"].request("GET", PATH)["value"] == "here"
|
||||
@@ -14,7 +14,7 @@ def test_manager_does_not_read_a_personal_case(client, db):
|
||||
ada = Actor(client, "ada@example.test", "Ada")
|
||||
ada.login()
|
||||
private = case_of(ada, "Persoenliche Akte")
|
||||
room = ada.request("POST", "/api/v1/rooms", json={"name": "Haushalt"}, status=201)
|
||||
room = ada.request("POST", "/api/v1/rooms", json={"name": "Haushalt", "default_visibility": "private"}, status=201)
|
||||
ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": "ben@example.test", "role": "manager"})
|
||||
ben = Actor(client, "ben@example.test", "Ben")
|
||||
ben.login()
|
||||
|
||||
@@ -0,0 +1,377 @@
|
||||
"""Raum als Team: Akten und Vorgänge werden mit Datenräumen geteilt, unabhängig vom Heimatraum."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.auth.accounts import create_account
|
||||
from tests.support import PASSWORD, Actor, document, matter_of, note_on
|
||||
|
||||
|
||||
def _second_client():
|
||||
from app.main import app
|
||||
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _make(db, email: str, name: str):
|
||||
account = create_account(db, email, name, PASSWORD)
|
||||
db.commit()
|
||||
return account
|
||||
|
||||
|
||||
def _actor(client, db, key: str, email: str, *, main: bool = False) -> Actor:
|
||||
actor = Actor(client if main else _second_client(), email, key.title())
|
||||
_make(db, actor.email, actor.name)
|
||||
actor.login()
|
||||
return actor
|
||||
|
||||
|
||||
def _id(db, email: str) -> str:
|
||||
row = db.execute("SELECT id FROM auth_accounts WHERE email = %s", (email,)).fetchone()
|
||||
db.rollback()
|
||||
return str(row["id"])
|
||||
|
||||
|
||||
def _share(actor: Actor, plural: str, resource_id: str, room: str, access: str = "edit", status: int = 200):
|
||||
return actor.request("PUT", f"/api/v1/{plural}/{resource_id}/room-share/rooms/{room}", json={"access": access}, status=status)
|
||||
|
||||
|
||||
def _unshare(actor: Actor, plural: str, resource_id: str, room: str, status: int = 204):
|
||||
return actor.request("DELETE", f"/api/v1/{plural}/{resource_id}/room-share/rooms/{room}", status=status)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def world(client, db):
|
||||
"""Ada owns the room; Ben is a member, Cem a reader, Dan is outside."""
|
||||
actors = {
|
||||
"ada": _actor(client, db, "ada", "ada-raum@example.test", main=True),
|
||||
"ben": _actor(client, db, "ben", "ben-raum@example.test"),
|
||||
"cem": _actor(client, db, "cem", "cem-raum@example.test"),
|
||||
"dan": _actor(client, db, "dan", "dan-raum@example.test"),
|
||||
}
|
||||
ada = actors["ada"]
|
||||
room = ada.request("POST", "/api/v1/rooms", json={"name": "Werkstatt"}, status=201)
|
||||
assert room["default_visibility"] == "room"
|
||||
ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": actors["ben"].email, "role": "member"})
|
||||
ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": actors["cem"].email, "role": "reader"})
|
||||
ada.use_room(room["id"])
|
||||
actors["room"] = room["id"]
|
||||
return actors
|
||||
|
||||
|
||||
def test_a_new_entry_follows_the_room_preset_and_rights_follow_the_role(world, db):
|
||||
ada, ben, cem, dan, room = world["ada"], world["ben"], world["cem"], world["dan"], world["room"]
|
||||
shared = ada.request("POST", "/api/v1/cases", json={"title": "Gemeinsame Akte"}, status=201)
|
||||
view = ada.request("GET", f"/api/v1/cases/{shared['id']}/room-share")
|
||||
assert [(s["room_name"], s["access"]) for s in view["shares"]] == [("Werkstatt", "edit")]
|
||||
|
||||
assert ben.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == {
|
||||
"read": True, "edit": True, "share": False, "delete": False, "download": True,
|
||||
}
|
||||
assert cem.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == {
|
||||
"read": True, "edit": False, "share": False, "delete": False, "download": True,
|
||||
}
|
||||
dan.request("GET", f"/api/v1/cases/{shared['id']}", status=404)
|
||||
assert "Gemeinsame Akte" in {item["title"] for item in ben.request("GET", "/api/v1/cases")["items"]}
|
||||
assert dan.request("GET", "/api/v1/cases")["items"] == []
|
||||
|
||||
version = ben.request("GET", f"/api/v1/cases/{shared['id']}")["version"]
|
||||
ben.request("PATCH", f"/api/v1/cases/{shared['id']}", json={"expected_version": version, "title": "Von Ben geändert"})
|
||||
cem.request("PATCH", f"/api/v1/cases/{shared['id']}", json={"expected_version": version + 1, "title": "Nein"}, status=403)
|
||||
ben.request("POST", f"/api/v1/cases/{shared['id']}/delete", json={"expected_version": version + 1}, status=403)
|
||||
ben.request("POST", f"/api/v1/cases/{shared['id']}/grants", json={"email": dan.email, "can_read": True}, status=403)
|
||||
|
||||
|
||||
def test_unsharing_and_leaving_take_the_rights_back_at_once(world, db):
|
||||
ada, ben, room = world["ada"], world["ben"], world["room"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Zeitweise sichtbar"}, status=201)
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
_unshare(ada, "cases", case["id"], room)
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
|
||||
_share(ada, "cases", case["id"], room)
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
ada.request("DELETE", f"/api/v1/rooms/{room}/members/{_id(db, ben.email)}", status=204)
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
|
||||
assert ben.request("GET", "/api/v1/cases")["items"] == []
|
||||
|
||||
|
||||
def test_an_archived_room_shares_nothing_until_it_is_restored(world, db):
|
||||
ada, ben, room = world["ada"], world["ben"], world["room"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Archivtest"}, status=201)
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
db.execute("UPDATE data_rooms SET status = 'archived' WHERE id = %s", (room,))
|
||||
db.commit()
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
|
||||
db.execute("UPDATE data_rooms SET status = 'active' WHERE id = %s", (room,))
|
||||
db.commit()
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
|
||||
|
||||
def test_the_owner_sees_all_own_entries_whatever_happens_to_the_room(world, db):
|
||||
ada, ben, room = world["ada"], world["ben"], world["room"]
|
||||
mine = ada.request("POST", "/api/v1/cases", json={"title": "Meine Akte im Raum"}, status=201)
|
||||
personal = Actor(ada.client, ada.email, ada.name)
|
||||
personal_body = personal.login()
|
||||
personal.request("POST", "/api/v1/cases", json={"title": "Meine persönliche Akte"}, status=201)
|
||||
# Ben owns an entry filed in the room; Ada, the owner of the room, does not see it.
|
||||
ben.use_room(room)
|
||||
bens = ben.request("POST", "/api/v1/cases", json={"title": "Bens Akte"}, status=201)
|
||||
|
||||
def titles(actor):
|
||||
return {item["title"] for item in actor.request("GET", "/api/v1/cases")["items"]}
|
||||
|
||||
assert {"Meine Akte im Raum", "Meine persönliche Akte"} <= titles(personal)
|
||||
assert "Bens Akte" in titles(personal) # shared with the room by the preset
|
||||
_unshare(ben, "cases", bens["id"], room)
|
||||
assert "Bens Akte" not in titles(personal)
|
||||
assert "Bens Akte" in titles(ben)
|
||||
|
||||
# Ben leaves the room, the room is archived: he still sees and edits what he owns.
|
||||
personal.request("DELETE", f"/api/v1/rooms/{room}/members/{_id(db, ben.email)}", status=204)
|
||||
# Ben's old room headers no longer fit his session; he is told to reload, then lists everything he owns.
|
||||
assert ben.request("GET", "/api/v1/cases", status=403)["code"] == "scope_changed"
|
||||
body = ben.request("GET", "/api/v1/auth/session")
|
||||
assert body["scope"]["kind"] == "personal"
|
||||
ben.scope, ben.csrf = body["scope"], body["csrf_token"]
|
||||
assert "Bens Akte" in titles(ben)
|
||||
ben.request("GET", f"/api/v1/cases/{bens['id']}")
|
||||
db.execute("UPDATE data_rooms SET status = 'archived' WHERE id = %s", (room,))
|
||||
db.commit()
|
||||
assert {"Meine Akte im Raum", "Meine persönliche Akte"} <= titles(personal)
|
||||
personal.request("GET", f"/api/v1/cases/{mine['id']}")
|
||||
assert personal_body["account"]["email"] == ada.email
|
||||
|
||||
|
||||
def test_one_member_can_be_excluded(world, db):
|
||||
ada, ben, cem, dan = world["ada"], world["ben"], world["cem"], world["dan"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Ohne Ben"}, status=201)
|
||||
view = ada.request("GET", f"/api/v1/cases/{case['id']}/room-share")
|
||||
assert {(m["display_name"], m["role"]) for m in view["shares"][0]["members"]} == {("Ben", "member"), ("Cem", "reader")}
|
||||
base = f"/api/v1/cases/{case['id']}/room-share/people"
|
||||
ada.request("PUT", f"{base}/{_id(db, ben.email)}", json={"excluded": True})
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
|
||||
cem.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
assert any(m["excluded"] for m in ada.request("GET", f"/api/v1/cases/{case['id']}/room-share")["shares"][0]["members"])
|
||||
ada.request("PUT", f"{base}/{_id(db, ben.email)}", json={"excluded": False})
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
ada.request("PUT", f"{base}/{_id(db, ada.email)}", json={"excluded": True}, status=422)
|
||||
ada.request("PUT", f"{base}/{_id(db, dan.email)}", json={"excluded": True}, status=404)
|
||||
ben.request("PUT", f"{base}/{_id(db, cem.email)}", json={"excluded": True}, status=404)
|
||||
|
||||
|
||||
def test_contents_follow_the_room_role(world, db):
|
||||
ada, ben, cem, dan = world["ada"], world["ben"], world["cem"], world["dan"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Akte mit Notiz"}, status=201)
|
||||
note = note_on(ada, "Notiz in der Akte", "Raumtext", case["id"])
|
||||
detail = ben.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
assert any(b["element"]["title"] == "Notiz in der Akte" for b in detail["bindings"])
|
||||
context = {"kind": "case", "id": case["id"]}
|
||||
ben.request("PATCH", f"/api/v1/notes/{note['id']}", json={"expected_version": note["version"], "document": document("Von Ben ergänzt"), "context": context})
|
||||
cem.request("PATCH", f"/api/v1/notes/{note['id']}", json={"expected_version": note["version"] + 1, "document": document("Nein"), "context": context}, status=403)
|
||||
dan.request("GET", f"/api/v1/cases/{case['id']}", status=404)
|
||||
assert dan.request("GET", "/api/v1/search", params={"q": "Notiz in der Akte"})["items"] == []
|
||||
assert any(i["title"] == "Notiz in der Akte" for i in cem.request("GET", "/api/v1/search", params={"q": "Notiz in der Akte"})["items"])
|
||||
|
||||
|
||||
def test_a_standalone_matter_is_shared_like_a_case(world, db):
|
||||
ada, ben, cem, room = world["ada"], world["ben"], world["cem"], world["room"]
|
||||
matter = matter_of(ada, "Eigener Vorgang")
|
||||
assert ben.request("GET", f"/api/v1/matters/{matter['id']}")["rights"]["edit"] is True
|
||||
assert cem.request("GET", f"/api/v1/matters/{matter['id']}")["rights"] == {
|
||||
"read": True, "edit": False, "share": False, "delete": False, "download": True,
|
||||
}
|
||||
ben.request("POST", f"/api/v1/matters/{matter['id']}/delete", json={"expected_version": matter["version"]}, status=403)
|
||||
_unshare(ada, "matters", matter["id"], room)
|
||||
ben.request("GET", f"/api/v1/matters/{matter['id']}", status=404)
|
||||
assert "Eigener Vorgang" not in {item["title"] for item in ben.request("GET", "/api/v1/matters")["items"]}
|
||||
|
||||
|
||||
def test_subcases_follow_their_parent(world, db):
|
||||
ada, ben, room = world["ada"], world["ben"], world["room"]
|
||||
parent = ada.request("POST", "/api/v1/cases", json={"title": "Eltern"}, status=201)
|
||||
child = ada.request(
|
||||
"POST", "/api/v1/cases",
|
||||
json={"title": "Kind", "parent_case_id": parent["id"], "rights_mode": "inherit_parent"}, status=201,
|
||||
)
|
||||
ben.request("GET", f"/api/v1/cases/{child['id']}")
|
||||
_unshare(ada, "cases", parent["id"], room)
|
||||
_unshare(ada, "cases", child["id"], room)
|
||||
ben.request("GET", f"/api/v1/cases/{child['id']}", status=404)
|
||||
|
||||
|
||||
def test_an_entry_in_the_personal_room_can_be_shared_with_a_team(world, db):
|
||||
ada, ben, dan, room = world["ada"], world["ben"], world["dan"], world["room"]
|
||||
personal = Actor(ada.client, ada.email, ada.name)
|
||||
personal.login()
|
||||
case = personal.request("POST", "/api/v1/cases", json={"title": "Aus dem persönlichen Raum"}, status=201)
|
||||
assert personal.request("GET", f"/api/v1/cases/{case['id']}/room-share")["shares"] == []
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
|
||||
shared = personal.request("GET", f"/api/v1/cases/{case['id']}/room-share")
|
||||
assert [item["name"] for item in shared["available"]] == ["Werkstatt"]
|
||||
_share(personal, "cases", case["id"], room)
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
dan.request("GET", f"/api/v1/cases/{case['id']}", status=404)
|
||||
|
||||
|
||||
def test_one_matter_goes_to_the_lawyer_and_the_rest_of_the_case_stays_hidden(client, db):
|
||||
ada = _actor(client, db, "ada", "ada-anwalt@example.test", main=True)
|
||||
lawyer = _actor(client, db, "anwalt", "anwalt@example.test")
|
||||
team = ada.request("POST", "/api/v1/rooms", json={"name": "Anwalt Müller", "default_visibility": "private"}, status=201)
|
||||
ada.request("POST", f"/api/v1/rooms/{team['id']}/members", json={"email": lawyer.email, "role": "member"})
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Vermietung"}, status=201)
|
||||
shared = ada.request("POST", "/api/v1/matters", json={"title": "Mietminderung"}, status=201)
|
||||
hidden = ada.request("POST", "/api/v1/matters", json={"title": "Eigenbedarf intern"}, status=201)
|
||||
for matter in (shared, hidden):
|
||||
ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
|
||||
note_on(ada, "Schreiben des Mieters", "Minderung", case["id"])
|
||||
_share(ada, "matters", shared["id"], team["id"], access="edit")
|
||||
|
||||
lawyer.request("GET", f"/api/v1/cases/{case['id']}", status=404)
|
||||
assert lawyer.request("GET", "/api/v1/cases")["items"] == []
|
||||
listed = {item["title"] for item in lawyer.request("GET", "/api/v1/matters")["items"]}
|
||||
assert listed == {"Mietminderung"}
|
||||
lawyer.request("GET", f"/api/v1/matters/{hidden['id']}", status=404)
|
||||
assert lawyer.request("GET", f"/api/v1/matters/{shared['id']}")["rights"]["edit"] is True
|
||||
|
||||
|
||||
def test_the_share_caps_the_role_and_several_rooms_add_up(world, db):
|
||||
ada, ben, room = world["ada"], world["ben"], world["room"]
|
||||
other = ada.request("POST", "/api/v1/rooms", json={"name": "Zweites Team", "default_visibility": "private"}, status=201)
|
||||
ada.request("POST", f"/api/v1/rooms/{other['id']}/members", json={"email": ben.email, "role": "member"})
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Begrenzt"}, status=201)
|
||||
_share(ada, "cases", case["id"], room, access="read")
|
||||
assert ben.request("GET", f"/api/v1/cases/{case['id']}")["rights"]["edit"] is False
|
||||
_share(ada, "cases", case["id"], other["id"], access="edit")
|
||||
assert ben.request("GET", f"/api/v1/cases/{case['id']}")["rights"]["edit"] is True
|
||||
_unshare(ada, "cases", case["id"], other["id"])
|
||||
assert ben.request("GET", f"/api/v1/cases/{case['id']}")["rights"]["edit"] is False
|
||||
_unshare(ada, "cases", case["id"], other["id"], status=404)
|
||||
|
||||
|
||||
def test_only_the_owner_shares_and_only_into_rooms_where_he_writes(world, db):
|
||||
ada, ben, cem, dan, room = world["ada"], world["ben"], world["cem"], world["dan"], world["room"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Nur Ada teilt"}, status=201)
|
||||
ben.request("PUT", f"/api/v1/cases/{case['id']}/room-share/rooms/{room}", json={"access": "edit"}, status=404)
|
||||
ben.request("DELETE", f"/api/v1/cases/{case['id']}/room-share/rooms/{room}", status=404)
|
||||
bens = ben.request("GET", "/api/v1/auth/session") # Ben may share his own entries into rooms he writes in
|
||||
assert any(r["id"] == room for r in bens["rooms"])
|
||||
ben.use_room(room)
|
||||
own = ben.request("POST", "/api/v1/cases", json={"title": "Bens"}, status=201)
|
||||
# A reader may not share into the room; an outsider cannot even see it.
|
||||
cem.use_room(room)
|
||||
cem_own = Actor(cem.client, cem.email, cem.name)
|
||||
cem_own.login()
|
||||
mine = cem_own.request("POST", "/api/v1/cases", json={"title": "Von Cem"}, status=201)
|
||||
cem_own.request("PUT", f"/api/v1/cases/{mine['id']}/room-share/rooms/{room}", json={"access": "edit"}, status=403)
|
||||
dan_own = Actor(dan.client, dan.email, dan.name)
|
||||
dan_own.login()
|
||||
theirs = dan_own.request("POST", "/api/v1/cases", json={"title": "Von Dan"}, status=201)
|
||||
dan_own.request("PUT", f"/api/v1/cases/{theirs['id']}/room-share/rooms/{room}", json={"access": "edit"}, status=403)
|
||||
assert own["title"] == "Bens"
|
||||
|
||||
|
||||
def test_leaving_the_team_takes_the_own_shares_along(world, db):
|
||||
ada, ben, cem, room = world["ada"], world["ben"], world["cem"], world["room"]
|
||||
ben.use_room(room)
|
||||
bens = ben.request("POST", "/api/v1/cases", json={"title": "Bens Freigabe"}, status=201)
|
||||
cem.request("GET", f"/api/v1/cases/{bens['id']}")
|
||||
ada.request("PATCH", f"/api/v1/rooms/{room}/members/{_id(db, ben.email)}", json={"role": "reader"})
|
||||
cem.request("GET", f"/api/v1/cases/{bens['id']}", status=404)
|
||||
ben.request("GET", f"/api/v1/cases/{bens['id']}")
|
||||
|
||||
|
||||
def test_the_bulk_action_and_the_exposure_count_own_entries(world, db):
|
||||
ada, ben, room = world["ada"], world["ben"], world["room"]
|
||||
old = ada.request("POST", "/api/v1/cases", json={"title": "Bestand"}, status=201)
|
||||
db.execute("DELETE FROM room_shares WHERE resource_id = %s", (old["id"],))
|
||||
db.commit()
|
||||
ben.request("GET", f"/api/v1/cases/{old['id']}", status=404)
|
||||
assert ada.request("GET", f"/api/v1/rooms/{room}/exposure")["cases"] == {"room": 0, "private": 1}
|
||||
assert ada.request("POST", f"/api/v1/rooms/{room}/my-content/visibility", json={"visibility": "room"}) == {"changed": 1}
|
||||
ben.request("GET", f"/api/v1/cases/{old['id']}")
|
||||
assert ada.request("GET", f"/api/v1/rooms/{room}/exposure")["cases"] == {"room": 1, "private": 0}
|
||||
ben.use_room(room)
|
||||
theirs = ben.request("POST", "/api/v1/cases", json={"title": "Bens"}, status=201)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/my-content/visibility", json={"visibility": "private"})
|
||||
ben.request("GET", f"/api/v1/cases/{old['id']}", status=404)
|
||||
ben.request("GET", f"/api/v1/cases/{theirs['id']}")
|
||||
world["dan"].request("GET", f"/api/v1/rooms/{room}/exposure", status=403)
|
||||
|
||||
|
||||
def test_a_room_can_start_without_sharing(client, db):
|
||||
ada = _actor(client, db, "ada", "ada-start@example.test", main=True)
|
||||
ben = _actor(client, db, "ben", "ben-start@example.test")
|
||||
room = ada.request("POST", "/api/v1/rooms", json={"name": "Privat", "default_visibility": "private"}, status=201)
|
||||
ada.use_room(room["id"])
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Nur ich"}, status=201)
|
||||
ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": ben.email, "role": "member"})
|
||||
ben.request("GET", f"/api/v1/cases/{case['id']}", status=404)
|
||||
ada.request("PATCH", f"/api/v1/rooms/{room['id']}", json={"default_visibility": "room"})
|
||||
other = ada.request("POST", "/api/v1/cases", json={"title": "Jetzt geteilt"}, status=201)
|
||||
ben.request("GET", f"/api/v1/cases/{other['id']}")
|
||||
ben.request("PATCH", f"/api/v1/rooms/{room['id']}", json={"default_visibility": "private"}, status=403)
|
||||
|
||||
|
||||
def test_lists_tell_the_owner_what_is_shared_and_rooms_are_managed_from_any_room(world, db):
|
||||
ada, ben, room = world["ada"], world["ben"], world["room"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Liste"}, status=201)
|
||||
item = next(i for i in ada.request("GET", "/api/v1/cases")["items"] if i["id"] == case["id"])
|
||||
assert item["is_owner"] is True and [s["name"] for s in item["shared_with"]] == ["Werkstatt"]
|
||||
seen = next(i for i in ben.request("GET", "/api/v1/cases")["items"] if i["id"] == case["id"])
|
||||
assert seen["is_owner"] is False and seen["shared_with"] == []
|
||||
matter = matter_of(ada, "Listenvorgang")
|
||||
row = next(i for i in ada.request("GET", "/api/v1/matters")["items"] if i["id"] == matter["id"])
|
||||
assert row["is_owner"] is True and [s["name"] for s in row["shared_with"]] == ["Werkstatt"]
|
||||
|
||||
# The owner manages the team while working in the personal room, without switching.
|
||||
personal = Actor(ada.client, ada.email, ada.name)
|
||||
body = personal.login()
|
||||
assert body["scope"]["kind"] == "personal"
|
||||
members = personal.request("GET", f"/api/v1/rooms/{room}/members")["items"]
|
||||
assert {m["role"] for m in members} == {"manager", "member", "reader"}
|
||||
personal.request("PATCH", f"/api/v1/rooms/{room}/members/{_id(db, ben.email)}", json={"role": "reader"})
|
||||
personal.request("PATCH", f"/api/v1/rooms/{room}", json={"name": "Werkstatt neu"})
|
||||
assert [r["name"] for r in personal.request("GET", "/api/v1/rooms")["items"] if r["id"] == room] == ["Werkstatt neu"]
|
||||
|
||||
|
||||
def test_room_endpoints_are_closed_to_outsiders_and_do_not_reveal_which_ids_exist(world, db):
|
||||
import uuid
|
||||
|
||||
ada, ben, cem, dan, room = world["ada"], world["ben"], world["cem"], world["dan"], world["room"]
|
||||
foreign = str(uuid.uuid4())
|
||||
dan_id = _id(db, dan.email)
|
||||
ben_id = _id(db, ben.email)
|
||||
attempts = [
|
||||
("GET", "/members", None),
|
||||
("POST", "/members", {"email": dan.email, "role": "manager"}),
|
||||
("PATCH", f"/members/{ben_id}", {"role": "manager"}),
|
||||
("DELETE", f"/members/{ben_id}", None),
|
||||
("GET", "/invitations", None),
|
||||
("PATCH", "", {"name": "Übernommen"}),
|
||||
("POST", "/owner", {"subject_id": dan_id}),
|
||||
("GET", "/exposure", None),
|
||||
("POST", "/my-content/visibility", {"visibility": "room"}),
|
||||
]
|
||||
for method, suffix, body in attempts:
|
||||
# Dan is no member, Cem is a reader, Ben a plain member: none of them administers the room.
|
||||
for actor in (dan, cem, ben):
|
||||
if method == "GET" and suffix == "/exposure" and actor in (cem, ben):
|
||||
continue # members may read their own exposure counts
|
||||
if method == "POST" and suffix == "/my-content/visibility" and actor is ben:
|
||||
continue # members may share their own entries
|
||||
actor.request(method, f"/api/v1/rooms/{room}{suffix}", json=body, status=403)
|
||||
# A room that does not exist answers like a room that is closed to the caller.
|
||||
dan.request(method, f"/api/v1/rooms/{foreign}{suffix.replace(ben_id, dan_id)}", json=body, status=403)
|
||||
dan.request("POST", "/api/v1/invitations", json={"email": "x@example.test", "room_id": room}, status=403)
|
||||
dan.request("POST", "/api/v1/invitations", json={"email": "x@example.test", "room_id": foreign}, status=403)
|
||||
dan.request("GET", "/api/v1/admin/rooms", status=403)
|
||||
dan.request("POST", f"/api/v1/admin/rooms/{room}/owner", json={"email": dan.email}, status=403)
|
||||
dan.request("GET", "/api/v1/admin/events", status=403)
|
||||
# Nothing changed.
|
||||
members = ada.request("GET", f"/api/v1/rooms/{room}/members")["items"]
|
||||
assert {m["email"]: m["role"] for m in members}[ben.email] == "member"
|
||||
assert dan.email not in {m["email"] for m in members}
|
||||
assert db.execute("SELECT name FROM data_rooms WHERE id = %s", (room,)).fetchone()["name"] == "Werkstatt"
|
||||
db.rollback()
|
||||
@@ -0,0 +1,249 @@
|
||||
"""Datenraumrollen (Mitglied, Verwalter, Leser), Einladungen, Betreiberübersicht."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from tests.support import ORIGIN, PASSWORD, Actor, register
|
||||
|
||||
|
||||
def _second_client():
|
||||
from app.main import app
|
||||
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _setup(client, db):
|
||||
ada = Actor(client, "ada-rolle@example.test", "Ada Rolle")
|
||||
ben = Actor(_second_client(), "ben-rolle@example.test", "Ben Rolle")
|
||||
cem = Actor(_second_client(), "cem-rolle@example.test", "Cem Rolle")
|
||||
for actor in (ada, ben, cem):
|
||||
register(db, actor.email, actor.name)
|
||||
actor.login()
|
||||
room = ada.request("POST", "/api/v1/rooms", json={"name": "Verein"}, status=201)
|
||||
ada.use_room(room["id"])
|
||||
return ada, ben, cem, room["id"]
|
||||
|
||||
|
||||
def test_manager_sets_roles_and_a_reader_creates_nothing(client, db):
|
||||
ada, ben, cem, room = _setup(client, db)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "reader"})
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": cem.email, "role": "member"})
|
||||
members = {item["email"]: item["role"] for item in ada.request("GET", f"/api/v1/rooms/{room}/members")["items"]}
|
||||
assert members == {ada.email: "manager", ben.email: "reader", cem.email: "member"}
|
||||
|
||||
ben.use_room(room)
|
||||
cem.use_room(room)
|
||||
refused = ben.request("POST", "/api/v1/cases", json={"title": "Nicht erlaubt"}, status=403)
|
||||
assert "Leser" in refused["detail"]
|
||||
ben.request("POST", "/api/v1/matters", json={"title": "Auch nicht"}, status=403)
|
||||
cem.request("POST", "/api/v1/cases", json={"title": "Erlaubt"}, status=201)
|
||||
|
||||
# The role is read from the database at every request.
|
||||
ada.request("PATCH", f"/api/v1/rooms/{room}/members/{_subject(ada, room, ben.email)}", json={"role": "member"})
|
||||
ben.request("POST", "/api/v1/cases", json={"title": "Jetzt erlaubt"}, status=201)
|
||||
ada.request("PATCH", f"/api/v1/rooms/{room}/members/{_subject(ada, room, ben.email)}", json={"role": "reader"})
|
||||
ben.request("POST", "/api/v1/cases", json={"title": "Wieder nicht"}, status=403)
|
||||
|
||||
|
||||
def test_a_reader_gets_no_edit_grant_and_loses_existing_ones(client, db):
|
||||
ada, ben, cem, room = _setup(client, db)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "member"})
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": cem.email, "role": "reader"})
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Gemeinsam"}, status=201)
|
||||
refused = ada.request(
|
||||
"POST",
|
||||
f"/api/v1/cases/{case['id']}/grants",
|
||||
json={"email": cem.email, "can_read": True, "can_edit": True, "can_share": False},
|
||||
status=422,
|
||||
)
|
||||
assert "Leser" in refused["detail"]
|
||||
ada.request(
|
||||
"POST",
|
||||
f"/api/v1/cases/{case['id']}/grants",
|
||||
json={"email": cem.email, "can_read": True, "can_edit": False, "can_share": False},
|
||||
status=201,
|
||||
)
|
||||
ada.request(
|
||||
"POST",
|
||||
f"/api/v1/cases/{case['id']}/grants",
|
||||
json={"email": ben.email, "can_read": True, "can_edit": True, "can_share": True},
|
||||
status=201,
|
||||
)
|
||||
ada.request("PATCH", f"/api/v1/rooms/{room}/members/{_subject(ada, room, ben.email)}", json={"role": "reader"})
|
||||
grant = db.execute(
|
||||
"SELECT can_read, can_edit, can_share FROM access_grants WHERE grantee_subject_id = (SELECT id FROM auth_accounts WHERE email = %s)",
|
||||
(ben.email,),
|
||||
).fetchone()
|
||||
db.rollback()
|
||||
assert grant == {"can_read": True, "can_edit": False, "can_share": False}
|
||||
|
||||
|
||||
def test_the_last_manager_stays(client, db):
|
||||
ada, ben, _cem, room = _setup(client, db)
|
||||
me = _subject(ada, room, ada.email)
|
||||
ada.request("PATCH", f"/api/v1/rooms/{room}/members/{me}", json={"role": "member"}, status=422)
|
||||
ada.request("DELETE", f"/api/v1/rooms/{room}/members/{me}", status=422)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ada.email, "role": "reader"}, status=422)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "manager"})
|
||||
# Ada owns the room and stays manager until she hands it over.
|
||||
ada.request("PATCH", f"/api/v1/rooms/{room}/members/{me}", json={"role": "member"}, status=422)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/owner", json={"subject_id": _subject(ada, room, ben.email)})
|
||||
ada.request("PATCH", f"/api/v1/rooms/{room}/members/{me}", json={"role": "member"})
|
||||
# Ben is owner and the only manager now.
|
||||
ben.use_room(room)
|
||||
ben.request("DELETE", f"/api/v1/rooms/{room}/members/{_subject(ben, room, ben.email)}", status=422)
|
||||
ada.request("GET", f"/api/v1/rooms/{room}/members", status=403)
|
||||
|
||||
|
||||
def test_owner_transfer_and_operator_step_in(client, db):
|
||||
ada, ben, cem, room = _setup(client, db)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "member"})
|
||||
ben.use_room(room)
|
||||
ben_id = _subject(ben, room, ben.email)
|
||||
ben.request("POST", f"/api/v1/rooms/{room}/owner", json={"subject_id": ben_id}, status=403)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/owner", json={"subject_id": _subject(ada, room, cem.email)}, status=422)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/owner", json={"subject_id": _subject(ada, room, ada.email)}, status=422)
|
||||
# Ada cannot leave or be demoted while she owns the room, and cannot be disabled while members depend on it.
|
||||
ada_id = _subject(ada, room, ada.email)
|
||||
db.execute("UPDATE auth_accounts SET origin = 'operator' WHERE id = %s", (ada_id,))
|
||||
db.commit()
|
||||
operator = Actor(_second_client(), "betreiber-eigner@example.test", "Betreiber Eigner")
|
||||
register(db, operator.email, operator.name, superadmin=True)
|
||||
operator.login()
|
||||
operator.request("PATCH", f"/api/v1/accounts/{ada_id}", json={"status": "disabled"}, status=422)
|
||||
operator.request("POST", f"/api/v1/admin/rooms/{room}/owner", json={"email": ben.email}, status=403)
|
||||
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/owner", json={"subject_id": ben_id})
|
||||
ben.request("GET", f"/api/v1/rooms/{room}/members")
|
||||
owners = [r for r in ben.request("GET", "/api/v1/auth/session")["rooms"] if r["id"] == room]
|
||||
assert owners[0]["is_owner"] is True
|
||||
ada.request("PATCH", f"/api/v1/rooms/{room}", json={"status": "archived"}, status=403)
|
||||
ben.request("PATCH", f"/api/v1/rooms/{room}", json={"default_visibility": "private"})
|
||||
|
||||
# The old owner may be disabled now; the room keeps its owner. A disabled owner is replaced by the operator.
|
||||
operator.request("PATCH", f"/api/v1/accounts/{ada_id}", json={"status": "disabled"})
|
||||
db.execute("UPDATE data_rooms SET owner_id = %s WHERE id = %s", (ada_id, room))
|
||||
db.commit()
|
||||
stepped = operator.request("POST", f"/api/v1/admin/rooms/{room}/owner", json={"email": ben.email})
|
||||
assert stepped["owner_id"] == ben_id
|
||||
events = operator.request("GET", "/api/v1/admin/events", params={"limit": 100})["items"]
|
||||
assert "room_owner_changed" in [item["action"] for item in events]
|
||||
|
||||
|
||||
def test_a_removed_member_loses_the_room_at_once(client, db):
|
||||
ada, ben, _cem, room = _setup(client, db)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "member"})
|
||||
ben.use_room(room)
|
||||
ben.request("GET", "/api/v1/cases")
|
||||
ada.request("DELETE", f"/api/v1/rooms/{room}/members/{_subject(ada, room, ben.email)}", status=204)
|
||||
ben.request("GET", "/api/v1/cases", status=403)
|
||||
|
||||
|
||||
def test_invitations_carry_a_role_and_can_be_revoked(client, db):
|
||||
ada, ben, _cem, room = _setup(client, db)
|
||||
invited = ada.request(
|
||||
"POST",
|
||||
"/api/v1/invitations",
|
||||
json={"email": "neu-rolle@example.test", "room_id": room, "role": "reader"},
|
||||
status=201,
|
||||
)
|
||||
assert invited["role"] == "reader" and invited["token"]
|
||||
ada.request("POST", "/api/v1/invitations", json={"email": ben.email, "room_id": room}, status=422)
|
||||
open_items = ada.request("GET", f"/api/v1/rooms/{room}/invitations")["items"]
|
||||
assert [item["email"] for item in open_items] == ["neu-rolle@example.test"]
|
||||
assert "token" not in open_items[0]
|
||||
ben.request("GET", f"/api/v1/rooms/{room}/invitations", status=403)
|
||||
|
||||
guest = _second_client()
|
||||
accepted = guest.post(
|
||||
f"/api/v1/invitations/{invited['id']}/accept",
|
||||
json={"token": invited["token"], "display_name": "Neu Gast", "password": PASSWORD},
|
||||
headers={"Origin": ORIGIN},
|
||||
)
|
||||
assert accepted.status_code == 201, accepted.text
|
||||
assert [(r["name"], r["role"]) for r in accepted.json()["rooms"] if r["kind"] == "organization"] == [("Verein", "reader")]
|
||||
again = _second_client().post(
|
||||
f"/api/v1/invitations/{invited['id']}/accept",
|
||||
json={"token": invited["token"], "display_name": "Zweiter", "password": PASSWORD},
|
||||
headers={"Origin": ORIGIN},
|
||||
)
|
||||
assert again.status_code == 404
|
||||
|
||||
second = ada.request("POST", "/api/v1/invitations", json={"email": "widerruf@example.test", "room_id": room}, status=201)
|
||||
ada.request("DELETE", f"/api/v1/rooms/{room}/invitations/{second['id']}", status=204)
|
||||
refused = _second_client().post(
|
||||
f"/api/v1/invitations/{second['id']}/accept",
|
||||
json={"token": second["token"], "display_name": "Widerruf", "password": PASSWORD},
|
||||
headers={"Origin": ORIGIN},
|
||||
)
|
||||
assert refused.status_code == 404
|
||||
ada.request("DELETE", f"/api/v1/rooms/{room}/invitations/{second['id']}", status=404)
|
||||
|
||||
|
||||
def test_rooms_are_renamed_archived_and_restored_by_a_manager(client, db):
|
||||
ada, ben, _cem, room = _setup(client, db)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "member"})
|
||||
ben.request("PATCH", f"/api/v1/rooms/{room}", json={"name": "Fremd"}, status=403)
|
||||
renamed = ada.request("PATCH", f"/api/v1/rooms/{room}", json={"name": "Verein e.V."})
|
||||
assert renamed["name"] == "Verein e.V."
|
||||
ada.request("PATCH", f"/api/v1/rooms/{room}", json={"status": "archived"})
|
||||
# The session of the archiving manager moved back to the personal room.
|
||||
ada.request("GET", "/api/v1/rooms", status=403)
|
||||
body = ada.request("GET", "/api/v1/auth/session")
|
||||
assert body["scope"]["kind"] == "personal"
|
||||
ada.scope, ada.csrf = body["scope"], body["csrf_token"]
|
||||
listed = ada.request("GET", "/api/v1/rooms", params={"include_archived": "true"})["items"]
|
||||
assert any(item["id"] == room and item.get("status") == "archived" for item in listed)
|
||||
ada.request("POST", "/api/v1/auth/session/scope", json={"kind": "organization", "id": room}, status=403)
|
||||
ada.request("PATCH", f"/api/v1/rooms/{room}", json={"status": "active"})
|
||||
ada.use_room(room)
|
||||
|
||||
|
||||
def test_operator_sees_rooms_without_content_and_fills_an_orphaned_room(client, db):
|
||||
ada, ben, _cem, room = _setup(client, db)
|
||||
operator = Actor(_second_client(), "betreiber-rolle@example.test", "Betreiber Rolle")
|
||||
register(db, operator.email, operator.name, superadmin=True)
|
||||
operator.login()
|
||||
ada.request("POST", "/api/v1/cases", json={"title": "Nur für Ada"}, status=201)
|
||||
overview = operator.request("GET", "/api/v1/admin/rooms")["items"]
|
||||
row = next(item for item in overview if item["id"] == room)
|
||||
assert row["managers"] == ["Ada Rolle"] and row["members"] == 1 and row["has_manager"] is True
|
||||
assert row["owner"] == "Ada Rolle" and row["owner_active"] is True
|
||||
assert "Nur für Ada" not in str(overview)
|
||||
operator.request("GET", f"/api/v1/rooms/{room}/members", status=403)
|
||||
ben.request("GET", "/api/v1/admin/rooms", status=403)
|
||||
operator.request("POST", f"/api/v1/admin/rooms/{room}/managers", json={"email": ben.email}, status=403)
|
||||
|
||||
db.execute("UPDATE auth_accounts SET status = 'disabled' WHERE email = %s", (ada.email,))
|
||||
db.commit()
|
||||
assigned = operator.request("POST", f"/api/v1/admin/rooms/{room}/managers", json={"email": ben.email})
|
||||
assert assigned["role"] == "manager"
|
||||
ben.use_room(room)
|
||||
assert {item["email"] for item in ben.request("GET", f"/api/v1/rooms/{room}/members")["items"]} >= {ben.email}
|
||||
|
||||
|
||||
def test_room_events_reach_the_operator_audit_without_secrets(client, db):
|
||||
ada, ben, _cem, room = _setup(client, db)
|
||||
operator = Actor(_second_client(), "audit-rolle@example.test", "Audit Rolle")
|
||||
register(db, operator.email, operator.name, superadmin=True)
|
||||
operator.login()
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "reader"})
|
||||
invited = ada.request("POST", "/api/v1/invitations", json={"email": "audit-gast@example.test", "room_id": room}, status=201)
|
||||
events = operator.request("GET", "/api/v1/admin/events", params={"limit": 50})
|
||||
actions = [item["action"] for item in events["items"]]
|
||||
assert {"room_created", "membership_added", "invitation_created"} <= set(actions)
|
||||
text = str(events)
|
||||
assert "audit-gast@example.test" not in text and invited["token"] not in text
|
||||
ben.request("GET", "/api/v1/admin/events", status=403)
|
||||
page = operator.request("GET", "/api/v1/admin/events", params={"limit": 1})
|
||||
assert len(page["items"]) == 1 and page["next_cursor"] == 1
|
||||
|
||||
|
||||
def _subject(actor: Actor, room: str, email: str) -> str:
|
||||
# A manager lists the members; Ada manages in these tests. Fall back to the account table.
|
||||
from app.core.settings import get_settings
|
||||
import psycopg
|
||||
|
||||
with psycopg.connect(get_settings().dsn(), row_factory=psycopg.rows.dict_row) as conn:
|
||||
return str(conn.execute("SELECT id FROM auth_accounts WHERE email = %s", (email,)).fetchone()["id"])
|
||||
@@ -0,0 +1,178 @@
|
||||
"""Room members read linked originals through the owner's connector only when the owner lends it to them."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
import app.sources as sources
|
||||
from app.auth.accounts import create_account
|
||||
from tests.support import ORIGIN, PASSWORD, Actor
|
||||
|
||||
OWNER_TOKEN = "raum-owner-paperless-token"
|
||||
UNAVAILABLE = "Das Original ist über die Freigabe nicht abrufbar."
|
||||
|
||||
|
||||
def _second_client():
|
||||
from app.main import app
|
||||
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _actor(client, db, key: str, email: str, *, main: bool = False) -> Actor:
|
||||
actor = Actor(client if main else _second_client(), email, key.title())
|
||||
create_account(db, actor.email, actor.name, PASSWORD)
|
||||
db.commit()
|
||||
actor.login()
|
||||
return actor
|
||||
|
||||
|
||||
def _id(db, email: str) -> str:
|
||||
row = db.execute("SELECT id FROM auth_accounts WHERE email = %s", (email,)).fetchone()
|
||||
db.rollback()
|
||||
return str(row["id"])
|
||||
|
||||
|
||||
def _raw(actor: Actor, path: str):
|
||||
headers = {"Origin": ORIGIN, "X-CSRF-Token": actor.csrf}
|
||||
if actor.scope is not None:
|
||||
headers["X-Scope-Kind"] = actor.scope["kind"]
|
||||
headers["X-Scope-Id"] = actor.scope["id"]
|
||||
return actor.client.get(path, headers=headers)
|
||||
|
||||
|
||||
def _lend(actor: Actor, room: str, subject: str, enabled: bool, status: int = 200):
|
||||
return actor.request(
|
||||
"PUT",
|
||||
f"/api/v1/rooms/{room}/source-access/{subject}",
|
||||
json={"enabled": enabled},
|
||||
status=status,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def world(client, db, monkeypatch):
|
||||
"""Ada owns the room and a case with a Paperless document. Ben is a member, Cem a reader, Dan outside."""
|
||||
calls = []
|
||||
|
||||
def fake_file(base, token, path, max_bytes=40 * 1024 * 1024):
|
||||
calls.append({"token": token, "path": path})
|
||||
if path.endswith("/preview/"):
|
||||
return (b"%PDF-1.4\nraum\n", "application/pdf", "vertrag.pdf")
|
||||
return None
|
||||
|
||||
monkeypatch.setattr(sources, "_paperless_file", fake_file)
|
||||
monkeypatch.setattr(sources, "_paperless_metadata", lambda *args, **kwargs: None)
|
||||
|
||||
actors = {
|
||||
"ada": _actor(client, db, "ada", "ada-rq@example.test", main=True),
|
||||
"ben": _actor(client, db, "ben", "ben-rq@example.test"),
|
||||
"cem": _actor(client, db, "cem", "cem-rq@example.test"),
|
||||
"dan": _actor(client, db, "dan", "dan-rq@example.test"),
|
||||
}
|
||||
ada = actors["ada"]
|
||||
room = ada.request("POST", "/api/v1/rooms", json={"name": "Mandat"}, status=201)["id"]
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": actors["ben"].email, "role": "member"})
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": actors["cem"].email, "role": "reader"})
|
||||
ada.use_room(room)
|
||||
actors["cem"].use_room(room)
|
||||
actors["ben"].use_room(room)
|
||||
paper = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={"kind": "paperless", "name": "Ada Archiv", "base_url": "https://paper.example.test", "token": OWNER_TOKEN},
|
||||
status=201,
|
||||
)["id"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Mandatsakte"}, status=201)
|
||||
document = ada.request(
|
||||
"POST",
|
||||
"/api/v1/external-refs",
|
||||
json={
|
||||
"title": "Vertrag",
|
||||
"source": "paperless",
|
||||
"external_id": "15",
|
||||
"context": {"kind": "case", "id": case["id"]},
|
||||
"detail": {"connector_id": paper},
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
actors.update(
|
||||
room=room,
|
||||
case=case["id"],
|
||||
path=f"/api/v1/external-refs/{document['id']}/content?context_kind=case&context_id={case['id']}",
|
||||
calls=calls,
|
||||
ids={key: _id(db, actors[key].email) for key in ("ada", "ben", "cem", "dan")},
|
||||
)
|
||||
return actors
|
||||
|
||||
|
||||
def test_a_room_reader_reads_originals_only_after_the_owner_lends_them(world, db):
|
||||
ada, cem, room, ids, calls = world["ada"], world["cem"], world["room"], world["ids"], world["calls"]
|
||||
assert cem.request("GET", f"/api/v1/cases/{world['case']}")["rights"]["read"] is True
|
||||
|
||||
refused = _raw(cem, world["path"])
|
||||
assert refused.status_code == 422
|
||||
assert refused.json()["detail"] == UNAVAILABLE
|
||||
assert calls == []
|
||||
|
||||
_lend(ada, room, ids["cem"], True)
|
||||
members = ada.request("GET", f"/api/v1/rooms/{room}/members")["items"]
|
||||
flags = {item["subject_id"]: item["my_sources"] for item in members}
|
||||
assert flags[ids["cem"]] is True
|
||||
assert flags[ids["ben"]] is False
|
||||
share = ada.request("GET", f"/api/v1/cases/{world['case']}/room-share")
|
||||
shown = {item["subject_id"]: item["sources"] for item in share["shares"][0]["members"]}
|
||||
assert shown[ids["cem"]] is True
|
||||
|
||||
opened = _raw(cem, world["path"])
|
||||
assert opened.status_code == 200, opened.text
|
||||
assert opened.content.startswith(b"%PDF")
|
||||
assert calls == [{"token": OWNER_TOKEN, "path": "/api/documents/15/preview/"}]
|
||||
assert OWNER_TOKEN not in json.dumps(cem.request("GET", f"/api/v1/cases/{world['case']}"))
|
||||
events = db.execute(
|
||||
"SELECT result FROM domain_events WHERE action = 'source_read_mediated' AND actor_subject_id = %s",
|
||||
(ids["cem"],),
|
||||
).fetchall()
|
||||
db.rollback()
|
||||
assert [row["result"] for row in events] == ["ok"]
|
||||
|
||||
_lend(ada, room, ids["cem"], False)
|
||||
assert _raw(cem, world["path"]).status_code == 422
|
||||
|
||||
|
||||
def test_only_the_lending_person_decides_and_only_for_members(world):
|
||||
ada, ben, cem, dan, room, ids = world["ada"], world["ben"], world["cem"], world["dan"], world["room"], world["ids"]
|
||||
# Ben lends his own connectors to Cem. That does not open Ada's originals.
|
||||
_lend(ben, room, ids["cem"], True)
|
||||
assert _raw(cem, world["path"]).status_code == 422
|
||||
# A reader cannot share into the room and so cannot lend.
|
||||
_lend(cem, room, ids["ben"], True, status=403)
|
||||
# Outsiders and non-members are not addressable.
|
||||
_lend(dan, room, ids["cem"], True, status=404)
|
||||
_lend(ada, room, ids["dan"], True, status=404)
|
||||
_lend(ada, room, ids["ada"], True, status=422)
|
||||
|
||||
|
||||
def test_exclusion_leaving_the_room_and_ending_the_share_close_the_access(world):
|
||||
ada, cem, room, ids = world["ada"], world["cem"], world["room"], world["ids"]
|
||||
_lend(ada, room, ids["cem"], True)
|
||||
assert _raw(cem, world["path"]).status_code == 200
|
||||
|
||||
ada.request("PUT", f"/api/v1/cases/{world['case']}/room-share/people/{ids['cem']}", json={"excluded": True})
|
||||
assert _raw(cem, world["path"]).status_code == 404
|
||||
ada.request("PUT", f"/api/v1/cases/{world['case']}/room-share/people/{ids['cem']}", json={"excluded": False})
|
||||
assert _raw(cem, world["path"]).status_code == 200
|
||||
|
||||
ada.request("DELETE", f"/api/v1/cases/{world['case']}/room-share/rooms/{room}", status=204)
|
||||
assert _raw(cem, world["path"]).status_code == 404
|
||||
ada.request("PUT", f"/api/v1/cases/{world['case']}/room-share/rooms/{room}", json={"access": "read"})
|
||||
assert _raw(cem, world["path"]).status_code == 200
|
||||
|
||||
ada.request("DELETE", f"/api/v1/rooms/{room}/members/{ids['cem']}", status=204)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": cem.email, "role": "reader"})
|
||||
cem.use_room(room)
|
||||
assert _raw(cem, world["path"]).status_code == 422
|
||||
flags = {item["subject_id"]: item["my_sources"] for item in ada.request("GET", f"/api/v1/rooms/{room}/members")["items"]}
|
||||
assert flags[ids["cem"]] is False
|
||||
@@ -0,0 +1,226 @@
|
||||
"""A third source appears only by registering its module."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import io
|
||||
import zipfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from tests.sample_source import install_sample_source, remove_sample_source
|
||||
from tests.support import ORIGIN, Actor, document, register
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
TEXT = "Der Probenbrief bleibt lesbar."
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_source():
|
||||
install_sample_source()
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
remove_sample_source()
|
||||
|
||||
|
||||
def test_registered_sample_source_links_reads_and_exports(client, db, sample_source):
|
||||
del sample_source
|
||||
ada = Actor(client, "ada-sample@example.test", "Ada Probe")
|
||||
ben = Actor(client, "ben-sample@example.test", "Ben Probe")
|
||||
register(db, ada.email, ada.name)
|
||||
register(db, ben.email, ben.name)
|
||||
ada.login()
|
||||
refused = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={"kind": "missing", "name": "Unbekannt"},
|
||||
status=422,
|
||||
)
|
||||
assert refused["code"] == "unprocessable"
|
||||
ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={"kind": "sample", "name": "Ohne Katalog", "config": {"catalog": "kein-katalog"}},
|
||||
status=422,
|
||||
)
|
||||
connector_id = ada.request(
|
||||
"POST",
|
||||
"/api/v1/connectors",
|
||||
json={"kind": "sample", "name": "Katalog Alpha", "config": {"catalog": "alpha"}},
|
||||
status=201,
|
||||
)["id"]
|
||||
probed = ada.request("POST", f"/api/v1/connectors/{connector_id}/probe")
|
||||
assert probed["ok"] is True
|
||||
assert "2 Einträge" in probed["detail"]
|
||||
blocked = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/sample/search",
|
||||
params={"q": "Probe", "correspondent": "geheim-wert"},
|
||||
status=422,
|
||||
)
|
||||
assert blocked["code"] == "unsupported"
|
||||
assert "geheim-wert" not in blocked["detail"]
|
||||
ada.request("GET", "/api/v1/sources/sample/navigate", params={"connector_id": connector_id}, status=422)
|
||||
found = ada.request("GET", "/api/v1/sources/sample/search", params={"q": "Proben", "connector_id": connector_id})
|
||||
assert [item["id"] for item in found["items"]] == ["brief"]
|
||||
preview = ada.request(
|
||||
"GET",
|
||||
"/api/v1/sources/sample/preview",
|
||||
params={"connector_id": connector_id, "item": "brief"},
|
||||
)
|
||||
assert preview["text"] == TEXT
|
||||
matter = ada.request("POST", "/api/v1/matters", json={"title": "Probenvorgang"}, status=201)
|
||||
linked = ada.request(
|
||||
"POST",
|
||||
"/api/v1/external-refs",
|
||||
json={
|
||||
"title": "Probenbrief",
|
||||
"source": "sample",
|
||||
"external_id": "brief",
|
||||
"context": {"kind": "matter", "id": matter["id"]},
|
||||
"detail": {"connector_id": connector_id},
|
||||
},
|
||||
status=201,
|
||||
)
|
||||
opened = _raw(ada, f"/api/v1/external-refs/{linked['id']}/content?context_kind=matter&context_id={matter['id']}")
|
||||
assert opened.status_code == 200
|
||||
assert opened.content == TEXT.encode("utf-8")
|
||||
assert opened.headers["content-type"].startswith("text/plain")
|
||||
detail = ada.request("GET", f"/api/v1/matters/{matter['id']}")
|
||||
element = next(item["element"] for item in detail["bindings"] if item["element"]["id"] == linked["id"])
|
||||
assert element["preview"]["media"] == "text"
|
||||
written = ada.request(
|
||||
"PATCH",
|
||||
f"/api/v1/notes/{linked['id']}",
|
||||
json={
|
||||
"expected_version": element["version"],
|
||||
"document": document("Das darf nicht geschrieben werden."),
|
||||
"context": {"kind": "matter", "id": matter["id"]},
|
||||
},
|
||||
status=422,
|
||||
)
|
||||
assert written["code"] == "unsupported"
|
||||
tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]
|
||||
selected = [node["id"] for node in _walk(tree) if node["kind"] == "binding" and node.get("exportable")]
|
||||
body = {"context": {"kind": "matter", "id": matter["id"]}, "selected": selected}
|
||||
review = ada.request("POST", f"/api/v1/matters/{matter['id']}/export/review", json=body)
|
||||
assert review["ready"] is True, review
|
||||
package = _post_zip(ada, matter["id"], body)
|
||||
assert package.status_code == 200, package.text
|
||||
archive = zipfile.ZipFile(io.BytesIO(package.content))
|
||||
assert any(archive.read(name) == TEXT.encode("utf-8") for name in archive.namelist())
|
||||
|
||||
ben.login()
|
||||
ben.request(
|
||||
"GET",
|
||||
"/api/v1/sources/sample/search",
|
||||
params={"connector_id": connector_id, "q": "Proben"},
|
||||
status=404,
|
||||
)
|
||||
hidden = _raw(ben, f"/api/v1/external-refs/{linked['id']}/content?context_kind=matter&context_id={matter['id']}")
|
||||
assert hidden.status_code == 404
|
||||
ada.login()
|
||||
ada.request(
|
||||
"POST",
|
||||
f"/api/v1/matters/{matter['id']}/grants",
|
||||
json={"email": ben.email, "can_read": True, "can_edit": False, "can_share": False, "use_owner_sources": False},
|
||||
status=201,
|
||||
)
|
||||
ben.login()
|
||||
denied = _raw(ben, f"/api/v1/external-refs/{linked['id']}/content?context_kind=matter&context_id={matter['id']}")
|
||||
assert denied.status_code == 422
|
||||
assert denied.json()["detail"] == "Das Original ist über die Freigabe nicht abrufbar."
|
||||
ada.login()
|
||||
grant_id = next(item["id"] for item in ada.request("GET", f"/api/v1/matters/{matter['id']}")["grants"])
|
||||
ada.request("DELETE", f"/api/v1/grants/{grant_id}", status=204)
|
||||
ada.request(
|
||||
"POST",
|
||||
f"/api/v1/matters/{matter['id']}/grants",
|
||||
json={"email": ben.email, "can_read": True, "can_edit": False, "can_share": False, "use_owner_sources": True},
|
||||
status=201,
|
||||
)
|
||||
ben.login()
|
||||
shared = _raw(ben, f"/api/v1/external-refs/{linked['id']}/content?context_kind=matter&context_id={matter['id']}")
|
||||
assert shared.status_code == 200
|
||||
assert shared.content == TEXT.encode("utf-8")
|
||||
shown = ben.request("GET", f"/api/v1/matters/{matter['id']}")
|
||||
visible = next(item["element"] for item in shown["bindings"] if item["element"]["id"] == linked["id"])
|
||||
assert "connector_id" not in (visible["external"].get("detail") or {})
|
||||
ada.login()
|
||||
grant_id = next(item["id"] for item in ada.request("GET", f"/api/v1/matters/{matter['id']}")["grants"])
|
||||
ada.request("DELETE", f"/api/v1/grants/{grant_id}", status=204)
|
||||
ben.login()
|
||||
revoked = _raw(ben, f"/api/v1/external-refs/{linked['id']}/content?context_kind=matter&context_id={matter['id']}")
|
||||
assert revoked.status_code == 404
|
||||
|
||||
|
||||
def test_sample_registration_does_not_edit_generic_modules():
|
||||
forbidden = [
|
||||
"backend/app/api/schemas.py",
|
||||
"backend/app/exporting.py",
|
||||
"backend/app/present.py",
|
||||
"frontend/src/pages/Cases.jsx",
|
||||
"frontend/src/pages/Matters.jsx",
|
||||
"frontend/src/pages/ReadingPane.jsx",
|
||||
"frontend/src/pages/ExportPackage.jsx",
|
||||
"frontend/src/App.jsx",
|
||||
"frontend/src/pages/Sources.jsx",
|
||||
]
|
||||
for relative in forbidden:
|
||||
text = (ROOT / relative).read_text(encoding="utf-8")
|
||||
assert '"sample"' not in text and "'sample'" not in text, relative
|
||||
# The backend image that runs this suite has no Node. The sample module is
|
||||
# small enough to check against the registry operations it calls.
|
||||
sample = (ROOT / "frontend/src/sources/sample-source.js").read_text(encoding="utf-8")
|
||||
registry = (ROOT / "frontend/src/sources/registry-core.js").read_text(encoding="utf-8")
|
||||
assert "registerSourceModule" in sample and "unregisterSourceModule" in sample
|
||||
assert 'kind: "sample"' in sample and 'representation: "text"' in sample
|
||||
assert 'unregisterSourceModule("sample")' in sample
|
||||
assert "modules.set(module.kind, module)" in registry
|
||||
assert "modules.delete(kind)" in registry
|
||||
modules: dict[str, dict] = {}
|
||||
|
||||
def register(module: dict) -> dict:
|
||||
modules[module["kind"]] = module
|
||||
return module
|
||||
|
||||
def unregister(kind: str) -> None:
|
||||
modules.pop(kind, None)
|
||||
|
||||
register({"kind": "sample", "representation": "text"})
|
||||
assert any(item["kind"] == "sample" and item["representation"] == "text" for item in modules.values())
|
||||
unregister("sample")
|
||||
assert not any(item["kind"] == "sample" for item in modules.values())
|
||||
|
||||
|
||||
def _raw(actor: Actor, path: str):
|
||||
return actor.client.get(
|
||||
path,
|
||||
headers={
|
||||
"Origin": ORIGIN,
|
||||
"X-CSRF-Token": actor.csrf,
|
||||
"X-Scope-Kind": actor.scope["kind"],
|
||||
"X-Scope-Id": actor.scope["id"],
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def _post_zip(actor: Actor, matter_id: str, body: dict):
|
||||
return actor.client.post(
|
||||
f"/api/v1/matters/{matter_id}/export",
|
||||
json=body,
|
||||
headers={
|
||||
"Origin": ORIGIN,
|
||||
"X-CSRF-Token": actor.csrf,
|
||||
"Content-Type": "application/json",
|
||||
"X-Scope-Kind": actor.scope["kind"],
|
||||
"X-Scope-Id": actor.scope["id"],
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def _walk(node):
|
||||
yield node
|
||||
for child in node.get("children") or []:
|
||||
yield from _walk(child)
|
||||
@@ -0,0 +1,220 @@
|
||||
"""Hauptnutzer, Mitarbeiter und Teamverwaltung."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import uuid
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.auth.accounts import create_account
|
||||
from app.core.errors import unprocessable
|
||||
from tests.support import ORIGIN, PASSWORD, Actor
|
||||
|
||||
|
||||
def _second_client():
|
||||
from app.main import app
|
||||
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _main(client, db, key: str, *, main: bool = False, superadmin: bool = False) -> Actor:
|
||||
actor = Actor(client if main else _second_client(), f"{key}-team@example.test", key.title())
|
||||
create_account(db, actor.email, actor.name, PASSWORD, is_superadmin=superadmin)
|
||||
db.commit()
|
||||
actor.login()
|
||||
return actor
|
||||
|
||||
|
||||
def _invite(owner: Actor, room: str, email: str, role: str = "member", name: str = "Mitarbeiter") -> Actor:
|
||||
invited = owner.request("POST", "/api/v1/invitations", json={"email": email, "room_id": room, "role": role}, status=201)
|
||||
client = _second_client()
|
||||
response = client.post(
|
||||
f"/api/v1/invitations/{invited['id']}/accept",
|
||||
json={"token": invited["token"], "display_name": name, "password": PASSWORD},
|
||||
headers={"Origin": ORIGIN},
|
||||
)
|
||||
assert response.status_code == 201, response.text
|
||||
employee = Actor(client, email, name)
|
||||
employee.login()
|
||||
return employee
|
||||
|
||||
|
||||
def _id(db, email: str) -> str:
|
||||
row = db.execute("SELECT id FROM auth_accounts WHERE email = %s", (email,)).fetchone()
|
||||
db.rollback()
|
||||
return str(row["id"])
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def world(client, db):
|
||||
ada = _main(client, db, "ada", main=True)
|
||||
room = ada.request("POST", "/api/v1/rooms", json={"name": "Kanzlei"}, status=201)["id"]
|
||||
ada.use_room(room)
|
||||
employee = _invite(ada, room, "emp-team@example.test", name="Eva Mitarbeiterin")
|
||||
return {"ada": ada, "room": room, "emp": employee}
|
||||
|
||||
|
||||
def test_an_invitation_creates_an_employee_account_sponsored_by_the_owner(world, db):
|
||||
row = db.execute("SELECT account_kind, sponsor_id FROM auth_accounts WHERE email = 'emp-team@example.test'").fetchone()
|
||||
db.rollback()
|
||||
assert row["account_kind"] == "employee"
|
||||
assert str(row["sponsor_id"]) == _id(db, world["ada"].email)
|
||||
assert world["emp"].request("GET", "/api/v1/auth/session")["account"]["account_kind"] == "employee"
|
||||
assert world["ada"].request("GET", "/api/v1/auth/session")["account"]["account_kind"] == "main"
|
||||
|
||||
|
||||
def test_an_employee_works_only_in_the_rooms_he_was_invited_to(world, db):
|
||||
emp, room = world["emp"], world["room"]
|
||||
emp.request("POST", "/api/v1/rooms", json={"name": "Eigener Raum"}, status=403)
|
||||
# The session starts in the team room, not in a personal room.
|
||||
assert emp.scope["kind"] == "organization" and emp.scope["id"] == room
|
||||
# In the personal room nothing is created.
|
||||
personal = emp.request("POST", "/api/v1/auth/session/scope", json={"kind": "personal", "id": _id(db, emp.email)})
|
||||
emp.scope, emp.csrf = personal["scope"], personal["csrf_token"]
|
||||
emp.request("POST", "/api/v1/cases", json={"title": "Privat"}, status=403)
|
||||
emp.request("POST", "/api/v1/matters", json={"title": "Privat"}, status=403)
|
||||
emp.use_room(room)
|
||||
case = emp.request("POST", "/api/v1/cases", json={"title": "Im Team"}, status=201)
|
||||
world["ada"].request("GET", f"/api/v1/cases/{case['id']}")
|
||||
# Rights follow the role: a reader only reads.
|
||||
world["ada"].request("PATCH", f"/api/v1/rooms/{room}/members/{_id(db, emp.email)}", json={"role": "reader"})
|
||||
emp.request("POST", "/api/v1/cases", json={"title": "Nicht mehr"}, status=403)
|
||||
emp.request("GET", f"/api/v1/cases/{case['id']}")
|
||||
|
||||
|
||||
def test_only_the_owner_invites_and_an_employee_never_does(world, client, db):
|
||||
ada, emp, room = world["ada"], world["emp"], world["room"]
|
||||
ben = _main(client, db, "ben")
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": ben.email, "role": "manager"})
|
||||
ben.use_room(room)
|
||||
# A manager who is not the owner adds existing accounts but creates no new ones.
|
||||
ben.request("POST", "/api/v1/invitations", json={"email": "neu-team@example.test", "room_id": room}, status=403)
|
||||
ben.request("POST", f"/api/v1/rooms/{room}/members", json={"email": emp.email, "role": "reader"})
|
||||
emp.request("POST", "/api/v1/invitations", json={"email": "neu-team@example.test", "room_id": room}, status=403)
|
||||
|
||||
|
||||
def test_an_employee_cannot_own_a_room(world, db):
|
||||
ada, emp, room = world["ada"], world["emp"], world["room"]
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/owner", json={"subject_id": _id(db, emp.email)}, status=422)
|
||||
operator = _main(world["ada"].client.__class__ and _second_client(), db, "betreiber", superadmin=True)
|
||||
db.execute("UPDATE auth_accounts SET status = 'disabled' WHERE id = %s", (_id(db, ada.email),))
|
||||
db.commit()
|
||||
operator.request("POST", f"/api/v1/admin/rooms/{room}/owner", json={"email": emp.email}, status=422)
|
||||
|
||||
|
||||
def test_my_team_lists_only_people_in_my_rooms_and_acts_only_on_my_employees(world, client, db):
|
||||
ada, emp = world["ada"], world["emp"]
|
||||
cara = _main(client, db, "cara")
|
||||
emp_id = _id(db, emp.email)
|
||||
listed = ada.request("GET", "/api/v1/team")["items"]
|
||||
assert [(p["email"], p["mine"], p["rooms"][0]["role"]) for p in listed] == [(emp.email, True, "member")]
|
||||
assert cara.request("GET", "/api/v1/team")["items"] == []
|
||||
emp.request("GET", "/api/v1/team", status=403)
|
||||
unknown = str(uuid.uuid4())
|
||||
for actor in (cara,):
|
||||
foreign = actor.request("PATCH", f"/api/v1/team/{emp_id}", json={"status": "disabled"}, status=403)
|
||||
missing = actor.request("PATCH", f"/api/v1/team/{unknown}", json={"status": "disabled"}, status=403)
|
||||
assert foreign["detail"] == missing["detail"]
|
||||
actor.request("POST", f"/api/v1/team/{emp_id}/password-reset", status=403)
|
||||
actor.request("DELETE", f"/api/v1/team/{emp_id}/memberships", status=403)
|
||||
# A main user is not a sponsored employee: no team action on him, not even by the owner.
|
||||
cara_id = _id(db, cara.email)
|
||||
ada.request("PATCH", f"/api/v1/team/{cara_id}", json={"status": "disabled"}, status=403)
|
||||
ada.request("POST", f"/api/v1/team/{cara_id}/password-reset", status=403)
|
||||
|
||||
|
||||
def test_the_owner_disables_resets_and_removes_an_employee(world, db):
|
||||
ada, emp, room = world["ada"], world["emp"], world["room"]
|
||||
emp_id = _id(db, emp.email)
|
||||
ada.request("PATCH", f"/api/v1/team/{emp_id}", json={"status": "disabled"})
|
||||
emp.request("GET", "/api/v1/auth/session", status=401)
|
||||
login = emp.client.post("/api/v1/auth/login", json={"email": emp.email, "password": PASSWORD}, headers={"Origin": ORIGIN})
|
||||
assert login.status_code == 401
|
||||
ada.request("PATCH", f"/api/v1/team/{emp_id}", json={"status": "active"})
|
||||
reset = ada.request("POST", f"/api/v1/team/{emp_id}/password-reset")
|
||||
emp.password = reset["temporary_password"]
|
||||
assert emp.login()["account"]["must_change_password"] is True
|
||||
emp.request("GET", "/api/v1/cases", status=403)
|
||||
|
||||
ada.request("DELETE", f"/api/v1/team/{emp_id}/memberships", status=204)
|
||||
assert ada.request("GET", "/api/v1/team")["items"][0]["rooms"] == []
|
||||
# Without a room the employee lands in the personal room, where he can do nothing but change his password.
|
||||
assert emp.login()["scope"]["kind"] == "personal"
|
||||
ada.request("DELETE", f"/api/v1/team/{emp_id}/memberships", status=403)
|
||||
ada.request("DELETE", f"/api/v1/team/{_id(db, ada.email)}/memberships", status=403)
|
||||
assert room
|
||||
|
||||
|
||||
def test_the_operator_sees_the_teams_as_metadata_and_exports_them_safely(world, client, db):
|
||||
ada, room = world["ada"], world["room"]
|
||||
_invite(ada, room, "formel-team@example.test", role="reader", name="=SUM(1+1)")
|
||||
operator = _main(_second_client(), db, "betreiber", superadmin=True)
|
||||
note = ada.request("POST", "/api/v1/cases", json={"title": "Geheimer Inhalt"}, status=201)
|
||||
overview = operator.request("GET", "/api/v1/admin/team")["items"]
|
||||
owner = next(item for item in overview if item["email"] == ada.email)
|
||||
assert {e["email"] for e in owner["employees"]} == {"emp-team@example.test", "formel-team@example.test"}
|
||||
assert all(r["name"] == "Kanzlei" for e in owner["employees"] for r in e["rooms"])
|
||||
assert "Geheimer Inhalt" not in str(overview) and note["title"] == "Geheimer Inhalt"
|
||||
response = operator.client.get(
|
||||
"/api/v1/admin/team",
|
||||
params={"format": "csv"},
|
||||
headers={"Origin": ORIGIN, "X-Scope-Kind": operator.scope["kind"], "X-Scope-Id": operator.scope["id"]},
|
||||
)
|
||||
assert response.status_code == 200 and response.headers["content-type"].startswith("text/csv")
|
||||
lines = response.text.splitlines()
|
||||
assert lines[0] == "Hauptnutzer,Mitarbeiter,E-Mail,Status,Datenraum,Rolle"
|
||||
assert any("'=SUM(1+1)" in line for line in lines)
|
||||
assert not any(line.split(",")[1].startswith("=") for line in lines[1:])
|
||||
world["emp"].request("GET", "/api/v1/admin/team", status=403)
|
||||
ada.request("GET", "/api/v1/admin/team", status=403)
|
||||
|
||||
|
||||
def test_only_the_operator_promotes_an_employee(world, client, db):
|
||||
ada, emp, room = world["ada"], world["emp"], world["room"]
|
||||
emp_id = _id(db, emp.email)
|
||||
ada.request("PATCH", f"/api/v1/accounts/{emp_id}", json={"account_kind": "main"}, status=403)
|
||||
operator = _main(_second_client(), db, "betreiber", superadmin=True)
|
||||
listed = {a["email"]: a for a in operator.request("GET", "/api/v1/accounts")["items"]}
|
||||
assert listed[emp.email]["account_kind"] == "employee" and listed[emp.email]["sponsor_name"] == "Ada"
|
||||
assert operator.request("GET", f"/api/v1/accounts/{_id(db, ada.email)}")["employees"][0]["email"] == emp.email
|
||||
operator.request("PATCH", f"/api/v1/accounts/{emp_id}", json={"account_kind": "main"})
|
||||
emp.request("GET", "/api/v1/cases", status=401)
|
||||
fresh = Actor(emp.client, emp.email, emp.name)
|
||||
assert fresh.login()["account"]["account_kind"] == "main"
|
||||
fresh.request("POST", "/api/v1/rooms", json={"name": "Eigener Raum"}, status=201)
|
||||
assert room
|
||||
|
||||
|
||||
def test_limits_have_one_place_and_are_checked_where_they_matter(world, client, db, monkeypatch):
|
||||
ada, room = world["ada"], world["room"]
|
||||
seen = []
|
||||
|
||||
def block_room(conn, owner_id):
|
||||
seen.append(("room", owner_id))
|
||||
raise unprocessable("Grenze erreicht.")
|
||||
|
||||
def block_member(conn, owner_id, room_id):
|
||||
seen.append(("member", owner_id, room_id))
|
||||
raise unprocessable("Grenze erreicht.")
|
||||
|
||||
cem = _main(client, db, "cem")
|
||||
monkeypatch.setattr("app.api.rooms.ensure_can_create_room", block_room)
|
||||
ada.request("POST", "/api/v1/rooms", json={"name": "Noch ein Raum"}, status=422)
|
||||
monkeypatch.setattr("app.api.rooms.ensure_can_add_member", block_member)
|
||||
ada.request("POST", f"/api/v1/rooms/{room}/members", json={"email": cem.email, "role": "member"}, status=422)
|
||||
ada.request("POST", "/api/v1/invitations", json={"email": "grenze-team@example.test", "room_id": room}, status=422)
|
||||
assert [entry[0] for entry in seen] == ["room", "member", "member"]
|
||||
assert all(entry[1] == uuid.UUID(_id(db, ada.email)) for entry in seen)
|
||||
# Changing the role of an existing member needs no check.
|
||||
monkeypatch.undo()
|
||||
invited = ada.request("POST", "/api/v1/invitations", json={"email": "spaet-team@example.test", "room_id": room}, status=201)
|
||||
monkeypatch.setattr("app.api.routes.ensure_can_add_member", block_member)
|
||||
refused = _second_client().post(
|
||||
f"/api/v1/invitations/{invited['id']}/accept",
|
||||
json={"token": invited["token"], "display_name": "Spät", "password": PASSWORD},
|
||||
headers={"Origin": ORIGIN},
|
||||
)
|
||||
assert refused.status_code == 422
|
||||
assert db.execute("SELECT 1 FROM auth_accounts WHERE email = 'spaet-team@example.test'").fetchone() is None
|
||||
db.rollback()
|
||||
@@ -81,7 +81,7 @@ def test_t_anchor_assignee_sees_the_task_but_not_the_hidden_matter(client, db):
|
||||
ada = Actor(client, "ada@example.test", "Ada")
|
||||
ada.login()
|
||||
matter = ada.request("POST", "/api/v1/matters", json={"title": "Geheimer Vorgang Anker"}, status=201)
|
||||
room = ada.request("POST", "/api/v1/rooms", json={"name": "Gleicher Raum"}, status=201)
|
||||
room = ada.request("POST", "/api/v1/rooms", json={"name": "Gleicher Raum", "default_visibility": "private"}, status=201)
|
||||
ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": "ben@example.test", "role": "member"})
|
||||
ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": "cara@example.test", "role": "member"})
|
||||
ada.use_room(room["id"])
|
||||
|
||||
@@ -0,0 +1,261 @@
|
||||
"""Kontoverwaltung: Einmal-Passwort, Deaktivieren, Betreiberrolle, Sitzungen, Login-Begrenzung."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.auth.accounts import create_account
|
||||
from tests.support import ORIGIN, PASSWORD, Actor
|
||||
|
||||
NEW_PASSWORD = "Neues-Passwort-2026"
|
||||
|
||||
|
||||
def register(conn, email: str, name: str, *, superadmin: bool = False):
|
||||
"""Accounts of the operator kind, because the account list hides fixture accounts."""
|
||||
account = create_account(conn, email, name, PASSWORD, is_superadmin=superadmin)
|
||||
conn.commit()
|
||||
return account
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def operator(client, db) -> Actor:
|
||||
actor = Actor(client, "betreiber-admin@example.test", "Betreiber Admin")
|
||||
register(db, actor.email, actor.name, superadmin=True)
|
||||
actor.login()
|
||||
return actor
|
||||
|
||||
|
||||
def _user(client, db, email: str = "nutzer-admin@example.test", name: str = "Nutzer Admin") -> Actor:
|
||||
actor = Actor(client, email, name)
|
||||
register(db, actor.email, actor.name)
|
||||
return actor
|
||||
|
||||
|
||||
def _second_client():
|
||||
from app.main import app
|
||||
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def test_operator_creates_an_account_with_a_one_time_password(client, operator):
|
||||
created = operator.request(
|
||||
"POST",
|
||||
"/api/v1/accounts",
|
||||
json={"email": "neu@example.test", "display_name": "Neu"},
|
||||
status=201,
|
||||
)
|
||||
temporary = created["temporary_password"]
|
||||
assert len(temporary) >= 10
|
||||
assert created["must_change_password"] is True
|
||||
|
||||
fresh = Actor(client, "neu@example.test", "Neu")
|
||||
fresh.password = temporary
|
||||
body = fresh.login()
|
||||
assert body["account"]["must_change_password"] is True
|
||||
refused = fresh.request("GET", "/api/v1/cases", status=403)
|
||||
assert refused["code"] == "password_change_required"
|
||||
fresh.request("GET", "/api/v1/auth/session")
|
||||
|
||||
fresh.request(
|
||||
"POST",
|
||||
"/api/v1/auth/password",
|
||||
json={"current_password": "falsch-falsch-1", "new_password": NEW_PASSWORD},
|
||||
status=422,
|
||||
)
|
||||
fresh.request("POST", "/api/v1/auth/password", json={"current_password": temporary, "new_password": temporary}, status=422)
|
||||
fresh.request("POST", "/api/v1/auth/password", json={"current_password": temporary, "new_password": "kurz"}, status=422)
|
||||
fresh.request(
|
||||
"POST",
|
||||
"/api/v1/auth/password",
|
||||
json={"current_password": temporary, "new_password": NEW_PASSWORD},
|
||||
status=204,
|
||||
)
|
||||
fresh.request("GET", "/api/v1/cases")
|
||||
assert fresh.request("GET", "/api/v1/auth/session")["account"]["must_change_password"] is False
|
||||
|
||||
again = Actor(client, "neu@example.test", "Neu")
|
||||
again.password = NEW_PASSWORD
|
||||
again.login()
|
||||
old = client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"email": "neu@example.test", "password": temporary},
|
||||
headers={"Origin": ORIGIN},
|
||||
)
|
||||
assert old.status_code == 401
|
||||
|
||||
|
||||
def test_only_the_operator_manages_accounts(client, db, operator):
|
||||
user = _user(client, db)
|
||||
target = operator.request("GET", "/api/v1/accounts")["items"][0]["id"]
|
||||
user.login()
|
||||
user.request("GET", "/api/v1/accounts", status=403)
|
||||
user.request("GET", f"/api/v1/accounts/{target}", status=403)
|
||||
user.request("PATCH", f"/api/v1/accounts/{target}", json={"status": "disabled"}, status=403)
|
||||
user.request("POST", f"/api/v1/accounts/{target}/password-reset", status=403)
|
||||
user.request("POST", f"/api/v1/accounts/{target}/sessions/revoke", status=403)
|
||||
user.request("POST", "/api/v1/accounts", json={"email": "x@example.test", "display_name": "X"}, status=403)
|
||||
|
||||
|
||||
def test_a_disabled_account_cannot_sign_in_and_its_sessions_end(client, db, operator):
|
||||
user = _user(client, db)
|
||||
other = _second_client()
|
||||
victim = Actor(other, user.email, user.name)
|
||||
victim.login()
|
||||
victim.request("GET", "/api/v1/cases")
|
||||
|
||||
operator.request("PATCH", f"/api/v1/accounts/{_id(operator, user.email)}", json={"status": "disabled"})
|
||||
victim.request("GET", "/api/v1/cases", status=401)
|
||||
refused = client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"email": user.email, "password": PASSWORD},
|
||||
headers={"Origin": ORIGIN},
|
||||
)
|
||||
assert refused.status_code == 401
|
||||
|
||||
listed = operator.request("GET", "/api/v1/accounts", params={"status": "disabled"})
|
||||
assert [item["email"] for item in listed["items"]] == [user.email]
|
||||
operator.request("PATCH", f"/api/v1/accounts/{_id(operator, user.email)}", json={"status": "active"})
|
||||
Actor(client, user.email, user.name).login()
|
||||
|
||||
|
||||
def test_the_last_operator_and_the_own_account_are_protected(client, db, operator):
|
||||
me = _id(operator, operator.email)
|
||||
operator.request("PATCH", f"/api/v1/accounts/{me}", json={"status": "disabled"}, status=422)
|
||||
operator.request("PATCH", f"/api/v1/accounts/{me}", json={"is_operator": False}, status=422)
|
||||
user = _user(client, db)
|
||||
other = _id(operator, user.email)
|
||||
operator.request("PATCH", f"/api/v1/accounts/{other}", json={"is_operator": True})
|
||||
# A second operator exists now, so the first may step down.
|
||||
operator.request("PATCH", f"/api/v1/accounts/{me}", json={"is_operator": False})
|
||||
promoted = Actor(client, user.email, user.name)
|
||||
promoted.login()
|
||||
promoted.request("PATCH", f"/api/v1/accounts/{promoted_id(promoted)}", json={"status": "disabled"}, status=422)
|
||||
promoted.request("PATCH", f"/api/v1/accounts/{promoted_id(promoted)}", json={"is_operator": False}, status=422)
|
||||
|
||||
|
||||
def test_granting_the_operator_role_ends_the_target_sessions(client, db, operator):
|
||||
user = _user(client, db)
|
||||
other = _second_client()
|
||||
target = Actor(other, user.email, user.name)
|
||||
target.login()
|
||||
target.request("GET", "/api/v1/cases")
|
||||
operator.request("PATCH", f"/api/v1/accounts/{_id(operator, user.email)}", json={"is_operator": True})
|
||||
target.request("GET", "/api/v1/cases", status=401)
|
||||
fresh = Actor(other, user.email, user.name)
|
||||
assert fresh.login()["account"]["is_superadmin"] is True
|
||||
|
||||
|
||||
def test_password_reset_sets_a_one_time_password_and_ends_sessions(client, db, operator):
|
||||
user = _user(client, db)
|
||||
other = _second_client()
|
||||
target = Actor(other, user.email, user.name)
|
||||
target.login()
|
||||
account_id = _id(operator, user.email)
|
||||
operator.request("POST", f"/api/v1/accounts/{operator_id(operator)}/password-reset", status=422)
|
||||
reset = operator.request("POST", f"/api/v1/accounts/{account_id}/password-reset")
|
||||
target.request("GET", "/api/v1/cases", status=401)
|
||||
renewed = Actor(other, user.email, user.name)
|
||||
renewed.password = reset["temporary_password"]
|
||||
assert renewed.login()["account"]["must_change_password"] is True
|
||||
renewed.request("GET", "/api/v1/cases", status=403)
|
||||
detail = operator.request("GET", f"/api/v1/accounts/{account_id}")
|
||||
assert detail["must_change_password"] is True
|
||||
assert detail["active_sessions"] == 1
|
||||
revoked = operator.request("POST", f"/api/v1/accounts/{account_id}/sessions/revoke")
|
||||
assert revoked["revoked"] == 1
|
||||
renewed.request("GET", "/api/v1/auth/session", status=401)
|
||||
|
||||
|
||||
def test_own_sessions_can_be_listed_and_ended(client, db):
|
||||
user = _user(client, db)
|
||||
user.login()
|
||||
other = _second_client()
|
||||
second = Actor(other, user.email, user.name)
|
||||
second.login()
|
||||
items = user.request("GET", "/api/v1/auth/sessions")["items"]
|
||||
assert len(items) == 2
|
||||
assert sum(1 for item in items if item["current"]) == 1
|
||||
current = next(item for item in items if item["current"])
|
||||
foreign = next(item for item in items if not item["current"])
|
||||
user.request("DELETE", f"/api/v1/auth/sessions/{current['id']}", status=422)
|
||||
user.request("DELETE", f"/api/v1/auth/sessions/{foreign['id']}", status=204)
|
||||
second.request("GET", "/api/v1/cases", status=401)
|
||||
third = Actor(other, user.email, user.name)
|
||||
third.login()
|
||||
assert user.request("POST", "/api/v1/auth/sessions/revoke-others")["revoked"] == 1
|
||||
third.request("GET", "/api/v1/cases", status=401)
|
||||
user.request("GET", "/api/v1/cases")
|
||||
|
||||
|
||||
def test_login_attempts_are_counted_in_the_database_without_the_address(client, db):
|
||||
user = _user(client, db)
|
||||
for _ in range(8):
|
||||
response = client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"email": user.email, "password": "falsch-falsch-1"},
|
||||
headers={"Origin": ORIGIN},
|
||||
)
|
||||
assert response.status_code == 401
|
||||
blocked = client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"email": user.email, "password": PASSWORD},
|
||||
headers={"Origin": ORIGIN},
|
||||
)
|
||||
assert blocked.status_code == 429
|
||||
rows = db.execute("SELECT bucket FROM auth_login_attempts").fetchall()
|
||||
assert len(rows) == 8
|
||||
assert all(user.email not in row["bucket"] and len(row["bucket"]) == 64 for row in rows)
|
||||
db.rollback()
|
||||
# Another address is a separate bucket and still works.
|
||||
other = _user(client, db, "andere-adresse@example.test", "Andere")
|
||||
Actor(client, other.email, other.name).login()
|
||||
|
||||
|
||||
def test_unknown_and_wrong_password_answer_alike(client, db):
|
||||
user = _user(client, db)
|
||||
wrong = client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"email": user.email, "password": "falsch-falsch-1"},
|
||||
headers={"Origin": ORIGIN},
|
||||
)
|
||||
unknown = client.post(
|
||||
"/api/v1/auth/login",
|
||||
json={"email": "gibt-es-nicht@example.test", "password": "falsch-falsch-1"},
|
||||
headers={"Origin": ORIGIN},
|
||||
)
|
||||
assert wrong.status_code == unknown.status_code == 401
|
||||
assert wrong.json()["detail"] == unknown.json()["detail"]
|
||||
|
||||
|
||||
def test_admin_actions_are_audited_without_secrets(client, db, operator):
|
||||
created = operator.request(
|
||||
"POST",
|
||||
"/api/v1/accounts",
|
||||
json={"email": "audit-ziel@example.test", "display_name": "Audit Ziel"},
|
||||
status=201,
|
||||
)
|
||||
account_id = created["id"]
|
||||
operator.request("POST", f"/api/v1/accounts/{account_id}/password-reset")
|
||||
operator.request("PATCH", f"/api/v1/accounts/{account_id}", json={"status": "disabled"})
|
||||
rows = db.execute(
|
||||
"SELECT action, detail FROM domain_events WHERE resource_kind = 'account' AND resource_id = %s ORDER BY occurred_at",
|
||||
(account_id,),
|
||||
).fetchall()
|
||||
assert [row["action"] for row in rows] == ["account_created", "password_reset", "account_disabled"]
|
||||
text = str(rows) + str(db.execute("SELECT * FROM domain_events").fetchall())
|
||||
assert "audit-ziel@example.test" not in text
|
||||
assert created["temporary_password"] not in text
|
||||
|
||||
|
||||
def _id(actor: Actor, email: str) -> str:
|
||||
items = actor.request("GET", "/api/v1/accounts")["items"]
|
||||
return next(item["id"] for item in items if item["email"] == email)
|
||||
|
||||
|
||||
def operator_id(actor: Actor) -> str:
|
||||
return _id(actor, actor.email)
|
||||
|
||||
|
||||
def promoted_id(actor: Actor) -> str:
|
||||
return _id(actor, actor.email)
|
||||
@@ -0,0 +1,46 @@
|
||||
"""R-11: other people's rows must not push your own out of the overview and the search."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from tests.support import Actor, case_of, note_on, register
|
||||
|
||||
|
||||
def test_own_entries_are_found_behind_many_foreign_ones(client, db, monkeypatch):
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.api import routes
|
||||
from app.main import app
|
||||
|
||||
# A tiny batch size makes the paging visible with few rows.
|
||||
monkeypatch.setattr(routes, "SCAN_BATCH", 2)
|
||||
register(db, "ada-scan@example.test", "Ada")
|
||||
register(db, "ben-scan@example.test", "Ben")
|
||||
ada = Actor(client, "ada-scan@example.test", "Ada")
|
||||
ben = Actor(TestClient(app), "ben-scan@example.test", "Ben")
|
||||
ada.login()
|
||||
ben.login()
|
||||
|
||||
ada_case = case_of(ada, "Adas Akte")
|
||||
for index in range(7):
|
||||
matter = ada.request("POST", "/api/v1/matters", json={"title": f"Adas Vorgang {index}"}, status=201)
|
||||
ada.request("POST", "/api/v1/tasks", json={"title": f"Frühe Aufgabe {index}", "due_on": "2026-01-0%d" % (index + 1), "matter_id": matter["id"]}, status=201)
|
||||
ada.request("POST", "/api/v1/deadlines", json={"title": f"Frühe Frist {index}", "due_on": "2026-01-0%d" % (index + 1), "matter_id": matter["id"]}, status=201)
|
||||
note_on(ada, f"Gemeinsames Stichwort {index}", "Zebrastreifen", ada_case["id"])
|
||||
|
||||
ben_matter = ben.request("POST", "/api/v1/matters", json={"title": "Bens Vorgang"}, status=201)
|
||||
ben.request("POST", "/api/v1/tasks", json={"title": "Bens späte Aufgabe", "due_on": "2027-01-01", "matter_id": ben_matter["id"]}, status=201)
|
||||
ben.request("POST", "/api/v1/deadlines", json={"title": "Bens späte Frist", "due_on": "2027-01-01", "matter_id": ben_matter["id"]}, status=201)
|
||||
ben_case = case_of(ben, "Bens Akte")
|
||||
note_on(ben, "Bens Zebrastreifen-Notiz", "Zebrastreifen", ben_case["id"])
|
||||
|
||||
assert [item["title"] for item in ben.request("GET", "/api/v1/views/open-tasks")["items"]] == ["Bens späte Aufgabe"]
|
||||
assert [item["title"] for item in ben.request("GET", "/api/v1/views/open-deadlines")["items"]] == ["Bens späte Frist"]
|
||||
found = ben.request("GET", "/api/v1/search", params={"q": "Zebrastreifen"})["items"]
|
||||
assert [item["title"] for item in found] == ["Bens Zebrastreifen-Notiz"]
|
||||
|
||||
# The own entries still come in order and the cap on the list holds.
|
||||
monkeypatch.setattr(routes, "VIEW_LIMIT", 3)
|
||||
first = ada.request("GET", "/api/v1/views/open-tasks")["items"]
|
||||
assert [item["title"] for item in first] == ["Frühe Aufgabe 0", "Frühe Aufgabe 1", "Frühe Aufgabe 2"]
|
||||
monkeypatch.setattr(routes, "SEARCH_LIMIT", 4)
|
||||
assert len(ada.request("GET", "/api/v1/search", params={"q": "Zebrastreifen"})["items"]) == 4
|
||||
+17
-1
@@ -30,7 +30,7 @@ Unter `/home/lars/docker/` legt der Lauf nur diese zwei Verzeichnisse an:
|
||||
|----------|---------|--------|
|
||||
| `deploy-dev.yml` | Push `develop` | Deploy nach `/home/lars/docker/tsumugu-dev`, Health `localhost:8094` und `localhost:3094` |
|
||||
| `deploy-prod.yml` | Push `main` | Deploy nach `/home/lars/docker/tsumugu`, Health `localhost:8007` und `localhost:3007` |
|
||||
| `test.yml` | Push `develop`, nach erfolgreichem Dev-Deploy, manuell | Pytest gegen `tsumugu_test` auf der Dev-Postgres, Smoke der laufenden Dev-App, Frontend-Build |
|
||||
| `test.yml` | Push auf `develop` (wartet, bis der Dev-Checkout den Commit enthält), manuell | Pytest gegen `tsumugu_test` auf der Dev-Postgres, Smoke der laufenden Dev-App, Frontend-Build |
|
||||
|
||||
Gearbeitet wird auf `develop`. Production entsteht nur durch einen Merge-Commit `develop` → `main` (`git merge --no-ff develop` auf `main`) und den anschließenden Push von `main`. Kein Fast-Forward, kein direkter Commit auf `main`, kein manuelles `git pull` auf dem Prod-Checkout. Gitea (`deploy-prod.yml`) ist der einzige Prod-Schreibpfad für Code.
|
||||
|
||||
@@ -42,6 +42,22 @@ Die Pflicht-Suite ist der eigene Workflow `test.yml`, nach dem Vorbild von Kansh
|
||||
|
||||
---
|
||||
|
||||
## Bekannte Betriebsgrenzen (Stand Code-Review 18.10.2026)
|
||||
|
||||
Diese Punkte sind im [Code-Review](review/06_BEFUNDE.md) beschrieben. Sie stehen hier, damit sie beim Betrieb sichtbar bleiben.
|
||||
|
||||
| Thema | Ist-Stand | Folge für den Betrieb | Review |
|
||||
|---|---|---|---|
|
||||
| Betreiberkonto | Auf einer leeren Datenbank legt die öffentliche Anmeldeseite das Betreiberkonto an. Keine MFA | Nach jedem Neuaufsetzen einer Umgebung sofort selbst anmelden, bevor die Adresse öffentlich erreichbar ist. Alternativ vorher `docker compose exec backend python -m app.cli create-account --email … --name … --password …` ausführen | R-04 |
|
||||
| Sicherung | Es gibt kein Backup von Datenbank und Volume `tsumugu-media`/`dev-tsumugu-media` und keinen geprobten Restore | Laut technischer Spezifikation 8.2 nur synthetische Daten in Produktion, bis Paket P7 umgesetzt ist | R-21 |
|
||||
| Release | `deploy-prod.yml` baut bei jedem Push auf `main` neu. Tests laufen nur auf `develop`, sobald der Dev-Deploy den Commit ausgecheckt hat | Vor dem Merge nach `main` den grünen `test.yml`-Lauf zum selben Stand prüfen | R-21, R-27 |
|
||||
| Datenbankzugang | Das Backend migriert beim Start mit dem Owner-Zugang. Die Runtime-Rolle `tsumugu_runtime` erhält dasselbe Passwort wie `DB_USER` | Ein Wechsel von `DB_PASSWORD` ändert beim nächsten Start beide Rollen | R-09 |
|
||||
| Quellen-Geheimnisse | Paperless-Token und IMAP-Passwörter stehen unverschlüsselt in der Tabelle `connectors` | Datenbank-Dumps wie Zugangsdaten schützen | R-05 |
|
||||
| Sessions | 14 Tage gültig, keine Leerlaufabmeldung, kein Passwortwechsel in der Anwendung | Passwort nur über die Datenbank oder ein neues Konto änderbar | R-08 |
|
||||
| Testläufe | `test.yml` startet je Push einmal, parallel zum Deploy, und wartet auf dessen Checkout (`workflow_run` startete auf dieser Gitea nicht verlässlich); alle Läufe teilen die Datenbank `tsumugu_test`, und das Image bleibt das Laufzeitimage | Zwei manuelle Läufe gleichzeitig vermeiden; sie würden sich die Datenbank wegnehmen | R-27 |
|
||||
|
||||
---
|
||||
|
||||
## Erreichbarkeit von außen
|
||||
|
||||
TLS endet wie bei Kanshō auf dem Synology-NAS `192.168.2.63` (DSM Reverse Proxy), nicht auf dem Pi.
|
||||
|
||||
@@ -0,0 +1,97 @@
|
||||
# Entwicklung und Tests – lokal
|
||||
|
||||
**Stand:** 18.10.2026. Erstellt im Code-Review aus Code und Workflows. Deployment auf dem Raspberry Pi: [DEPLOYMENT.md](DEPLOYMENT.md).
|
||||
|
||||
## Voraussetzungen
|
||||
|
||||
- Python 3.12, Node.js (das Build-Image nutzt Node 22; lokal funktioniert auch Node 24)
|
||||
- PostgreSQL 16. Der Benutzer aus `DB_USER` muss Tabellen anlegen und die Rolle `tsumugu_runtime` erstellen dürfen (`CREATEROLE`). Im Compose-Stack ist das der Superuser des Postgres-Containers.
|
||||
|
||||
## Konfiguration
|
||||
|
||||
Das Backend liest ausschließlich die Prozessumgebung. Eine `.env`-Datei wird nicht automatisch geladen.
|
||||
|
||||
| Variable | Pflicht | Default | Bedeutung |
|
||||
|---|---|---|---|
|
||||
| `TSUMUGU_ENV` | ja | – | `development` oder `production`; ein anderer Wert verhindert den Start |
|
||||
| `DB_NAME`, `DB_USER`, `DB_PASSWORD` | ja | – | Owner-Zugang; Migration und Runtime-Rolle |
|
||||
| `DB_HOST`, `DB_PORT` | nein | `localhost`, `5432` | – |
|
||||
| `DB_RUNTIME_USER` | nein | `tsumugu_runtime` | Rolle des laufenden Pools; erhält dasselbe Passwort wie `DB_USER` |
|
||||
| `ALLOWED_ORIGINS` | nein | `http://localhost:5173,http://localhost:3094` | erlaubte `Origin`-Werte für schreibende Aufrufe |
|
||||
| `APP_URL` | nein | `http://localhost:5173` | öffentliche Adresse |
|
||||
| `MEDIA_ROOT` | nein | `data/media` | Ablage eigener Dateien |
|
||||
| `PAPERLESS_MEDIA_ROOT` | nein | leer | lesender Paperless-Ablageordner als Rückfallweg |
|
||||
| `SEED_DEMO` | nein | `false` | wirkt nur in Development mit Datenbank `*_test`; in Production verhindert `true` den Start |
|
||||
| `SESSION_TTL_HOURS` | nein | `336` | Laufzeit einer Session |
|
||||
| `UPLOAD_MAX_BYTES` | nein | `20971520` | Upload-Grenze (Nginx erlaubt 21 MiB) |
|
||||
|
||||
## Backend starten
|
||||
|
||||
```bash
|
||||
cd backend
|
||||
python -m venv .venv && . .venv/bin/activate # Windows: .venv\Scripts\activate
|
||||
pip install -r requirements-dev.txt
|
||||
export TSUMUGU_ENV=development DB_NAME=tsumugu_local DB_USER=postgres DB_PASSWORD=…
|
||||
python -m app.cli migrate
|
||||
python -m app.cli create-account --email ich@example.test --name "Ich" --password "mindestens-zehn"
|
||||
uvicorn main:app --reload --port 8000
|
||||
```
|
||||
|
||||
Das erste per CLI angelegte Konto wird Betreiber. Alternativ zeigt die Anmeldeseite auf einer leeren Datenbank das Formular „Betreiberkonto“ (siehe Review R-04). `python -m app.entrypoint` entspricht dem Containerstart: Migration, Entfernen von Fixture-Konten, danach Uvicorn auf Port 8000.
|
||||
|
||||
## Frontend starten
|
||||
|
||||
```bash
|
||||
cd frontend
|
||||
npm ci
|
||||
npm run dev # http://localhost:5173, Proxy für /api und /health auf 127.0.0.1:8000
|
||||
```
|
||||
|
||||
Ein anderes Backend erreicht der Proxy über `VITE_API_PROXY`. Über HTTP heißt das Session-Cookie `jinkendo-session`. Die Kennzeichnung „Entwicklungsumgebung“ erscheint im Vite-Server automatisch, im Image über `VITE_TSUMUGU_ENV=development`.
|
||||
|
||||
Produktionsbuild: `npm run build`. Für Development-Images ergänzt `mark-environment.mjs` danach Titel, Manifest und Farbe.
|
||||
|
||||
## Tests
|
||||
|
||||
### Backend
|
||||
|
||||
Die Suite läuft gegen echtes PostgreSQL. Sie verweigert jede Datenbank, deren Name nicht auf `_test` endet, sowie `tsumugu`, `tsumugu_dev`, `postgres` und die Templates. Vor und nach jedem Test werden alle Tabellen geleert.
|
||||
|
||||
```bash
|
||||
cd backend
|
||||
createdb tsumugu_local_test
|
||||
export DB_NAME=tsumugu_local_test DB_USER=… DB_PASSWORD=… DB_HOST=localhost
|
||||
python -m pytest tests -ra --basetemp=.pytest-tmp
|
||||
```
|
||||
|
||||
- `conftest.py` setzt `TSUMUGU_ENV=development`, `ALLOWED_ORIGINS=http://testserver`, `SEED_DEMO=false` und ein temporäres `MEDIA_ROOT`.
|
||||
- Unter Windows kann das Standard-Temp-Verzeichnis von pytest gesperrt sein. `--basetemp=.pytest-tmp` umgeht das; der Ordner gehört nicht ins Repository.
|
||||
- Zwei Läufe dürfen nicht gleichzeitig dieselbe Testdatenbank verwenden.
|
||||
- Paperless und IMAP werden in den Tests durch lokale Attrappen ersetzt. Es entsteht kein Netzzugriff.
|
||||
|
||||
### Frontend
|
||||
|
||||
```bash
|
||||
cd frontend
|
||||
node --test src/list-meta.test.mjs
|
||||
```
|
||||
|
||||
Weitere Frontend-Tests gibt es nicht. Ein `npm test`-Skript ist nicht registriert.
|
||||
|
||||
### In CI
|
||||
|
||||
`.gitea/workflows/test.yml` erzeugt auf der Dev-Postgres die Datenbank `tsumugu_test` neu und führt die Suite im Backend-Image aus. Danach folgen ein lesender Health-Smoke der laufenden Dev-App und ein Frontend-Build. Bekannte Schwächen: [Review 07](review/07_TESTS_UND_CI.md).
|
||||
|
||||
## Neue Migration
|
||||
|
||||
1. Datei `backend/migrations/YYYYMMDDTHHMMSSZ_kurzname.sql` anlegen, Zeitstempel in UTC, lexikalisch nach der letzten.
|
||||
2. Keine eigene Transaktionssteuerung in der Datei; der Runner kapselt jede Datei.
|
||||
3. Angewandte Dateien nie ändern: Die Prüfsumme im Ledger verhindert danach den Start.
|
||||
4. [DATENMODELL_IST.md](architecture/DATENMODELL_IST.md) nachziehen.
|
||||
|
||||
## Neue Route
|
||||
|
||||
1. Route in `api/routes.py`, `api/sources.py` oder `api/export.py` mit `Depends(get_principal)` und `Depends(get_conn)` anlegen.
|
||||
2. Rechte über die Funktionen in `access/policy.py` prüfen, nie nur im Frontend.
|
||||
3. Änderung samt `audit(...)` in derselben Verbindung.
|
||||
4. [API_REFERENZ.md](architecture/API_REFERENZ.md) nachziehen.
|
||||
@@ -7,6 +7,9 @@ Diese Regeln sind die Arbeitsgrundlage der ersten Lieferung. Sie sind keine endg
|
||||
3. **Einbindung und Löschen.** „Aus diesem Kontext entfernen“ löscht die Einbindung und ihre Anmerkungen. Das Element bleibt bei der Eigentümerin oder dem Eigentümer, auch ohne Einbindung. „Überall löschen“ darf nur diese Person. Paperless-Originale werden nicht gelöscht.
|
||||
4. **Aktenvererbung.** Die Zuordnung eines Vorgangs gibt die Rechte dieser Akte an den Vorgang und an Inhalte ohne ausdrückliche Ausnahme weiter. Was die zuordnende Person nicht weitergeben darf, bleibt in diesem Aktenkontext unsichtbar, ohne Titel und ohne Anzahl. Querverweise vererben nichts. Die Ownership bleibt unverändert.
|
||||
|
||||
5. **Herunterladen von Originalen.** Das Recht „Herunterladen“ ist getrennt vom Lesen, standardmäßig überall erlaubt und je Raum und Rolle abschaltbar (Voreinstellung am Konto des Hauptnutzers). Es ist eine Nutzungsregel, kein Kopierschutz: Lesen in der App bleibt möglich, Abfotografieren und Entwicklerwerkzeuge verhindert die Regel nicht. Ob später eine strengere Rechtegrundlage nötig ist, entscheiden Datenschutz und Recht.
|
||||
6. **Bilder in E-Mails.** Bilder fremder Server werden nicht automatisch geladen. Auf Wunsch lädt der Server sie für die Person nach, das Gerät kontaktiert den Absender nicht. Dass die Nachricht geöffnet wurde, kann der Absender erkennen.
|
||||
|
||||
Der gewählte Datenraum legt fest, wo neue Objekte entstehen. Er ist nicht selbst der Rechtepfad. Eine gültige Sitzung muss einen Datenraum gewählt haben; der Server prüft danach den mitgeschickten Handlungskontext.
|
||||
|
||||
Technische Anpassung: Das Session-Cookie heißt in Production `__Host-jinkendo-session` und ist `Secure`. Development nutzt diesen Namen nur bei HTTPS. Über die dokumentierten HTTP-Adressen im LAN heißt es `jinkendo-session`, weil ein `__Host-`-Cookie dort nicht gespeichert werden kann.
|
||||
@@ -0,0 +1,99 @@
|
||||
# Tsumugu – Dokumentation
|
||||
|
||||
Übersicht aller Dokumente im Repository. Verbindlichkeit laut [AGENTS.md](../AGENTS.md): Fachlich führend ist die Produktspezifikation, technisch der Entwurf in `architecture/`. Vorläufige Rechte- und Löschregeln stehen in den MVP-Annahmen.
|
||||
|
||||
## Einstieg
|
||||
|
||||
| Ich will … | Dokument |
|
||||
|---|---|
|
||||
| wissen, was Tsumugu ist und wo es läuft | [../README.md](../README.md) |
|
||||
| lokal entwickeln und testen | [ENTWICKLUNG_UND_TESTS.md](ENTWICKLUNG_UND_TESTS.md) |
|
||||
| deployen und Ports nachschlagen | [DEPLOYMENT.md](DEPLOYMENT.md) |
|
||||
| den fachlichen Stand und offene Entscheidungen kennen | [product/TSUMUGU_PRODUCT_SPEC.md](product/TSUMUGU_PRODUCT_SPEC.md) |
|
||||
| den aktuellen Qualitätsstand und offene Mängel sehen | [review/README.md](review/README.md) |
|
||||
|
||||
## Produkt (`product/`)
|
||||
|
||||
| Dokument | Rolle | Stand |
|
||||
|---|---|---|
|
||||
| [TSUMUGU_PRODUCT_SPEC.md](product/TSUMUGU_PRODUCT_SPEC.md) | führende Fachspezifikation, alle bestätigten Entscheidungen F-01 bis F-08, S-01 | 0.37 |
|
||||
| [TSUMUGU_UX_MVP_ERGAENZUNG.md](product/TSUMUGU_UX_MVP_ERGAENZUNG.md) | Bedienung, Orientierung, Abnahmekriterien UX-01 bis UX-21 | 0.8 |
|
||||
| [TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md](product/TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md) | Auftrag F-06f, hat Vorrang vor älteren Darstellungsvorgaben | 1.0 |
|
||||
| [TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md](product/TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md) | Auftrag F-06e | 1.2 |
|
||||
| [TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md](product/TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md) | Auftrag F-06c, Typ-Symbole und Logo-Rahmen | 17.10.2026 |
|
||||
| [TSUMUGU_ENSO_ANIMATION_AUFTRAG.md](product/TSUMUGU_ENSO_ANIMATION_AUFTRAG.md) | Einbindung der Ensō-Animation | 17.10.2026 |
|
||||
| [TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md](product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md) | Auftrag F-07a–c, Übergabepaket | 17.10.2026 |
|
||||
| [TSUMUGU_EXPORT_PRUEFBERICHT_2026-10-17.md](product/TSUMUGU_EXPORT_PRUEFBERICHT_2026-10-17.md) | Prüfbericht der Exportlieferung | 17.10.2026 |
|
||||
| [TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md](product/TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md) | Auftrag F-08a | 17.10.2026 |
|
||||
| [TSUMUGU_UNTERKAPITEL_PRUEFBERICHT_2026-10-17.md](product/TSUMUGU_UNTERKAPITEL_PRUEFBERICHT_2026-10-17.md) | Prüfbericht Unterkapitel | 17.10.2026 |
|
||||
| [TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md](product/TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md) | Bestandsanalyse Paperless/IMAP, Umbauschätzung | 17.10.2026 |
|
||||
| [TSUMUGU_CONNECTOR_UMBAU_AUFTRAG_2026-10-19.md](product/TSUMUGU_CONNECTOR_UMBAU_AUFTRAG_2026-10-19.md) | begrenzter Umsetzungsauftrag, Abschnitt A beauftragt, Abschnitt B der nächste Ausbau | 19.10.2026 |
|
||||
| [TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md](product/TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md) | Abschlusskriterien der Kapselung; Vorrang vor einem teilweise integrierten Zwischenstand | 19.10.2026 |
|
||||
| [TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md](product/TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md) | Kriterium, Nachweis und Ergebnis der Kapselung | 19.10.2026 |
|
||||
| [TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md](product/TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md) | Nacharbeit: IMAP-Seiten, Paperless-Suche, Markdown-Notiz | 19.10.2026 |
|
||||
| [TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md](product/TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md) | Korrektur K1–K7: IMAP-Ordner, MIME, Transaktion, Markdown, Leser, Paperless-Antworten | 20.10.2026 |
|
||||
| [TSUMUGU_IMAP_SENT_ITEMS_MIME_BEFUND_UND_FIXAUFTRAG_2026-10-20.md](product/TSUMUGU_IMAP_SENT_ITEMS_MIME_BEFUND_UND_FIXAUFTRAG_2026-10-20.md) | Befund zu Sent Items und MIME, unverändert übernommen | 20.10.2026 |
|
||||
| [TSUMUGU_RELEASE_GATE_BACKUP_AUFTRAG_2026-10-22.md](product/TSUMUGU_RELEASE_GATE_BACKUP_AUFTRAG_2026-10-22.md) | Auftrag P7: Release-Gate, Backup und Restore vor Produktion (R-21), für eine eigene Sitzung | 22.10.2026 |
|
||||
| [TSUMUGU_CONNECTOR_NACHARBEIT_REVIEW_2026-10-20.md](product/TSUMUGU_CONNECTOR_NACHARBEIT_REVIEW_2026-10-20.md) | Review der Nacharbeit, unverändert übernommen | 20.10.2026 |
|
||||
| [TSUMUGU_CONNECTOR_BASIS_ERGEBNIS_2026-10-19.md](product/TSUMUGU_CONNECTOR_BASIS_ERGEBNIS_2026-10-19.md) | früherer Zwischenstand von Abschnitt A vor den Abschlusskriterien | 19.10.2026 |
|
||||
| [TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md](product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md) | Einstieg für die fachliche Weiterplanung | 17.10.2026 |
|
||||
| [TECHNICAL_SPEC_HANDOFF.md](product/TECHNICAL_SPEC_HANDOFF.md) | historischer Auftrag zur technischen Spezifikation | 16.10.2026 |
|
||||
| [Tsumugu_Product_Recovery_Baseline_v0.1.md](product/Tsumugu_Product_Recovery_Baseline_v0.1.md) | unveränderte historische Ausgangsbasis | 0.1 |
|
||||
|
||||
## Architektur (`architecture/`)
|
||||
|
||||
| Dokument | Rolle | Stand |
|
||||
|---|---|---|
|
||||
| [TSUMUGU_TECHNICAL_SPEC.md](architecture/TSUMUGU_TECHNICAL_SPEC.md) | technischer Entwurf (Soll): Pakete, Datenmodell, Rechte, API, Nachweise | 0.3 mit Ergänzungen |
|
||||
| [API_REFERENZ.md](architecture/API_REFERENZ.md) | tatsächlich registrierte Endpunkte (Ist) | 19.10.2026 |
|
||||
| [DATENMODELL_IST.md](architecture/DATENMODELL_IST.md) | Schema nach allen Migrationen (Ist) | 19.10.2026 |
|
||||
| [RECHTEMODELL_IST.md](architecture/RECHTEMODELL_IST.md) | implementierte Rechteauswertung (Ist) | 19.10.2026 |
|
||||
| [BENUTZERVERWALTUNG.md](architecture/BENUTZERVERWALTUNG.md) | Konten, Rollen, Einmal-Passwort, Einladungen, Audit (Ist) und Abgrenzung zum Sicherheitskonzept | 20.10.2026 |
|
||||
| [ARCHITECTURE_DISCOVERY.md](architecture/ARCHITECTURE_DISCOVERY.md) | Ist-Aufnahme der Jinkendo-Familie vor Tsumugu, keine Beschlüsse | 15.10.2026 |
|
||||
| [TSUMUGU_CONNECTOR_STORAGE_VERTRAG_v0.1_2026-10-19.md](architecture/TSUMUGU_CONNECTOR_STORAGE_VERTRAG_v0.1_2026-10-19.md) | Umsetzungsvorschlag Source- und Storage-Vertrag | 19.10.2026 |
|
||||
| [Tsumugu_Connector_Suite_Architektur_v0.2.md](architecture/Tsumugu_Connector_Suite_Architektur_v0.2.md) | Zielarchitektur der Connector Suite, keine pauschale Beschlussübernahme | 19.10.2026 |
|
||||
| [TSUMUGU_STORAGE_SCHLUESSEL_PRUEFAUFTRAG_2026-10-19.md](architecture/TSUMUGU_STORAGE_SCHLUESSEL_PRUEFAUFTRAG_2026-10-19.md) | vorbereiteter Prüfauftrag an die Architektur-Session, nicht versandt | 19.10.2026 |
|
||||
|
||||
## Design (`design/`)
|
||||
|
||||
| Dokument | Rolle | Stand |
|
||||
|---|---|---|
|
||||
| [LIEFERUNG_2026-10-17.md](design/LIEFERUNG_2026-10-17.md) | Lieferbericht der Arbeitsfläche, bewusste Abweichungen | 17.10.2026, historisch |
|
||||
|
||||
Das ausgewählte Designkonzept und die Assetpakete liegen außerhalb des Repositorys unter `C:/Dev/jinkendo-app-design-2026-10-17/`. Die übernommenen Assets stehen in `frontend/public/brand/` und `frontend/public/ui/`.
|
||||
|
||||
## Referenz (`reference/`)
|
||||
|
||||
Familienweite Vorgaben der Jinkendo-Anwendungen. Verbindliche Verträge und anpassbare Defaults sind dort jeweils getrennt.
|
||||
|
||||
| Dokument | Geltung für Tsumugu |
|
||||
|---|---|
|
||||
| [A – Technische Referenzarchitektur v0.3](reference/jinkendo-phase3-2-technical-reference-architecture-v0.3-2026-10-16/A_Jinkendo_Technical_Reference_Architecture.md) | verbindlich |
|
||||
| [B – Implementation Blueprint Foundation v0.3](reference/jinkendo-phase3-2-technical-reference-architecture-v0.3-2026-10-16/B_Implementation_Blueprint_Application_Foundation.md) | verbindlich |
|
||||
| [C – Technische Entscheidungen v0.3](reference/jinkendo-phase3-2-technical-reference-architecture-v0.3-2026-10-16/C_Technical_Decisions_Open_Issues.md) | verbindlich |
|
||||
| [Auth, Session & Scope](reference/Jinkendo_Auth_Session_Scope_Blueprint.md) | verbindlich |
|
||||
| [Medien, Dateien & sicheres Rendering](reference/Jinkendo_Media_Files_Safe_Rendering_Blueprint.md) | verbindlich |
|
||||
| [Release, Betrieb & Recovery](reference/Jinkendo_Release_Betrieb_Recovery_Blueprint.md) | verbindlich vor echtem Betrieb (Paket P7) |
|
||||
| [KI-Gateway](reference/Jinkendo_AI_Gateway_Provider_Privacy_Blueprint.md), [Prompt/Workflow](reference/Jinkendo_Prompt_Placeholder_Workflow_Blueprint.md), [Entitlements](reference/Jinkendo_Entitlements_Usage_Quotas_Blueprint.md) | nur als Grenze; keine MVP-Pflicht |
|
||||
|
||||
Die Links innerhalb der Referenzdokumente zeigen auf die ursprünglichen Ablageorte unter `C:/Dev/…` und funktionieren im Repository nicht.
|
||||
|
||||
## Betrieb und Regeln
|
||||
|
||||
| Dokument | Rolle |
|
||||
|---|---|
|
||||
| [DEPLOYMENT.md](DEPLOYMENT.md) | Umgebungen, Ports, Workflows, Proxy, bekannte Betriebsgrenzen |
|
||||
| [MVP_ANNAHMEN.md](MVP_ANNAHMEN.md) | vorläufige Rechte- und Löschregeln, Cookie-Abweichung in Development |
|
||||
| [ENTWICKLUNG_UND_TESTS.md](ENTWICKLUNG_UND_TESTS.md) | Konfiguration, lokaler Start, Tests, neue Migration und Route |
|
||||
|
||||
## Review (`review/`)
|
||||
|
||||
| Dokument | Inhalt |
|
||||
|---|---|
|
||||
| [review/README.md](review/README.md) | Code-Review vom 18.10.2026: Gesamtbewertung, Anforderungsabdeckung, Befunde, Maßnahmenplan |
|
||||
|
||||
## Pflege
|
||||
|
||||
- Neue Fachentscheidung → Produktspezifikation (Abschnitt 5 und Fortschreibung).
|
||||
- Neue Route, Migration oder Rechteregel → die passende Ist-Datei in `architecture/` im selben Commit.
|
||||
- Neuer Auftrag oder Prüfbericht → `product/`, hier in der Tabelle eintragen.
|
||||
@@ -1,6 +1,6 @@
|
||||
# Tsumugu – API-Referenz (Ist-Stand)
|
||||
|
||||
**Stand:** 18.10.2026. Erstellt im Code-Review aus `backend/app/main.py`, `api/routes.py`, `api/sources.py`, `api/export.py` und `api/correspondence.py`.
|
||||
**Stand:** 18.10.2026, ergänzt am 19.10.2026 um Quelleninstanzen, Fähigkeiten und Zuordnung und am 23.10.2026 um Download-Regeln, HTML-Mail mit Bildern, Übersicht und Suche. Erstellt im Code-Review aus `backend/app/main.py`, `api/routes.py`, `api/sources.py`, `api/export.py` und `api/correspondence.py`.
|
||||
|
||||
Diese Datei beschreibt die tatsächlich registrierten Endpunkte. Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 6.2](TSUMUGU_TECHNICAL_SPEC.md). OpenAPI ist in allen Umgebungen abgeschaltet (`docs_url=None`, `openapi_url=None`). Diese Datei ist deshalb die einzige Übersicht. Sie wird bei jeder Routenänderung mitgepflegt.
|
||||
|
||||
@@ -31,28 +31,63 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
|
||||
|
||||
| Methode | Pfad | Auth | Zweck |
|
||||
|---|---|---|---|
|
||||
| POST | `/api/v1/auth/login` | – | E-Mail, Passwort → Session-Sicht und Cookie. 8 Versuche je IP+E-Mail in 10 min (Prozessspeicher) |
|
||||
| POST | `/api/v1/auth/login` | – | E-Mail, Passwort → Session-Sicht und Cookie. 8 Fehlversuche je Bucket (Hash aus IP und E-Mail) in 10 min, gezählt in `auth_login_attempts` |
|
||||
| POST | `/api/v1/auth/logout` | S | Session widerrufen, Cookie löschen, 204 |
|
||||
| GET / PUT | `/api/v1/auth/download-defaults` | S+R, Hauptnutzer | Voreinstellung je Rolle und `direct` (direkt freigegebene Personen); neue Räume übernehmen die drei Rollenwerte. Audit `download_defaults_changed` |
|
||||
| GET / PUT | `/api/v1/auth/preferences/{key}` | S+R | Einstellung des Kontos mit Erbung. GET liefert `value` (wirksam), `source` (`locked`/`own`/`team`/`default`), `own`, `inherited`, `locked`, `allowed`, `can_lock`, `team_mode`. PUT setzt den eigenen Wert (`value`, `null` = erben) und beim Hauptnutzer die Verbindlichkeit für das Team (`team_mode` `free`/`locked`). Ein Mitarbeiter erhält bei verbindlicher Vorgabe 403. Schlüssel: `duplicate_check` (`off`/`here`/`inside`/`around`, Standard `here`). Audit `preference_changed` |
|
||||
| GET | `/api/v1/auth/session` | S | Konto, bestätigter Datenraum, Räume, CSRF-Token, Epoche |
|
||||
| POST | `/api/v1/auth/session/scope` | S | Datenraum wechseln (`kind`, `id`); erhöht die Epoche |
|
||||
| GET | `/api/v1/auth/bootstrap` | – | `{available: true}`, solange kein Betreiber existiert, sonst 404 |
|
||||
| POST | `/api/v1/auth/bootstrap` | – | erstes Konto als Betreiber anlegen, nur ohne vorhandenen Betreiber |
|
||||
| GET | `/api/v1/auth/demo` | – | Beispielkonten; nur Development mit Datenbank `*_test` und `SEED_DEMO=true`, sonst 404 |
|
||||
| GET | `/api/v1/accounts` | S+R, B | aktive Betreiberkonten (`origin='operator'`) |
|
||||
| POST | `/api/v1/accounts` | S+R, B | Konto mit Passwort anlegen, erhält persönlichen Raum |
|
||||
| GET | `/api/v1/accounts` | S+R, B | Betreiberkonten (`origin='operator'`) mit Status, Rolle, letzter Anmeldung; Filter `status=active\|disabled` |
|
||||
| GET | `/api/v1/accounts/{id}` | S+R, B | Detail mit Raummitgliedschaften und Zahl aktiver Sitzungen |
|
||||
| POST | `/api/v1/accounts` | S+R, B | Konto anlegen, persönlicher Raum, `must_change_password`. Ohne `password` erzeugt der Server ein Einmal-Passwort und liefert es einmal als `temporary_password`. `is_operator` optional |
|
||||
| PATCH | `/api/v1/accounts/{id}` | S+R, B | `display_name`, `is_operator`, `status` (`active`/`disabled`), `account_kind: main` (Mitarbeiter zum Hauptnutzer machen). Letzter Betreiber und eigenes Konto sind geschützt |
|
||||
| POST | `/api/v1/accounts/{id}/password-reset` | S+R, B | neues Einmal-Passwort, beendet alle Sitzungen; nicht für das eigene Konto |
|
||||
| POST | `/api/v1/accounts/{id}/sessions/revoke` | S+R, B | alle Sitzungen des Kontos beenden |
|
||||
| POST | `/api/v1/auth/password` | S | eigenes Passwort ändern (`current_password`, `new_password`); beendet die anderen Sitzungen; 204. Erlaubt auch bei `must_change_password` |
|
||||
| GET | `/api/v1/auth/sessions` | S | eigene aktive Sitzungen (Gerätehinweis, zuletzt aktiv) |
|
||||
| DELETE | `/api/v1/auth/sessions/{id}` | S | eigene andere Sitzung beenden; die aktuelle über Abmelden |
|
||||
| POST | `/api/v1/auth/sessions/revoke-others` | S | überall sonst abmelden |
|
||||
| GET | `/api/v1/principals?email=` | S+R | aktives Konto per E-Mail auflösen (ID, Anzeigename) |
|
||||
| POST | `/api/v1/invitations` | S+R, M | Einladung in einen gemeinsamen Raum; Antwort enthält das Token einmalig. Keine Oberfläche |
|
||||
| POST | `/api/v1/invitations/{id}/accept` | – | Token, Anzeigename, Passwort → Konto, Mitgliedschaft, Session |
|
||||
| POST | `/api/v1/invitations` | S+R, M | Einladung in einen gemeinsamen Raum mit `role` (`member`/`manager`/`reader`); Antwort enthält das Token einmalig |
|
||||
| POST | `/api/v1/invitations/{id}/accept` | – | Token, Anzeigename, Passwort → Konto, Mitgliedschaft mit der Rolle der Einladung, Session. Widerrufene, benutzte oder abgelaufene Einladung: 404 |
|
||||
|
||||
## Datenräume
|
||||
|
||||
| Methode | Pfad | Auth | Zweck |
|
||||
|---|---|---|---|
|
||||
| GET | `/api/v1/rooms` | S+R | wählbare Räume |
|
||||
| GET | `/api/v1/rooms` | S+R | wählbare Räume; `include_archived=true` ergänzt die archivierten Räume der Person |
|
||||
| POST | `/api/v1/rooms` | S+R | gemeinsamen Raum anlegen, Anlegende Person wird Verwalter |
|
||||
| GET | `/api/v1/rooms/{id}/members` | S+R, M | Mitglieder |
|
||||
| POST | `/api/v1/rooms/{id}/members` | S+R, M | bestehendes Konto als `member` oder `manager` aufnehmen |
|
||||
| DELETE | `/api/v1/rooms/{id}/members/{subject_id}` | S+R, M | Mitgliedschaft beenden; letzter Verwalter bleibt. Keine Oberfläche |
|
||||
| PATCH | `/api/v1/rooms/{id}` | S+R, M / E | `name` (Verwalter); `status` und `default_visibility` nur der Eigentümer (E). Archivieren setzt Sitzungen im Raum auf den persönlichen Raum zurück |
|
||||
| GET / PUT | `/api/v1/rooms/{id}/download-policy` | S+R, Mitglied / E | je Rolle (`manager`, `member`, `reader`), ob das Original gespeichert oder geöffnet werden darf; `can_change` nennt, ob die Person ändern darf. Fremde und unbekannte Räume: 404. Audit `room_download_policy_changed` |
|
||||
| GET | `/api/v1/rooms/{id}/members` | S+R, M | Mitglieder mit Rolle und Kontostatus, `is_self` und `my_sources` (eigene Quellenfreigabe an die Person) |
|
||||
| PUT | `/api/v1/rooms/{id}/source-access/{subject_id}` | S+R, Mitglied oder Verwalter | `enabled`: dem Mitglied die verknüpften Originale der eigenen, mit dem Raum geteilten Einträge über die eigenen Zugänge freigeben oder entziehen (protokolliert) |
|
||||
| POST | `/api/v1/rooms/{id}/members` | S+R, M | bestehendes Konto als `member`, `manager` oder `reader` aufnehmen oder dessen Rolle setzen |
|
||||
| PATCH | `/api/v1/rooms/{id}/members/{subject_id}` | S+R, M | Rolle ändern; letzter Verwalter bleibt. Rückstufung auf `reader` entzieht Bearbeiten- und Freigeben-Grants auf Objekte des Raums |
|
||||
| DELETE | `/api/v1/rooms/{id}/members/{subject_id}` | S+R, M | Mitgliedschaft beenden; letzter Verwalter bleibt |
|
||||
| GET | `/api/v1/rooms/{id}/invitations` | S+R, M | offene Einladungen ohne Token |
|
||||
| DELETE | `/api/v1/rooms/{id}/invitations/{invitation_id}` | S+R, M | Einladung widerrufen |
|
||||
| POST | `/api/v1/rooms/{id}/owner` | S+R, E | Raum an ein aktives Mitglied übertragen (Eigentümer); der neue Eigentümer wird Verwalter |
|
||||
| GET | `/api/v1/rooms/{id}/exposure` | S+R, Mitglied | eigene Akten und Vorgänge: mit dem Raum geteilt (`room`) oder dort abgelegt, aber nicht geteilt (`private`) |
|
||||
| POST | `/api/v1/rooms/{id}/my-content/visibility` | S+R, Mitglied | `room`: alle eigenen im Raum abgelegten Akten und Vorgänge mit dem Raum teilen; `private`: alle eigenen Freigaben an diesen Raum beenden |
|
||||
| GET | `/api/v1/cases/{id}/room-share`, `/api/v1/matters/{id}/room-share` | S+R, Owner | Freigaben des Eintrags an Datenräume (mit Mitgliedern, Rolle, Ausnahme) und die Räume, mit denen er noch teilen kann |
|
||||
| PUT / DELETE | `/api/v1/cases/{id}/room-share/rooms/{room_id}` (PUT antwortet zusätzlich mit `effect`), `/api/v1/matters/{id}/room-share/rooms/{room_id}` | S+R, Owner | mit dem Raum teilen (`access`: `edit` = Rechte nach Rolle, `read` = höchstens Lesen) oder die Freigabe beenden; nur in Räumen, in denen der Owner Mitglied oder Verwalter ist |
|
||||
| PUT | `/api/v1/cases/{id}/room-share/people/{subject_id}`, `/api/v1/matters/{id}/room-share/people/{subject_id}` | S+R, Owner | eine Person von der Raumfreigabe ausnehmen (`excluded`) |
|
||||
| POST | `/api/v1/admin/rooms/{id}/owner` | S+R, B | Betreiber setzt einen Eigentümer ein, nur wenn der bisherige nicht mehr handeln kann (Konto deaktiviert oder nicht mehr Mitglied) |
|
||||
| GET | `/api/v1/rooms/overview` | S+R | Räume der Person als Kacheln: Rolle, Eigentümer, Zahl der Mitglieder und der lesbaren Akten und Vorgänge; Mitgliedernamen nur für Verwalter |
|
||||
| GET | `/api/v1/rooms/{id}/contents` | S+R, Mitglied | Akten und Vorgänge, die mit dem Raum geteilt und für die Person lesbar sind, mit Zählern |
|
||||
| POST | `/api/v1/rooms/{id}/shares` | S+R, Mitglied | mehrere eigene Einträge auf einmal mit dem Raum teilen (alle oder keiner); Antwort nennt die Wirkung je Mitglied |
|
||||
| GET | `/api/v1/cases/{id}/outline`, `/api/v1/matters/{id}/outline` | S+R | Struktur für den Navigationsbaum: Kapitel, Unterakten und Vorgänge bzw. Teilvorgänge, nur aus Lesbarem; für Vorgänge optional `context_kind=case&context_id=` |
|
||||
| GET | `/api/v1/team` | S+R, Hauptnutzer | Personen in den eigenen Räumen mit Rolle je Raum; `mine` = selbst eingeladen |
|
||||
| PATCH | `/api/v1/team/{id}` | S+R, Hauptnutzer | `status` eines selbst eingeladenen Mitarbeiters; fremde und unbekannte ID: 403 |
|
||||
| POST | `/api/v1/team/{id}/password-reset` | S+R, Hauptnutzer | Einmal-Passwort für einen selbst eingeladenen Mitarbeiter |
|
||||
| DELETE | `/api/v1/team/{id}/memberships` | S+R, Hauptnutzer | Person aus allen eigenen Räumen entfernen |
|
||||
| GET | `/api/v1/admin/team` | S+R, B | Hauptnutzer mit Mitarbeitern, Räumen und Rollen; `format=csv` für den Export |
|
||||
| GET | `/api/v1/admin/rooms` | S+R, B | alle gemeinsamen Räume mit Zustand, Mitgliederzahl, Verwaltern; keine Inhalte |
|
||||
| POST | `/api/v1/admin/rooms/{id}/managers` | S+R, B | Verwalter einsetzen, nur wenn der Raum keinen aktiven Verwalter hat |
|
||||
| GET | `/api/v1/admin/events` | S+R, B | Verwaltungsprotokoll (`cursor`, `limit`) für Konto, Sitzung, Raum, Mitgliedschaft, Einladung |
|
||||
|
||||
## Akten
|
||||
|
||||
@@ -111,8 +146,9 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
|
||||
| POST | `/api/v1/notes` | Notiz mit Einbindung (`context`, optional `placement`, `chapter_id`, `dates`, `communication_direction`) |
|
||||
| PATCH | `/api/v1/notes/{id}` | gemeinsamen Text ändern; Antwort mit `visible_bindings` und `notice` |
|
||||
| POST | `/api/v1/files` | Datei hochladen (Multipart: `title`, `context_kind`, `context_id`, `upload`, optional Platzierung, Kapitel, Daten, Richtung); PDF, PNG, JPEG, WebP bis 20 MiB |
|
||||
| GET | `/api/v1/files/{id}/content` | Datei als `attachment`, `no-store` |
|
||||
| POST | `/api/v1/external-refs` | externe Referenz (`paperless`, `imap`, `url`) mit `detail` |
|
||||
| GET | `/api/v1/files/{id}/content` | Datei als `attachment` mit Dateiname (UTF-8, `filename*`), `no-store`. Mit `save=true` zusätzlich das Download-Recht, sonst 403 |
|
||||
| POST | `/api/v1/external-refs` | externe Referenz (`paperless`, `imap`, `url`) mit `detail`. `duplicate` (`ask` Standard, `insert`): bei `ask` antwortet ein bereits vorhandenes Dokument mit 409 `already_present`, wenn nur sichere Treffer auf der Prüfstufe des Kontos zählen (Einstellung `duplicate_check`). `bind_element_id` bindet stattdessen das vorhandene Element zusätzlich in den Zielcontainer (eine Referenz, eine weitere Einbindung; Audit `external_ref_bound`). Nur ein sicherer, lesbarer Treffer im Umfeld des Ziels, mit Weitergaberecht (sonst 403 bzw. 404) |
|
||||
| POST | `/api/v1/external-refs/existing` | nur lesend: `context`, optional `placement`, `items` (`source`, `external_id`, `connector_id`) → je Dokument die Treffer (`element_id`, `title`, `where` `here`/`inside`/`around`, `certain`, `chapter`, `container`, `can_bind`) auf der Prüfstufe des Kontos. Nur Lesbares, ein Treffer außerhalb der Rechte gilt als nicht vorhanden |
|
||||
| POST | `/api/v1/sources/link` | wie oben, nur `paperless`/`imap` (doppelter Weg, siehe Connectoren-Befund) |
|
||||
| GET | `/api/v1/elements` | eigene, nicht eingebundene Elemente (max. 100) |
|
||||
| POST | `/api/v1/elements/{id}/delete` | überall löschen; nur Element-Owner |
|
||||
@@ -143,8 +179,8 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
|
||||
| POST | `/api/v1/deadlines` | Frist |
|
||||
| PATCH | `/api/v1/deadlines/{id}` | Titel, Datum |
|
||||
| POST | `/api/v1/deadlines/{id}/fulfill` | als erfüllt kennzeichnen |
|
||||
| GET | `/api/v1/views/open-tasks` | offene sichtbare Aufgaben (siehe Review R-11) |
|
||||
| GET | `/api/v1/views/open-deadlines` | offene sichtbare Fristen (siehe Review R-11) |
|
||||
| GET | `/api/v1/views/open-tasks` | offene sichtbare Aufgaben, höchstens 200. Gelesen wird in Blöcken mit Rechteprüfung je Zeile (R-11 behoben) |
|
||||
| GET | `/api/v1/views/open-deadlines` | offene sichtbare Fristen, wie oben |
|
||||
| GET | `/api/v1/views/recent-matters` | acht zuletzt geänderte sichtbare Vorgänge |
|
||||
| GET | `/api/v1/placement-targets` | bearbeitbare Akten und Vorgänge als Ziele |
|
||||
| GET | `/api/v1/search?q=` | Akten, Vorgänge, Elemente (Titel und Notiztext), max. 50 |
|
||||
@@ -153,20 +189,31 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
|
||||
|
||||
| Methode | Pfad | Zweck |
|
||||
|---|---|---|
|
||||
| GET | `/api/v1/connectors` | eigene Zugänge ohne Secret |
|
||||
| POST | `/api/v1/connectors` | Paperless (überschreibt den vorhandenen) oder IMAP anlegen |
|
||||
| DELETE | `/api/v1/connectors/{id}` | Zugang löschen |
|
||||
| POST | `/api/v1/connectors/{id}/probe` | Zugang prüfen |
|
||||
| GET | `/api/v1/sources/paperless/documents?q=` | Paperless-Suche (letzter eigener Zugang) |
|
||||
| GET | `/api/v1/connectors` | eigene Zugänge ohne Secret, mit Fähigkeiten der registrierten Quelle, `has_secret` und letztem Prüfstand (`probe`) |
|
||||
| GET | `/api/v1/connectors/{id}` | Detail eines eigenen Zugangs: nicht geheime Einstellungen, `has_secret`, Fähigkeiten, Schutzprofil, Prüfstand und Zahl der eigenen Verknüpfungen. Nie das Secret. Fremde Instanz: 404 |
|
||||
| POST | `/api/v1/connectors` | neue Instanz einer registrierten Quelle; Body `{kind, name, config}`. `config` wird gegen das Feldmanifest des Moduls geprüft (`modules[].config_fields` aus `/api/v1/sources/capabilities`); unbekannte Art oder unbekanntes Feld wird abgewiesen; ersetzt keinen vorhandenen Zugang. Die flachen Felder der ersten Lieferung (`base_url`, `token`, `host`, …) gelten nur als Kompatibilität und werden in `config` übersetzt |
|
||||
| PATCH | `/api/v1/connectors/{id}` | Name, Einstellungen und Zugangsdaten derselben Instanz. Ein leeres Geheimnisfeld behält das gespeicherte Geheimnis; der letzte Prüfstand wird zurückgesetzt |
|
||||
| DELETE | `/api/v1/connectors/{id}` | Zugang löschen; bestehende Referenzen bleiben und werden nicht umgehängt |
|
||||
| POST | `/api/v1/connectors/{id}/probe` | gespeicherten Zugang prüfen; Ergebnis (auch ein Fehler) wird als Prüfstand festgehalten. Es gibt keine Prüfung mit ungespeicherten Entwürfen |
|
||||
| GET | `/api/v1/sources/capabilities` | erklärte Such-, Lese- und Editorfähigkeiten; nicht Vorhandenes bleibt falsch |
|
||||
| GET | `/api/v1/sources/{kind}/search` | Suche der registrierten Quelle im erklärten Umfang. Außer `q`, `connector_id`, `mailbox`, `before` und `uidvalidity` ist jeder Abfrageparameter ein Filter, den das Modul in `search_params` deklariert; unbekannte Art, nicht deklarierte oder nicht erklärte Filter und unbekannte Parameter antworten `422` |
|
||||
| GET | `/api/v1/sources/{kind}/navigate?connector_id=` | Fachnavigation, wenn die Quelle sie erklärt |
|
||||
| GET | `/api/v1/sources/{kind}/preview` | Vorschau vor dem Übernehmen, wenn die Quelle sie erklärt |
|
||||
| GET | `/api/v1/sources/paperless/documents?q=&connector_id=` | Paperless-Suche, 20 Treffer je Seite, `cursor` ist die Seitennummer. `mode`: `title_content` (Standard, Titel und Inhalt ohne Index), `title`, `content`, `index` (Volltextindex von Paperless). Filter: `title`, `correspondent`, `document_type`, `storage_path` (jeweils Nummer oder `none` für „ohne“), `tag` (Nummern, durch Komma) mit `tag_mode` `all` (Standard), `any` oder `none`, `document_from`/`document_to` (Dokumentdatum), `added_from`/`added_to` (Hinzugefügt), `asn`, `custom` (JSON-Liste `[{field, op, value}]`, höchstens 5, alle zugleich; `field` ist die Nummer aus `facets.custom_fields`, `op` je Feldtyp `exact`, `icontains`, `istartswith`, `iendswith`, `gt`, `gte`, `lt`, `lte`, `range` oder `exists`; Dokumentverweis-Felder sind nicht filterbar; wird als `custom_field_query` an Paperless gegeben), `sort` (`created`, `added`, `title`, jeweils mit `-`; `-score` nur bei `mode=index` mit Suchtext). Ein ungültiger Wert antwortet `422`. Je Treffer: `title`, `document_on`, `added_on`, `correspondent`, `document_type`, `storage_path`, `tags` (Namen), `pages`, `asn`, `snippet` (Textauszug, reiner Text) und `open_url`; dazu `total`, `next_page`, `previous_page` |
|
||||
| GET | `/api/v1/sources/{kind}/facets?connector_id=` | Auswahllisten der Instanz (Paperless: Korrespondenten, Dokumenttypen, Speicherpfade, Tags, Zusatzfelder mit Typ und Auswahlwerten). Namen und Listen werden je Instanz und Schlüssel eine Minute lang vorgehalten |
|
||||
| GET | `/api/v1/sources/paperless/documents/{id}/preview?connector_id=` | Datei zum Ansehen vor dem Übernehmen |
|
||||
| GET | `/api/v1/sources/{kind}/thumbnail?connector_id=&item=` | Vorschaubild eines Treffers, nur wenn das Modul `search.result_preview` erklärt und ein `thumbnail` bereitstellt, sonst `422`. Läuft über den Server der eigenen Instanz, `private, no-store`, nur Rastergrafiken (PNG, JPEG, WebP, GIF); fremde Instanz `404`, eine Antwort ohne Bild `422` |
|
||||
| GET | `/api/v1/sources/imap/mailboxes?connector_id=` | IMAP-Fächer |
|
||||
| GET | `/api/v1/sources/imap/messages?connector_id=&mailbox=&q=&before=` | Nachrichtenliste, 30 je Seite |
|
||||
| GET | `/api/v1/sources/imap/messages?connector_id=&mailbox=&q=&before=` | Nachrichtenliste, 30 je Seite, Fortsetzung über `before` |
|
||||
| GET | `/api/v1/sources/imap/message?connector_id=&mailbox=&uid=` | Vorschau vor dem Übernehmen |
|
||||
| GET | `/api/v1/external-refs/{id}/content` | Paperless-Datei zum Ansehen (`inline`) |
|
||||
| GET | `/api/v1/external-refs/{id}/mail` | vollständige E-Mail als JSON, Identität per Message-ID geprüft |
|
||||
| GET | `/api/v1/external-refs/{id}/mail/original` | EML |
|
||||
| GET | `/api/v1/external-refs/{id}/mail/attachments/{index}` | Anlage (`inline`, siehe Review R-03) |
|
||||
| GET | `/api/v1/external-refs/{id}/content` | Original der gebundenen Instanz über das registrierte Modul (`inline`, mit Dateiname). Mit `save=true` zusätzlich das Download-Recht |
|
||||
| GET | `/api/v1/external-refs/{id}/mail` | vollständige E-Mail als JSON, Identität per Message-ID geprüft; `html` ist bereinigt, `remote_images` zählt Bilder fremder Server |
|
||||
| GET | `/api/v1/external-refs/{id}/mail/html-with-images` | dieselbe bereinigte Mail, die Bilder fremder Server lädt der Server auf Anforderung und liefert sie eingebettet (`loaded`, `failed`) |
|
||||
| GET | `/api/v1/external-refs/{id}/mail/original` | EML unter dem Betreff als Name; verlangt das Download-Recht (403 sonst) |
|
||||
| GET | `/api/v1/external-refs/{id}/mail/attachments/{index}` | Anlage (`inline`, siehe Review R-03); mit `save=true` das Download-Recht |
|
||||
| POST | `/api/v1/external-refs/{id}/assignment` | Owner ordnet eine mehrdeutige oder ungebundene Referenz bewusst einer eigenen Instanz zu |
|
||||
|
||||
Quelleninhalte werden mit den Zugängen der **anfragenden** Person geladen (Review R-10).
|
||||
Quelleninhalte einer eigenen Referenz laufen über die gebundene Instanz. Eine freigegebene Referenz mit `use_owner_sources` oder mit einer Quellenfreigabe im Raum (`room_source_access`) nutzt den gebundenen Zugang des Owners. Zugangsdaten und die übrigen Treffer dieses Zugangs werden nicht ausgeliefert. Eine Suche ohne `connector_id` wählt bei mehreren eigenen Instanzen nicht den zuletzt angelegten Zugang (Review R-10).
|
||||
|
||||
## Übergabepaket
|
||||
|
||||
@@ -174,7 +221,7 @@ Quelleninhalte werden mit den Zugängen der **anfragenden** Person geladen (Revi
|
||||
|---|---|---|
|
||||
| GET | `/api/v1/matters/{id}/export-tree` | Auswahlbaum mit `exportable` und Grund |
|
||||
| POST | `/api/v1/matters/{id}/export/review` | Prüfung: `ready`, `issues`, `notices`, `entries` mit Paketpfaden |
|
||||
| POST | `/api/v1/matters/{id}/export` | ZIP nur bei `ready`; Audit `export_created`. Knoten `attachment`, `dispatch-item` und `evidence` gehören zur Auswahl |
|
||||
| POST | `/api/v1/matters/{id}/export` | ZIP nur bei `ready` und mit Download-Recht am Vorgang (403 sonst); Audit `export_created`. Knoten `attachment`, `dispatch-item` und `evidence` gehören zur Auswahl |
|
||||
|
||||
## Anlagen und Versand
|
||||
|
||||
|
||||
@@ -0,0 +1,118 @@
|
||||
# Benutzerverwaltung, Rollen und Rechte (Ist, 20.10.2026)
|
||||
|
||||
Erster Schnitt der Administration. Er baut auf den vorhandenen Mechanismen auf (Kontext-Grants, Datenräume, Audit über `domain_events`) und führt kein neues Fachmodell ein. Die Auswertung der Objektrechte bleibt unverändert, siehe [RECHTEMODELL_IST.md](RECHTEMODELL_IST.md).
|
||||
|
||||
## Rollen
|
||||
|
||||
Feste Bündel, kein Rolleneditor (Technische Spezifikation 5.2). Rollen werden bei jeder Anfrage aus der Datenbank gelesen, nicht in der Session gehalten (`backend/app/access/roles.py`).
|
||||
|
||||
| Ebene | Rolle | Darf |
|
||||
|---|---|---|
|
||||
| Plattform | Betreiber (`is_superadmin`, mehrere möglich) | Konten anlegen, deaktivieren und aktivieren, Passwort zurücksetzen, Sitzungen beenden, Betreiberrolle vergeben und entziehen, Räume mit Verwaltern sehen, Verwalter in einen Raum ohne Verwalter einsetzen, Verwaltungsprotokoll lesen. **Kein Leserecht auf Inhalte.** |
|
||||
| Plattform | Nutzer | eigenes Passwort ändern, eigene Sitzungen ansehen und beenden |
|
||||
| Datenraum | Verwalter (`manager`) | Mitglieder und Rollen verwalten, Einladungen, Raum umbenennen, archivieren und wieder aktivieren |
|
||||
| Datenraum | Mitglied (`member`) | Inhalte im Raum anlegen. Objektrechte weiter nur per Grant |
|
||||
| Datenraum | Leser (`reader`) | Raum wählen und freigegebene Inhalte lesen. Legt im Raum nichts an. Erhält für Objekte dieses Raums keine Bearbeiten- oder Freigeben-Grants |
|
||||
|
||||
### Schutzregeln
|
||||
|
||||
- Der letzte aktive Betreiber lässt sich weder deaktivieren noch zurückstufen. Niemand deaktiviert das eigene Konto.
|
||||
- Der letzte aktive Verwalter eines Raums bleibt Verwalter. Er kann weder zurückgestuft noch entfernt werden.
|
||||
- Wer zum Betreiber befördert wird, verliert alle Sitzungen und meldet sich neu an.
|
||||
- Konten werden **deaktiviert, nicht gelöscht**. Inhalte, Owner-Bezüge und Protokoll bleiben. Löschen oder Anonymisieren ist ein eigener späterer Schnitt.
|
||||
|
||||
### Wirkung der Leser-Rolle
|
||||
|
||||
Einzelfreigaben (Grants) hängen am Objekt, nicht am Raum. Der Leser begrenzt daher zusätzlich zur Raumfreigabe (siehe unten, dort liest er nur) drei Stellen:
|
||||
|
||||
1. Anlegen von Akte, Vorgang, Notiz, Datei, Referenz, Aufgabe und Frist mit diesem Heimatraum (`ensure_can_create` in `ops.py`).
|
||||
2. Vergabe neuer Bearbeiten- oder Freigeben-Grants an einen Leser für Objekte dieses Raums (`grant_access`).
|
||||
3. Beim Zurückstufen auf Leser werden dessen vorhandene Bearbeiten- und Freigeben-Grants auf Objekte dieses Raums in derselben Transaktion entzogen. Lese-Grants bleiben.
|
||||
|
||||
Grants auf Objekte anderer Räume bleiben unberührt.
|
||||
|
||||
## Datenräume, Eigentümer und Raumfreigabe (seit 21.10.2026)
|
||||
|
||||
- **Mehrere Räume:** Jede Person kann beliebig viele gemeinsame Datenräume anlegen. Ein Raum mit nur dem Eigentümer als Mitglied ist **privat**, mit weiteren Mitgliedern **Mehrbenutzer**. Der persönliche Raum bleibt unverändert.
|
||||
- **Eigentümer** (`data_rooms.owner_id`): der Ersteller. Er ist stets Verwalter, lässt sich nicht entfernen oder zurückstufen und überträgt den Raum an ein aktives Mitglied. Nur er archiviert und stellt wieder her und ändert die Voreinstellung für neue Einträge. Ein Konto, das einen Raum mit weiteren Mitgliedern besitzt, lässt sich erst nach Übertragung deaktivieren. Ist der Eigentümer nicht mehr handlungsfähig, setzt der Betreiber einen neuen ein (protokolliert). Die Eigentümerrolle verleiht kein Leserecht.
|
||||
- **Raumfreigabe:** Ein Raum ist ein Team. Der Owner teilt eine Akte, Unterakte oder einen Vorgang mit einem oder mehreren seiner Räume, unabhängig davon, wo der Eintrag abgelegt ist. Mitglieder erhalten Rechte nach Rolle (Leser lesen; Mitglied und Verwalter bearbeiten; Weitergeben und Löschen nie), die Freigabe kann auf „nur lesen“ begrenzt werden, einzelne Personen lassen sich ausnehmen. Ein einzelner Vorgang lässt sich teilen, ohne die Akte offenzulegen (Beispiel: nur die Vorgänge, die der Anwalt sehen soll). Die Voreinstellung eines Raums teilt neu angelegte Einträge, die in diesem Raum entstehen, automatisch mit ihm. Der Owner sieht seine Einträge unabhängig von Raum und Mitgliedschaft. Wer ein Team verlässt oder Leser wird, nimmt seine Freigaben an dieses Team mit; wer aus einem Raum entfernt wird, arbeitet danach im persönlichen Raum. Beim ersten weiteren Mitglied zeigt die Oberfläche, was bereits mit dem Raum geteilt ist. Bestehende Freigaben wurden übernommen, nicht geteilte Einträge blieben privat.
|
||||
- **Quellzugänge (seit 04.11.2026):** Die Raumfreigabe allein gibt keine Paperless- oder Mail-Zugänge des Owners frei. Wer in einem Raum teilen darf (Mitglied oder Verwalter), kann einem einzelnen Mitglied dort „Originale über meine Zugänge“ freigeben (Tabelle `room_source_access`). Die Person liest dann verknüpfte Originale aller Akten und Vorgänge dieses Owners, die mit dem Raum geteilt sind, über dessen Zugänge; sie erhält keine Zugangsdaten und kann nicht im Archiv oder Postfach suchen. Entscheiden kann nur die Person, deren Zugänge benutzt werden. Personenausnahmen, das Ende der Raumfreigabe und das Verlassen des Raums schließen den Abruf; wer aus dem Raum entfernt wird, verliert die Freigabe auch nach einer Rückkehr. Wird der Owner Leser oder verlässt er den Raum, enden seine Quellenfreigaben dort. Daneben bleibt die Einzelfreigabe mit der Option.
|
||||
- **Löschen:** Akte und Vorgang löscht nur der Owner (oder wer ein Löschrecht hat), nicht jeder Bearbeiter.
|
||||
|
||||
## Zugang
|
||||
|
||||
- **Einmal-Passwort:** Der Betreiber legt ein Konto an oder setzt das Passwort zurück. Tsumugu erzeugt ein Passwort und zeigt es einmal an. Das Konto steht auf `must_change_password`, bis die Person ein eigenes festgelegt hat. Bis dahin antworten nur `auth/session`, `auth/password` und `auth/logout`, alles andere mit 403 `password_change_required`.
|
||||
- **Einladungslink:** Ein Verwalter erstellt eine Einladung mit Rolle. Der Link enthält das Token im URL-Fragment (`/invite/{id}#{token}`), es erreicht also keinen Server-Log. Der Link gilt 7 Tage und einmal und lässt sich widerrufen. Es gibt keinen E-Mail-Versand.
|
||||
- **Passwortregel:** mindestens 10 Zeichen, höchstens 72 UTF-8-Byte (bcrypt). Beim Ändern des eigenen Passworts enden alle anderen Sitzungen.
|
||||
|
||||
## Anmeldung
|
||||
|
||||
- Die Versuchsbegrenzung steht in der Tabelle `auth_login_attempts` (8 Fehlversuche in 10 Minuten je Bucket). Der Bucket ist ein SHA-256 aus Adresse und E-Mail, die Roh-E-Mail wird nicht gespeichert. Ein erfolgreicher Login löscht den Bucket.
|
||||
- Unbekannte und deaktivierte Konten laufen durch einen bcrypt-Vergleich und erhalten dieselbe Antwort wie ein falsches Passwort.
|
||||
- Der CSRF-Vergleich ist konstantzeitlich. `last_seen_at` wird höchstens alle 5 Minuten geschrieben.
|
||||
|
||||
## Audit
|
||||
|
||||
Alle schreibenden Aktionen schreiben in `domain_events`, ohne E-Mail, Passwort und Token. Ressourcenarten: `account`, `session`, `room`, `membership`, `invitation`. Der Betreiber liest sie unter `GET /api/v1/admin/events`. Nicht protokolliert werden fehlgeschlagene Anmeldungen (die Begrenzung zählt sie in `auth_login_attempts`).
|
||||
|
||||
## Bewusst nicht enthalten (Sicherheitskonzept)
|
||||
|
||||
MFA (später optional für alle Konten), Leerlaufablauf und Rotation der Sitzung, Änderung der Sitzungsdauer von 14 Tagen, Härtung des Web-Bootstraps für das erste Betreiberkonto (R-04), Mindestlänge 15, Einschränkung von `GET /api/v1/principals`, E-Mail-Versand, Löschen und Anonymisieren von Konten, Übertragung von Ownership.
|
||||
|
||||
## Bedienung (21.10.2026)
|
||||
|
||||
- **Eine Stelle für Datenräume:** Verwaltung → Datenräume listet alle eigenen Räume mit Zustand, Rolle und Eigentümer. Ein Klick öffnet die Verwaltung des Raums (`/rooms/{id}`): Mitglieder, Rollen, Einladungen, Umbenennen, Voreinstellung, Übertragung, Archivieren. Dafür ist kein Wechsel in den Raum nötig. Der Betreiber sieht darunter zusätzlich alle Räume mit Eigentümer und Verwalter.
|
||||
- **Nutzer ist etwas anderes:** Verwaltung → Nutzer (nur Betreiber) verwaltet Konten, Verwaltungsprotokoll das Audit. Mein Konto betrifft das eigene Passwort und die Geräte.
|
||||
- **Ablage mit Ordnerbaum und Kacheln** (Akten, Vorgänge, Räume): Links ein Ordnerbaum („Meine Ablage“ mit Akten und Vorgängen, darunter „Räume“), rechts Kacheln: Ordnersymbol für Akte und Unterakte, Dokumentstapel für Vorgang, Teamordner für Räume. Umschaltbar auf eine kompakte Liste. Ein Klick öffnet den Eintrag, „Inhalt ›“ wechselt in den Ordner (Unterakten und Vorgänge der Akte). Am Handy liegt der Baum hinter „Ordner anzeigen“.
|
||||
- **Räume sind virtuelle Ordner:** Ein Eintrag kann in mehreren Räumen liegen, ohne verschoben zu werden. „In Raum legen“ und „Aus Raum nehmen“ ändern nur die Zuordnung. Auf jeder Kachel zeigen Marken, in welchen Räumen der Eintrag liegt (nur dem Owner).
|
||||
- **Vier Wege zum Zuordnen:** (1) im Raum „Hinzufügen“ mit Auswahl eigener Akten und Vorgänge, (2) eine Kachel auf einen Raum im Baum oder auf eine Raumkachel ziehen, (3) Knopf „In Raum legen“ auf der Kachel (auch am Handy), (4) die Marke auf der Kachel öffnen und „Aus Raum nehmen“. Jede Aktion nennt danach, wer Zugriff hat (zum Beispiel „Ben bearbeitet, Cem liest“).
|
||||
- **Neu anlegen** fragt nicht mehr nach dem Heimatraum. In der Raumansicht entsteht ein Eintrag gleich mit diesem Raum geteilt.
|
||||
|
||||
## Betreiber, Hauptnutzer und Mitarbeiter (seit 22.10.2026)
|
||||
|
||||
| Ebene | Kontoart | Aufgabe |
|
||||
|---|---|---|
|
||||
| Betreiber | Hauptnutzer mit `is_superadmin` | SaaS-Betreiber: verwaltet Hauptnutzer, sieht Räume und Team-Übersicht (Metadaten), keine Inhalte |
|
||||
| Hauptnutzer | `account_kind = main` | privater Raum und eigene Team-Räume; Eigentümer; lädt Mitarbeiter ein und verwaltet sie |
|
||||
| Mitarbeiter | `account_kind = employee` | arbeitet nur in eingeladenen Räumen nach Raumrolle; legt keine Räume an; kein privater Arbeitsbereich |
|
||||
|
||||
- **Einladung:** nur der Eigentümer des Raums (als Hauptnutzer). Das neue Konto ist ein Mitarbeiter; `sponsor_id` ist der Eigentümer. Ein Verwalter ohne Eigentum nimmt nur bestehende Konten auf.
|
||||
- **Mitarbeiter-Sitzung:** beginnt im ersten Team-Raum, in dem die Person Mitglied ist. Im persönlichen Raum legt ein Mitarbeiter nichts an. Ohne Raum kann er sich anmelden, aber nichts tun.
|
||||
- **Eigentümer:** nur ein Hauptnutzer kann Raum-Eigentümer sein, auch bei Übertragung und beim Einsetzen durch den Betreiber.
|
||||
- **Mein Team** (`/team`): zeigt die Personen in den eigenen Räumen mit Rolle je Raum. Für selbst eingeladene Mitarbeiter: deaktivieren/aktivieren, Einmal-Passwort, Entfernen aus allen eigenen Räumen. Fremde und unbekannte Konten antworten gleich mit 403.
|
||||
- **Betreiber:** `/admin/team` zeigt Hauptnutzer mit ihren Mitarbeitern, Räumen und Rollen (auch als CSV, mit Schutz vor Formeleingabe). Nur der Betreiber macht einen Mitarbeiter zum Hauptnutzer; die Person meldet sich dann neu an.
|
||||
|
||||
### Vorbereitung Subscription
|
||||
|
||||
`backend/app/access/limits.py` ist die einzige Stelle für Grenzen. `ensure_can_create_room(conn, owner_id)` läuft beim Anlegen eines Raums, `ensure_can_add_member(conn, owner_id, room_id)` beim Aufnehmen, Einladen und Annehmen einer Einladung. Heute lassen beide alles zu. Das Kontingentsubjekt ist der Eigentümer des Raums, ein Hauptnutzer, wie der Verein bei Shinkan (Entitlements-Blueprint). Vorgesehene Messgrößen: aktive Mitarbeiter je Hauptnutzer und je Raum, aus der Datenbank gezählt. Der Betreiber setzt den Plan. Zahlungsdienst und Tarife gehören nicht in diese Stufe. Offene Entscheidung: Ein Mitarbeiter, den ein zweiter Hauptnutzer als bestehendes Konto aufnimmt, zählt beim Raum-Eigentümer; die Zuständigkeit bei Grenzen klärt das Tarifkonzept.
|
||||
|
||||
### Ein Navigationsbaum für Ablage, Akten und Vorgänge (seit 23.10.2026)
|
||||
|
||||
Der Baum „Meine Ablage“ steht links auf den Listenseiten und auf den Seiten von Akte und Vorgang. Die frühere Spalte „Struktur“ ist darin aufgegangen.
|
||||
|
||||
- **Aufklappen mit Fokus:** Ein Klick auf eine Akte oder einen Vorgang öffnet ihn und klappt seine Struktur auf. Der Pfad dorthin bleibt offen, die aktuelle Zeile (auch ein Kapitel) ist hervorgehoben. Nach dem Neuladen der Seite stimmt der Fokus wieder.
|
||||
- **Unter einer Akte:** Überblick, „Direkt in dieser Akte“, Kapitel mit Unterkapiteln, Unterakten und die Vorgänge der Akte. **Unter einem Vorgang:** „Alle Inhalte“, Kapitel, Teilvorgänge. „Neues Kapitel“ und die Pfeile zum Verschieben stehen im Baum, solange der Eintrag offen ist.
|
||||
- **Direkt von Vorgang zu Vorgang:** Ein Vorgang erscheint unter jeder Akte, in der er liegt, und unter „Vorgänge“. Ein Klick unter einer Akte öffnet ihn in diesem Aktenkontext, unter „Vorgänge“ ohne Akte. Die frühere Auswahl des Handlungskontexts entfällt. Querverweise und weitere Akten stehen unter dem Titel des Vorgangs.
|
||||
- **Nachladen:** Die Wurzeln kommen aus `/cases` und `/matters`, die Struktur eines Knotens aus `GET /cases/{id}/outline` und `GET /matters/{id}/outline`, einmal beim Aufklappen. Die Antworten enthalten nur Lesbares (keine Inhalte). Ändert sich der offene Eintrag (Kapitel, Unterakte, Vorgang), lädt der Baum seine Struktur neu.
|
||||
- **Breite und Dichte:** Der Baum lässt sich an seiner rechten Kante mit der Maus ziehen (200 bis 560 Pixel, Pfeiltasten auf dem Griff, Doppelklick setzt zurück). Die Breite wird im Browser gemerkt (`localStorage`, Schlüssel `tsumugu-tree-width`); ohne Speicher gilt die Standardbreite. Zeilen und Einrückung sind kompakt, damit tiefe Strukturen hineinpassen.
|
||||
- **Vorgang aus einer Akte lösen:** Im Menü des Vorgangs steht „Aus Akte lösen“, wenn er in Akten liegt. Gelöst wird nur die Zuordnung zur gewählten Akte (`DELETE /matter-case-links/{id}`); der Vorgang, seine Inhalte und seine anderen Akten bleiben. Erlaubt ist es mit Bearbeitungsrecht in der Akte oder mit Teilen-Recht am Vorgang.
|
||||
|
||||
### Herunterladen von Originalen (seit 23.10.2026)
|
||||
|
||||
- **Regel je Rolle:** Das Recht „Herunterladen“ ist neben Lesen, Bearbeiten, Teilen und Löschen ein eigenes Recht. Der Eigentümer hat es immer. Über einen Raum folgt es der Rolle (Verwalter, Mitglied, Leser) laut Regel des Raums; direkt freigegebene Personen folgen dem Wert „direkt“ des Eigentümers. Ohne Leserecht gibt es kein Herunterladen.
|
||||
- **Wo einstellen:** Voreinstellung am Konto des Hauptnutzers („Mein Konto“, wird beim Anlegen eines Raums übernommen), danach je Raum in der Raumverwaltung (nur Eigentümer). Bestehende Daten bleiben erlaubt (Migration `20261023T090000Z_download_policy.sql`).
|
||||
- **Was geprüft wird (serverseitig):** Speichern oder Öffnen des Originals (`?save=true` bei Dateien, Paperless-Dokumenten und Mail-Anlagen), die vollständige E-Mail (`.eml`) und das Übergabepaket. Lesen in Tsumugu bleibt möglich; die Regel ist ein Nutzungsrecht, kein Kopierschutz (Abfotografieren oder Entwicklerwerkzeuge verhindert sie nicht).
|
||||
- **Dateiname:** Gespeichert wird unter dem echten Namen (UTF-8, `filename*`), die E-Mail unter ihrem Betreff.
|
||||
- **Endpunkte:** `GET/PUT /rooms/{id}/download-policy`, `GET/PUT /auth/download-defaults`.
|
||||
|
||||
### E-Mails als HTML
|
||||
|
||||
Die Mail wird formatiert (Standard) oder als Text gezeigt. Der Server bereinigt das HTML mit einer Positivliste (keine Skripte, Formulare, Rahmen, `<style>`-Blöcke; Formatierung nur aus erlaubten Eigenschaften, ohne `url()`, Position oder Ausdrücke; Bilder nur eingebettet als PNG/JPEG/GIF/WebP; Links nur `http(s)` und `mailto`, mit `noopener`). Im Browser läuft die Ansicht in einem Rahmen mit leerem `sandbox` (eigene Herkunft, keine Skripte), Content-Security-Policy `default-src 'none'; img-src data:` und ohne Referrer. Fremde Bilder werden nicht geladen.
|
||||
|
||||
### Bilder in E-Mails nachladen
|
||||
|
||||
Bilder von fremden Servern bleiben standardmäßig draußen. „Bilder nachladen“ (oder die Einstellung „Automatisch nachladen“ unter „Mein Konto“, getrennt für Computer und Touch-Geräte, gespeichert im Browser; die Gerätegruppe folgt `pointer: coarse`) ruft `GET /external-refs/{id}/mail/html-with-images` auf. Der Server lädt die Bilder selbst und liefert sie eingebettet zurück, das Gerät kontaktiert den Absender nicht. Schutz (`app/remoteimages.py`): nur `https` auf Port 443, keine Zugangsdaten in der Adresse, Auflösung der Adresse einmal und Verbindung genau dorthin (kein DNS-Rebinding), alle Ergebnisse müssen öffentliche Adressen sein (kein Loopback, privat, Link-Local, Metadaten), höchstens drei Weiterleitungen mit gleicher Prüfung, 5 Sekunden, 1,5 MB je Bild, 12 Bilder und 6 MB je Nachricht, Prüfung des Inhalts an der Dateikennung (PNG, JPEG, GIF, WebP; kein SVG). Restrisiko: Der Absender sieht den Abruf und weiß damit, dass die Nachricht geöffnet wurde.
|
||||
|
||||
### Handy
|
||||
|
||||
PDFs werden auf iPhone und iPad seitenweise mit pdf.js (Legacy-Build) gezeichnet, weil Safari PDFs in einem Rahmen nicht zuverlässig anzeigt (`pages/DocumentView.jsx`); die PDF-Vorschau in der Liste ist dort weiterhin eingeschränkt, die Leseansicht funktioniert. Der Rahmen der Ablage begrenzt die Höhe, damit die Liste in Akte und Vorgang scrollt, und der Kopf der Leseansicht ist am Handy kompakt.
|
||||
@@ -1,6 +1,6 @@
|
||||
# Tsumugu – Datenmodell (Ist-Stand)
|
||||
|
||||
**Stand:** 18.10.2026, nach den Migrationen in `backend/migrations/` (letzte: `20261018T090000Z_correspondence.sql`). Erstellt im Code-Review.
|
||||
**Stand:** 19.10.2026, nach den Migrationen in `backend/migrations/` (letzte: `20261025T090000Z_account_preferences.sql`). Entstanden im Code-Review vom 18.10.2026 und für die Connector-Grundlage nachgezogen. Die Arten `connectors.kind` und `external_references.source` prüft die Registrierung. Die früheren Prüflisten in der Datenbank sind entfernt. `url` bleibt eine Referenz ohne Connector.
|
||||
|
||||
Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TECHNICAL_SPEC.md). Diese Datei beschreibt, was tatsächlich angelegt ist. Bei jeder neuen Migration nachziehen.
|
||||
|
||||
@@ -16,11 +16,18 @@ Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TE
|
||||
|
||||
| Tabelle | Wesentliche Spalten | Regeln |
|
||||
|---|---|---|
|
||||
| `auth_accounts` | `id`, `email` (unique), `display_name`, `password_hash` (bcrypt), `status` (`active`/`disabled`), `is_superadmin`, `origin` (`operator`/`fixture`) | Konten mit `origin='fixture'` entfernt der Start in jeder Umgebung |
|
||||
| `auth_sessions` | `id`, `account_id`, `secret_hash` (SHA-256, unique), `csrf_token`, `scope_kind`, `scope_id`, `epoch`, `expires_at`, `revoked_at` | der bestätigte Datenraum steht in der Session |
|
||||
| `auth_invitations` | `email`, `room_id`, `token_hash`, `invited_by`, `expires_at`, `accepted_at` | 7 Tage gültig |
|
||||
| `auth_accounts` | `id`, `email` (unique), `display_name`, `password_hash` (bcrypt), `status` (`active`/`disabled`), `is_superadmin`, `origin` (`operator`/`fixture`), `must_change_password`, `password_changed_at`, `last_login_at`, `disabled_at`, `disabled_by`, `account_kind` (`main`/`employee`), `sponsor_id` (Förderer eines Mitarbeiters; nur bei `employee`) | Konten mit `origin='fixture'` entfernt der Start in jeder Umgebung |
|
||||
| `auth_sessions` | `id`, `account_id`, `secret_hash` (SHA-256, unique), `csrf_token`, `scope_kind`, `scope_id`, `epoch`, `expires_at`, `revoked_at`, `last_seen_at`, `label` (kurzer Gerätehinweis) | der bestätigte Datenraum steht in der Session |
|
||||
| `auth_invitations` | `email`, `room_id`, `token_hash`, `invited_by`, `expires_at`, `accepted_at`, `role`, `revoked_at` | 7 Tage gültig |
|
||||
| `data_rooms` | `id`, `kind` (`personal`/`organization`), `name`, `status` (`active`/`archived`), `created_by` | persönlicher Raum: `id = account_id` |
|
||||
| `room_memberships` | PK (`room_id`, `subject_id`), `role` (`member`/`manager`), `status` (`active`/`removed`) | – |
|
||||
| `room_memberships` | PK (`room_id`, `subject_id`), `role` (`member`/`manager`/`reader`), `status` (`active`/`removed`) | – |
|
||||
| `auth_accounts` (Spalte seit 23.10.2026) | `download_defaults` (jsonb: `manager`, `member`, `reader`, `direct`; Voreinstellung für das Herunterladen von Originalen, Standard überall erlaubt) | Neue Räume übernehmen die drei Rollenwerte |
|
||||
| `account_preferences` (seit 25.10.2026) | PK (`account_id`, `key`), `value` (jsonb, `NULL` = erben), `team_mode` (`free`/`locked`, nur beim Hauptnutzer ausgewertet), `updated_at` | Ein Mitarbeiter erbt den Wert seines Hauptnutzers (`sponsor_id`) und kann ihn ändern. Ist die Einstellung für das Team verbindlich, gilt der Wert des Hauptnutzers; ein eigener Wert bleibt gespeichert und gilt wieder, sobald die Bindung endet. Erlaubte Werte und Standard je Schlüssel stehen in `app/preferences.py` |
|
||||
| `data_rooms` (Spalte seit 23.10.2026) | `download_roles` (jsonb: `manager`, `member`, `reader`) | Regel je Raum, nur der Eigentümer ändert sie |
|
||||
| `data_rooms` (Spalten seit 21.10.2026) | `owner_id` (Eigentümer; für persönliche Räume das Konto), `default_visibility` (`private`/`room`, Voreinstellung für neue Akten und Vorgänge) | Bestehende Räume `private`, Eigentümer aus `created_by` |
|
||||
| `room_shares` | `resource_kind` (`case`/`matter`), `resource_id`, `room_id`, `access` (`read`/`edit`), `created_by` | Freigabe einer Akte oder eines Vorgangs an einen Datenraum (Team); eindeutig je Eintrag und Raum. Endet, wenn der Freigebende den Raum verlässt oder Leser wird |
|
||||
| `room_source_access` | PK (`room_id`, `owner_id`, `subject_id`), `created_at` | Quellenfreigabe im Raum: `owner_id` lässt `subject_id` die verknüpften Originale seiner mit dem Raum geteilten Einträge über seine Zugänge lesen. Entfällt, wenn die Person den Raum verlässt oder der Owner dort Leser wird oder ihn verlässt |
|
||||
| `auth_login_attempts` | `bucket` (SHA-256 aus Adresse und E-Mail), `attempted_at` | zählt Fehlversuche; erfolgreicher Login löscht den Bucket |
|
||||
|
||||
## Struktur
|
||||
|
||||
@@ -42,17 +49,17 @@ Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TE
|
||||
| `elements` | Anker¹, `title`, `kind` (`note`/`file`/`external_ref`), `summary` (≤ 400) | gemeinsamer Inhaltsträger |
|
||||
| `note_bodies` | `element_id`, `document_json`, `version` | ein Text je Notiz; Format `{version: 1, blocks: [...]}` mit Absatz- oder einem Markdown-Block |
|
||||
| `correspondence_dates` | `element_id`, `document_on`, `sent_on`, `received_on` | getrennte Datumssachen; Erfassung = `elements.created_at` |
|
||||
| `external_references` | `element_id`, `source` (`paperless`/`url`/`imap`), `external_id`, `detail` (JSON) | IMAP: Message-ID als `external_id`, `connector_id`, `mailbox`, `uid` im JSON; kein Eindeutigkeitsindex |
|
||||
| `external_references` | `element_id`, `source` (`paperless`/`url`/`imap`), `external_id`, `detail` (JSON), `connector_id`, `resolution` (`bound`/`ambiguous`/`unresolved`/`none`) | IMAP: Message-ID als `external_id`, `mailbox` und `uid` im JSON. `connector_id` ist keine Fremdschlüsselbeziehung: ein gelöschter Zugang lässt die Referenz stehen und hängt sie nicht um. Mehrdeutiger Bestand bleibt `ambiguous`, bis der Owner zuordnet |
|
||||
| `bindings` | `element_id`, `context_kind` (`case`/`matter`), `context_id`, `chapter_id`, `position`, `communication_direction` (`in`/`out`/`local`/NULL), `direction_explicit`, `list_fold` (`attachment`/`evidence`/NULL) | unique (`element_id`, `context_kind`, `context_id`); kein FK auf den Kontext (polymorph). `list_fold` gilt nur für dieses Vorkommen |
|
||||
| `attachment_uses` | Behälter, `host_element_id`, `attachment_element_id`, `position`, optionales `label` | flache Zuordnung je Hauptschriftstück und Behälter; keine Dateikopie; kein Selbstbezug |
|
||||
| `dispatches` | Behälter, `host_element_id`, `channel`, `sent_on`, `counterpart`, `completeness`, `provenance`, `version` | mehrere Versände je Schreiben; `sent_on` leer bleibt undatiert |
|
||||
| `dispatch_items` | Rolle `host`/`attachment`, Titel, Dokumentdatum, `source_state` `snapshot`/`gap`, Hash, optionales Notiz-JSON | Manifest der übermittelten Fassung; Lücke ersetzt nicht die Arbeitsdatei |
|
||||
| `dispatch_snapshots` | Bytes, Hash, Dateiname | Datei unter `MEDIA_ROOT/dispatch/<id>`; fällt in den Löschpfad des Elements |
|
||||
| `dispatch_snapshots` | Bytes, Hash, Dateiname, Speicherinstanz, Generation, Objektkennung, Inhaltsrevision, Schutzprofil | Datei unter der gebundenen Wurzel als `dispatch/<id>`; fällt in den Löschpfad des Elements. Ein späterer Wurzelwechsel liest die alte Generation weiter am gebundenen Ort |
|
||||
| `dispatch_evidence` | `element_id`, Rolle `email`/`submission`/`delivery`/`other`, Identitätsprüfung, `comparisons` | manuelle Zuordnung; Einlieferung ist keine Zustellung |
|
||||
| `dispatch_corrections` | Zeitpunkt, Zusammenfassung | Berichtigung ohne stilles Umschreiben der Bytes |
|
||||
| `context_annotations` | `binding_id`, `body` (≤ 4 000), `author_subject_id` | Kaskade mit der Einbindung |
|
||||
| `element_references` | PK (`element_id`, `refers_to_element_id`) | kein Selbstbezug; Zyklusprüfung in der Anwendung; FK-Kaskade greift nur bei physischem Löschen, Elemente werden aber nur markiert (Review R-13) |
|
||||
| `media_assets` | `id`, `element_id` (unique), Owner, Heimatraum, `original_filename`, `content_type`, `byte_size`, `sha256`, `revision`, `status` (`active`/`purging`/`purged`) | Bytes unter `MEDIA_ROOT/<asset_id>` |
|
||||
| `media_assets` | `id`, `element_id` (unique), Owner, Heimatraum, `original_filename`, `content_type`, `byte_size`, `sha256`, `revision`, `status` (`active`/`purging`/`purged`), Speicherinstanz, Generation, `object_key`, `content_revision`, `protection_profile`, `key_responsibility` | Bytes über den lokalen Storage-Port. Bestandsgeneration `legacy-local-1`, Schlüsselzuständigkeit `none`, Profil `legacy-plaintext`. Der Bytehash bleibt intern |
|
||||
| `media_operations` | `element_id`, `asset_id`, `phase`, `status` | derzeit reines Protokoll |
|
||||
|
||||
## Rechte
|
||||
@@ -75,7 +82,8 @@ Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TE
|
||||
|
||||
| Tabelle | Wesentliche Spalten | Regeln |
|
||||
|---|---|---|
|
||||
| `connectors` | `owner_id`, `kind` (`paperless`/`imap`), `name`, `settings` (JSON), `secret` (Klartext, Review R-05) | Paperless höchstens einmal je Konto (in der Anwendung) |
|
||||
| `connectors` | `owner_id`, `kind` (`paperless`/`imap`), `name`, `settings` (JSON), `secret` (Klartext, Review R-05), `last_probe_at`/`last_probe_ok`/`last_probe_detail` (nur Anzeige des letzten Prüfstands) | Mehrere Instanzen je Art sind möglich. Ein POST legt eine neue Instanz an. Ein PATCH ändert Zugangsdaten derselben Id. Das Secret bleibt im Adapter und ist keine SaaS-Schlüsselhaltung |
|
||||
| `storage_instances` | `kind` (`local`), `generation` (eindeutig), `root_path` | Die Bestandsgeneration `legacy-local-1` wird einmal an die Wurzel gebunden. Ein späterer Wurzelwechsel erzeugt eine neue Generation und hängt alte Referenzen nicht um |
|
||||
| `domain_events` | `actor_subject_id`, `scope_id`, `action`, `resource_kind`, `resource_id`, `context_kind/id`, `occurred_on`, `occurred_at`, `result` | append-only; Grundlage von Chronologie und fachlichem Verlauf |
|
||||
|
||||
## Nicht angelegt (bewusst)
|
||||
|
||||
@@ -0,0 +1,103 @@
|
||||
# Tsumugu – Rechteauswertung (Ist-Stand)
|
||||
|
||||
**Stand:** 18.10.2026, Commit `f21c64a`, ergänzt am 19.10.2026 um die Quellenauflösung. Erstellt im Code-Review aus `backend/app/access/policy.py`, `api/deps.py` und `ops.py`.
|
||||
|
||||
Fachlich gelten die bestätigten Entscheidungen der [Produktspezifikation](../product/TSUMUGU_PRODUCT_SPEC.md) (F-01a–f, S-01b–d) und die vorläufigen [MVP-Annahmen](../MVP_ANNAHMEN.md). Den Sollentwurf beschreibt die [technische Spezifikation, Abschnitt 4.5 und 5](TSUMUGU_TECHNICAL_SPEC.md). Diese Datei beschreibt, wie der Code entscheidet.
|
||||
|
||||
## 1. Vor jeder Fachroute
|
||||
|
||||
1. **Session** (`deps._session_row`): Cookie-Hash muss zu einer nicht widerrufenen, nicht abgelaufenen Session eines aktiven Kontos gehören, sonst 401. Bei unsicheren Methoden muss `X-CSRF-Token` gleich dem Session-Token sein, sonst 403.
|
||||
2. **Origin** (Middleware in `main.py`): unsichere Methoden unter `/api/` nur mit `Origin` aus `ALLOWED_ORIGINS`.
|
||||
3. **Datenraum** (`deps.get_principal`): `X-Scope-Kind` und `X-Scope-Id` müssen vorhanden sein und dem in der Session bestätigten Raum entsprechen. Persönlicher Raum nur der eigene, gemeinsamer Raum nur bei aktiver Mitgliedschaft. Sonst 403.
|
||||
|
||||
Der Datenraum bestimmt, **wo neue Objekte entstehen**. Er ist nicht der Rechtepfad. Objekte anderer Räume bleiben über Grants und Einbindungen erreichbar.
|
||||
|
||||
## 2. Rechte und Antwortcodes
|
||||
|
||||
Ein Ergebnis `Rights(read, edit, share, delete, download)` entsteht je Objekt und Handlungskontext. `download` (Original speichern oder öffnen, Übergabepaket) hat der Owner immer; über einen Raum folgt es `data_rooms.download_roles` der Rolle, bei direkten Grants dem Wert `direct` im Konto des Owners. Es setzt Leserecht voraus, und eine Ausnahme, die das Lesen entzieht, entzieht auch das Herunterladen. Verweigert wird mit 403 und einem erklärenden Text; Lesen in der App bleibt möglich. `_require` übersetzt:
|
||||
|
||||
- `read` fehlt → **404** (das Objekt existiert für diese Person nicht)
|
||||
- `read` vorhanden, verlangte Fähigkeit fehlt → **403**
|
||||
|
||||
Ausnahmen (`access_grants.is_exception`) **entfernen** Fähigkeiten im genannten Kontext. Sie gelten für alle Personen (`grantee_subject_id IS NULL`), auch für den Owner. Nur der Owner des Objekts setzt sie (`PUT /exceptions`).
|
||||
|
||||
## 3. Auswertung je Objektart
|
||||
|
||||
### Akte (`case_rights`)
|
||||
|
||||
| Fall | Basis |
|
||||
|---|---|
|
||||
| Unterakte mit `inherit_parent` | Rechte der Elternakte |
|
||||
| Owner | alle Rechte |
|
||||
| sonst | direkter Grant `resource_kind='case'` |
|
||||
|
||||
Danach Abzug von Akten-Ausnahmen ohne Kontext (im Code vorgesehen, über die API nicht setzbar).
|
||||
|
||||
### Vorgang (`matter_rights`)
|
||||
|
||||
| Handlungskontext | Basis | Bedingung |
|
||||
|---|---|---|
|
||||
| keiner | Owner = alle Rechte, sonst direkter Grant | – |
|
||||
| Akte C | Rechte der Akte C | Vorgang ist C zugeordnet, oder sein Elternvorgang ist C zugeordnet (dann Elternrechte in C) |
|
||||
| Vorgang P | direkte Rechte an P | Vorgang ist Teilvorgang von P |
|
||||
|
||||
Danach Abzug der Vorgangsausnahme genau in diesem Kontext. Ein Querverweis erzeugt keine Rechte.
|
||||
|
||||
### Element (`element_rights`)
|
||||
|
||||
| Handlungskontext | Basis | Bedingung |
|
||||
|---|---|---|
|
||||
| keiner | Owner = alle Rechte, sonst direkter Grant | – |
|
||||
| Akte C | Rechte der Akte C | Element ist direkt in C eingebunden **oder** in einem Vorgang, der C erreicht. Im zweiten Fall darf kein `case_link_blocks`-Eintrag bestehen |
|
||||
| Vorgang M | direkte Rechte an M | Element ist in M oder in einem Teilvorgang von M eingebunden |
|
||||
|
||||
Danach Abzug der Elementausnahme in diesem Kontext.
|
||||
|
||||
**Grenze:** Eine Ausnahme am **Vorgang** im Aktenkontext wird für Elemente dieses Vorgangs nicht abgezogen (Review R-07).
|
||||
|
||||
### Aufgabe und Frist (`task_rights`, `deadline_rights`)
|
||||
|
||||
| Fall | Basis |
|
||||
|---|---|
|
||||
| zugewiesene Person, ohne Kontext | Lesen; Aufgabe zusätzlich `edit`, falls ein Grant es gibt. Status ändern über `can_change_status` |
|
||||
| ohne Kontext | Owner = alle Rechte, sonst direkter Grant |
|
||||
| Kontext = eigener Vorgang | direkte Rechte am Vorgang |
|
||||
| Kontext = Akte | Rechte des Vorgangs in dieser Akte |
|
||||
| Kontext = Elternvorgang | nur Aufgaben; bei Fristen fehlt dieser Zweig (Review R-15) |
|
||||
|
||||
Danach Abzug der jeweiligen Ausnahme.
|
||||
|
||||
## 4. Schreibende Aktionen
|
||||
|
||||
| Aktion | Verlangte Rechte |
|
||||
|---|---|
|
||||
| Inhalt in Behälter anlegen | `edit` am Zielbehälter im Kontext (`require_container_edit`) |
|
||||
| Gemeinsamen Notiztext ändern | `edit` am Element im Kontext |
|
||||
| In weiteren Kontext einbinden | `share` am Element im Quellkontext und `edit` am Ziel |
|
||||
| Vorgang einer Akte zuordnen | `share` am Vorgang und `edit` an der Akte. Inhalte, die die Person nicht freigeben darf, landen in `case_link_blocks` |
|
||||
| Zuordnung lösen | `edit` an der Akte oder `share` am Vorgang |
|
||||
| Querverweis | `edit` am Quellvorgang, `read` am Ziel in einem eigenen Kontext |
|
||||
| Grant erteilen | Owner oder `share`; `can_edit` nur mit eigenem `edit`, `can_share` nur mit eigenem `share` |
|
||||
| Grant entziehen | Owner der Ressource oder `share` |
|
||||
| Einbindung lösen | `edit` am Element im Kontext (Kontextzugehörigkeit unscharf geprüft, Review R-02) |
|
||||
| Element überall löschen | nur Owner des Elements |
|
||||
| Akte oder Vorgang löschen | `edit` (Review R-01: laut Rollentabelle nur Owner) |
|
||||
| Reihenfolge, Kapitel, Ordnungsart | `edit` am Behälter im Kontext; nur sichtbare Einbindungen; verborgene behalten ihre Position |
|
||||
| Aufgabe zuweisen | Owner oder `share`; legt ein Lese-Grant für die zugewiesene Person an |
|
||||
| Export | je ausgewähltem Inhalt `read` und `share` im Kontext |
|
||||
|
||||
## 5. Sichtbarkeit in Listen und Antworten
|
||||
|
||||
- Listen (`list_cases`, `list_matters`) filtern grob im SQL und prüfen danach jedes Objekt einzeln.
|
||||
- Einbindungen, Anmerkungen, Bezüge, Zuordnungen, Querverweise, Teilvorgänge und Elternnamen erscheinen nur, wenn die Person sie im jeweiligen Kontext lesen darf. Verborgenes wird weder benannt noch gezählt (`visible_bindings_for_element`, `matter_title_if_readable`).
|
||||
- Die Chronologie zeigt nur Ereignisse, deren Ressource im Seitenkontext lesbar ist (`_event_title`).
|
||||
- Breadcrumbs nennen nur lesbare Stationen. Bei mehreren lesbaren Aktenzuordnungen ohne gewählten Kontext erscheint keine Hauptakte.
|
||||
- Betreiber- und Verwalterrolle verleihen kein Leserecht auf persönliche Inhalte.
|
||||
- **Raumfreigabe** (Tabelle `room_shares`): Der Owner teilt eine Akte oder einen Vorgang mit beliebigen Datenräumen, in denen er Mitglied oder Verwalter ist. Der Heimatraum spielt dafür keine Rolle. Aktive Mitglieder eines aktiven Raums erhalten Rechte nach Rolle: Leser lesen, Mitglied und Verwalter lesen und bearbeiten, Weitergeben und Löschen nie (`ROOM_RIGHTS`, `room_default` in `policy.py`). Die Obergrenze der Freigabe (`access = read`) begrenzt auf Lesen. Mehrere Freigaben addieren sich, danach wirken Ausnahmen. Eine Personenausnahme (Grant mit `is_exception` auf eine Person, Kontext leer) nimmt eine Person aus. Elemente und Aufgaben ohne Akte oder Vorgang bleiben beim Owner. Die Rechte der Akte reichen in Vorgänge und Inhalte wie bisher; ein Vorgang kann einzeln geteilt werden, ohne dass die Akte sichtbar wird. Der Owner sieht seine Einträge unabhängig von Raum und Mitgliedschaft. Das Löschen von Akte und Vorgang verlangt Owner oder ausdrückliches Löschrecht, nicht mehr nur Bearbeiten (schließt R-01 des Reviews). Verknüpfte Originale über die Zugänge des Owners liest ein Mitglied nur mit ausdrücklicher Quellenfreigabe im Raum (`room_source_access`, `room_source_access()` und `mediated_source_owner` in `policy.py`) oder mit der Einzelfreigabe `use_owner_sources`.
|
||||
- Kontoarten: Ein Mitarbeiter-Konto legt keine Räume an und keine Inhalte im persönlichen Raum an; es arbeitet in den eingeladenen Räumen nach Raumrolle (`ensure_can_create`, `require_main_user`). Raum-Eigentümer und Einladende sind Hauptnutzer. Beschreibung in [BENUTZERVERWALTUNG.md](BENUTZERVERWALTUNG.md).
|
||||
- Plattform- und Raumrollen (Betreiber, Verwalter, Mitglied, Leser) und ihre Schutzregeln beschreibt [BENUTZERVERWALTUNG.md](BENUTZERVERWALTUNG.md). Der Leser legt im Raum nichts an und erhält dort keine Bearbeiten- oder Freigeben-Grants; die Auswertung der Objektrechte bleibt unverändert.
|
||||
- Ein Quellabruf prüft zuerst das Leserecht im Kontext. Danach wird nur der an der Referenz gebundene Zugang des Owners verwendet. Eine Suche ohne `connector_id` nimmt bei mehreren eigenen Instanzen nicht die zuletzt angelegte. Ein Empfänger erhält weder Zugangsdaten noch die übrigen Treffer des Owners. Ein Entzug gilt beim nächsten Abruf, weil jedes Lesen die Rechte erneut prüft.
|
||||
|
||||
## 6. Bekannte Abweichungen
|
||||
|
||||
Siehe [Review-Befunde](../review/06_BEFUNDE.md): R-01 (Behälter löschen), R-02 (Detach/Anmerkung), R-07 (Vorgangsausnahme), R-12 (Teilvorgangstiefe), R-15 (Fristen im Elternkontext).
|
||||
@@ -0,0 +1,133 @@
|
||||
# Tsumugu – Connector- und Storage-Vertrag
|
||||
|
||||
**Version:** 0.1 · **Stand:** 19.10.2026
|
||||
**Status:** Technischer Umsetzungsvorschlag mit Migrationsplan; hier wurde keine Anwendung geändert. Der begleitende Cursor-Auftrag wird erst durch seine Übergabe zur Umsetzung erteilt.
|
||||
**Ziel:** Kleine produktlokale Grundlage für Paperless, IMAP und die bestehende eigene Dateiablage. Bestehende Fachfunktionen und Daten bleiben erhalten.
|
||||
|
||||
## 1. Verbindliche Grundlage und Liefergrenze
|
||||
|
||||
Fachlich führen die aktuelle Produktspezifikation und die jüngsten Nutzerentscheidungen. Die Connector Suite v0.2 vom 19.10.2026 ist die Grundlage für die Connector-Zielarchitektur. Ihre Vorschläge und offenen Punkte werden nicht pauschal zu bestätigten Beschlüssen. Architekturverträge aus `C:/Dev/tsumugu/docs/reference` gelten; konkrete Dateinamen und Vertragsbezeichnungen unten sind lokale Umsetzungsvorschläge.
|
||||
|
||||
Bestätigt sind: vollständiges Self-Hosting und spätere SaaS-Nutzung; Quellen als regelhafter Ort externer Originale; Fähigkeiten je Quelle/Ressource; gemeinsame UI mit möglichen Spezialansichten; getrennte Freigaben für Speicherung und Verarbeitung; optional vollständig deaktivierbare dauerhafte Cloud-Inhaltsspeicherung. SaaS-Nutzer müssen ihre Entschlüsselungsschlüssel auf eigenen Geräten beziehungsweise ihrer lokalen Runtime halten können. Diese Option ist Zielanforderung, noch kein nachgewiesenes Produktmerkmal.
|
||||
|
||||
**Primäres Nutzerziel:** Tsumugu wird aktuell vorwiegend privat genutzt und kontinuierlich erweitert. Der erste Schnitt legt tragfähige Grundlagen und vermeidet später großflächige Änderungen an Datenidentitäten, Berechtigungspfaden und Modulgrenzen. Funktionale Vollständigkeit der späteren SaaS-Plattform ist keine Voraussetzung. Daraus folgt keine Garantie, dass neue Anforderungen ohne jede Anpassung bleiben; Änderungen sollen überwiegend in den zuständigen Adaptern und Komponenten möglich sein.
|
||||
|
||||
**Erste Lieferung – Grundlagen:** Bestehende Paperless-/IMAP-Zugänge gemeinsam hinter Source-Verträge bringen, eigene Dateien und Versandfassungen über einen kleinen Storage-Vertrag anbinden und eine gemeinsame Frontend-Zugriffsschicht mit registrierten Darstellungs-/Quellmodulen einführen. Heutige Picker, Leser und Notizbearbeitung bleiben nutzbar. Keine vollständige Neugestaltung aller Dialoge als Fertigkriterium; gemeinsame Zustands-/Auswahlverträge dort einführen, wo dadurch bestehende Quellverzweigungen aus Fachseiten entfernt werden.
|
||||
|
||||
**Nächster Funktionsausbau:** Der Quellenbrowser wird auf den gemeinsamen Bausteinen vervollständigt und die Paperless-Suche gemäß Abschnitt 6 deutlich erweitert. Neue Text-/Markdown-Dateieditoren folgen anschließend auf denselben Verträgen. Diese Fähigkeiten bleiben eingeplant und werden nicht allein für eine scheinbar kleine Basis gestrichen; sie sind separat lieferbar.
|
||||
|
||||
**Spätere Lieferungen:** lokale Remote-Runtime, produktive kundenseitige Schlüsselhaltung, automatische lokale EML-Sicherung, dynamische Quellsammlungen, Dateisystem-/NAS-Source, Banking und KI. Text-/MD-Dateibearbeitung wird im Vertragsmodell berücksichtigt; die erste Lieferung implementiert vorhandene Notizbearbeitung und sichere Anzeige unterstützter Dateien. Neue MD-Dateischreibfunktionen benötigen anschließend einen konkret beauftragten Schnitt.
|
||||
|
||||
## 2. Geprüfter Ausgangspunkt
|
||||
|
||||
Gezielter statischer Abgleich am 19.10.2026, keine ausgeführten Anwendungstests oder Live-Quellenzugriffe:
|
||||
|
||||
| Bestand | Verwendung und erforderliche Anpassung |
|
||||
|---|---|
|
||||
| `backend/app/sources.py`, `api/sources.py` | Vorhandene Paperless-/IMAP-Protokollarbeit wiederverwenden. Quelle und Operation sind heute an mehreren Stellen fest verzweigt. |
|
||||
| `backend/app/retrieval.py`, `mailpack.py` | Vollständigen Originalabruf, EML-Parsing, Identitätsprüfung und Fehlerfälle in die gemeinsame Lesestrecke überführen. |
|
||||
| `frontend/src/pages/Sources.jsx` | Zwei Picker und Quellenformulare auf gemeinsame Hülle mit quellenspezifischen Ergänzungen umstellen. |
|
||||
| `ReadingPane.jsx`, `content.jsx`, `markdown.jsx` | Leser nach Darstellungsart anbinden; vorhandenen Markdown-Notizeditor weiterverwenden. |
|
||||
| `media/storage.py`, `ops.create_file`, `api/routes.py` | Browserupload kopiert PDF/Fotos in die eigene Ablage. Das Ursprungsverzeichnis wird danach nicht mehr benötigt. Ablage erfolgt derzeit über `MEDIA_ROOT`, im Compose-Betrieb `/data/media`. |
|
||||
| `correspondence.py`, `dispatch_snapshots` | Anlagen, Versandereignisse und gespeicherte Fassungen erhalten. Direkte Dateioperationen ebenfalls an Storage anbinden. |
|
||||
| `access.policy`, `use_owner_sources` | Kontextrechte und ausdrücklichen Owner-vermittelten Abruf verknüpfter Inhalte erhalten. Keine Erweiterung auf Browsen des übrigen Owner-Quellenbestands. |
|
||||
|
||||
Die heute konfigurierbare lokale Serverablage ist noch keine kundenseitige Remote-Ablage in einem SaaS-Modell. Anwendungseigene Dateiverschlüsselung ist im gelesenen Speicherpfad nicht implementiert; darunterliegende Laufwerksverschlüsselung wurde nicht geprüft. Frühere Prüfberichte belegen nur ihren jeweiligen Stand und werden nicht als aktueller Testlauf ausgegeben.
|
||||
|
||||
## 3. Verantwortlichkeiten
|
||||
|
||||
```text
|
||||
Quellenbrowser / Ressourcenleser / Editor / Export
|
||||
-> Tsumugu-Anwendungsdienst: Identität, Kontext, Objekt- und Quellrechte, DataPolicy
|
||||
-> Source-Port -> Paperless-Adapter oder IMAP-Adapter
|
||||
-> Content-Zugriff -> geschützter Storage-Port -> lokaler Ablageadapter
|
||||
-> Fachrepository: bestehende Elemente, Einbindungen, Aufgaben, Versandstände
|
||||
```
|
||||
|
||||
Die erste Adapterausführung bleibt im bestehenden Backend. Aufrufe verwenden einen expliziten Operationskontext und wohldefinierte Ein-/Ausgaben; Adapter erhalten keine Browser-Session oder frei verwendbare Fach-DB-Verbindung. Ein späterer Runtime-Transport kann dieselbe Verantwortung übernehmen. Ein Netzwerkprotokoll wird jetzt nicht implementiert.
|
||||
|
||||
Authentifizierung, Kontext-/Objektprüfung und fachliche Freigabe liegen im Anwendungsdienst. Ein Adapter kann Fähigkeiten und Quellrechte zusätzlich einschränken. Der Storage-Adapter entscheidet nicht selbst, wer einen Vorgang lesen darf. Fachliches Linking bleibt Tsumugu-Funktion.
|
||||
|
||||
## 4. Source-Vertrag
|
||||
|
||||
Ein kleiner registrierter Adaptervertrag umfasst:
|
||||
|
||||
| Operation | Ein-/Ausgabe und Zusage |
|
||||
|---|---|
|
||||
| Verbindung beschreiben und prüfen | Konkrete Instanz-ID, Typ, Name, Fähigkeiten und serverseitig geprüfter Verbindungszustand. Zugangsdaten bleiben im zuständigen Secret-/Transportadapter. |
|
||||
| Navigieren | Parent-/Navigationskennung, begrenzter Cursor; Ergebnis sind Navigationsknoten und/oder Ressourcen. Keine beliebigen Serverpfade vom Browser übernehmen. |
|
||||
| Suchen | Typisierte Suchanfrage, Suchbereich, Filter, Sortierung, Cursor; begrenzte Ergebnisseite und Fortsetzungsinformation. Nicht unterstützte Filter ausdrücklich melden. |
|
||||
| Ressource auflösen | Instanzgebundene Referenz; Metadaten, Quellstand, Darstellungsarten und aktuell zulässige Operationen. Fehlendes Original löscht die Referenz nicht. |
|
||||
| Inhalt lesen | Original, Vorschau, Text oder bestimmte Anlage getrennt anfordern; Typ, Größe, Quellstand und vollständiger/gekürzter Zustand sind erkennbar. |
|
||||
| Bearbeiten, wenn unterstützt | Inhalts- und Metadatenänderung sind getrennte Operationen mit erwartbarem Quellstand und Konfliktbehandlung. Im ersten Source-Schnitt nicht angeboten. |
|
||||
|
||||
Fähigkeiten werden je Connector und Ressource bestimmt. Die tatsächliche Ausführung prüft erneut Quelle, aktuelle Rechte und DataPolicy. Ein UI-Flag ist keine Autorität. Fehlende Fähigkeit bleibt fehlend; ein Original darf nicht durch eine gekürzte Vorschau ersetzt werden.
|
||||
|
||||
Ergebnisse beschreiben mindestens Instanz und externe Ressourcenkennung, Typ, Titel, vorhandene fachliche Daten, knappen erlaubten Auszug und Darstellungsarten. Paging-Cursor sind an die konkrete Verbindung und Suchanfrage gebunden. Suchtreffer allein erzeugen keine dauerhaften Elemente. Erst ausdrückliches Einbinden schreibt Fachreferenzen.
|
||||
|
||||
Bestehende Element- und Binding-IDs bleiben erhalten. Gleiche externe IDs verschiedener Instanzen sind verschieden. Eine instanzgebundene Quellkennung ist kein Anlass zum automatischen Zusammenführen bereits vorhandener Elemente. IMAP-ID, fachliches Element und Dateihash bleiben unterscheidbare Begriffe.
|
||||
|
||||
Einheitliche Zustände: nicht erreichbar, nicht berechtigt, nicht auffindbar, mehrdeutig, veraltet, Konflikt, Entsperrung erforderlich, nicht unterstützte Fähigkeit/Schutzprofil, Größenlimit und Verarbeitungsfehler. Geheimnisse und verborgene Quelleninformationen gehören nicht in Fehlermeldungen.
|
||||
|
||||
## 5. Gemeinsame UI und Fähigkeiten
|
||||
|
||||
Produktlokale, registrierte Komponenten:
|
||||
|
||||
1. Verbindungseinrichtung mit gemeinsamer Hülle und quellenspezifischen Zugangsfeldern.
|
||||
2. Quellenbrowser: Navigation, Suchbereich, Filter, Ergebnisse, Paging, erhaltene Auswahl und Vorschau.
|
||||
3. Übernahme: gewählte Ressourcen, aktiver Vorgang/Akte, Kapitel und sichtbare Wirkung; erfolgreiche Teilübernahmen und Wiederholungen nachvollziehbar behandeln.
|
||||
4. Ressourcenleser nach Darstellungsart: PDF, Bild, Text/Markdown, E-Mail einschließlich Anlagen und Metadatenformular.
|
||||
5. Editorhülle: Laden, Berechtigungszustand, ungesicherte Eingaben, Speichern/Abbrechen und Konfliktanzeige; bestehende Notizbearbeitung als erster konkreter Editor.
|
||||
|
||||
Filter und Spezialansichten können als Tsumugu-eigene registrierte Ergänzungen eingebunden werden. Vom Connector gelieferter ausführbarer Frontend-Code und ein universeller Formulargenerator gehören nicht zur Lieferung. Dieselben Browserkomponenten funktionieren als Dialog oder vollständige schmale Ansicht. Tastaturfokus, Rückkehr, Abbruch und unveränderte Eingaben bei Layoutwechseln gehören zur Hülle.
|
||||
|
||||
Ressourcen-ID, Zielcontainer und Handlungskontext bleiben getrennt. Mehrfachauswahl verwendet die Verbindung als Teil der Identität und bleibt bei Such-/Seitenwechsel erhalten. Ein unbemerkter Wechsel des Zielkapitels oder Datenraums darf keine Übernahme auslösen.
|
||||
|
||||
## 6. Paperless: funktionaler Suchausbau
|
||||
|
||||
Der unmittelbar folgende Funktionsausbau umfasst kombinierbare Freitext-/Titelsuche, Filter für Korrespondenten, Dokumenttypen und Tags, Dokumentdatumsbereich, Sortierung und vollständiges Paging im berechtigten Bestand. Auswahlwerte aus der konkreten Quelle beziehen. Bei Tagkombinationen UND/ODER-Bedeutung sichtbar machen; tatsächlich unterstützte Kombinationen gegen die eingesetzte Paperless-Version prüfen. In der Grundlagenlieferung werden dafür Anfrage-/Ergebnisvertrag, Capability-Angaben und instanzgebundene Fortsetzungsinformation festgelegt; noch nicht implementierte Suchfähigkeiten bleiben ausdrücklich nicht verfügbar.
|
||||
|
||||
Dokumentdatum und Erfassungsdatum bleiben getrennt. Wenn ein weiterer Datumsfilter angeboten wird, passend beschriften. Treffer vor Einbindung lesen können. Mehrfachauswahl über mehrere Seiten/Suchläufe erhalten. Keine feste Begrenzung auf die ersten 20 Treffer und kein vollständiger lokaler Dokumentindex als Voraussetzung.
|
||||
|
||||
Typgerechte Filter für benutzerdefinierte Felder bleiben der nächste Suchausbau. Der Vertrag muss sie aufnehmen können, ohne eine generische Abfragesprache oder Finanzfunktion jetzt einzuführen. Bestandsfelder nicht mit ungeprüften API-Schlüsseln gleichsetzen.
|
||||
|
||||
## 7. Storage, Inhaltsrevision und Verschlüsselung
|
||||
|
||||
Der kleine Storage-Port speichert, öffnet, beschreibt und löscht begrenzte Byteinhalte. Er arbeitet mit opaken Speicherreferenzen. Diese binden Speicherinstanz, Generation, Objektkennung und Inhaltsrevision. Namensanzeige und Medientyp sind Metadaten; Dateiname oder beliebiger Clientpfad sind keine Speicheradresse.
|
||||
|
||||
Der lokale Adapter übernimmt zunächst bestehende Medien und Versandfassungen. Bisherige Dateien bleiben lesbar, ohne Neu-Upload oder Umbenennung im Bestand. Alte Referenzen dürfen durch Ändern des konfigurierten Wurzelverzeichnisses nicht unbemerkt auf einen anderen Speicher zeigen.
|
||||
|
||||
Neue Inhalte erst nach erfolgreicher geprüfter Ablage als verfügbar melden. Dateiablage und DB sind keine gemeinsame atomare Transaktion: kurze DB-Phasen, nachvollziehbare Operationskennung/Receipts und Wiederherstellung unvollständiger Abläufe nach dem Medien-Blueprint verwenden. Bestehende Größenlimits erhalten. Externe Aufrufe und größere Dateioperationen außerhalb offener Fachtransaktionen durchführen, Zugriffs-/Versionszustand vor abschließender Veröffentlichung erneut prüfen.
|
||||
|
||||
Neue Inhaltsstände erhalten neue Revisionen. Versandfassungen bleiben an ihren festgehaltenen Stand gebunden. Ein interner Bytehash prüft die jeweilige Repräsentation; er ist keine allgemeine Ressourcenidentität und wird nicht als öffentliches Fingerprint-API angeboten.
|
||||
|
||||
**Speicherort und Entschlüsselung sind getrennte Verträge:**
|
||||
|
||||
- Der Storage-Port verarbeitet opake Bytes und benötigt keinen Entschlüsselungsschlüssel.
|
||||
- Ein versioniertes Schutzprofil bezeichnet Klartextbestand, verwaltet verschlüsselte Inhalte oder kundenseitig verschlüsselte Inhalte. Schlüsselreferenz und Schlüsselzuständigkeit sind getrennt vom Speicherort; geheime Schlüssel werden nicht in die fachliche Speicherreferenz geschrieben.
|
||||
- Ein gesonderter Content-/Crypto-Zugriff bestimmt, ob die konkrete Ausführungsstelle entschlüsseln darf. Der Core darf nicht voraussetzen, dass SaaS Inhalte immer lesen kann. Kundenseitig geschützte Inhalte können als verschlüsselt/gesperrt bekannt sein, ohne einen Klartextpfad anzubieten.
|
||||
- Der Dateispeicher erzwingt keine PDF-/Bildinterpretation. Typprüfung und Reader benötigen autorisierten Klartext an der passenden Stelle; spätere Browser-/Runtime-Entschlüsselung muss dort anschließbar sein.
|
||||
- Der vorhandene unverschlüsselte Bestand wird als Legacy-Zustand ausdrücklich beschrieben. Die erste Basislieferung verspricht noch keine Dateiverschlüsselung. Verschlüsselte Speicherung erst nach abgeschlossenem Schlüssel-/Recovery-Entwurf und passenden Nachweisen aktivieren. Bis dahin keine Datenschutz- oder SaaS-Freigabe daraus ableiten.
|
||||
|
||||
Die Vorbereitung wird durch Vertragsprüfungen mit zwei Ablageadaptern und einem gesperrten Inhaltszugriff belegt. Opake Testbytes sind kein Nachweis realer Kryptografie. Eine produktive Browser-Schlüsselhaltung wird damit nicht behauptet.
|
||||
|
||||
DataPolicy unterscheidet dauerhafte Ablage, temporären Cache, Übertragung für Live-Funktionen und externe Verarbeitung. Diese Trennung gilt auch für Leser, Exporte und Versandfassungen. Die erste Ausführung bleibt im vorhandenen Self-Hosting-Betrieb; für Hybridbetrieb ist anschließend der lokale Kommunikationskanal auszuarbeiten. EML-Archivkopien bleiben nach v0.2 ausschließlich im Kundenbereich. Eine verschlüsselte SaaS-Ablage ändert diese Sonderregel nicht.
|
||||
|
||||
## 8. Migrationsfolge und Erhaltung
|
||||
|
||||
1. Aktuellen Bestand und Tests erfassen; nur betroffene Schutz- und Blueprint-Abweichungen in den Schnitt aufnehmen.
|
||||
2. Registrierten Source-Vertrag mit vorhandenen Paperless-/IMAP-Funktionen implementieren. Alte Routen bei Bedarf als kurzlebige delegierende Kompatibilitätsadapter erhalten; keine doppelte Fachlogik.
|
||||
3. Bestehende Referenzen einer konkreten Connector-Instanz zuordnen. Eindeutige Bestände migrieren; mehrdeutige oder nicht auflösbare Einträge erhalten und zur Zuordnung markieren. Niemals auf die zuletzt angelegte Verbindung zurückfallen. Credentialwechsel innerhalb derselben Quelle ist von einem Wechsel der Quellinstanz zu unterscheiden.
|
||||
4. Speicherinstanz/-generation für heutige Medien und Versandstände einführen; bestehende IDs, Pfade und Bytes erhalten. Reads zuerst kompatibel machen, danach neue Writes auf den Vertrag umstellen.
|
||||
5. Frontend-Zugriff, registrierte Quell-/Darstellungsmodule und Ressourcenzugriff umstellen. Auch Export, Anlagen und Nachweise über die gemeinsame autorisierte Lesestrecke führen. Quellenbrowser und erweiterte Paperless-Suche danach als eigenen nutzbaren Funktionsausbau liefern. Keine neuen Quellverzweigungen in Akten-/Vorgangsseiten ergänzen; bestehende während der Migration gezielt in die zuständigen Quellmodule überführen.
|
||||
6. Fachspec, technische Beschreibung und Ist-Dokumentation gezielt nachziehen. F-02b/c bleibt bis zu einer ausdrücklichen späteren Entscheidung erhalten; dieser lesende Source-Schnitt entscheidet keinen Ersatz der bidirektionalen Feldanforderung.
|
||||
|
||||
Keine automatische Umdeutung von Kapiteln, Anlagenrollen oder virtuellen Freigabezusammenstellungen. Bestehende Kontextrechte, gemeinsame Notizänderungen, lokale Ordnung, unabhängige Aufgaben/Fristen und vollständige EML-Exporte bleiben erhalten. Ein Owner-vermittelter Dokumentabruf ist weiterhin auf ausdrücklich freigegebene Ressourcen begrenzt.
|
||||
|
||||
## 9. Quellen und weitere Prüfaufträge
|
||||
|
||||
Projekt: `C:/Dev/tsumugu/AGENTS.md`, aktuelle Fachspec 0.38 und technische/Ist-Dateien unter `docs/architecture`; Connector Suite v0.2; vorhandene Export-, Unterkapitel- und Schreiben/Anlagen/Versand-Aufträge. Die unveränderte Connector Suite v0.2 wird dem Paket als Quelle beigelegt; vorgesehener Repositorypfad: `C:/Dev/tsumugu/docs/architecture/Tsumugu_Connector_Suite_Architektur_v0.2.md`.
|
||||
|
||||
Familienreferenzen ausschließlich aus den Projektkopien unter `C:/Dev/tsumugu/docs/reference`: A/B/C v0.3, Auth/Session/Scope, Medien/Dateien/sicheres Rendering und Release/Betrieb/Recovery. KI-Gateway, Workflow und Entitlements nur bei konkretem Bedarf. Bestehende Varianten bleiben gemäß A0 zulässig; keine Frameworkmigration oder neue familienweite Referenzarchitektur.
|
||||
|
||||
Begleitend: `TSUMUGU_CONNECTOR_UMBAU_AUFTRAG_2026-10-19.md` und `TSUMUGU_STORAGE_SCHLUESSEL_PRUEFAUFTRAG_2026-10-19.md`. Der Schlüssel-Prüfauftrag geht an die bestehende Architektur-Session, ohne sie hier automatisch zu kontaktieren.
|
||||
@@ -0,0 +1,23 @@
|
||||
# Begrenzter Prüfauftrag an die bestehende Jinkendo-Architektur-Session
|
||||
|
||||
**Stand:** 19.10.2026 · **Status:** Vorbereitet, nicht versandt. Keine Implementierung und keine neue parallele Referenzarchitektur.
|
||||
|
||||
## Bedarf und Eingaben
|
||||
|
||||
Tsumugu entwickelt eine kleine Source-/Storage-Basis aus Paperless, IMAP und eigener Dateiablage. Die spätere SaaS-Nutzung muss sowohl kundenseitig gehaltene Schlüssel als auch optional verwaltete Verschlüsselung unterstützen. Lokale Ablage und verschlüsselte zentrale Ablage sind getrennte Speicheroptionen. Speicherung, Live-Übertragung und externe Verarbeitung haben getrennte Freigaben. EML-Archivkopien bleiben gemäß Connector Suite v0.2 lokal im Kundenbereich.
|
||||
|
||||
Lies die aktuellen Projektkopien unter `C:/Dev/tsumugu/docs/reference`, besonders A/B/C, Auth/Session/Scope, Medien/Dateien/sicheres Rendering und Release/Recovery. Ergänzend die Connector Suite v0.2 und `C:/Dev/tsumugu/docs/architecture/TSUMUGU_CONNECTOR_STORAGE_VERTRAG_v0.1_2026-10-19.md`. Prüfe vorhandene Implementierungen nur für tatsächlich wiederverwendbare Mechanismen. Ein Konzept oder vorhandener Test ist noch kein erfolgreicher Produktnachweis.
|
||||
|
||||
## Eng begrenzte Fragen
|
||||
|
||||
1. Passt die Trennung aus opakem Storage-Port, versionierter Speicherreferenz und gesondertem Content-/Crypto-Zugriff zum Medien-Blueprint? Benenne notwendige Korrekturen am kleinen ersten Vertrag.
|
||||
2. Skizziere einen überprüfbaren Einstieg für verwaltete Dateiverschlüsselung: Secret-/Schlüsselreferenz, Schutzprofil, Inhaltsrevision, Wiederherstellung, Rotation und Backupbindung. Nutze etablierte Mechanismen; keine eigene Kryptografie entwickeln.
|
||||
3. Welche Metadaten des Inhalts-/Schutzformats müssen schon jetzt berücksichtigt werden, damit spätere kundenseitige Verschlüsselung vor dem Upload möglich bleibt? Der Core darf Entschlüsselung nicht voraussetzen. Benenne bewusst, welche Metadaten weiterhin zentral lesbar sein dürfen beziehungsweise einer späteren fachlichen Festlegung bedürfen.
|
||||
4. Prüfe die Grenzen eines späteren Browsermodus: Gerätebindung, Wiederherstellung, Mehrgerätezugang und Freigabe an weitere Personen. Browserausführung und Schlüsselhaltung allein nicht als Schutz gegen jede Änderung am ausgelieferten Anwendungscode darstellen. Gib Sicherheitsannahmen ausdrücklich an.
|
||||
5. Definiere höchstens eine spätere Anschlussstelle für lokale Runtime beziehungsweise KI-Processing. Kein Netzwerkprotokoll, keine Providerwahl und keine multimodale Pipeline jetzt ausarbeiten.
|
||||
|
||||
## Erwartetes Ergebnis
|
||||
|
||||
Eine kurze Ergänzung beziehungsweise Zuordnung zu den vorhandenen Blueprints: wiederverwendbare Mechanismen mit aktuellem Nachweisgrad, vorgeschlagene Schutz-/Schlüsselgrenzen, erforderliche Erstimplementierungsentscheidungen und eine kleine Negativtestliste. Klar trennen: Was kann die erste Connector-/Storage-Basis bereits vorbereiten, was muss vor realer Verschlüsselung fertig entschieden sein, was bleibt bis zur späteren Kunden-Runtime offen?
|
||||
|
||||
Kein allgemeines SaaS-Framework, neues Identitätssystem, Schlüsselserver, DMS oder vollständiges E2EE-Produkt entwerfen. Ungeklärte Schlüsselwiederherstellung darf nicht durch Betreiber-Klartextzugriff oder stillen Schlüsselupload ersetzt werden. Keine Anwendung, Secrets, Datenbank, Konfiguration oder Deployments ändern. Rückgabe an die fachliche Tsumugu-Planung; durch diesen Text wird keine andere Session kontaktiert.
|
||||
@@ -378,7 +378,7 @@ Dieselbe Grenze gilt für Finanzobjekte. Eine unzugeordnete Zahlung sehen Owner
|
||||
|
||||
### 5.6 Anwalt und RLS
|
||||
|
||||
Ein registriertes Konto mit Leserecht an Akte oder Vorgang kann verknüpfte Paperless-Dokumente und E-Mails über die serverseitigen Zugänge des Owners lesen, wenn der Owner das an der Freigabe ausdrücklich einschaltet (`use_owner_sources`). Der Empfänger richtet dafür keine eigenen Quellen ein, erhält keine Secrets und kann das Archiv oder Postfach nicht durchsuchen. Ein Gastzugang ohne Konto bleibt offen und ist nicht Teil dieses Schnitts. Das Übergabepaket bleibt ein eigener Stand und nutzt weiter die Zugänge der exportierenden Person.
|
||||
Ein registriertes Konto mit Leserecht an Akte oder Vorgang kann verknüpfte Paperless-Dokumente und E-Mails über die serverseitigen Zugänge des Owners lesen, wenn der Owner das an der Freigabe ausdrücklich einschaltet (`use_owner_sources`) oder es der Person in einem Datenraum, mit dem der Eintrag geteilt ist, ausdrücklich freigibt (`room_source_access`, seit 04.11.2026). Der Empfänger richtet dafür keine eigenen Quellen ein, erhält keine Secrets und kann das Archiv oder Postfach nicht durchsuchen. Ein Gastzugang ohne Konto bleibt offen und ist nicht Teil dieses Schnitts. Das Übergabepaket bleibt ein eigener Stand und nutzt weiter die Zugänge der exportierenden Person.
|
||||
|
||||
Vertrag ADR-06 und offener Punkt O1: vertrauliche Mehrraumdaten brauchen eine ausdrückliche RLS-Prüfung. Vorschlag: ab P1 App-Policy, zusammengesetzte Fremdschlüssel und eine Runtime-Rolle ohne DDL, Owner und `BYPASSRLS`. Vor dem ersten Produktivbetrieb mit echten Daten zusätzlich RLS als zweite Linie, mit transaktionslokalem Subjekt und einem Grant-Prädikat, das datenraumübergreifende Leserechte nur über `access_grants` zulässt. Pool-Rückgabe darf diesen Kontext nicht behalten. RLS ersetzt die App-Policy nicht. Ein stiller, auf die Scope-ID beschränkter RLS-Filter wäre ein Fehler, weil er bestätigte Freigaben aussperren oder, bei zu weiter Policy, fremde Akten öffnen würde.
|
||||
|
||||
@@ -485,6 +485,8 @@ Erster Dateischnitt, Vorschlag der registrierten Profile: JPEG, PNG, WebP und PD
|
||||
|
||||
Upload startet nur bei Bearbeitungsrecht am Zielkontext. Der Download nutzt den Readplan: Sessioncookie, geprüfter Scope, lesbare Einbindung, lesbares Asset, aktuelle Revision. Kein öffentlicher `/media`-Mount und keine Session in der URL.
|
||||
|
||||
**Stand 19.10.2026, Implementierung der Grundlage:** Eigene Dateien und Versandfassungen laufen über einen kleinen Storage-Port mit lokalem Adapter. Die Speicherreferenz trägt Instanz, Generation, Objektkennung und Inhaltsrevision. Das Schutzprofil und die Schlüsselzuständigkeit liegen daneben; geheime Schlüssel stehen nicht in der Referenz. Der vorhandene Bestand ist `legacy-plaintext`. Profile `managed-encrypted` und `client-encrypted` werden geschlossen abgelehnt und nicht entschlüsselt. Paperless und IMAP sind registrierte Source-Adapter. Die Art prüft die Registrierung, nicht eine Datenbankliste. Ein dritter Testadapter belegt, dass Fachseiten, Reader und Export dafür nicht erweitert werden. Eine Referenz bindet eine konkrete Instanz. Dieselbe externe Nummer in zwei Instanzen bleibt getrennt. Mehrdeutiger Altbestand wird nicht auf den zuletzt angelegten Zugang gelegt. F-02b und F-02c bleiben offen und werden durch diesen lesenden Schnitt nicht ersetzt. Zugangsdaten liegen weiterhin im Adapter, derzeit als Klartext in `connectors.secret`. Das ist kein Nachweis von Verschlüsselung oder SaaS-Reife.
|
||||
|
||||
Ausfall des Storage: neue Uploads und Downloads antworten 503 `storage_unavailable`. Bereits gespeicherte fachliche Metadaten bleiben lesbar. Die Oberfläche zeigt den Dateizustand `unavailable`, ohne einen leeren Erfolg zu melden.
|
||||
|
||||
### 7.2 Paperless-Felder
|
||||
|
||||
@@ -0,0 +1,306 @@
|
||||
# Tsumugu – Connector Suite: Architekturkonzept
|
||||
|
||||
**Version:** 0.2 · **Stand:** 19.10.2026
|
||||
**Status:** Konsolidierter fachlich-technischer Konzeptstand, **keine Implementierungsfreigabe**
|
||||
**Geltungsbereich:** Tsumugu; mögliche spätere Wiederverwendung in Jinkendo nach gesonderter Prüfung
|
||||
**Grundlage:** Fortgeschriebene Festlegungen in dieser Unterhaltung vom 18.–19.10.2026 und `Tsumugu_Product_Recovery_Baseline_v0.1.md` (16.10.2026).
|
||||
|
||||
## 1. Zielbild und Abgrenzung
|
||||
|
||||
Tsumugu ist ein **universeller Vorgangs-, Akten- und Informationsmanager**. Es führt Ressourcen und Informationen zu Vorgängen zusammen, ohne die angeschlossenen Systeme zu ersetzen. Aktenstruktur, Beziehungen, Notizen, Aufgaben, Fristen, Chronologie und fachliche Zuordnungen sind Tsumugu-eigene Informationen. Dokumente, E-Mails, Dateien und Bankbuchungen verbleiben grundsätzlich in ihren Quellen.
|
||||
|
||||
Die **Connector Suite** erschließt externe Ressourcen und Dienste über eine einheitliche Integrationsarchitektur. Sie ermöglicht Navigation, Suche, Lesen, Metadaten, Darstellung, bei geeigneter Quelle Bearbeitung und selektive Aktualisierung. Sie ist **keine generelle Import-, Spiegelungs- oder Archivierungsplattform**.
|
||||
|
||||
**Geschäftliches Ziel:** Dasselbe Produkt soll sowohl **vollständig selbst gehostet** als auch als **SaaS mit kundenseitig betriebener Connector Runtime** angeboten werden können. Eine SaaS-Variante mit zentralen Connectoren bleibt möglich. Self-Hosting ist insbesondere für datenschutz- und selbsthostingaffine Paperless-Nutzer relevant. Die kommerzielle Nachfrage ist eine Hypothese, keine nachgewiesene Tatsache.
|
||||
|
||||
**Leitprinzipien:**
|
||||
- *Source of Truth:* Externe Quelldaten bleiben im jeweiligen führenden System.
|
||||
- *Reference first:* Tsumugu speichert primär Referenzen, eigene Fachdaten und nötige, freigegebene Metadaten.
|
||||
- *Least privilege:* Rechte aus Quellsystem **und** Tsumugu gelten gemeinsam.
|
||||
- *Policy-based placement:* Pro Connector-Instanz und Datenklasse bestimmen, was gespeichert, übertragen oder verarbeitet werden darf. Lokale Speicherung ist eine Option, keine pauschale Pflicht.
|
||||
- *Cloud content opt-out:* SaaS-Kunden können die dauerhafte Cloud-Speicherung von Dokumentinhalten und KI-Artefakten vollständig deaktivieren.
|
||||
- *Capability based:* Verschiedene Connectoren bieten verschiedene Operationen, Ressourcentypen und Darstellungsarten an.
|
||||
- *Pragmatic UI:* Generische Tsumugu-Komponenten vor beliebig ladbarem Connector-Frontend-Code.
|
||||
- *Demand driven:* Keine allgemeine Plattformkomplexität oder zusätzliche Blueprints ohne konkreten Modulbedarf.
|
||||
|
||||
## 2. Logische Gesamtarchitektur
|
||||
|
||||
```text
|
||||
┌──────────────────────────────────────────────┐
|
||||
│ Tsumugu UI │
|
||||
│ Akten | Ressourcenbrowser | Suche | Preview │
|
||||
│ Metadatenansicht/-editor | Aufgaben/Fristen │
|
||||
└───────────────────┬──────────────────────────┘
|
||||
│ standardisierte Ressourcen-/UI-Verträge
|
||||
┌───────────────────▼──────────────────────────┐
|
||||
│ Tsumugu Core │
|
||||
│ Akten, Links, Notizen, Metadatenindex, │
|
||||
│ CollectionBindings, Rechte, Daten-Policies │
|
||||
└───────────────────┬──────────────────────────┘
|
||||
│ autorisierte Connector-Operationen
|
||||
┌───────────────────▼──────────────────────────┐
|
||||
│ Connector Runtime / Adapter │
|
||||
│ Fähigkeiten, Quellzugang, Mapping, Sync, │
|
||||
│ Export, Zugriffskontrolle, lokale Ablage │
|
||||
└─────┬──────────┬──────────┬───────────┬─────┘
|
||||
│ │ │ │
|
||||
Paperless IMAP Dateien Bank/API
|
||||
│
|
||||
Lokales NAS
|
||||
Processing-Dienste (z.B. KI) als
|
||||
eigener Fähigkeitsvertrag
|
||||
```
|
||||
|
||||
### Betriebsformen
|
||||
|
||||
**A – Self-Hosted:** Tsumugu Core und Connector Runtime laufen in einer selbst betriebenen Umgebung, gegebenenfalls auf separaten lokalen Systemen.
|
||||
|
||||
**B – Hybrid-SaaS (bevorzugte Zielrichtung):** Tsumugu Core läuft beim Anbieter, die Connector Runtime optional beim Kunden. Sie verbindet lokale/zugängliche Quellsysteme und setzt Datenfreigaben durch. Tsumugu persistiert nur freigegebene Referenzen/Metadaten und eigene Fachdaten. Originaldokumente müssen nicht im SaaS-Speicher liegen.
|
||||
|
||||
**C – SaaS mit zentralen Connectoren:** Für Nutzer ohne lokale Infrastruktur grundsätzlich möglich, aber nicht als Voraussetzung für die erste Umsetzung.
|
||||
|
||||
**Grenze:** Eine lokale Runtime schützt Daten nicht automatisch vor Cloud-Übertragung. Vorschau, Live-Suche, KI-Anfragen, Protokolle und temporäre Verarbeitung unterliegen ebenfalls einer expliziten Datenfluss-Policy. Der sichere Kommunikationskanal (Initiierung, Authentisierung, Autorisierung, Verbindungsausfall) ist noch technisch auszugestalten.
|
||||
|
||||
## 3. Connector-Kategorien
|
||||
|
||||
| Kategorie | Wesentliche Aufgabe | Erste Anwendungsfälle | Architektonische Einordnung |
|
||||
|---|---|---|---|
|
||||
| **Source** | Datenbestand navigieren, suchen, lesen, optional bearbeiten | Paperless, IMAP, Dateien | Gemeinsamer Ressourcenkontrakt |
|
||||
| **Financial** | Buchungen und Kontoinformationen strukturiert lesen | Banken / Kontoinformationsanbieter | Spezialisierte Source-Fähigkeiten, zunächst read-only |
|
||||
| **Processing** | Inhalte auswerten und strukturierte Ergebnisse erzeugen | KI, perspektivisch OCR/Konvertierung | **Kein gewöhnlicher Ressourcenbrowser**; eigener Eingabe-/Ergebnisvertrag |
|
||||
| **Storage** | Konfiguriert ablegen und wiederfinden | NAS-/Dateiablage, `.eml`-Archiv | Eigener Ablage-/Abrufvertrag; kann Infrastruktur mit Datei-Source teilen |
|
||||
|
||||
Die vier Kategorien sind **Ordnungsbegriffe**, keine Verpflichtung zu vier separaten Servern, Frameworks oder vollständigen APIs. Gemeinsamkeiten werden nur dort standardisiert, wo sie bereits benötigt werden.
|
||||
|
||||
### 3.1 Source: Paperless
|
||||
- Vollständige Suche/Navigation im durch Quellidentität berechtigten Bestand, nicht nur in bereits aktenverknüpften Elementen.
|
||||
- Dokumentreferenz, Quelle, Metadaten, OCR-/Textabruf auf Anfrage, Original-/Vorschauzugriff.
|
||||
- Bearbeitung **führender Paperless-Metadaten** über Paperless, wenn Connector- und Quellrechte dies erlauben; Tsumugu-eigene Felder separat.
|
||||
- Selektiver Metadatenindex, nicht generelle Dokument-/Volltextreplikation.
|
||||
- Navigation etwa über Dokumenttypen, Korrespondenten und Tags; konkrete UI-Komponenten noch zu spezifizieren.
|
||||
|
||||
### 3.2 Source: IMAP
|
||||
- Postfächer und Ordner navigieren, Nachrichten suchen, Header, Inhalt und Anhänge zugänglich machen.
|
||||
- **Explizite Einzelreferenzen bleiben bei Ordnerwechsel als Aktenverknüpfung bestehen.** IMAP-UID ist typischerweise ordnerbezogen; der Adapter braucht eine belastbare Wiedererkennungsstrategie bzw. meldet nicht auflösbare Referenzen, ohne sie zu löschen.
|
||||
- Ordner können als **dynamische Sammlung** referenziert werden, auch für künftige passende Nachrichten.
|
||||
- Optionales lokales `.eml`-Archiv, Details in Abschnitt 7.
|
||||
- Umfang einer vollständigen E-Mail-Bearbeitung (Versenden, Verschieben etc.) ist **nicht** festgelegt und kein Grund für eine komplette E-Mail-Client-Nachbildung.
|
||||
|
||||
### 3.3 Source: Dateien
|
||||
- Zugriff auf explizit freigegebene Verzeichnisse / Netzlaufwerke, Navigation, Suche, Lesezugriff, Vorschau, Metadaten.
|
||||
- Pfad und Ressource nach Möglichkeit getrennt modellieren; Verschieben/Umbenennen darf nicht ungeprüft Aktenverknüpfungen löschen.
|
||||
- Schreiboperationen nur bei ausdrücklicher Fähigkeit und Berechtigung.
|
||||
|
||||
### 3.4 Financial: Banken (beschlossenes Grundmodell)
|
||||
- Financial ist technisch eine **spezialisierte Source-Integration**, keine eigene Banking-Plattform.
|
||||
- Es werden **bestehende Banking-/Kontoinformationsdienste** integriert; zu Beginn ausschließlich **lesender Zugriff auf Einzelbuchungen**. Keine Überweisungen oder Zahlungsinitiierung.
|
||||
- Vollständige Abfrage des freigegebenen Buchungsbestands ist möglich; Tsumugu speichert **standardmäßig keine komplette Umsatzhistorie**.
|
||||
- Dauerhaft verbleiben insbesondere explizit zugeordnete Buchungsreferenzen und die für Rechnung, Zahlung, Teilzahlung, Sammelzahlung oder Erstattung benötigten Metadaten (etwa Betrag, Datum, Gegenpartei, Verwendungszweck), sofern durch die Datenrichtlinie freigegeben.
|
||||
- Rechnungs-/Zahlungszuordnungen sind **Tsumugu-eigene Viele-zu-viele-Beziehungen** und bleiben auch erhalten, wenn der Banking-Anbieter eine frühere Buchung nicht mehr abrufen kann.
|
||||
- Providerwahl, konkrete Einwilligungs-/Zugangsmechanik und Buchungsidentitäten sind integrationsbezogene Umsetzungsfragen.
|
||||
|
||||
### 3.5 Processing / KI (beschlossenes Grundmodell)
|
||||
- Processing Connectoren sind **Verarbeitungsdienste**, keine normale Ressourcenquelle; eigener Eingabe-/Ergebnisvertrag statt erzwungenem Source-Interface.
|
||||
- Wesentliche fachliche Fähigkeiten: **Extraktion, Klassifikation, Zusammenfassung, informationsgestützte Fragen, Beziehungsanalyse und Handlungsvorschläge**. Diese Fähigkeiten sind Aufgabenarten, nicht zwingend eigenständige APIs.
|
||||
- Eingaben können **Text, strukturierte Daten, Bilder und PDF-Dokumente** sein. Moderne multimodale APIs bzw. lokale Modelle können Original-PDFs/Fotos interpretieren; ein separater OCR-Dienst ist **optional, keine Pflicht**. Vorhandene Paperless-OCR-Texte sollen bei Eignung bevorzugt wiederverwendet werden.
|
||||
- Ausführung **lokal oder extern** entsprechend Datenfreigabe, unterstützter Modellfähigkeit und geeigneter Kosten-/Leistungsabwägung.
|
||||
- Verarbeitungsschritte dürfen **kombinierbar** sein. Keine neue umfassende KI-Agenten- oder Workflow-Plattform als Voraussetzung; bestehende Jinkendo-KI-Gateway-/Workflow-Blueprints bei konkret benötigten Modulen prüfen.
|
||||
- Ergebnisse umfassen nachvollziehbare **Quellreferenz, Quellstand, Verarbeitungsart und Prüfstatus**. Vorschläge (insbesondere Fristen und finanzielle Aussagen) werden nicht ungeprüft zu bestätigten Fakten oder automatischen Aktionen.
|
||||
- Wiederverwendbare Ergebnisse können persistiert werden; **reine Zwischenstände werden gelöscht**. Speicherort nach Datenrichtlinie, nicht generell lokal.
|
||||
- Die **Freigabe zur temporären externen Verarbeitung** ist ausdrücklich getrennt von der **Freigabe zur dauerhaften Cloud-Speicherung**.
|
||||
- Konkrete priorisierte KI-Use-Cases bleiben Produktentscheidungen; Beispiele begründen noch keine umfassende Workflow-Engine.
|
||||
|
||||
### 3.6 Storage (erweiterter Fähigkeitenbereich)
|
||||
- Storage dient der **konfigurierbaren, sicheren Ablage und dem autorisierten Abruf** von Artefakten: z.B. `.eml`-Archivkopien, strukturierte KI-Extraktionen, Zusammenfassungen, OCR-Volltexte oder temporäre Verarbeitungsdateien.
|
||||
- Storage ist **kein eigenes DMS**, keine Pflichtspiegelung aller Quelldaten und keine Wissens- oder Workflow-Engine.
|
||||
- Physische Speicherdienste können **lokal** (z.B. NAS, Dateisystem, objektbasierter Speicher) oder **zentral** bereitgestellt werden, soweit Datenrichtlinien dies zulassen.
|
||||
- Fachliche Zuordnung, Herkunft und Prüfstatus verwaltet Tsumugu als **Result Management**; die Storage-Schicht verwaltet Ablage, Abruf, Integrität, Lebensdauer und Löschanforderungen. Result Management ist zunächst eine logische Funktion, **kein neuer Pflicht-Microservice**.
|
||||
- Sonderregel IMAP bleibt bestehen: Aktivierte `.eml`-Archivkopien liegen **nur an einem konfigurierbaren lokalen Ablageort**, auch bei SaaS-Nutzung.
|
||||
|
||||
## 4. Ressourcen- und Referenzmodell
|
||||
|
||||
**Logische Konzepte – kein endgültiges Datenbankschema:**
|
||||
|
||||
| Konzept | Bedeutung |
|
||||
|---|---|
|
||||
| `Resource` | Tsumugu-interne stabile Identität eines referenzierten fachlichen Elements |
|
||||
| `ResourceLocator` | Einer von mehreren Zugriffswegen zur Ressource (z.B. IMAP-Original, NAS-Archivkopie) |
|
||||
| `ResourceMetadata` | Quellmetadaten, normalisierte Suchfelder und Herkunft; Tsumugu-eigene Metadaten fachlich getrennt |
|
||||
| `CollectionBinding` | Referenz auf Container/gespeicherte Abfrage mit Zuordnung zu einer Akte und dynamischer Mitgliedschaft |
|
||||
| `ConnectorInstance` | Konkrete konfigurierte Verbindung samt Identität, Fähigkeiten und Datenrichtlinien |
|
||||
| `DataPolicy` | Erlaubte Speicherung, Übertragung und Verarbeitung je Datenklasse/Connector-Instanz |
|
||||
|
||||
**Ressourcen-Lebenszyklus:** Eine live entdeckte Ressource muss nicht automatisch dauerhaft gespeichert werden. Eine explizit zugeordnete Ressource erhält eine stabile Referenz. Ressourcen können zusätzlich durch ausdrücklich konfigurierte Indexierung aufgenommen werden.
|
||||
|
||||
**Identität und Kopie:** IMAP-Original und gesicherte `.eml`-Kopie können mehrere Locator derselben Tsumugu-Ressource sein. Ein E-Mail-Anhang, der separat in Paperless eingegangen ist, ist grundsätzlich eine **eigene**, möglicherweise verknüpfte Ressource, nicht automatisch identisch. Ähnliche Inhalte werden nicht ungeprüft zusammengelegt.
|
||||
|
||||
**Änderungen:** Externe Pfade sind nicht notwendigerweise stabile IDs. Bei fehlendem Original bleibt die Aktenreferenz erhalten und zeigt einen differenzierten Auflösungs-/Verfügbarkeitsstatus; wo vorhanden wird eine autorisierte alternative Repräsentation genutzt.
|
||||
|
||||
## 5. Aktenzuordnung und dynamische Sammlungen
|
||||
|
||||
Festgelegt sind drei Grundfälle:
|
||||
|
||||
1. **Einzelreferenz:** bewusstes, dauerhaftes Verknüpfen einer Ressource mit einer oder mehreren Akten; bei Quellverschiebung bleibt die Verknüpfung bestehen.
|
||||
2. **Statische Auswahl:** aktuell ausgewählte Elemente werden einzeln referenziert; sie sind unabhängig von späterer Sammlungsmitgliedschaft.
|
||||
3. **Dynamische Sammlung:** Ordner, Sammlungen oder geeignete gespeicherte Suchregeln können Akten zugeordnet werden. Aktuelle und später hinzukommende passende Ressourcen werden dynamisch angezeigt, **ohne Originaldaten zu importieren**.
|
||||
|
||||
**Wichtige Abgrenzung:** Eine dynamische Sammlung erzeugt nicht zwingend dauerhafte Einzelreferenzen. Explizite Einzelreferenzen bleiben auch dann erhalten, wenn eine Ressource die Sammlung verlässt. Automatische KI-Bearbeitung/Fristauslösung wird daraus nicht abgeleitet.
|
||||
|
||||
**Noch offen:** Ob einzelne `CollectionBindings` bei Verlassen der Sammlung optional ein dauerhaftes Referenzieren aller bisherigen Mitglieder erlauben. Die zuletzt besprochene Empfehlung war *live/dynamisch als Standard, dauerhafte Übernahme optional*; dieser Zusatz wurde **nicht ausdrücklich endgültig entschieden**.
|
||||
|
||||
## 6. Datenhoheit, selektiver Index und temporäre Verarbeitung
|
||||
|
||||
| Datenklasse | Grundverhalten |
|
||||
|---|---|
|
||||
| Originaldokumente, E-Mail-Original, Dateien | Verbleiben in führender Quelle |
|
||||
| Quellreferenzen und technische IDs | Bei Verknüpfung dauerhaft in Tsumugu |
|
||||
| Tsumugu-eigene Akten, Notizen, Beziehungen, Aufgaben, Fristen, Finanzzuordnungen | Dauerhafte Tsumugu-Daten |
|
||||
| Relevante Quellmetadaten | Selektiv und freigegeben indexierbar für Suche/Fristen/Navigation |
|
||||
| Volltexte, OCR, PDFs, Vorschauen | Kein generelles permanentes Spiegeln; auf Abruf, bei Bedarf temporär |
|
||||
| KI-Arbeitstexte/-Zwischenergebnisse | Zweckgebunden und kurzlebig; definierter Standort, Aufbewahrung und Löschung |
|
||||
| KI-abgeleitete Metadaten | Vorschlag mit Herkunft/Prüfstatus; selektiv bestätigte Fakten in Tsumugu nutzbar |
|
||||
| Wiederverwendbare KI-Artefakte / Analysen | Optional dauerhaft im lokalen oder zentralen Artifact Storage, gemäß Daten- und Verarbeitungsrichtlinie |
|
||||
| `.eml`-Archivkopie | Nur am konfigurierten lokalen Ablageort, nicht im SaaS-Dateispeicher |
|
||||
| Zugangsdaten einer lokalen Quelle | Vertrauenswürdige lokale Connector Runtime; nicht als Nutzdaten an SaaS senden |
|
||||
|
||||
**Verbindliche SaaS-Option:** Kunden können **jede dauerhafte Cloud-Speicherung von Dokumentinhalten und KI-Artefakten deaktivieren**. Dann verbleiben zentral nur Tsumugu-eigene Akteninformationen, freigegebene Metadaten und Referenzen. Dies bedeutet **nicht**, dass bei gesondert genehmigter externer Analyse niemals Daten übertragen werden. Temporäre Übertragungen, Caches und Logs sind separat zu kontrollieren.
|
||||
|
||||
**Datenrichtlinien** gelten **pro Connector-Instanz und Datenklasse** und unterscheiden mindestens: *dauerhaft speichern*, *temporär zwischenspeichern*, *für Live-Funktion übertragen*, *an externen Processor weitergeben*. Konkrete Feldlisten/Schutzprofile werden **bei Implementierung des jeweiligen Connectors** festgelegt, nicht als globales Vollschema aller Quellen.
|
||||
|
||||
**Metadatenhoheit (bestätigt):** Quellmetadaten werden bei vorhandenen Schreibrechten **im führenden Quellsystem** bearbeitet; nach Erfolg wird der Tsumugu-Index aktualisiert. Tsumugu-eigene Felder bleiben separat. Kein automatisches Zurückschreiben von Tsumugu-Feldern in die Quelle. Bei konkurrierenden Änderungen möglichst Konflikterkennung statt stiller Überschreibung.
|
||||
|
||||
**Aktualisierung (bestätigte Richtung):** Bedarfsgesteuert beim Öffnen, ereignisbasiert wenn möglich und/oder periodisch. Standardmäßig referenzierte Ressourcen und dynamische Sammlungen; optionale umfassendere Indexierung. Live-Suche des gesamten berechtigten Quellbestands bleibt unabhängig davon möglich.
|
||||
|
||||
## 7. IMAP: dauerhafte Referenzen und optionale `.eml`-Sicherung
|
||||
|
||||
**Verbindlich beschlossen:** Jede IMAP-Connector-Instanz erhält eine Archivierungsoption:
|
||||
|
||||
| Modus | Verhalten |
|
||||
|---|---|
|
||||
| `automatic` (**Standard**) | Explizite Zuordnung einer E-Mail zu einer Akte löst lokale `.eml`-Sicherung aus |
|
||||
| `manual` | Sicherung nur auf Nutzeraktion |
|
||||
| `disabled` | Keine `.eml`-Archivierung |
|
||||
|
||||
- Bloße Mitgliedschaft in einer dynamischen Sammlung löst **keine automatische Sicherung** aus.
|
||||
- `.eml` wird über lokale Runtime am konfigurierbaren Ablageort, z.B. NAS, gesichert; nicht im zentralen SaaS.
|
||||
- Akteneintrag kann IMAP-Original und lokale Archivkopie als alternative Locator derselben Ressource kennen.
|
||||
- Erfolg erst nach geprüfter Ablage melden; Integritätsmerkmal (z.B. Prüfsumme), Zeitpunkt und Fehlerstatus festhalten.
|
||||
- Archivkopie ist **nicht automatisch revisionssicheres Archiv oder vollständige Backupstrategie**.
|
||||
- Der Zugriff auf lokale Archivkopien ist ebenfalls zu autorisieren; keine Erhöhung von Berechtigungen durch bloße Existenz einer Kopie.
|
||||
|
||||
## 8. Berechtigungs- und Sichtbarkeitsmodell
|
||||
|
||||
Der effektive Zugriff auf eine externe Ressource setzt voraus:
|
||||
|
||||
1. die Erlaubnis durch **Tsumugu** (Datenraum, Akte, Freigabe bzw. Connector-Nutzung), **und**
|
||||
2. die Berechtigung der **verwendeten Quellidentität** sowie die jeweilige Connector-Fähigkeit.
|
||||
|
||||
Pro Connector-Instanz können **individuelle Benutzerzugänge** oder ein **verwalteter gemeinsamer Zugang** genutzt werden. Bei gemeinsamem API-Key/Service-Konto darf dessen technischer Zugriff nicht unkontrolliert auf alle Tsumugu-Nutzer übertragen werden. Der Kontext des aufrufenden Nutzers und die zulässige Delegation sind bei jeder Operation relevant.
|
||||
|
||||
Die Suche und Navigation umfassen grundsätzlich den **vollständigen durch diese Rechte erreichbaren Quellbestand**, nicht bloß bereits gespeicherte Referenzen. Eine Aktenfreigabe allein darf keine unberechtigten externen Inhalte offenlegen. Offline-Status und fehlende Quellrechte müssen unterscheidbar angezeigt werden.
|
||||
|
||||
## 9. Präsentationsvertrag und UI-Grenze
|
||||
|
||||
Connectoren sollen neben Daten und Fähigkeiten **deklarative UI-Metadaten** liefern können (Ressourcentyp, Felder und Feldtypen, Labels, erlaubte Operationen, Navigationsstruktur, verfügbare Vorschau- oder Editorarten).
|
||||
|
||||
**Bevorzugte Stufen:**
|
||||
1. **Generische Tsumugu-Komponenten:** Baum/Navigation, Liste/Tabelle, Suche/Filter, Detail/Metadaten, Vorschau, Formular/Metadateneditor.
|
||||
2. **Registrierte, Tsumugu-eigene Spezialansichten:** z.B. E-Mail-Thread, Buchungsdetails oder PDF-Viewer, soweit fachlich nötig.
|
||||
3. **Von Connectoren gelieferter ausführbarer Frontend-Code:** **nicht Bestandteil der anfänglichen Zielarchitektur**; später nur bei nachgewiesenem Bedarf und mit eigenem Sicherheitskonzept.
|
||||
|
||||
Ziel ist **kein universeller Low-Code-UI-Generator** und keine vollständige Nachbildung der Oberflächen von Paperless, E-Mail-Clients oder Bankportalen. Der volle **berechtigte Datenbestand** ist navigier-/durchsuchbar; Bearbeitung wird nur für konkret angebotene Fähigkeiten umgesetzt.
|
||||
|
||||
## 10. Querschnittsfähigkeiten und Vertragsgrenzen
|
||||
|
||||
**Gemeinsamer Minimalvertrag für Source-artige Connectoren (konzeptionell):**
|
||||
- Identität, Instanz und angebotene Fähigkeiten ermitteln.
|
||||
- Navigation/Listen und Suche innerhalb der Quellrechte.
|
||||
- Ressource auflösen, Metadaten lesen, Inhalt/Vorschau bei Fähigkeit abrufen.
|
||||
- Unterstützte Schreib-/Exportoperationen autorisiert ausführen.
|
||||
- Änderungen erkennen bzw. selektiven Index aktualisieren, soweit unterstützt.
|
||||
- Verständliche Zustände melden: nicht erreichbar, nicht berechtigt, nicht auffindbar, veraltet, Konflikt, Fehler.
|
||||
|
||||
**Kein falscher Universalvertrag:** Banking benötigt transaktionale Semantik, KI einen Processing-Vertrag und lokaler Storage einen Ablage-/Abrufvertrag. Gemeinsame Technik wird nur bei konkret gemeinsamem Bedarf herausgezogen.
|
||||
|
||||
**Sicherheitsgrenzen:** Quellzugangsdaten geschützt verwahren; starke Authentisierung der lokalen Runtime gegenüber SaaS; Autorisierung pro Operation; keine willkürlichen Dateipfade und keine überprivilegierten Service-Accounts; sichere Vorschau/Rendering; kontrolliertes Egress und Löschung temporärer Daten. Konkrete Technologieentscheidungen werden in den zuständigen technischen Blueprints geprüft.
|
||||
|
||||
## 11. Storage- und Result-Management-Architektur (konsolidiert v0.2)
|
||||
|
||||
### 11.1 Verantwortlichkeiten
|
||||
|
||||
| Baustein | Verantwortlichkeit | Nicht seine Aufgabe |
|
||||
|---|---|---|
|
||||
| **Tsumugu Core / Result Management** | Verknüpft Ergebnis mit Akte/Ressource, kennt Herkunft, Quellstand, Status, Zugriffsrechte, Wiederverwendbarkeit und Speicherreferenz | Große Artefakte ungefragt in die Core-Datenbank aufnehmen |
|
||||
| **Artifact Storage** | Speichert/liest/löscht Inhalte, gewährleistet Integritätsprüfung, Version-/Ablagebezug und geregelte Retention | Fachliche Rechnungsinterpretation oder KI-Entscheidungen |
|
||||
| **Connector Runtime** | Autorisierter Zugriff auf lokale Quellen/Speicher; führt lokal erlaubte Ablage und Abholung aus | Umgehung von Quellrechten oder Datenrichtlinien |
|
||||
| **Processing Connector** | Erzeugt Ergebnisse aus explizit autorisierten Eingaben | Legt Datenresidenz oder Aufbewahrung eigenmächtig fest |
|
||||
|
||||
Das Modell unterstützt **eine fachliche Ressource mit mehreren Zugriffspfaden** (z.B. IMAP und gesicherte `.eml`-Kopie) und **mehrere aus ihr abgeleitete Artefakte** (z.B. OCR-Text, Extraktions-JSON, Zusammenfassung). Diese sind nicht mit dem Original identisch und müssen nicht im selben Speicher liegen.
|
||||
|
||||
### 11.2 Speicherentscheidung
|
||||
|
||||
**Kein pauschaler Vorrang lokaler Ablage.** Eine lokale Runtime kann langsam oder zeitweise unerreichbar sein; bei externer KI-Verarbeitung werden erlaubte Inhalte ohnehin zeitweise übertragen. Die Datenschutzwirkung hängt daher stärker vom **gesamten Datenfluss, Schlüsselzugriff und Verarbeitungsort** als nur vom physischen Speicherort ab.
|
||||
|
||||
Grundsätzliche Speicheroptionen:
|
||||
- **SaaS-/Managed-Storage:** Für ausdrücklich freigegebene abgeleitete Ergebnisse; gute serverseitige Verfügbarkeit. Verschlüsselung und kontrollierte Löschung sind Pflicht. Serverseitige Verschlüsselung allein bedeutet nicht, dass der Betreiber keine Klartextzugriffsmöglichkeit besitzt.
|
||||
- **Lokaler Storage:** Für sensible Inhalte oder Nutzerpräferenzen; lokale Verfügbarkeit hängt von Runtime/NAS und Verbindung ab. Lokale Verarbeitung kann tatsächliche Übertragung vermeiden.
|
||||
- **Hybrid:** Auswahl nach Datenklasse und Connector-Instanz, getrennt nach Speicherung, temporärem Zugriff und externer Verarbeitung.
|
||||
|
||||
**SaaS-Cloud-Content-Opt-out ist verbindlich:** Originalinhalte und KI-Artefakte müssen ohne dauerhafte Cloud-Speicherung verwendbar sein. Die dafür benötigten Tsumugu-eigenen Akteninformationen und freigegebenen Metadaten bleiben separat behandelbar.
|
||||
|
||||
### 11.3 Mindestfähigkeiten des Storage-Vertrags
|
||||
|
||||
1. **`put/get/delete`** für typisierte Artefakte (Dateien, Text, JSON etc.), nur nach Autorisierung und Policy-Prüfung.
|
||||
2. **Referenzen und alternative Speicherorte** statt ungefragter Binärkopien im Core; stabile Zuordnung zu Quellressource und ggf. Verarbeitungsstand.
|
||||
3. **Integrität und nachvollziehbarer Status:** Prüfsumme, erfolgreiche bestätigte Ablage, Unterscheidung zwischen vorhanden, nicht erreichbar, nicht autorisiert und nicht mehr vorhanden.
|
||||
4. **Version und Herkunft:** Ergebnis kann einem bestimmten Quell-/Analysezustand zugeordnet und bei Quelländerung als möglicherweise veraltet erkannt werden.
|
||||
5. **Aufbewahrung und Löschung:** Dauerhaft vs. befristet, Löschung inklusive geregelter Cache-/Backup-Fristen; keine falsche Garantie sofortiger physischer Löschung aller Sicherungskopien.
|
||||
6. **Sichere lokale Speicherpfade und Schlüsselverwaltung:** Kein vom Client frei vorgebbarer Dateisystempfad, keine Rechteausweitung durch Archivkopien.
|
||||
7. **Kontrollierbare Abrufwege:** Bei lokaler Ablage kann SaaS die Referenz anzeigen, aber Inhalte nur bei erreichbarer und autorisierter lokaler Runtime ausliefern.
|
||||
|
||||
Keine Pflicht zur universellen Dateiversionierung, geografischen Replikation, komplexen Storage-Abstraktion oder zentralen Search-Index-Engine für den MVP.
|
||||
|
||||
### 11.4 Wiederverwendung von KI-Ergebnissen
|
||||
|
||||
Ein Analyseergebnis darf nur dann als aktuell wiederverwendet werden, wenn Verarbeitungsaufgabe, Quellstand und Prüfstatus geeignet sind. Der Core verwaltet knappe, relevante Ergebnis-Metadaten; das größere Artefakt kann lokal oder zentral liegen. Fachliche Bestätigungen (z.B. ein akzeptierter Rechnungsbetrag) werden als Tsumugu-Daten geführt und nicht mit unbestätigten KI-Vorschlägen vermischt.
|
||||
|
||||
### 11.5 Betriebliche Mindestfragen – zur Umsetzung, nicht jetzt als Plattformprojekt
|
||||
|
||||
Für den Hybridbetrieb bleiben drei technische Klärungen: **(a)** sicherer SaaS-zu-Lokal-Kanal, vorzugsweise ohne eingehende Kundenports, **(b)** Autorisierung jeder Aktion einschließlich gemeinsamer Quellkonten, **(c)** Einrichtung, Updates und Verbindungs-/Versionskompatibilität der lokalen Runtime. Verfügbarkeit und erwartbare Abrufgeschwindigkeit sind bei der ersten produktiven Hybridstrecke praktisch zu messen.
|
||||
|
||||
---
|
||||
|
||||
## 12. Technische Referenzarchitektur und Umsetzungsmodus
|
||||
|
||||
Der separate Jinkendo-Architektur-Workstream betreut technische Standards/Blueprints (u.a. Auth/Scopes, Release/Recovery, KI-Gateway/Privacy, Workflows, Entitlements/Quotas, Medien/Rendering). **Tsumugu** liefert die fachlichen Modulanforderungen. Bei größeren Modulen wird zunächst geprüft, ob vorhandene Jinkendo-Implementierungen und Blueprints anwendbar sind. Neue Spezial-Blueprints nur **bei Bedarf**; keine pauschale Blueprint-Produktion. Konzepte sind nicht automatisch getestet oder produktionsreif.
|
||||
|
||||
**Schlanker Realisierungspfad (Vorschlag, keine freigegebene Roadmap):**
|
||||
1. Erstes durchgängiges Source-Szenario mit Paperless: Navigation/Suche → Referenzieren → Metadaten → Akte/Preview → Quell-Edit, falls nötig.
|
||||
2. Gemeinsame `Resource`/`Locator`/Berechtigungs-/Datenpolicy-Prinzipien anhand IMAP inkl. optionaler `.eml`-Sicherung validieren.
|
||||
3. Dynamische CollectionBindings, lokale Hybrid-Runtime und selektiver Index nach echten Use Cases absichern.
|
||||
4. Banking read-only und KI/Processing jeweils als begrenzte eigene Integrationen ergänzen.
|
||||
|
||||
Die Reihenfolge steht unter fachlichem MVP-Vorbehalt und ist keine Verpflichtung, alles vor dem ersten Release zu bauen.
|
||||
|
||||
## 13. Nur noch wesentliche offene Architekturfragen
|
||||
|
||||
| Thema | Klärung bei | Warum relevant |
|
||||
|---|---|---|
|
||||
| Hybrid-SaaS ↔ lokale Runtime: Verbindung, Vertrauensgrenze, Live-Zugriff | Vor Hybrid-Implementierung | Sicherheit, Erreichbarkeit, Datenschutz |
|
||||
| Datenprofile pro konkreter Connector-Instanz, inkl. Vorschau, Suche, Cache/Logs | Je Connector-Implementierung | Wirkliche Datenkontrolle statt nur Marketingversprechen |
|
||||
| Identität/Recovery beim Verschieben von IMAP-/Datei-Ressourcen | Bei IMAP-/Datei-Anbindung | Haltbare explizite Referenzen |
|
||||
| Rechte auf Akten-/Unterakten-/Ressourcenebene und Delegation gemeinsam genutzter Quellzugänge | Vor Mehrnutzer-Freigabe | Keine Datenlecks |
|
||||
| Dynamische Sammlung: optionale dauerhafte Übernahme bei Austritt | Wenn benötigt | Bewusst nicht festgelegt |
|
||||
| Konkrete KI-Use-Case-Priorität, Eingabe-/Ergebnisumfang und Freigaben | Vor KI-Funktion | Verarbeitung und fachliche Korrektheit |
|
||||
| Artifact-Storage-Adapter, Verschlüsselung/Schlüsselmodell, Retention und tatsächliche Löschwege | Vor Storage-Implementierung | Datenhoheit, Verfügbarkeit und Compliance |
|
||||
| Banking-Anbieter/Einwilligung und Datenfeldumfang | Vor Banking-Funktion | Technische und rechtliche Realisierbarkeit |
|
||||
|
||||
**Bewusst nicht jetzt vertiefen:** generisches Plugin-Sandboxing für UI-Code, universelle Editor-DSL, vollautomatisches Daten-Mirroring, jede mögliche Synchronisationskonfliktklasse, universelle KI-Workflow-Engine, zentraler Lizenz-/Billingdienst.
|
||||
|
||||
## 14. Status- und Entscheidungsspur
|
||||
|
||||
**Festgelegt in der aktuellen Unterhaltung (einschließlich Entscheidungen nach v0.1):** Dualer Betriebsansatz Self-Hosted/SaaS; Hybrid mit lokaler Runtime als bevorzugte Richtung; Daten überwiegend in Quellen; vollständige berechtigte Navigation/Suche; Rechte aus Quellsystem und Tsumugu; individuelle und gemeinsam verwaltete Quellzugänge; unterschiedliche Connector-Fähigkeiten; generische UI vor Connector-Frontend-Code; eigene Notizen/selektive Metadaten in Tsumugu; zeitweise Textverarbeitung; Referenzen und dynamische Sammlungen; explizite Referenzen trotz Ordnerwechsel; IMAP `.eml`-Archivmodi mit `automatic` als Standard, Archiv ausschließlich lokal; Quellmetadaten im Quellsystem editieren, eigene Tsumugu-Felder getrennt; standardmäßig referenzierte Ressourcen und dynamische Sammlungen aktualisieren, Vollindex optional; Banking zunächst read-only, keine gesamte Buchungshistorie standardmäßig, nur zugeordnete Buchungsreferenzen/-metadaten persistent; KI-Processing mit Text, Bild, PDF und strukturierten Daten sowie lokalen/externen Anbietern; bestehende OCR bevorzugt, multimodale PDF-/Bildinterpretation möglich; sechs grundlegende KI-Aufgaben, kombinierbare Verarbeitungsschritte, Wiederverwendung mit Herkunft/Prüfstatus; Ergebnisse lokal **oder** zentral nach Policy speicherbar; separate Datenfreigabe für externe Verarbeitung; ausdrücklicher SaaS-Schalter zum vollständigen Verbot dauerhafter Cloud-Speicherung von Dokumentinhalten und KI-Artefakten; Storage mit Artifact-Ablage, Integrität, Retention und Result Management.
|
||||
|
||||
**Architekturvorschläge, noch keine eigenständigen Beschlüsse:** Namen der logischen Objekte und APIs; konkrete UI-Deklarationsstruktur; drei konkrete Betriebsvarianten als technische Deployments; technischer Umsetzungsplan; Cache-TTLs, Protokolle und Feldlisten; optionale Sticky-Sammlung; konkrete API-Signaturen und Speichertechnologien, Verschlüsselungs-/Schlüsselimplementierung und Retrieval-/Verfügbarkeits-SLOs.
|
||||
|
||||
**Dokumentpflege:** Jede neue Entscheidung soll gezielt im betroffenen Abschnitt und in dieser Entscheidungsspur ergänzt werden. Keine stillschweigende Umdeutung der Tsumugu-Produkt-Baseline oder Erhebung einer Tsumugu-Lösung zum allgemeinen Jinkendo-Standard.
|
||||
@@ -0,0 +1,61 @@
|
||||
# Bestandsaufnahme Gitea und Runner (P7, Schritt 1)
|
||||
|
||||
**Stand:** 22.10.2026 · Auftrag: [Release-Gate, Backup und Restore](../product/TSUMUGU_RELEASE_GATE_BACKUP_AUFTRAG_2026-10-22.md), Abschnitt 5.1 · Nur lesend erhoben, nichts am Server oder Pi verändert.
|
||||
|
||||
**Nachweisarten:** **B** = am Server beobachtet (anonyme API, öffentliche Job-Logs) · **D** = aus Gitea-Dokumentation für 1.22, am Server nicht ausprobiert · **O** = offen, braucht Admin-Zugang oder Sicht auf den Pi.
|
||||
|
||||
## 1. Gitea-Server `192.168.2.144:3000` (auch `gitea.stommer.de`)
|
||||
|
||||
| Punkt | Befund | Art |
|
||||
|---|---|---|
|
||||
| Version | Gitea **1.22.0** | B |
|
||||
| Sichtbarkeit des Repos | `Lars/tsumugu` ist **öffentlich**. Code, Pull Requests, Commit-Status und **Job-Logs** sind ohne Anmeldung lesbar (z. B. `/Lars/tsumugu/actions/runs/149/jobs/0/logs`). | B |
|
||||
| Branch-Schutz | `main` und `develop`: `protected=false`, keine Pflicht-Statuschecks, keine Pflicht-Reviews. Jeder mit Schreibrecht kann direkt auf `main` pushen und damit Prod deployen. | B |
|
||||
| Merge-Stile | Merge, Rebase, Squash und Fast-Forward-only sind erlaubt; Default `merge` | B |
|
||||
| Bisheriger Release-Weg | PR #1–#8 `develop → main`, jeweils von `Lars` gemergt. `main` steht auf `1bc464e` (18.10.2026). | B |
|
||||
| Statuskontexte | Gitea setzt sie als `<Workflow-Name> / <Job> (<Event>)`, z. B. `Test Suite / pytest-backend (push)`, `Deploy Production / deploy (push)`. Diese Namen wären als Pflichtchecks verwendbar. | B |
|
||||
| Pflicht-Statuschecks im Branch-Schutz | vorhanden, mit Mustern | D |
|
||||
| Menschliche Freigabe per Review | Gitea lässt keine Freigabe des eigenen PR zu. Bei einem einzigen Nutzer `Lars` ist „1 Approval nötig“ nicht erfüllbar. Als Freigabe bleibt der bewusste Merge des Release-PR durch eine Person auf der Merge-Whitelist. | D |
|
||||
| `jobs.<id>.environment` | wird ignoriert, ist kein Gate (Technische Spezifikation 8.2) | D |
|
||||
| `concurrency` in Workflows | in 1.22 nicht unterstützt. Serialisierung muss auf dem Host entstehen (`flock`). | D |
|
||||
| `workflow_dispatch` | Trigger vorhanden; Bedienung über Weboberfläche am Server noch nicht geprüft | D/O |
|
||||
| Effektive Rechte, Collaborators, Push-/Merge-Whitelist, Repo-Secrets | Anonym nicht lesbar (`branch_protections` → 401) | O |
|
||||
|
||||
## 2. Runner
|
||||
|
||||
| Punkt | Befund | Art |
|
||||
|---|---|---|
|
||||
| Runner | `Raspi5-Paperless`, act_runner **v0.2.11**, Label `ubuntu-latest` | B (Job-Log) |
|
||||
| Ausführungsmodus | **Host-Modus.** Die Logs zeigen kein Job-Image und kein `docker pull`; die Schritte arbeiten direkt in `/home/lars/docker/tsumugu*` und rufen `docker compose` des Hosts auf. | B |
|
||||
| Isolation | **Keine.** Jeder Job läuft als Nutzer des Runners auf dem Pi mit Zugriff auf den Docker-Socket, also faktisch mit Root-Rechten. Er erreicht Prod-Checkout, `.env` mit `DB_PASSWORD`, Volumes `tsumugu-db-data` und `tsumugu-media` sowie die Stacks der anderen Produkte auf demselben Pi. | B |
|
||||
| Mitbenutzung | Die Job-Nummern (8466, 8795) deuten auf einen Runner für mehrere Repositories. Workflows anderer Produkte haben damit dieselbe Reichweite auf Tsumugu-Prod. | B (Indiz) / O |
|
||||
| Parallelität | Dev-Deploy und Test liefen auch bisher gleichzeitig; Kapazität des Runners nicht gesehen | O |
|
||||
| Untrusted Code | Heute startet kein Workflow bei `pull_request`. Ein Fork-PR führt daher keinen Code aus. **Das muss so bleiben**, solange der Runner im Host-Modus läuft und das Repo öffentlich ist. | B |
|
||||
| Werkzeuge auf dem Pi | `age`, `flock`, freier Platz, Ziel für eine Kopie außerhalb des Hosts | O |
|
||||
|
||||
## 3. Weitere Beobachtungen für P7
|
||||
|
||||
- Die öffentlichen Job-Logs sind ein Kanal nach außen. Backup-, Restore- und Deploy-Schritte dürfen dort keine Secrets, Dateinamen aus der Medienablage oder Inhalte ausgeben.
|
||||
- `backend/Dockerfile` enthält `tests/` nicht; heute läuft pytest im Laufzeitimage nach `pip install` gegen den eingehängten Checkout (R-27). Für „das gebaute Image testen“ braucht es eine Test-Stufe, die auf genau diesen Image-Schichten aufsetzt.
|
||||
- Basisimages sind nicht gepinnt (`python:3.12-slim`, `postgres:16-alpine`, Frontend-Basis). Zwei Builds desselben Commits können sich unterscheiden.
|
||||
- Der Migrator kapselt jede Datei in eine eigene Transaktion. Scheitert Datei *n*, bleiben 1…*n−1* committed. `docker compose up` hat den alten Backend-Container dann schon ersetzt; Prod steht still, bis ein Rückweg greift.
|
||||
- Zwischen `main` (Prod) und `develop` liegen sieben Migrationen, darunter `20261021T150000Z_room_shares.sql` mit der nicht umkehrbaren Entfernung von `visibility`. Der nächste Merge nach `main` ist damit der erste, für den ein Backup vor der Migration zwingend ist.
|
||||
- Für die Kontenquarantäne nach Restore gibt es schon `auth_accounts.status` (`active`/`disabled`) und die Tabelle `auth_sessions`.
|
||||
|
||||
## 4. Folgerungen für den Entwurf
|
||||
|
||||
1. **Gate im Prod-Workflow selbst, nicht im Branch-Schutz allein.** Der Branch-Schutz kann Pflichtchecks und eine Merge-Whitelist erzwingen, das ist ein guter Zusatz. Weil der Runner aber jeden Workflow eines Branches ausführt, prüft `deploy-prod` selbst: Merge-Commit stammt aus einem gemergten PR, der Develop-Stand hat einen grünen Qualifikationsnachweis im Host-Verzeichnis, Trees stimmen überein, frisches Backup liegt vor. Fehlt etwas, bricht der Lauf vor jeder Änderung ab.
|
||||
2. **Menschliche Freigabe** = Merge des Release-PR durch `Lars` (Merge-Whitelist). Ein zusätzliches Review ist bei einem einzigen Nutzer technisch nicht möglich.
|
||||
3. **Qualifikationsnachweise** liegen in einem Host-Verzeichnis außerhalb der Checkouts. Workflows können es trotzdem beschreiben; die Herkunft sichert nur der Branch-Schutz plus der Umstand, dass nur `develop`- und `main`-Pushes Workflows starten. Diese Grenze wird im Runbook benannt, nicht kaschiert.
|
||||
4. **Testlauf** als eigenes Compose-Projekt je Lauf (`tsumugu-test-<run>`), eigene Postgres ohne Hostport, Aufräumen auch bei Fehler. Serialisierung über `flock`, weil `concurrency` fehlt.
|
||||
5. **Keine Workflows mit `pull_request`-Trigger** auf diesem Runner.
|
||||
|
||||
## 5. Offene Punkte für den Nutzer
|
||||
|
||||
| Nr. | Frage | Warum |
|
||||
|---|---|---|
|
||||
| O-1 | Bleibt das Repository öffentlich? | Öffentliche Job-Logs; ein privates Repo senkt das Risiko ohne Umbau |
|
||||
| O-2 | Branch-Schutz für `main` setzen (kein direkter Push, Merge nur `Lars`, Pflichtcheck auf den Qualifikationslauf)? | Gitea-Einstellung, nur durch den Nutzer |
|
||||
| O-3 | Lesender Blick auf den Pi: Runner-Konfiguration (`config.yaml`, Kapazität), Nutzer des Runners, `age`/`flock` vorhanden, freier Platz | Nicht anonym ermittelbar; ich habe keinen SSH-Zugang |
|
||||
| O-4 | Ziel der Kopie außerhalb des Hosts (z. B. Synology `192.168.2.63`) und Transportweg | Lieferpunkt 4 |
|
||||
| O-5 | Wo liegt der private `age`-Schlüssel (nicht auf dem Pi, nicht in CI)? | Lieferpunkt 4, Blueprint 10.3 |
|
||||
@@ -0,0 +1,48 @@
|
||||
# Ergänzung zum Cursor-Auftrag: vollständige Connector-Kapselung
|
||||
|
||||
**Stand:** 19.10.2026 · **Verbindliche Präzisierung aus dem aktuellen Nutzerauftrag**
|
||||
**Vorgesehener Ort:** `C:/Dev/tsumugu/docs/product/TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md`
|
||||
|
||||
Diese Ergänzung präzisiert Abschnitt A des Connector-/Storage-Auftrags und den technischen Vertrag v0.1. Sie hat Vorrang vor Formulierungen, die einen nur teilweise integrierten Zwischenstand als Abschluss zulassen. Laufende geeignete Implementierungen weiterverwenden; kein Neustart und keine vollständige Neuspezifikation.
|
||||
|
||||
## 1. Erwartetes Ergebnis
|
||||
|
||||
Ein funktionierendes Tsumugu mit vollständig integrierten, standardisiert angebundenen Paperless-/IMAP-Connectoren und gekapselter eigener Dateiablage. Neue Connectoren müssen durch ein eigenes Modul, Registrierung und gegebenenfalls eigene UI-Ergänzungen hinzukommen können. Der normale Erweiterungsweg verlangt keine Änderungen an Akten-/Vorgangslogik, generischen Lesern, Berechtigungslogik oder Exportabläufen.
|
||||
|
||||
Der private Ersteinsatz begrenzt den benötigten Funktionsumfang. Er rechtfertigt keine verbliebenen Quellsonderfälle im allgemeinen Anwendungscode. Erweiterte Paperless-Suche, neue MD-Dateischreibfunktionen, Remote-Runtime, produktive Verschlüsselung und KI bleiben die bereits ausgewiesenen späteren Funktionsausbauten. Die technische Anbindung der heute unterstützten Funktionen wird in Abschnitt A vollständig abgeschlossen.
|
||||
|
||||
## 2. Vollständige Kapselung
|
||||
|
||||
**Connector-Modul:** Manifest, Konfiguration und Validierung, Verbindungsprüfung, Navigation/Suche, Mapping, Ressourcenauflösung, Metadaten, Vorschau, Original-/Anlagenabruf, Fehlerübersetzung und angebotene Schreiboperationen gehören zum zuständigen Modul. Fähigkeiten müssen die tatsächlich ausführbaren Operationen beschreiben. Nicht vorhandene Funktionen bleiben ausdrücklich nicht verfügbar.
|
||||
|
||||
**Generischer Anwendungsdienst:** Verifizierte Identität, Datenraum, Handlungskontext, Objekt-/Freigaberechte und DataPolicy steuern alle Operationen. Connector und Quellidentität können weiter einschränken. Weder Quelle noch UI dürfen eine globale Freigabe oder einen Rechtebypass einführen. Bestehender Owner-vermittelter Einzelabruf bleibt erhalten, ohne Suchrechte auf den übrigen Quellenbestand zu erzeugen.
|
||||
|
||||
**UI-Modul und Standardkomponenten:** Gemeinsame Hüllen für Verbindung, Browser/Auswahl, Vorschau, Übernahme und Editorzustände müssen integriert funktionieren. Quellenspezifische Filter, Navigation, Metadatenansichten und besondere Leser/Editoren sind registrierte Ergänzungen im jeweiligen Modul. Die bestehenden visuellen Regeln bleiben erhalten. Das bloße Registrieren zweier weiterhin speziell in Fachseiten verdrahteter Picker genügt nicht.
|
||||
|
||||
**Generische Leser und Export:** Verfügbare Repräsentationen, Metadaten und Operationen kommen aus den Verträgen. PDF, Bild, Mail, Text oder Markdown werden über registrierte Darstellungen ausgewählt. Kein Quellname bestimmt im allgemeinen Reader, welchen Spezialendpunkt er direkt aufruft. Export, Anlagen und Versandnachweise verwenden denselben autorisierten Inhaltszugriff.
|
||||
|
||||
**Storage:** Eigene Uploads, Originaldownloads aus eigenem Speicher und Versandfassungen verwenden den Storage-Vertrag. Direkte Pfad-/Dateioperationen außerhalb des zuständigen Ablageadapters werden bereinigt. Aktuelle Rechte, Inhaltsrevisionen, Speicherfehler und spätere Schlüsselzuständigkeit bleiben berücksichtigt. Eine bloße Schnittstelle neben weiter aktiven alten Dateipfaden erfüllt die Lieferung nicht.
|
||||
|
||||
## 3. Wo Quellkenntnis zulässig ist
|
||||
|
||||
Quellnamen und Protokolldetails sind zulässig im jeweiligen Connector-/UI-Modul, seinen Tests, der expliziten Registrierung, gezielten historischen Migrationen und der Dokumentation. Der Composition Root darf die verfügbaren Module registrieren. Generische Fachseiten, zentrale Schemas, Datenbank-Prüflisten, Reader oder Export dürfen keine Liste aller Connector-Typen kennen müssen, die bei jeder weiteren Quelle erweitert werden muss.
|
||||
|
||||
Die einmalige Umstellung auf Registry-basierte Typvalidierung gehört zu diesem Schnitt. Unbekannte Typen und Fähigkeiten werden geschlossen abgewiesen. Quellenspezifische Konfigurations- und Anfragefelder validiert das registrierte Modul. Eine Registrierung ersetzt keine fachlichen Berechtigungen.
|
||||
|
||||
Altrouten dürfen während der Migration auf den neuen Dienst delegieren. Bei Abschluss dürfen sie nur dokumentierte Kompatibilitätshüllen ohne eigene Protokoll-, Rechte- oder Ressourcenauflösungslogik sein. Unbenutzte Altpfade und doppelte aktive Implementierungen entfernen. Eine Textsuche nach Quellnamen allein beweist weder Vollständigkeit noch einen Fehler; Fundstellen nach ihrer Verantwortung beurteilen.
|
||||
|
||||
## 4. Konkrete Abschlussnachweise
|
||||
|
||||
1. **Bestehendes System:** Paperless und IMAP tatsächlich über die neue Anbindung bedienen: einrichten/prüfen, navigieren/suchen im heute unterstützten Umfang, auswählen, vor beziehungsweise nach Einbindung wie unterstützt lesen, einbinden, herunterladen und exportieren. Dateien, Notizen, Anlagen, Unterkapitel und gesicherte Versandstände funktionieren weiterhin. Keine neuen Sackgassen oder nur nominell verfügbaren Fähigkeiten.
|
||||
2. **Weiterer Connector:** In der isolierten Testumgebung einen kleinen dritten Source-Adapter ergänzen. Er liefert Testkonfiguration, Suche/Navigation, Metadaten, Textvorschau und Originalabruf über Standardkomponenten. Einbinden, erneutes Öffnen und Export funktionieren. Dafür nur das Testmodul und seine Backend-/Frontend-Registrierung hinzufügen; keine Änderung an Fachseiten, zentralen Quell-Enums, Reader oder Export. Kein dritter produktiver Dienst und keine eigens für den Test gebaute Sonderoberfläche.
|
||||
3. **Erweiterungsweg dokumentieren:** Die für diesen Test tatsächlich geänderten Dateien auflisten. Daraus eine kurze Anleitung für einen neuen Connector ableiten. Zusätzliche Ressourcenformate dürfen neue registrierte Darstellungen benötigen; das ist von einem Source-Adapter mit bereits unterstützten Formaten zu unterscheiden.
|
||||
4. **Rechte:** Quelle, Kontext und Operation manipulieren; fehlende Quell-/Objekt-/Freigaberechte und Entzug prüfen. Ein nicht freigegebener Inhalt bleibt auch über Preview, Downloads und Export geschützt. Eine nicht unterstützte Schreiboperation wird serverseitig verweigert.
|
||||
5. **Storage und spätere Schlüssel:** Zwei Storage-Adapter gegen denselben Vertrag prüfen; bestehende Referenzen bleiben stabil. Ein gesperrtes Schutzprofil wird nicht serverseitig als Klartext geöffnet. Dies ist ein Vertragsnachweis, kein Nachweis implementierter Verschlüsselung.
|
||||
6. **Migration und Betrieb:** Bestands-IDs, Dateien und Referenzen erhalten; doppelte Quell-IDs verschiedener Instanzen korrekt auflösen; mehrdeutige Altreferenzen sicher behandeln. Relevante Tests und Build bestehen. Keine produktiven Datenbanken für Tests ändern.
|
||||
7. **Reststellenprüfung:** Quell-/Storage-Sonderfälle im allgemeinen Anwendungscode gezielt suchen, einordnen und bereinigen. Abschließend kurze Fundstellenliste der verbleibenden, zulässigen Quellkenntnis liefern. Keine umfassende neue Repositoryinventur.
|
||||
|
||||
## 5. Übergabe und Aufwand
|
||||
|
||||
Bestehende Implementierung gegen diese Kriterien prüfen und nur die belegten Lücken schließen. Keine zusätzlichen Fähigkeiten zur Erfüllung abstrakter Vollständigkeit erfinden. Tests gezielt erweitern; bestandene Prüfungen nur bei neuen Änderungen oder ungelösten Fehlern erneut breit ausführen. In einer kompakten Abschlussmatrix pro Kriterium Nachweis, Ergebnis und verbleibende Grenze nennen.
|
||||
|
||||
Wenn ein Kriterium technisch blockiert ist, den konkreten Blocker und seine Auswirkung benennen. Einen teilweise gekapselten Stand nicht als fertige Basis deklarieren. Diese Ergänzung autorisiert keinen Push, kein Deployment und kein Kontaktieren anderer Sessions.
|
||||
@@ -0,0 +1,118 @@
|
||||
# Abschlussmatrix der Connector-Kapselung
|
||||
|
||||
**Stand:** 19.10.2026. Die Kriterien stehen in [TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md](TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md) und haben Vorrang vor dem Zwischenstand in [TSUMUGU_CONNECTOR_BASIS_ERGEBNIS_2026-10-19.md](TSUMUGU_CONNECTOR_BASIS_ERGEBNIS_2026-10-19.md).
|
||||
|
||||
Kein Push und kein Deployment. Die Suite lief gegen `tsumugu_local_test`: **71 Tests, Exitcode 0**. Der Produktionsbau des Frontends ist durchgelaufen. Paperless und IMAP sind in den Tests nachgebildet. Es gab keinen Abruf einer lebenden Anlage.
|
||||
|
||||
**Korrektur am selben Tag:** Der Start hat die Module noch nicht geladen. Bestehende Referenzen ohne gespeicherte Instanz blieben `unresolved`, Akte und Vorgang zeigten sie als nicht zugeordnet. Die Vorbereitung registriert die Module jetzt vor dem Abgleich. Ein eindeutiger Bestand wird gebunden und lässt sich wieder öffnen. Mehrere Zugänge ohne gespeicherte Instanz bleiben bewusst offen, die Akte selbst bleibt lesbar. Liste, Prüfung und Suche sehen nur Zugänge des angemeldeten Kontos. Ein freigegebener Vorgang nutzt den Zugang des Owners nur für die konkrete Referenz und nur mit `use_owner_sources`. Die Suite dazu: **74 Tests, Exitcode 0**.
|
||||
|
||||
## Matrix
|
||||
|
||||
| Kriterium | Nachweis | Ergebnis |
|
||||
|---|---|---|
|
||||
| Bestehendes System über die neue Anbindung | Suite, darunter `test_connector_basis.py`, `test_owner_sources.py`, `test_export.py`, `test_mailboxes.py`, `test_correspondence.py` | Bestanden. Einrichten, Prüfen, Suche und Fachnavigation, Lesen, Einbinden, Download und Export laufen über die registrierten Module. Dateien, Notizen, Anlagen, Unterkapitel und Versandfassungen bleiben in derselben Suite grün. |
|
||||
| Vollständige Kapselung | `sourceregistry.py`, `sources.py`, generische Routen in `api/sources.py`, Reader über `preview.media` | Bestanden für die heute unterstützten Formate. Fähigkeiten beschreiben die ausführbaren Operationen. Nicht erklärte Filter und unbekannte Arten antworten `422`. |
|
||||
| Weiterer Connector | `backend/tests/test_sample_source.py` | Bestanden. Der Testadapter `sample` sucht, zeigt Text, bindet, öffnet die Bytes erneut und exportiert sie. Fachseiten, Schema, Reader und Export enthalten die Art nicht. |
|
||||
| Erweiterungsweg | dieselben Testdateien und `frontend/src/sources/sample-source.js` | Bestanden. Anleitung unten. Kein dritter produktiver Dienst und keine Sonderoberfläche. |
|
||||
| Rechte | derselbe Test plus die bestehende Owner-Suite | Bestanden. Fremder Abruf ist 404. Ohne `use_owner_sources` bleibt das Original unerreichbar. Mit der Freigabe liefert der Zugang des Owners nur diese Referenz. Nach Entzug wieder 404. Eine Notizbearbeitung der Referenz ist serverseitig `unsupported`. |
|
||||
| Storage und Schutzprofil | `test_connector_basis.py` | Bestanden als Vertragsnachweis. Zwei Adapter, stabile Referenzen, gesperrtes Profil ohne Klartext. Keine implementierte Verschlüsselung. |
|
||||
| Migration und Betrieb | Migration `20261019T150000Z_source_registry.sql`, bestehende Bestandsfälle, Frontend-Build | Bestanden. Prüflisten der Arten sind entfernt. Produktive Datenbanken wurden nicht verwendet. |
|
||||
| Reststellen | gezielte Suche in Fachseiten, Reader, Export, Schema und Ablage | Bereinigt, soweit die Fundstelle eine Typenliste war. Zulässige Fundstellen stehen unten. |
|
||||
|
||||
## Anleitung für einen neuen Connector
|
||||
|
||||
Für den Nachweis wurden nur diese Dateien neu angelegt:
|
||||
|
||||
- `backend/tests/sample_source.py` registriert das Modul im Testprozess und wieder ab.
|
||||
- `backend/tests/test_sample_source.py` prüft Konfiguration, Suche, Vorschau, Einbindung, erneutes Öffnen, Export und Rechte.
|
||||
- `frontend/src/sources/sample-source.js` trägt dasselbe Modul in die Oberflächenregistrierung ein. Die Anwendung importiert diese Datei nicht.
|
||||
|
||||
Ein produktiver Connector folgt demselben Schnitt:
|
||||
|
||||
1. Ein Modul liefert Konfiguration, Prüfung, Suche, optional Navigation und Vorschau, Originalabruf und Export. `register_source` hängt es im Composition Root ein.
|
||||
2. Die Fähigkeiten nennen nur Operationen, die das Modul ausführt. Die generische Suche lehnt andere Filter ab.
|
||||
3. Die Oberfläche ruft `registerSourceModule` auf. Ohne eigenes Formular oder ohne eigene Auswahl gilt die Standardhülle. `manual` erlaubt die schlichte Referenzerfassung. Eine bereits unterstützte Darstellung (`pdf`, `image`, `text`, `email`) braucht keinen neuen Reader.
|
||||
4. Ein bisher nicht dargestelltes Format braucht eine neue registrierte Darstellung. Das ist kein Eingriff in Akten, Vorgänge oder den Exportablauf.
|
||||
5. Die Art kommt nicht in eine Datenbankprüfliste und nicht in ein zentrales Enum.
|
||||
|
||||
## Zulässige verbleibende Quellkenntnis
|
||||
|
||||
- Protokoll, Konfiguration und Auswahl von Paperless und IMAP in `backend/app/sources.py` und `frontend/src/pages/Sources.jsx`.
|
||||
- Kompatibilitätsrouten `/api/v1/sources/paperless/documents` und `/api/v1/sources/imap/*`. Sie delegieren an dieselbe Suche, Navigation und Vorschau.
|
||||
- Die Darstellung `email` liest über die bestehenden Mail-Endpunkte. Deren Bytes liefert heute das IMAP-Modul. Eine weitere Quelle mit den Darstellungen `pdf`, `image` oder `text` braucht diese Endpunkte nicht.
|
||||
- Historische Migrationen, Testdoubles und die Dokumentation.
|
||||
- Der Paperless-Dateizugriff auf ein lokales Archiv bleibt im Connector-Modul. Eigene Uploads und Versandfassungen schreiben über den Storage-Port. Die Anfrage räumt danach nur Pfade ab, die der Adapter selbst veröffentlicht hat. Die Fixture-Bereinigung löscht Bestandsdateien an derselben Objektkennung.
|
||||
|
||||
## Grenzen vor der Nacharbeit
|
||||
|
||||
Dieser Absatz beschreibt den Stand vor der Nacharbeit am selben Tag. Die Anfrage-Transaktion umfasste damals noch den Quellabruf. Zugangsdaten liegen als Klartext in `connectors.secret`. Es gibt keine neue Verschlüsselung und keinen Remote-Speicher. Der Testadapter ist kein produktiver Dienst.
|
||||
|
||||
## Nacharbeit am 19.10.2026
|
||||
|
||||
Auftrag: [TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md](TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md). Die historische Suite oben bleibt unverändert. Die neue Suite `tests` lief danach mit **82 Tests, Exitcode 0**. Der Paperless-Filtertest wurde nach der Relevanzzuordnung einzeln erneut ausgeführt und ist grün. Der Frontend-Build ist durchgelaufen. Kein Push und kein Deployment.
|
||||
|
||||
IMAP, Paperless-Treffer und der Speicheradapter in `test_connector_followup.py` sind nachgebildet. Das ist kein lebender Postfach- oder Dokumentabruf. Die laufende Paperless-Instanz `paperless-webserver-1` wurde nur am Schema gelesen: Paperless-ngx **2.20.6**. `query` ist die Volltextsuche, `title__icontains` das eigene Titelfeld, `tags__id__all` die Und-Verknüpfung, `created` das Dokumentdatum neben `added` und `modified`. `score` ist kein Sortierfeld. Eine Suche ohne `ordering` ist dort die Relevanzreihenfolge. Dokumentinhalte wurden nicht gelesen.
|
||||
|
||||
| Paket | Nachweis | Ergebnis |
|
||||
|---|---|---|
|
||||
| A Gemeinsamer Zugriff, Darstellung, Speicher | `sourceaccess.py`, Briefkasten-Test ohne IMAP, Speicherstest über `adapter_for` | Bestanden in der nachgebildeten Suite. Upload, erneutes Lesen, Versandfassung, Export und Löschen laufen über die aufgelöste Instanz. Fehlende Instanzzeile bleibt der bisherige lokale Pfad. |
|
||||
| B IMAP-Seiten | `test_large_folder_is_bounded_and_a_late_hit_is_not_empty`, Fehler- und UIDVALIDITY-Tests | Bestanden gegen den nachgebildeten Server. Ein Fach mit Lücken bleibt seitenweise begrenzt. Ein Treffer hinter der ersten Seite ist kein leeres Fach. NO, abgebrochene Köpfe und ein UIDVALIDITY-Wechsel sind eigene Zustände. Ein lebendes Postfach wurde nicht geprüft. |
|
||||
| C Paperless-Suche | Filtertest und Schema 2.20.6 | Bestanden gegen den nachgebildeten Abruf und das gelesene Schema. Inhalt, Titel, Korrespondent, Typ, mehrere Tags, Dokumentdatum, Seite 3 und zwei Instanzen derselben Dokumentnummer sind getrennt. Eine Suche in den echten Dokumenten steht aus. |
|
||||
| D Markdown-Notiz | Notiztest und Browser am lokalen Testkonto | Bestanden für gemeinsamen Text, Export, Leserecht und Konflikt. Die formatierte Bearbeitung mit `@mdxeditor/editor` 3.52.4, MIT, ist im Browser geöffnet worden: Leiste, Quelltextumschaltung, gespeicherte Ansicht, Abbrechen. Ein Listenstrich und ein Stern gelten beim Öffnen als dieselbe Liste. Jede andere Abweichung bleibt im Quelltext. `markdown_file` bleibt aus. |
|
||||
|
||||
## Anleitung für ein weiteres Modul
|
||||
|
||||
Ein Quellenmodul registriert sich mit `register_source` und liefert nur Fähigkeiten, die es ausführt. Die Oberfläche ruft `registerSourceModule` auf und ersetzt die Registrierung nicht. Eine bekannte Darstellung wird mit `registerRepresentation` gebunden; die Notiz nutzt `markdown` → `note` und erscheint nicht unter Quellen. Ein Speicheradapter kommt in die Fabrik von `adapter_for` und wird über die gespeicherte Instanz aufgelöst. Ein Editor hängt an derselben Ressourcenansicht. Fachseiten, Rechte und das Schema zählen die Art nicht auf.
|
||||
|
||||
## Weiterhin zulässige Quellkenntnis
|
||||
|
||||
- Protokoll, Konfiguration, Suche und Auswahl von Paperless und IMAP in `backend/app/sources.py` und `frontend/src/pages/Sources.jsx`.
|
||||
- Die Kompatibilitätsrouten delegieren an dieselben Dienste.
|
||||
- Die Darstellung `email` öffnet das registrierte Modul und danach den gemeinsamen Mail-Leser.
|
||||
- Stammdaten, Seitenzahl und Vorschau bleiben an Instanz und Recht gebunden.
|
||||
- Historische Migrationen, Testdoubles und diese Dokumentation.
|
||||
|
||||
## Laufzeit und Erweiterbarkeit
|
||||
|
||||
Der Netzwerkabruf wird vor dem externen Aufruf aus der offenen Fachtransaktion gelöst und danach auf Recht und Instanz geprüft. Große IMAP-Fächer lesen begrenzte UID-Fenster, nicht die gesamte Liste je Seite. Paperless-Seiten sind die eigene Seitennummer, keine weitergereichte Fortsetzungsadresse. Die Erweiterung um eine Quelle, eine Darstellung oder einen Editor braucht kein neues Rechtsschema. Eine neue Speicherart braucht eine Fabrik und bleibt an die gespeicherte Instanz gebunden. Es gibt keine zusätzliche Verschlüsselung und keinen weiteren Produkt-Speicher.
|
||||
|
||||
## Korrektur am 20.10.2026
|
||||
|
||||
Auftrag: [TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md](TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md). Die Befunde vom selben Tag bleiben unverändert. Die historische Suite oben bleibt unverändert. `tests/test_correction_k1_k7.py` lief danach mit 7 bestandenen Tests. Export, Connector-Nacharbeit und Connector-Basis liefen in derselben lokalen Testdatenbank mit 26 bestandenen Tests. Die Versandtests liefen mit 3 bestandenen Tests. Der Frontend-Build ist durchgelaufen. Kein Push und kein Deployment.
|
||||
|
||||
Die Bedienprüfung lief gegen eine lokale API mit nachgebildetem IMAP und einem verzögerten Paperless-Stellvertreter. Das ist keine Prüfung des bestehenden Postfachs und keine Dokumentabfrage der bestehenden Paperless-Instanz.
|
||||
|
||||
| Korrektur | Geändertes Verhalten | Nachweis | Ergebnis | Grenze |
|
||||
|---|---|---|---|---|
|
||||
| K1 Ordnernamen | Fachnamen, die kein IMAP-Atom sind, werden gequotet. `INBOX` bleibt ungequotet. Ein Fach mit gemeldetem Bestand und leerer abgeschlossener Liste gilt nicht als leer. | Synthetisch: `test_mailbox_names_are_quoted_protocol_strings`, `test_a_filled_folder_with_spaces_is_not_reported_empty`. Bedienung: der Stellvertreter erhielt `INBOX` und `"Sent Items"`; Sent Items zeigte Nachrichten und die Richtung Ausgang. | Synthetisch und in der Bedienung bestanden. | Das bestehende Postfach mit mehr als 4.000 Nachrichten wurde nicht gelesen. |
|
||||
| K2 MIME | Eine Auswertung für Vorschau, Leser und Export. Anzeigename und Archivname sind getrennt. HTML wird bereinigt; die Textfassung ist gekennzeichnet. Eine angehängte Nachricht bleibt eine Anlage. | Synthetisch: `test_parse_mail_keeps_names_html_and_attached_messages`, `test_preview_below_and_above_the_limit_uses_the_same_parts`. Bedienung: Tabelle, `A & B`, Dateiname `Buero Uebergabe.pdf`, keine Skripte, keine fremde Bildadresse, Textfassung sichtbar. | Synthetisch und am Stellvertreter bestanden. | Keine Nutzermail. Bytezahl und SHA-256 zwischen Download, ZIP und Originalanlage einer betroffenen Mail sind nicht verglichen. |
|
||||
| K3 Transaktion | IMAP-Lesen, Export und Dateiveröffentlichung laufen ohne offene Fachtransaktion. Der Fachabschluss folgt danach. Ein fehlgeschlagener Abschluss lässt weder den Eintrag noch die veröffentlichten Bytes stehen. | Synthetisch: `test_upload_and_mail_fetch_leave_the_domain_transaction` sah `IDLE` am Upload und am Mailabruf. `test_failed_conclusion_keeps_no_partial_file` ließ keinen Eintrag und keine Prüfbytes zurück. Die bestehenden Versandtests blieben grün. | Für diese beiden Grenzen bestanden. | Entzug während der Veröffentlichung und ein gleichzeitiger Versionskonflikt sind nicht eigens geprüft. |
|
||||
| K4 Markdown | Der Leser nutzt einen Markdown-Renderer für die Ebenen 1–6, verschachtelte Listen und den Listenstart. HTML, `javascript:`-Links und externe Bilder werden nicht ausgeführt. | Markup-Prüfung der Leserhülle. Bedienung: gespeicherte Notiz mit den genannten Strukturen, Vorschau aus dem Quelltext, Abbrechen stellt die Ansicht wieder her. Bei 360 und 390 px kein Überlauf, Schaltfläche 44 px. | Lesen und Quelltextvorschau bestanden. | Die formatierte Leiste öffnete diese Notiz nicht, weil sie den gespeicherten Text verändert hätte. Der Quelltext blieb maßgeblich. |
|
||||
| K5 Registrierung | Die Leserhülle ruft die registrierte Darstellung auf. Die Beispielquelle bringt Formular und Registrierung in ihrem eigenen Modul mit und erscheint in der Produktauslieferung nicht. | Die Leserhülle rendert die Testdarstellung und speichert über den registrierten Testeditor. Bedienung mit `?probe=1`: Beispielquelle verbinden, nach „Proben“ suchen, übernehmen, öffnen, erneut öffnen, Übergabepaket prüfen und herunterladen. Der Download antwortete mit 200; der Prüfstand nannte `Probenbrief/Probenbrief.txt`. | Bestanden in der Testoberfläche. | Die Beispielquelle ist kein Produktzugang. |
|
||||
| K6 Paperless-Antworten | Eine verspätete Suche oder Facette schreibt nicht in die inzwischen gewählte Instanz. Der Instanzwechsel leert Filter und Trefferliste. | Bedienung am Stellvertreter: Suche auf „Alt“ starten, zu „Neu“ wechseln, die späte Antwort abwarten. Zugang, leere Suche und Facette blieben bei Neu. Die anschließende Suche zeigte „Treffer Neu“. Schließen während einer laufenden Suche ließ die Vorgangsliste unverändert. | In der Bedienung bestanden. | Keine echte Paperless-Instanz. |
|
||||
| K7 Filter und reale Quellen | Der synthetische Paperless-Abruf filtert den Katalog nach Inhalt, Titel, Metadaten, Datum und Seite. | `test_paperless_filters_change_the_hits`: nur der Inhaltstreffer, nur Titel „Vertrag“, die kombinierte Teilmenge und die zweite Seite unterscheiden sich. | Synthetisch bestanden. | Weder die bestehende Paperless-Dokumentabfrage noch das bestehende Postfach wurden ausgeführt. Schema-Lesen vom 19.10. ersetzt das nicht. |
|
||||
|
||||
## Konfigurationsansicht am 20.10.2026
|
||||
|
||||
Die Konfiguration einer Instanz gehört dem Modul. Ein Modul deklariert `config_fields` (`ConfigField` in `backend/app/sourceregistry.py`) und optional `normalize_config` für Protokollprüfungen. `parse_fields` validiert Pflicht, Typ, Grenzen und unbekannte Schlüssel; ein leeres Geheimnisfeld behält das gespeicherte. `/api/v1/sources/capabilities` liefert die Felder unter `modules`. Die Oberfläche (`frontend/src/sources/config-form.jsx`, `connector-config.jsx`, Route `sources/:connectorId`) rendert sie generisch; ein Modul kann mit `Form` im UI-Registereintrag eine eigene Maske mitbringen. Paperless (Adresse, API-Schlüssel) und IMAP (Server, Port, Verbindung, Benutzer, Passwort, Standardfach) sind darauf umgestellt; die flachen Felder der ersten Lieferung bleiben nur als Kompatibilität in `ConnectorIn`.
|
||||
|
||||
Neuer Connector: Modul mit `config_fields` in `register_source` eintragen, UI-Modul mit `registerSourceModule` registrieren. Kein Eingriff in `ConnectorIn`, `Sources.jsx` oder die Fachseiten.
|
||||
|
||||
Nachweis und Grenzen: `backend/tests/test_connector_config.py` (Manifest, Geheimnis, Instanzerhalt, Fremdzugriff, Prüfstand) und `frontend/src/sources/config-core.test.mjs` (6 Node-Tests bestanden), Frontend-Build erfolgreich. Die Backend-Tests wurden in dieser Umgebung **nicht ausgeführt** (kein Python, keine PostgreSQL-Instanz). Keine Bedienprüfung im Browser. Zugangsdaten bleiben im Klartext (R-05); Archivmodus und DataPolicy sind nicht Teil dieses Schnitts.
|
||||
|
||||
## Paperless-Suche, Erweiterung am 24.10.2026
|
||||
|
||||
Auf Wunsch des Nutzers erweitert über den Umfang von Abschnitt C des Nacharbeitsauftrags hinaus: Suchart (Titel und Inhalt als Standard ohne Index, nur Titel, nur Inhalt, Volltextindex), Speicherpfad, Tag-Verknüpfung (alle, mindestens eines, keines), „ohne“ bei Korrespondent, Typ und Pfad, Hinzugefügt-Datum, Archivnummer und Zusatzfelder. Dazu eine Trefferkarte mit Vorschaubild, Textauszug, Tags, Typ und Seitenzahl sowie ein großer Dialog mit Filtern links und Treffern rechts. Zusatzfeld-Abfragen waren im Auftrag ausdrücklich kein Pflichtumfang und sind hier auf Nutzerwunsch dazugekommen.
|
||||
|
||||
**Verantwortung im Modul:** Die Filternamen eines Moduls deklariert `SourceModule.search_params` (Parametername auf Fähigkeitsflag). Die gemeinsame Suchroute kennt keinen Filternamen mehr. Sie reicht alle übrigen Abfrageparameter weiter und weist jeden ab, den das Modul nicht deklariert oder dessen Fähigkeit nicht wahr ist. Das gilt auch für unbekannte Parameter. Das Vorschaubild ist eine optionale Modulfähigkeit (`SourceModule.thumbnail`, Route `/api/v1/sources/{kind}/thumbnail`, Flag `search.result_preview`). Ein Modul ohne Deklaration lehnt es mit `422` ab.
|
||||
|
||||
**Verbleibende Quellkenntnis im allgemeinen Code (zulässig):** Die Kompatibilitätsrouten `/api/v1/sources/paperless/documents` und `.../preview` in `backend/app/api/sources.py` delegieren nur und tragen keine eigene Protokoll- oder Rechtelogik. Die Fähigkeiten von Paperless und IMAP stehen jetzt in `backend/app/sources.py` beim jeweiligen Modul; `backend/app/sourceport.py` enthält nur noch die Editorfähigkeiten und die Nutzlasten. Die unbenutzte Liste `UNSUPPORTED_SEARCH` und `unsupported_filters` sind entfernt. In der Oberfläche liegt der Paperless-Auswahldialog in `frontend/src/pages/Sources.jsx` und wird über `registerSourceModule` (`large: true`) eingehängt; Fachseiten und Modal kennen nur das allgemeine Flag.
|
||||
|
||||
| Nachweis | Ergebnis |
|
||||
|---|---|
|
||||
| Backend-Suite gegen `tsumugu_local_test` (eingebettete PostgreSQL, Wegwerf-Umgebung) | **164 Tests bestanden** |
|
||||
| `test_connector_followup.py`: Parameterübertragung je Filter, Standardsuche, Textauszug, Namensauflösung, Zusatzfelder samt Ablehnung ungültiger Eingaben, fremder Filter und unbekannter Parameter `422`, Vorschaubild nur für Raster, fremde Instanz `404` | bestanden, gegen Attrappe |
|
||||
| Bedienung im Browser (Chrome headless, Desktop 1440×900 und 390×844) gegen die echte Oberfläche, die echte API und einen nachgebildeten Paperless-HTTP-Server: Dialoggröße, Suche, Vorschaubilder, Textauszug, Ansicht in der Karte, unvollständige Zusatzfeld-Zeile meldet statt zu senden, Zusatzfelder gehen als `custom_field_query` hinaus, Blättern erhält die Auswahl, Einfügen, keine Konsolenfehler | 38 von 38 Prüfungen bestanden. Dabei ist ein Überlappen von Filtern und Treffern auf 390 px gefunden und behoben worden. |
|
||||
|
||||
**Grenze:** Keine der Prüfungen lief gegen die echte Paperless-Instanz. Die Parameternamen (`title_content`, `tags__id__none`, `storage_path__id`, `added__date__gte`, `archive_serial_number`, `custom_field_query`) stammen aus der Kenntnis der Paperless-ngx-API und stehen am Stellvertreter, nicht an der Nutzerinstanz belegt. Die Flags `custom_fields` und `result_preview` sind damit nur durch Code und Attrappe ausführbar belegt. Offen sind insbesondere der Wert eines Betragsfelds (reine Zahl ohne Währung), der Textauszug im Volltextindex und die Mindestversion für Zusatzfeld-Abfragen. Eine Prüfung an der echten Instanz braucht eine ausdrückliche Freigabe.
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
# Tsumugu – Ergebnis der Connector-/Storage-Grundlage
|
||||
|
||||
**Stand:** 19.10.2026. Dies ist der Zwischenstand vor den Abschlusskriterien. Maßgeblich für den Abschluss ist [TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md](TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md). Die Kriterien stehen in [TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md](TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md) und haben Vorrang vor Formulierungen, die eine teilweise Integration als Abschluss zulassen.
|
||||
|
||||
Lokale Umsetzung von Abschnitt A aus [TSUMUGU_CONNECTOR_UMBAU_AUFTRAG_2026-10-19.md](TSUMUGU_CONNECTOR_UMBAU_AUFTRAG_2026-10-19.md) nach [TSUMUGU_CONNECTOR_STORAGE_VERTRAG_v0.1_2026-10-19.md](../architecture/TSUMUGU_CONNECTOR_STORAGE_VERTRAG_v0.1_2026-10-19.md).
|
||||
|
||||
Das ist ein Implementierungsnachweis, keine neue Fachversion. F-02b und F-02c bleiben. Abschnitt B, also der vervollständigte Quellenbrowser, die erweiterte Paperless-Suche und ein Editor für Markdown-Dateien, ist nicht begonnen.
|
||||
|
||||
Es gab keinen Push und kein Deployment.
|
||||
|
||||
## Übernommene Dokumente
|
||||
|
||||
Aus dem Paket `TSUMUGU_CONNECTOR_PLANUNG_2026-10-19.zip` liegen unverändert im Repository:
|
||||
|
||||
- `docs/architecture/TSUMUGU_CONNECTOR_STORAGE_VERTRAG_v0.1_2026-10-19.md`
|
||||
- `docs/architecture/Tsumugu_Connector_Suite_Architektur_v0.2.md`
|
||||
- `docs/architecture/TSUMUGU_STORAGE_SCHLUESSEL_PRUEFAUFTRAG_2026-10-19.md`
|
||||
- `docs/product/TSUMUGU_CONNECTOR_UMBAU_AUFTRAG_2026-10-19.md`
|
||||
|
||||
Die Begleitdatei `README.md` im Paket ist ein Deckblatt und wurde nicht über die Projekt-README gelegt. Der Prüfauftrag an die Architektur-Session wurde nur abgelegt, nicht versandt.
|
||||
|
||||
## Was die Grundlage jetzt tut
|
||||
|
||||
- Paperless und IMAP sind registrierte Adapter über den bestehenden Protokollcode. Ein POST legt eine weitere Instanz an. Ein PATCH ändert Zugangsdaten derselben Id.
|
||||
- Eine externe Referenz trägt `connector_id` ohne Fremdschlüssel und `resolution` (`bound`, `ambiguous`, `unresolved`, `none`). Dieselbe externe Nummer in zwei Instanzen bleibt getrennt. Ein gelöschter Zugang wird nicht auf eine andere Instanz umgehängt. Mehrdeutiger Bestand bleibt mehrdeutig, bis der Owner zuordnet. Ein eindeutiger Bestand wird beim Anlegen und einmalig im Backfill gebunden.
|
||||
- Eine Suche ohne `connector_id` ruft bei mehreren eigenen Paperless-Instanzen die Quelle nicht auf. Nicht erklärte Filter antworten `422` mit Code `unsupported`. IMAP behält Fach, Stichwort und Fortsetzung über `before`.
|
||||
- Ein Empfänger mit `use_owner_sources` liest das ausdrücklich freigegebene Original über den gebundenen Zugang des Owners. Zugangsdaten und die übrigen Treffer werden nicht ausgeliefert. Ohne diese Freigabe bleibt das Original unerreichbar.
|
||||
- Eigene Dateien und Versandfassungen laufen über den lokalen Storage-Port. Die Referenz trägt Instanz, Generation, Objektkennung und Inhaltsrevision. Schutzprofil und Schlüsselzuständigkeit liegen daneben. Der Bestand ist `legacy-plaintext` mit Schlüsselzuständigkeit `none`. Ein anderer `MEDIA_ROOT` erzeugt eine neue Schreibgeneration und liest die alte Generation weiter an der gebundenen Wurzel.
|
||||
- Profile `managed-encrypted` und `client-encrypted` liefern Metadaten und verweigern Klartext. Es gibt keine neue Verschlüsselung. Ein gespeicherter Dummy-Geheimtext, der unverändert zurückgelesen wird, ist kein Kryptographienachweis.
|
||||
- Die Oberfläche hängt die vorhandenen Paperless- und E-Mail-Auswahlen an eine gemeinsame Registrierung. Der Notizeditor bleibt der bestehende PATCH. `markdown_file` ist erklärt und nicht angeboten.
|
||||
|
||||
## Tests
|
||||
|
||||
Backend-Suite am 19.10.2026 gegen die lokale Datenbank `tsumugu_local_test`: **69 Tests, Exitcode 0**. Eine DeprecationWarning aus Starlette/anyio, kein Fehlschlag. Die sieben neuen Fälle in `backend/tests/test_connector_basis.py` prüfen Adapter-Rundlauf und Pfadabwehr, einen Wurzelwechsel ohne Umhängen, stabile Datei-Id und Bytes, die Ablehnung einer Notizbearbeitung an einer Datei, zwei Paperless-Instanzen mit derselben Nummer 15, eine Suche ohne Instanz ohne Quellaufruf, einen abgelehnten Korrespondent-Filter ohne Echo des Werts, mehrdeutigen Bestand bis zur Zuordnung, ein gesperrtes Profil ohne Klartext und einen PATCH, der die andere Instanz nicht verändert.
|
||||
|
||||
Die bestehende Suite blieb in demselben Lauf grün, darunter Export, Kapitel, Rechte, Postfächer, Owner-Quellen und Versandfassungen. Paperless und IMAP sind in diesen Tests nachgebildet. Es gab keinen Abruf einer lebenden Paperless- oder IMAP-Anlage. Die Mocks belegen den Vertrag im Prozess, nicht die entfernte API-Fassung.
|
||||
|
||||
## Oberfläche
|
||||
|
||||
Der Produktionsbau des Frontends ist nach der Umbenennung der Registrierung nach `frontend/src/sources/registry.jsx` durchgelaufen.
|
||||
|
||||
Zusätzlich lief die Anwendung lokal auf `127.0.0.1:8019` mit Vite auf `127.0.0.1:5173` gegen die weggeworfene Datenbank `tsumugu_browser_test`. Port 8000 war auf diesem Rechner schon belegt. Geprüft wurde:
|
||||
|
||||
- die Quellenseite zeigt beide registrierten Formulare, „Paperless-Instanz verbinden“ und „Konto hinzufügen“
|
||||
- zwei Paperless-Instanzen und ein IMAP-Konto bleiben nebeneinander stehen
|
||||
- „Zugang erneuern“ an Archiv Alpha sendet PATCH an dieselbe Id; das Secret der zweiten Instanz bleibt unverändert
|
||||
- in der Akte verlangt die Paperless-Auswahl bei zwei Instanzen eine Wahl und nennt die heutige Stichwortgrenze
|
||||
- die E-Mail-Auswahl zeigt das angelegte Konto, die IMAP-Grenze und bei einem unerreichbaren Beispielhost „Das Postfach ist nicht erreichbar“, ohne erfundene Fächer
|
||||
- eine Notiz lässt sich anlegen und im Leser öffnen; nach einer zwischenzeitlich erhöhten Version antwortet das Speichern mit 409, der Satz „Der Stand hat sich geändert. Der eingegebene Text bleibt stehen. Bitte neu laden.“ erscheint, und der eingegebene Text bleibt im Feld
|
||||
- bei 390 Pixel Breite bleiben Quellenseite und Leser ohne seitlichen Überlauf der Seite bedienbar
|
||||
|
||||
Die Beispielhosts waren nicht die echten Quellen. Ein Vorgang wurde nicht separat angeklickt; er verwendet dieselbe Registrierung wie die Akte.
|
||||
|
||||
Der Testlauf und die lokale Oberfläche benutzten eine temporäre Superuser-Rolle auf dem lokalen PostgreSQL. Diese Rolle und die Wegwerfdatenbank sind danach entfernt. Der bestehende Migrator setzt das Passwort von `tsumugu_runtime` auf das Passwort des verbindenden Owners. Damit dieses Testpasswort nicht liegen bleibt, wurde das Passwort der Runtime-Rolle lokal rotiert und nicht festgehalten. Der nächste Start mit dem Operatorpasswort setzt es wieder, wie im Datenmodell zu R-09 beschrieben.
|
||||
|
||||
## Grenzen
|
||||
|
||||
- Die anfragegebundene Datenbanktransaktion umschließt weiterhin den Quellabruf und das lokale Schreiben. Die Datei wird erst nach einem geprüften Rundlauf veröffentlicht, und ein Rollback entfernt die neue Datei. Das ist keine getrennte Transaktion von Datenbank und Dateisystem.
|
||||
- Zugangsdaten bleiben Klartext in `connectors.secret` (Review R-05). Es gibt keinen Schlüssel-Tresor und keinen SaaS-Nachweis.
|
||||
- Der Prüfauftrag zur Schlüsselhaltung wurde nicht an die Architektur-Session geschickt.
|
||||
- Abschnitt B ist der nächste, getrennt zu startende Funktionsausbau.
|
||||
- Der Befund R-10 beschreibt den früheren Zustand, dass der Betrachter seinen eigenen Zugang benutzte. Der Lesepfad folgt jetzt der dort empfohlenen Bindung an den Owner. Der Befundtext selbst wurde nicht umgeschrieben.
|
||||
+141
@@ -0,0 +1,141 @@
|
||||
# Cursor-Auftrag: Connector-Kapselung abschließen, IMAP und Paperless verbessern, Markdown-Notizen bearbeiten
|
||||
|
||||
**Stand:** 19.10.2026
|
||||
**Zielort:** `C:/Dev/tsumugu/docs/product/TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md`
|
||||
**Status:** Umsetzungsauftrag nach Übergabe an Cursor, bis zur lokalen Prüfung. Dieses Dokument selbst ändert keine Anwendung. Kein Push und kein Deployment.
|
||||
|
||||
## 1. Ziel und Verbindlichkeit
|
||||
|
||||
Arbeite im vorhandenen Repository `C:/Dev/tsumugu`. Erhalte laufende Änderungen, Bestandsdaten, bestätigte Fachentscheidungen und die ausgewählte Gestaltung. Liefere ein funktionierendes System mit standardisiert erweiterbaren Connectoren und den drei konkret benötigten Verbesserungen. Eine Registrierung neben weiter bestehenden Sonderwegen genügt nicht.
|
||||
|
||||
Lies gezielt:
|
||||
|
||||
1. `AGENTS.md` und die einschlägigen Abschnitte der aktuellen `docs/product/TSUMUGU_PRODUCT_SPEC.md`, insbesondere gemeinsamer Notizinhalt, kontextbezogene Rechte, Quellen und Export.
|
||||
2. `docs/product/TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md` und die aktuelle Abschlussmatrix. Die Matrix ist eine zu prüfende Ergebnisbehauptung, keine Ausnahme von den Anforderungen.
|
||||
3. `docs/architecture/TSUMUGU_CONNECTOR_STORAGE_VERTRAG_v0.1_2026-10-19.md` und die Connector Suite v0.2 im selben Verzeichnis; ergänzend den bisherigen Umbauauftrag für bestehende Schnittstellen und Abnahme.
|
||||
4. Die betroffenen Architekturregeln und Blueprints unter **`docs/reference/`**, insbesondere Auth/Session/Scope, Medien/Dateien/sicheres Rendering und die Regeln zu kurzen Transaktionen in der Referenzarchitektur. Der Verzeichnisname ist `reference`, nicht `references`. Lokale Kopien verwenden; alte absolute Pfade in diesen Dokumenten sind kein Auftrag zur Änderung anderer Produkte.
|
||||
|
||||
Dieser Auftrag startet die hier beschriebene erweiterte Paperless-Suche ausdrücklich. Er erweitert die bisher zurückgestellte Notizbedienung. Er startet keine bidirektionale Paperless-Synchronisation und keine allgemeine MD-Dateischreibfunktion. Frühere gegenteilige Umfangsgrenzen sind nur für diese ausdrücklich genannten Funktionen überholt. Keine erneute vollständige Produktspezifikation oder Repositoryinventur.
|
||||
|
||||
## 2. Befund und gewünschtes Verhalten unterscheiden
|
||||
|
||||
**Nutzerbeobachtungen:** Große IMAP-Ordner erscheinen leer; auch einschränkende Suche liefert dort nichts. Die Paperless-Suche wirkt wie reine Titelsuche und bietet keine weiteren Eingrenzungen. Notizen sollen nach dem Speichern formatiert lesbar sein; gewünscht ist ein echter Markdown-Editor, bevorzugt auch direkte Bearbeitung in der formatierten Ansicht mit Schaltern.
|
||||
|
||||
**Gezielte Codebefunde vor Übergabe, erneut am tatsächlichen Arbeitsstand prüfen:**
|
||||
|
||||
- `backend/app/sources.py::_imap_page` ruft eine ordnerweite UID-Suche auf, wertet nur `data[0]` aus und liefert auch bei `status != OK` eine leere Trefferliste. `_fetch_header` verwirft einzelne Abruffehler still. Das belegt problematische Fehlerbehandlung; die konkrete Ursache im betroffenen Ordner ist noch nicht nachgewiesen.
|
||||
- `paperless_documents` sendet bereits `query` an `/api/documents/`, begrenzt auf 20 Ergebnisse und reicht keine Fortsetzung weiter. Daraus folgt **kein** Beweis einer technisch ausschließlich auf Titel beschränkten Suche. `_paperless_find` verwirft zusätzliche Optionen; der allgemeine Suchaufruf reicht Filter nicht vollständig weiter.
|
||||
- `MarkdownEditor` ist derzeit ein Textfeld mit einfacher Vorschau. Der Reader bleibt auch nach dem Speichern im Bearbeitungsformular. `frontend/src/markdown.jsx` enthält einen begrenzten selbstgebauten Renderer.
|
||||
- Der dritte Source-Test belegt Backend-Aufrufe und eine Frontend-Registrierung, aber keinen vollständigen Bedienablauf. Der zweite Storage-Adapter wird isoliert geprüft; die Anwendung erzeugt an mehreren Stellen weiterhin direkt `LocalAdapter`.
|
||||
|
||||
Reproduziere Fehler vor der Behebung und kennzeichne Vermutungen als solche. Kein Bericht darf aus synthetischen Tests einen erfolgreichen Abruf der echten Nutzerquelle ableiten.
|
||||
|
||||
## 3. A – Kapselung tatsächlich abschließen
|
||||
|
||||
### Quellen, Rechte und Inhaltszugriff
|
||||
|
||||
- Protokoll, Konfiguration, Suchoptionen, Navigation, Ressourcenauflösung, Mapping und Fehlerübersetzung gehören zum registrierten Connector-Modul. Quellspezifische Formulare und Filter gehören zu dessen UI-Modul. Gemeinsame Seiten setzen diese Module zusammen.
|
||||
- Ein gemeinsamer Zugriffsdienst verantwortet Tsumugu-Identität, Datenraum, Kontextrechte, konkrete Quellinstanz und erlaubte Owner-Vermittlung. Ein neuer Adapter darf diese Freigabe- und Auditabläufe nicht kopieren müssen. Quellseitige zusätzliche Einschränkungen bleiben beim Adapter. Bestehende Rechte werden nicht erweitert.
|
||||
- Quelle und Darstellung trennen: Eine Quelle, die E-Mail-Originale bereitstellt, muss den vorhandenen Mail-Leser einschließlich Anlagen nutzen können. `_complete_mail` darf nicht direkt auf einen ausschließlich IMAP-fähigen Zugriff festgelegt bleiben. Analog PDF, Bild und Text über autorisierten Ressourcenabruf führen.
|
||||
- Leser und Editoren als registrierte Komponenten mit gemeinsamem Lebenszyklus anbinden. Neue Darstellungen dürfen eigene registrierte Bausteine benötigen, ohne Änderungen in Akten-/Vorgangsseiten oder Exportsteuerung. Eine Funktion, die nur feste Darstellungsnamen umbenennt, ist noch keine solche Registrierung.
|
||||
- Typisierte, vom jeweiligen Modul validierte Optionen und Ressourcenkennungen vollständig durchreichen. Keine dauerhafte zentrale Liste aller providerspezifischen Suchfelder. Bestehende Standardfelder können gemeinsame Verträge bleiben. Kompatibilitätsrouten delegieren an dieselben Dienste; keine zweite aktive Fachlogik.
|
||||
- Neue Module werden an einem ausdrücklichen Einstieg registriert. Eine Fachseite darf nicht beim Import die bereits gefüllte Registry löschen und neu mit zwei festen Quellen belegen.
|
||||
|
||||
### Storage und Transaktionen
|
||||
|
||||
- Den tatsächlichen Adapter anhand der gespeicherten Storage-Instanz über eine gemeinsame Auflösung beziehen. Uploads, Lesen, Löschen, Rollback-Bereinigung und Versandfassungen verwenden diesen Zugang. Direkte Konstruktion von `LocalAdapter` in Fachoperationen beseitigen; lokale Pfade gehören zum lokalen Adapter.
|
||||
- Den vorhandenen Testadapter durch diese echte Zugriffsstrecke prüfen, nicht nur seine Methoden nebeneinander aufrufen. Kein zusätzlicher produktiver Cloud-/NAS-Dienst erforderlich. Bestandsreferenzen, Generationen und Inhaltsrevisionen erhalten.
|
||||
- Externe Abrufe und größere Dateioperationen aus offenen Fachtransaktionen lösen. Autorisierten Abruf vorbereiten, externe Arbeit ausführen, vor Veröffentlichung beziehungsweise endgültiger Ausgabe erforderliche Rechte und Versionen erneut prüfen. DB und Ablage nicht als gemeinsame atomare Transaktion behandeln; Fehler und Bereinigung nach dem bestehenden Vertrag abwickeln.
|
||||
- Nicht unterstützte Schutzprofile bleiben gesperrt. Keine neue Verschlüsselung in diesem Auftrag.
|
||||
|
||||
## 4. B – IMAP: große Ordner korrekt anzeigen und durchsuchen
|
||||
|
||||
**Ergebnis:** Ein großer, befüllter Ordner ist durchblätterbar. Eine Suche erfasst den gesamten gewählten Ordner, auch Treffer außerhalb der ersten Seite. Leer, keine Treffer, unvollständiger Abruf und Fehler sind unterschiedliche Zustände.
|
||||
|
||||
1. Ursache mit aussagekräftigen, inhaltsarmen Diagnosen eingrenzen: Ordnerauswahl, Anzahl/UID-Bereich soweit verfügbar, Suchstatus, Antwortumfang und -form, Timeout/Protokollfehler und Headerabruf. Keine Zugangsdaten, Nachrichtentexte oder vollständigen privaten Header protokollieren.
|
||||
2. Erfolgreiche leere Suche von `NO`, `BAD`, Verbindungsabbruch, Timeout und ungültiger Antwort unterscheiden. Bei Fehlern keine Meldung „Ordner leer“ oder „keine Treffer“ ausgeben. Stille Fehler beim Headerabruf dürfen einen befüllten Ordner nicht scheinbar leeren.
|
||||
3. Ordnernavigation und Suche für große UID-Bestände begrenzen und seitenweise verarbeiten. Nicht bei jedem Blättern beliebig große vollständige UID-Listen übertragen und sortieren. Geeignete Serverfähigkeiten nutzen; eine kompatible, begrenzte Strategie für Server ohne zusätzliche Sucherweiterungen erhalten. Nicht pauschal globale Bibliothekslimits erhöhen oder Timeouts unbegrenzt verlängern.
|
||||
4. Suchkriterien serverseitig auf den ganzen Ordner anwenden beziehungsweise bei begrenzter Bereichssuche nachweisbar vollständig fortsetzen. Ein nicht untersuchter Rest darf nicht als endgültig trefferlos gelten. Eine Antwort enthält eine Fortsetzung oder einen erkennbaren unvollständigen Zustand, wenn die Suche noch nicht abgeschlossen ist.
|
||||
5. Cursor an Zugang, Ordner, Suchanfrage und nötigen Identitätsstand binden; UID-Lücken, entfernte Nachrichten und UIDVALIDITY-Wechsel sicher behandeln. Bei wechselndem Bestand keine unbemerkte Verwechslung mit einer anderen Nachricht.
|
||||
6. Antwortzeiten und Zahl externer Aufrufe für den Regressionstest dokumentieren. Nur Metadaten für die aktuelle Seite laden; vollständige Nachrichten und Anlagen erst auf Anforderung. Nur lesender Zugriff, keine Veränderung des Gelesen-Status.
|
||||
7. Bei schnellem Ordner-/Suchwechsel dürfen verspätete Antworten nicht die neue Ansicht überschreiben. Auswahl und Zielkontext bleiben korrekt. Fremde oder entzogene Zugänge bleiben geschützt.
|
||||
|
||||
## 5. C – Paperless: brauchbare Suche mit Eingrenzungen
|
||||
|
||||
**Ergebnis:** Dokumente lassen sich über ihren Inhalt finden und über sichtbare fachliche Filter eingrenzen. Die Suche funktioniert auch jenseits der ersten Ergebnisseite.
|
||||
|
||||
Liefern:
|
||||
|
||||
- Freitextsuche mit klarer Beschriftung für Titel und Dokumentinhalt sowie ein getrenntes Titelfeld zur zusätzlichen Eingrenzung. Inhaltsbegriffe, die nicht im Titel stehen, müssen im passenden Testbestand Treffer liefern.
|
||||
- Korrespondent und Dokumenttyp als Auswahl anhand der am konkreten Zugang sichtbaren Stammdaten; Tags als Mehrfachauswahl. Für mehrere Tags eine klar erkennbare Verknüpfung anbieten, mindestens „alle ausgewählten Tags“. Keine still wechselnde UND-/ODER-Semantik.
|
||||
- Dokumentdatum von/bis, mit sichtbarer Bedeutung; nicht ungefragt Upload-/Änderungsdatum verwenden. Leere Grenzen zulassen, ungültige Bereiche verständlich ablehnen.
|
||||
- Sortierung mindestens nach Dokumentdatum und Titel, auf-/absteigend; Relevanz anbieten, soweit die eingesetzte API dies für die gewählte Suche unterstützt. Stabile Fortsetzung berücksichtigen.
|
||||
- Weitere Ergebnisseiten, aktiven Filterzustand, Zurücksetzen und Vorschau vor Übernahme. Bereits bewusst gewählte Dokumente bei Seiten-/Suchwechsel erhalten und sichtbar machen; Auswahl nach Instanz und Ressourcen-ID führen.
|
||||
|
||||
Suchtext und verschiedene Filter werden gemeinsam angewendet. Filterdaten bleiben im zuständigen Connector. Der gemeinsame Dienst darf validierte Filter nicht nach der Prüfung verwerfen. Fähigkeiten erst aktiv ausweisen, wenn die Operation ausführbar ist. Nicht unterstützte Parameter dürfen nicht still ignoriert werden.
|
||||
|
||||
Die konkret eingesetzte Paperless-Version und deren API-Schema prüfen. Moderne Dokumentation ist keine Zusage über eine ältere Nutzerinstanz. Kein eigener Volltextindex und keine lokale Nachfilterung lediglich der ersten 20 Treffer. Von der API gelieferte Fortsetzungsadressen nur innerhalb der vertrauenswürdigen Instanz verwenden; keine Credential-Weitergabe an fremde Hosts. Instanz- und Rechtebindung gilt auch für Stammdaten, Zähler und Vorschau.
|
||||
|
||||
Die generelle Sucherweiterung ist beauftragt. Individuelle Finanzfelder, benutzerdefinierte Feldabfragen und Metadatenänderungen sind hier kein zusätzlicher Pflichtumfang.
|
||||
|
||||
## 6. D – Notizen: Markdown bearbeiten, anschließend formatiert lesen
|
||||
|
||||
### Fachliche Einordnung und Pflichtverhalten
|
||||
|
||||
Eine interne Notiz muss nicht als externe Quelle unter „Quellen“ erscheinen. Benötigt werden ein registrierter interner Notiz-Zugriff und ein wiederverwendbarer Markdown-Leser/Editor über die gemeinsame Ressourcen-/Editor-Schnittstelle. Notizen behalten ihre vorhandene Identität und Speicherung; sie werden nicht automatisch zu Dateien oder pro Einbindung kopiert. Eine spätere MD-Datei kann denselben Editor mit einem anderen Speicheradapter nutzen; das Schreiben externer MD-Dateien ist jetzt nicht beauftragt.
|
||||
|
||||
- **Öffnen:** Gespeicherte Notizen zunächst gerendert anzeigen. Bei Bearbeitungsrecht gibt es „Bearbeiten“; bei reinem Leserecht keinen aktiven Editor. Das gilt auch beim erneuten Öffnen und für bestehende Notizen.
|
||||
- **Bearbeiten:** Eine klar erkennbare Bearbeitungsansicht mit Formatierungsleiste und Markdown-Quelltextmodus. Entwurf, Auswahl und Inhalt beim Moduswechsel erhalten.
|
||||
- **Speichern:** Nach erfolgreichem Speichern in die gerenderte Leseansicht wechseln und den tatsächlich gespeicherten Stand zeigen. Bei Fehlern im Editor bleiben. „Abbrechen“ stellt den gespeicherten Stand wieder her. Navigation mit ungesicherten Änderungen bewusst behandeln.
|
||||
- **Inhalt:** Markdown bleibt die maßgebliche Darstellung. Kein HTML als unbemerkter Ersatz. Vorhandene Dokumenthüllen kompatibel adaptieren; eine neue DB-Struktur nur bei belegter Notwendigkeit und ohne Inhaltsverlust. Export gibt vollständiges Markdown aus.
|
||||
- **Umfang:** Überschriften, fett, kursiv, Listen, Links, Zitate, Inline-Code und Codeblöcke konsistent lesen und bearbeiten. Formatierungsschalter haben zugängliche Namen und sichtbaren Zustand. Bestehende Inhalte außerhalb des visuell unterstützten Umfangs unverändert erhalten und nötigenfalls im Quelltextmodus bearbeiten; keine verlustbehaftete Konvertierung.
|
||||
- **Rechte und Konflikte:** Gemeinsamer Notizinhalt bleibt in allen Einbindungen derselbe, lokale Anmerkungen bleiben lokal. Kontextbezogene Rechte und optimistische Versionsprüfung erhalten. Bei `409` bleibt der Entwurf erhalten; kein stilles Überschreiben und kein bloßes Neuladen mit Textverlust.
|
||||
- **Rendering:** Sicheren Markdown-Parser/Renderer verwenden oder den vorhandenen Mechanismus belastbar ersetzen. Rohes HTML, Skripte und gefährliche Linkprotokolle nicht ausführen. Externe Medien nicht automatisch nachladen. Keine Notizinhalte an einen externen Editordienst senden.
|
||||
|
||||
### Bevorzugtes Ziel: direkt formatiert bearbeiten
|
||||
|
||||
Der Nutzer wünscht idealerweise Bearbeitung direkt in der formatierten Ansicht mit Formatierungsschaltern. Setze das bevorzugt mit einer geeigneten, lokal eingebundenen und gepflegten Editor-Komponente um; Quelltext bleibt umschaltbar. Kein eigener Rich-Text-Editor auf Basis unkontrollierter DOM-/HTML-Konvertierung und keine breite Bibliotheksstudie. Eine kurze begründete Komponentenwahl genügt; aktuelle Version, Markdown-Roundtrip und Lizenz prüfen.
|
||||
|
||||
Das ist die bevorzugte Bedienung dieser Lieferung, keine Erlaubnis zu stillen Inhaltsverlusten. Falls sie sich im Bestand nicht zuverlässig umsetzen lässt, die konkrete Grenze und eine funktionsfähige Alternative aus Markdown-Bearbeitung, Formatierungsleiste und gerenderter Leseansicht benennen. Dann den Wunsch nach direkter formatierter Bearbeitung ausdrücklich als offen ausweisen; eine einfache Textarea mit Vorschau nicht als vollständig erfülltes Ideal melden. Die übrigen Pakete deshalb nicht anhalten.
|
||||
|
||||
## 7. Vorgehen und konkrete Abnahme
|
||||
|
||||
Erst eine kurze Liste: welche Punkte im aktuellen Stand bereits belegt sind, welche Lücken tatsächlich bestehen und in welcher Reihenfolge sie geschlossen werden. Dann implementieren. Keine wochenlange Rahmenwerksarbeit. Sinnvolle Reihenfolge: notwendige gemeinsame Anschlussstellen korrigieren, IMAP-Fehler beheben, Paperless-Suche ausbauen, Markdown-Bedienung integrieren. Technisch unabhängige Aufgaben müssen nicht auf eine vollständige Umstellung aller Details warten; am Ende die gemeinsame Integration prüfen.
|
||||
|
||||
| Nr. | Szenario und beobachtbares Ergebnis |
|
||||
|---|---|
|
||||
| A1 | Dritten Test-Connector nur durch Modul und ausdrückliche Registrierung anbinden. In der Testoberfläche einrichten, suchen/navigieren, vor Übernahme öffnen, einbinden, erneut öffnen und exportieren. Für sein Formular ist ein eigenes registriertes Modul zulässig; eine nicht vorhandene Standardform nicht behaupten. Keine Source-Sonderzweige in Fachseiten, generischem Reader oder Export ergänzen. |
|
||||
| A2 | Eine Testquelle mit E-Mail-Darstellung über den vorhandenen Leser einschließlich Anlagen öffnen. Der Zugriff läuft über ihre registrierte Ressourcenoperation, ohne IMAP-Zwang. Keine zusätzliche produktive Quelle erforderlich. |
|
||||
| A3 | Vorhandenen Test-Storage über die echte Speicherauflösung für Upload, erneutes Lesen, Export, Versandfassung und Löschen/Bereinigung verwenden. Einheitenprüfungen an zwei unverbundenen Adapterobjekten genügen nicht. IDs, Generationen und Originalbytes erhalten. |
|
||||
| A4 | Fehlende und entzogene Kontext-/Quellfreigabe sowie manipulierte Instanz und Ressource prüfen. Suche, Vorschau, Original, Anlagen und Export bleiben geschützt. Adapter wiederholen keine Tsumugu-Freigabelogik. Externen Abruf und Rechteentzug zwischen Vorbereitung und Abschluss prüfen. |
|
||||
| B1 | Großen Ordner mit mindestens 50.000 synthetischen UID-Einträgen, Lücken und mehr als einer Seite reproduzieren. Erste und weitere Seiten liefern Nachrichten, Suche findet einen gezielt außerhalb der ersten Seite liegenden Treffer. Große Antwort bzw. begrenzte Antwortstrategie prüfen; eine lange UID-Liste allein in einem Fake beweist keine reale Protokollverträglichkeit. Aufruf-/Datenumfang bleibt begrenzt. |
|
||||
| B2 | Erfolgreich leerer Ordner und erfolgreiche Suche ohne Treffer zeigen einen Leerzustand. `NO`, `BAD`, Timeout, Abbruch und fehlgeschlagene Headerabrufe zeigen passende Fehler/Teilzustände. Der vollständige Ausfall einer Ergebnisseite wird nicht „leer“. |
|
||||
| B3 | UIDVALIDITY-Wechsel, neue/gelöschte Nachrichten, Unicode-Suchtext und schneller Ordnerwechsel führen zu korrekter Fortsetzung oder verständlichem Neustart. Keine falsche Nachricht, kein veränderter Gelesen-Status. |
|
||||
| C1 | Mindestens 45 synthetische Paperless-Dokumente über mehrere Seiten: Ein Suchwort nur im Inhalt wird gefunden; ein getrenntes Titelfeld grenzt zusätzlich ein. Filter für Korrespondent, Typ, mehrere Tags und Datum werden einzeln und kombiniert bis zur API nachweisbar übergeben und korrekt angewandt. |
|
||||
| C2 | Sortierung und Seitenwechsel erhalten Filter und bewusste Mehrfachauswahl. Treffer hinter Seite eins vor Übernahme öffnen, einbinden, erneut öffnen und exportieren. Zwei Instanzen mit gleicher Dokument-ID bleiben getrennt. Fremde/entzogene Stammdaten und Treffer bleiben verborgen. |
|
||||
| D1 | Bestehende Notiz öffnen: gerenderte Ansicht. Bearbeiten mit Formatierungsleiste, Moduswechsel, Speichern: gerenderter neuer Stand; erneutes Öffnen identisch. Abbrechen und Navigation verlieren keinen Entwurf unbeabsichtigt. Formatierte Direktbearbeitung entweder vorführen oder als offen begründen. |
|
||||
| D2 | Dieselbe Notiz in zwei Vorgängen: berechtigte Änderung erscheint in beiden, lokale Anmerkung nur in ihrem Kontext. Leserecht erlaubt keine Änderung. Versionskonflikt bewahrt den Entwurf und überschreibt keinen anderen Stand. |
|
||||
| D3 | Markdown mit Links, Listen, Überschriften, Zitaten, Code und bisher nicht visuell unterstützter Syntax über Öffnen/Speichern/Moduswechsel erhalten. Kein Inhaltsverlust; schädliches HTML/Links werden nicht ausgeführt, externe Bilder nicht automatisch abgerufen. |
|
||||
| E1 | Bestehende Exportauswahl, Unterkapitel, eigene Dateien und gesicherte Versandstände funktionieren. E-Mail enthält weiterhin alle Anlagen, auch wenn ein separates Anlage-Vorkommen abgewählt ist. Gesicherte Versandbytes nicht durch aktuelle Quelldaten ersetzen. |
|
||||
| E2 | Betroffene Bedienabläufe auf Desktop und bei 390/360 px prüfen: Tastatur, Fokus und Rückkehr, Laden/Fehler/leer, Speichern/Abbrechen. Vorhandene Designrichtung und kompakte Listen erhalten. |
|
||||
|
||||
Vorhandene Tests gezielt erweitern. Nach den Änderungen relevante Regressionstests und Frontend-Build ausführen. Bestandene Prüfungen ohne neue Änderung oder ungelöste Sorge nicht wiederholt breit laufen lassen. Keine produktiven Datenbanken für automatisierte Tests verwenden.
|
||||
|
||||
Für tatsächliche Quellenchecks nur vorhandene autorisierte lokale Verbindungen lesend verwenden; keine neuen Credentials beschaffen und keine Inhalte veröffentlichen. Wenn ein echter Anschluss nicht verfügbar ist, synthetischen Nachweis und verbleibende reale Abnahme getrennt ausweisen. Keine Erfolgsmeldung für eine nicht durchgeführte Prüfung. Der Nutzer hat bereits grundsätzlich funktionierende Alltagsabläufe beobachtet; diese Beobachtung ersetzt keinen gezielten Großordner- oder Filtertest.
|
||||
|
||||
## 8. Dokumentation, Grenzen und Übergabe
|
||||
|
||||
- Dieses Dokument im vorgesehenen Produktverzeichnis ablegen und in `docs/README.md` sowie der Planungsübergabe verlinken. Die Fachspec gezielt um die aktuellen Nutzeranforderungen und spätere Implementierungsnachweise ergänzen; bevorzugte Bedienung und noch offene Punkte klar kennzeichnen.
|
||||
- Betroffene API-/Datenmodell-/Rechte-Dokumentation nur im nötigen Umfang nachführen. Die bestehende Abschlussmatrix korrigieren: alte Testergebnisse historisch erhalten, behobene Lücken mit neuen konkreten Nachweisen ergänzen. Nicht pauschal alles auf „bestanden“ setzen.
|
||||
- Abschlussbericht kurz halten: vier Arbeitspakete A–D mit Ergebnis, konkret ausgeführten Tests, realer oder nachgebildeter Quelle und verbleibender Grenze. Dazu Anleitung für neue Source-/Storage-/Darstellungs-/Editor-Module und Liste der weiterhin zulässigen Quellkenntnis. Laufzeitverhalten und Erweiterbarkeit getrennt bewerten.
|
||||
- Kein Push, Deployment, externer Versand oder Änderung anderer Produkte. Keine neue SaaS-/Runtime-/Kryptografieplattform, keine KI, Finanzfunktionen oder bidirektionalen Paperless-Schreiboperationen. Bestehende Schlüssel-/Storage-Zielanforderungen erhalten.
|
||||
|
||||
## 9. Technische Quellen für die Umsetzung
|
||||
|
||||
Die folgenden Primärquellen sind Orientierung, keine Zusage über die installierte Version. Vor konkretem Mapping die eingesetzte Version/API prüfen:
|
||||
|
||||
- [Paperless-ngx: REST API](https://docs.paperless-ngx.com/api/) – Suchmöglichkeiten, Filter und API-Versionierung. Die offizielle Dokumentation beschreibt Inhalts-/Titelsuche; der aktuelle lokale `query`-Aufruf belegt daher nicht die Ursache der beobachteten Titelsuche.
|
||||
- [Python: imaplib](https://docs.python.org/3/library/imaplib.html) – Rückgabestatus, Fehler und UID-Zugriff. Technische Details gegen die im Projekt eingesetzte Python-Version prüfen.
|
||||
- [RFC 9051: IMAP4rev2](https://www.rfc-editor.org/rfc/rfc9051.html) – Protokoll- und Identitätsregeln. Bestehende IMAP4rev1-Server weiterhin unterstützen; rev2 ist keine neue Mindestanforderung.
|
||||
|
||||
Die Notiz-Editorbibliothek wird mit kurzer Begründung im Repository festgelegt; dieser Auftrag schreibt keine unüberprüfte Bibliothek oder Version vor.
|
||||
@@ -0,0 +1,69 @@
|
||||
# Prüfung der Connector-Nacharbeit
|
||||
|
||||
**Stand:** 20.10.2026. Geprüfter Arbeitsstand: `C:/Dev/tsumugu`. Keine Änderung an Anwendung, Repositorydokumenten oder Datenbanken; kein Push oder Deployment.
|
||||
|
||||
## Ergebnis
|
||||
|
||||
Die Nacharbeit ist im Code vorhanden und ein deutlicher Fortschritt. Eine vollständige Abnahme des Auftrags ist noch nicht belegt. Die folgenden vier Restpunkte sind konkret eingegrenzt. Ein erneuter Architekturentwurf oder zusätzliche Produktfunktionen sind dafür nicht erforderlich.
|
||||
|
||||
## Was tatsächlich hinzugekommen ist
|
||||
|
||||
- Gemeinsame Quellenfreigabe über `sourceaccess.py`; der allgemeine E-Mail-Endpunkt verwendet das registrierte Modul statt eines fest eingebauten IMAP-Abrufs.
|
||||
- Paperless-Filter werden weitergereicht und auf Query, Titel, Korrespondent, Dokumenttyp, Tags, Dokumentdatum und Sortierung abgebildet. Ergebnisseiten und Stammdatenauswahl sind vorhanden.
|
||||
- IMAP verwendet begrenzte UID-Fenster, unterscheidet Suchfehler von leeren Ergebnissen und führt UIDVALIDITY sowie unvollständige Suchzustände mit.
|
||||
- Uploads und Versandfassungen verwenden `adapter_for`; die Lösch-/Bereinigungsobjekte können den zuständigen Adapter aufrufen.
|
||||
- MDXEditor ist lokal eingebunden. Notizen öffnen gerendert, lassen sich mit Formatierungsleiste bearbeiten und wechseln nach dem Speichern zurück zur Leseansicht.
|
||||
|
||||
## 1. Externe Abrufe laufen weiterhin teilweise innerhalb einer Fachtransaktion
|
||||
|
||||
**Beleg:** `backend/app/sourceaccess.py:125` beendet zunächst die Transaktion. Der IMAP-Callback in `backend/app/sources.py:387` ruft anschließend aber `load_imap_original` auf. Diese Funktion liest in `backend/app/sources.py:1123` über `_owned` erneut aus der Datenbank und startet damit vor `pull_rfc822` wieder eine Transaktion.
|
||||
|
||||
Auch `backend/app/sources.py:1251` und `:1272`, die Paperless-/IMAP-Originale für Export und Versandfassungen laden, lösen die Transaktion vor ihrem Netzwerkabruf nicht. Die Freigabeprüfung nach dem Abruf aus der gemeinsamen Lesestrecke wird dort ebenfalls nicht verwendet. Dateiveröffentlichungen in `ops.py` und `correspondence.py` erfolgen weiterhin zwischen Fachschreiboperationen.
|
||||
|
||||
**Eigener Nachweis:** Zwei isolierte Python-Prüfungen ohne DB und Netzwerk haben die tatsächlichen Funktionen mit kleinen Verbindungs-/Transportattrappen aufgerufen. Beim Einstieg in den externen Transport war der Status sowohl im IMAP-Lesepfad als auch im Paperless-Exportpfad `INTRANS`.
|
||||
|
||||
**Gezielte Nacharbeit:** Die freigegebenen Verbindungsdaten vor dem externen Teil vollständig auflösen. Im externen Teil keine DB-Nachfrage einbauen, die die Transaktion erneut eröffnet. Für Export und Versandfassung ebenfalls vorbereiten, extern lesen und danach erforderliche Rechte/Versionen erneut prüfen. Schreibabläufe ausdrücklich in vorbereitende und abschließende Phasen teilen; kein pauschales Zwischen-Commit als Ersatz für einen sicheren Ablauf. Die abschließende Korrektheit bei Fehler und Entzug testen.
|
||||
|
||||
## 2. Markdown-Editor und gespeicherte Leseansicht unterstützen unterschiedliche Formatierung
|
||||
|
||||
**Beleg:** `frontend/src/notes.jsx:154` aktiviert Überschriften ohne Einschränkung. Das installierte Plugin bietet Ebenen 1 bis 6 an. `frontend/src/markdown.jsx:61` rendert dagegen nur Ebenen 1 bis 3. Der Renderer behandelt eingerückte Listenelemente als gleichrangig und beginnt geordnete Listen stets bei 1.
|
||||
|
||||
**Eigener Nachweis:** Den tatsächlichen `MarkdownView` mit dem vorhandenen JSX-Werkzeug im Speicher übersetzt und mit React serverseitig gerendert. Kein Build und keine Dateischreiboperation im Repository nötig:
|
||||
|
||||
- `#### Unterpunkt` ergibt einen Absatz mit sichtbaren vier Rauten statt einer Überschrift.
|
||||
- `- Ebene 1` mit eingerücktem `- Ebene 2` ergibt zwei gleichrangige Listenelemente.
|
||||
- Eine mit `5.` beginnende geordnete Liste enthält kein `start`-Attribut und wird damit ab 1 angezeigt.
|
||||
|
||||
Der gespeicherte Quelltext wird durch diesen Befund nicht nachweislich verändert. Die Leseansicht stellt seine Bedeutung aber falsch dar.
|
||||
|
||||
**Gezielte Nacharbeit:** Einen zum Editor passenden sicheren Markdown-Renderer verwenden und den gemeinsamen unterstützten Umfang testen. Keine weitere Sammlung einzelner Regex-Sonderfälle. Überschriften, verschachtelte Listen und Listenstartwerte nach Bearbeiten, Speichern, erneutem Öffnen und Quelltextwechsel prüfen. Bisherige Schutzregeln zu HTML, gefährlichen Links und externen Medien erhalten.
|
||||
|
||||
## 3. Die Darstellungs-/Editor-Registrierung ist noch keine Registrierung ausführbarer Komponenten
|
||||
|
||||
**Beleg:** `frontend/src/sources/registry.jsx:29` registriert eine Zuordnung von Mediennamen auf Leserkennungen. `ReadingPane.jsx` entscheidet weiterhin anhand fest eingebauter Kennungen, welche Anzeige ausgeführt wird. Es importiert `NoteEditor` direkt und bindet ihn bei `element.kind === "note"` ein. Die `editors`-Struktur in `registry.jsx:160` ist eine feste Objektliste; ein neuer registrierter Editor wird daraus nicht dynamisch ausgeführt.
|
||||
|
||||
Dadurch lassen sich Quellen mit vorhandenen Standardformaten besser ergänzen. Ein neuer Leser oder Editor kann aber weiterhin Änderungen im allgemeinen Reader benötigen. Die Abschlussmatrix beschreibt diesen Teil weitergehend als der Code.
|
||||
|
||||
**Gezielte Nacharbeit:** Tatsächliche Komponenten und ihre gemeinsamen Lade-/Speicher-/Konfliktverträge registrieren. Die allgemeine Hülle muss die registrierte Komponente aufrufen. Die interne Notiz bleibt eine Notiz mit ihrem bisherigen Speicherweg; ihre fachliche Identität muss dafür nicht geändert werden.
|
||||
|
||||
**Abnahme:** Eine kleine zusätzliche Testdarstellung und einen Testeditor allein durch Module und Registrierung einhängen und über die echte Leserhülle ausführen. Kein neuer produktiver Connector erforderlich. Eine bloße Stringzuordnung genügt nicht.
|
||||
|
||||
## 4. Verspätete Paperless-Suchantworten können einen neueren Zustand überschreiben
|
||||
|
||||
**Beleg:** `frontend/src/pages/Sources.jsx:256` übernimmt nach jedem Suchaufruf ungeprüft `items`, `next_page` und `connector_id`. Währenddessen kann über das Auswahlfeld bei `:369` die Instanz gewechselt oder eine weitere Suche gestartet werden. Es fehlt eine Anfragenkennung beziehungsweise eine andere Sicherung gegen verspätete Antworten. Der IMAP-Picker hat eine solche Sicherung bereits.
|
||||
|
||||
**Auswirkung aus dem Codeablauf:** Eine langsame Suche A kann nach dem Wechsel auf B oder nach einer neueren Suche noch eintreffen und die aktuelle Trefferliste und Instanzauswahl zurücksetzen. Das ist ein belegter möglicher Ablauf; eine Browser-Reproduktion mit künstlicher Verzögerung wurde hier nicht ausgeführt.
|
||||
|
||||
**Gezielte Nacharbeit:** Such-, Vorschau- und Stammdatenantworten an Instanz und konkrete Anfrage binden. Überholte Antworten ignorieren beziehungsweise abbrechen. Nach Instanzwechsel fremde Filter-IDs zurücksetzen oder ausdrücklich neu validieren. Bewusst gewählte Treffer weiter anhand ihrer gespeicherten Instanz erhalten.
|
||||
|
||||
**Abnahme:** Antwort A künstlich verzögern, zu Instanz B beziehungsweise Suche B wechseln, A erst danach freigeben. Treffer, Vorschau, Filterzustand und Auswahl dürfen nicht auf A zurückspringen.
|
||||
|
||||
## Nachweisgrenzen
|
||||
|
||||
Die Abschlussmatrix nennt 82 bestandene Backend-Tests und einen erfolgreichen Frontend-Build. Diese vollständigen Läufe wurden bei dieser Prüfung nicht wiederholt. Die zusätzliche Prüfung war gezielt und lesend; sie hat keine echte Quelle und keine Datenbank angesprochen.
|
||||
|
||||
Der neue Paperless-Test belegt Parameterübertragung und Paging, sein Fake berechnet jedoch keine echte Filterwirkung: Er liefert dieselben Seitendaten unabhängig vom Suchinhalt. Die tatsächliche Filtersemantik an der Nutzerinstanz ist damit weiterhin offen. Laut Matrix wurde nur deren Schema gelesen.
|
||||
|
||||
Der bestehende dritte Source-Test prüft weiterhin die Frontend-Registrierung in Node und die Backend-Strecke. Er belegt keinen vollständigen Bedienablauf des dritten Connectors in der Oberfläche. Für den neuen Editor nennt die Matrix Browserprüfungen; eine zusätzliche eigene Browserprüfung wurde hier nicht vorgenommen.
|
||||
|
||||
Die reale Großordner-Abnahme bei IMAP und die Inhalts-/Filterabnahme bei Paperless bleiben nach dem vorliegenden Bericht offen. Bei Abschluss klar zwischen Codeänderung, synthetischem Nachweis und erfolgreichem Test an der echten Quelle unterscheiden.
|
||||
@@ -0,0 +1,64 @@
|
||||
# Auftrag an Cursor – erste gemeinsame Connector-/Storage-Basis
|
||||
|
||||
**Stand:** 19.10.2026 · **Status:** Vorbereiteter, begrenzter Umsetzungsauftrag. Durch Erstellung dieses Dokuments wurde keine Anwendung geändert. Übergabe an Cursor erteilt den Umsetzungsauftrag bis zur lokalen Prüfung.
|
||||
|
||||
## Ziel und Grundlagen
|
||||
|
||||
Arbeite in `C:/Dev/tsumugu`. Lies zuerst AGENTS.md, die aktuelle Fachspec, die Connector Suite v0.2 und `C:/Dev/tsumugu/docs/architecture/TSUMUGU_CONNECTOR_STORAGE_VERTRAG_v0.1_2026-10-19.md`. Nutze die bestehenden Architekturverträge und Blueprints unter `C:/Dev/tsumugu/docs/reference`. Das Repository verwendet den Ordnernamen `reference` im Singular.
|
||||
|
||||
Die Vertragsbeschreibung ist ein Umsetzungsvorschlag auf Basis der bestätigten Fachentscheidungen. Prüfe den aktuellen Code erneut. Erhalte bestehende Fremdänderungen, Fachmodell und ausgewählte Gestaltung. Vorhandene Paperless-/IMAP-Protokollarbeit, Medienablage, Reader und Notizeditor wiederverwenden. Keine neue Foundation oder parallele Connector-Anwendung.
|
||||
|
||||
## Lieferpaket
|
||||
|
||||
Primäres Ziel ist die belastbare Grundlage für die fortlaufende private Nutzung. Der Auftrag wird in zwei getrennt prüfbare Lieferabschnitte gegliedert. Zuerst Abschnitt A fertigstellen und lokal übergeben. Abschnitt B ist der vorbereitete nächste Funktionsausbau und wird durch diesen Basisauftrag nicht automatisch mitimplementiert. Es werden weder neue Plattformdienste noch ungenutzte Fachmodule auf Vorrat angelegt.
|
||||
|
||||
### Abschnitt A – jetzt beauftragt: Grundlagen bei erhaltener Funktion
|
||||
|
||||
1. Gemeinsamen Source-Vertrag und registrierte Adapter für Paperless und IMAP integrieren. Konkrete Verbindung, Ressource, Operation, Rechte und Fehlerzustand durchgängig erhalten.
|
||||
2. Eigene Dateiablage und gesicherte Versandfassungen an einen kleinen Storage-Port mit lokalem Adapter anbinden. Bestandsdateien ohne Neu-Upload erhalten. Storage-/Inhaltsrevision und Schlüsselzuständigkeit gemäß Vertrag trennen.
|
||||
3. Gemeinsame Frontend-Zugriffsschicht und Registry für Quell-/Darstellungsbausteine einführen. Bestehende Picker/Formulare als registrierte Quellmodule weiterverwenden. Gemeinsame Hüllen und Auswahl-/Zielkontextverträge gezielt herausziehen; eine vollständige Neugestaltung sämtlicher Dialoge ist nicht erforderlich.
|
||||
4. Reader nach Darstellungsart anbinden; vorhandene Notizbearbeitung erhalten und ihre Speichern-/Konfliktzustände hinter der gemeinsamen Editor-Anschlussstelle führen. Die bestehende Notiz-API bleibt der fachliche Speicherweg für Notizen. Noch nicht vorhandene Editorarten werden nicht als nutzbar angeboten.
|
||||
5. Typisierte Such-, Filter-, Sortier- und Paging-Verträge mit ausgewiesenen Fähigkeiten definieren. Die heutige Suche darf durch den Umbau keine Funktion verlieren; zusätzliche Filter werden in Abschnitt B geliefert. Ein gemeinsames Interface bedeutet keine vorgetäuschte Verfügbarkeit.
|
||||
6. Vorschau, Originaldownload, Export, Anlagen und Versandnachweise über dieselbe autorisierte Ressourcenauflösung führen. Keine spontane Auswahl eines anderen Quellenzugangs. Bibliotheks-/Frameworkmigrationen sind kein Teil der Grundlagenlieferung.
|
||||
|
||||
### Abschnitt B – nächster, separat zu startender Funktionsausbau
|
||||
|
||||
Gemeinsamen Quellenbrowser einschließlich Preview-vor-Übernahme vervollständigen. Paperless-Suche um Freitext/Titel, Korrespondent, Dokumenttyp, Tags, Dokumentdatumsbereich, Sortierung und weitere Ergebnisseiten erweitern. Konkrete API-Fähigkeiten gegen die eingesetzte Version prüfen. Mehrfachauswahl über Such-/Seitenwechsel erhalten. Dies ist bestätigter Ausbaubedarf, aber keine Abnahmevoraussetzung für Abschnitt A. Ein neuer MD-Dateieditor ist ein weiterer eigener Schnitt.
|
||||
|
||||
Beginne mit einer kurzen Bestands- und Aufwandsnotiz für diesen Schnitt; die alte Schätzung von 6–9 Tagen gilt nicht automatisch für diesen erweiterten Auftrag. Geplante und bereits vorhandene Funktionen unterscheiden. Eine erneute vollständige Produktspezifikation ist nicht erforderlich.
|
||||
|
||||
## Migration und Schutz
|
||||
|
||||
Bestehende Elemente, Einbindungen, Kapitel, Inhaltsdaten und Rechte erhalten. Eindeutige Quellinstanzen nachziehen; Mehrdeutigkeiten markieren und bewusst auflösen lassen. Rohdaten nicht kopieren, um Referenzen zu vereinfachen. Keine globale automatische Zusammenführung anhand externer ID oder Hash.
|
||||
|
||||
Bestehende Medien- und Snapshotdateien zunächst unter stabiler Legacy-Speichergeneration lesbar machen. Metadatenmigration genügt, wo kein physischer Umzug nötig ist. Neue Repräsentationen werden erst nach geprüftem Speichererfolg veröffentlicht. Fehlgeschlagene oder wiederholte Abläufe dürfen keine falschen Erfolgsmeldungen oder stillen Verluste erzeugen.
|
||||
|
||||
Keine Netzwerk-/großen Dateioperationen in offener Fachtransaktion. Aktuelle Rechte und Version vor Abschluss erneut prüfen. Quellcredentials bleiben im zuständigen Adapter. Befunde zu bestehender Credential-Speicherung und Schlüsselverwaltung ausdrücklich in der Aufwands-/Grenzennotiz behandeln; daraus keine behauptete SaaS-Reife ableiten.
|
||||
|
||||
Die erste Lieferung aktiviert keine neue Kryptografie. Sie muss den späteren Content-/Crypto-Zugriff über die festgelegte Grenze ermöglichen und unbehandelte Schutzprofile geschlossen ablehnen. Eine verschlüsselte Ablage darf erst nach dem gesonderten Schlüssel-/Recovery-Prüfergebnis und einem dafür konkretisierten Implementierungsauftrag aktiviert werden.
|
||||
|
||||
## Konkrete Abnahme
|
||||
|
||||
Mit synthetischen Daten und getrennten Testdatenbanken prüfen:
|
||||
|
||||
1. **Bestand:** PDF/Fotos, Notizen, Unterkapitel, geordnete Anlagen, Versandfassungen und Export bleiben nach Migration nutzbar. Vorhandene IDs und Originalbytes sind erhalten.
|
||||
2. **Instanzbindung:** Gleiche Dokumentnummer in zwei simulierten Paperless-Instanzen führt zu korrekten, getrennten Auflösungen. Änderung der Verbindungsreihenfolge lenkt Referenzen nicht um. Mehrdeutiger Altbestand bleibt vorhanden und verlangt Zuordnung.
|
||||
3. **Suche:** In Abschnitt A die heutige Suche und instanzgebundene Anfrage-/Ergebnisverträge prüfen; nicht implementierte Fähigkeiten korrekt ausweisen. Für Abschnitt B: mindestens 45 synthetische Treffer über mehrere Seiten, kombinierte Grundfilter und Sortierung prüfen, Treffer hinter Seite eins vor Einbindung öffnen. Suchwechsel erhält bewusst gewählte Ressourcen; fehlende Rechte verraten keine Titel oder Zähler.
|
||||
4. **IMAP:** Ordnernavigation, Paging, Nachricht, Anlagen, eindeutige Wiedererkennung bei Verschiebung sowie klare Fehler bei fehlender/mehrdeutiger Nachricht erhalten.
|
||||
5. **Owner-Abruf:** Berechtigter Empfänger liest ausdrücklich freigegebene Unterlagen über den erlaubten Owner-Zugang. Er bekommt weder Credentials noch Suchzugriff auf dessen übrigen Bestand. Entzug wirkt beim nächsten Abruf.
|
||||
6. **UI:** Beide vorhandenen Auswahlwege über die neue gemeinsame Zugriffsschicht tatsächlich bedienen. Zielcontainer, Kapitel und Handlungskontext bleiben korrekt. Desktop und 390/360 px, Tastatur, Dialogfokus/-rückkehr, Abbruch sowie Fehler beim Speichern/Einbinden prüfen. Der vollständig vereinheitlichte Quellenbrowser wird zusätzlich in Abschnitt B abgenommen.
|
||||
7. **Anzeige/Editor:** PDF/Bild und E-Mail korrekt anzeigen; Markdown-Notiz bearbeiten und Versionskonflikt behandeln. Nicht unterstützte Editierfähigkeit wird klar angezeigt und serverseitig verweigert. Keine künstliche MD-Dateibearbeitung durch Umwandlung in eine Notiz.
|
||||
8. **Storage-Vertrag:** Lokalen Adapter und einen kleinen Testadapter gegen denselben Vertrag prüfen. Opaque Bytes roundtrip, stabile Generation, Fehlerzustände und unveränderte Inhaltsrevisionen belegen. Der Testadapter ist kein zweiter produktiver Speicherdienst.
|
||||
9. **Vorbereitung kundenseitiger Schlüssel:** Ein gesperrtes/noch nicht unterstütztes Schutzprofil erlaubt Metadatenanzeige nach Recht, aber keinen stillen serverseitigen Klartextabruf. Dummy-Ciphertext unverändert speichern/lesen. Aus diesem Test keinen Verschlüsselungsnachweis ableiten.
|
||||
10. **Fehlerfälle:** Speicherfehler, DB-Abschlussfehler, Wiederholung, Quellausfall, Fremd-IDs, Pfadmanipulation und veraltete Bearbeitung abdecken. Veröffentlichung erst nach verifiziertem Erfolg; verwaiste Zwischenstände nachvollziehbar bereinigen.
|
||||
11. **Export:** Hierarchische Auswahl und vollständige EML samt Anlagen erhalten, auch bei separat abgewähltem Anlage-Vorkommen. Gesicherte Versandstände dürfen durch aktuelle Quellstände nicht ersetzt werden.
|
||||
|
||||
Passende vorhandene Backend-Tests weiterverwenden und gezielt ergänzen. Frontend-Build und erforderliche UI-Prüfungen ausführen. Reale Quellenrechte/API-Version in einer abschließenden, ausdrücklich autorisierten Anschlussprüfung bestätigen; Mocks und tatsächliche Quellenprüfungen im Bericht unterscheiden. Keine privaten Daten in Screenshots oder Logs übernehmen.
|
||||
|
||||
## Dokumentation und Abschluss
|
||||
|
||||
Nach tatsächlicher Änderung die Fachspec gezielt fortschreiben; bestätigte Nutzerentscheidungen, Vorschläge und Implementierungsnachweise unterscheiden. F-02b/c bleibt erhalten: Die erste Source-Lieferung ist lesend und hebt die frühere Feldsynchronisationsanforderung nicht auf. `API_REFERENZ.md`, `DATENMODELL_IST.md`, `RECHTEMODELL_IST.md` und betroffene technische Beschreibung im selben Schnitt aktualisieren. Neue Dokumente in `docs/README.md` und der Planungsübergabe verlinken.
|
||||
|
||||
Liefere Abschnitt A lokal integriert mit tatsächlichen Testergebnissen, wesentlichen Abweichungen und verbleibenden Grenzen. Benenne Abschnitt B ausdrücklich als nächsten Funktionsausbau. Alte Quellenwege nur während der Migration als delegierende Kompatibilität behalten; keine dauerhafte doppelte Fachlogik. Quellenspezifische registrierte UI-Komponenten sind zulässig, solange die Fachseiten die gemeinsamen Verträge verwenden.
|
||||
|
||||
Nicht enthalten: produktiver Hybridkanal, Browser-Schlüsseltresor, neue Verschlüsselungsimplementierung, automatische EML-Archivierung, Dateisystem-/NAS-Source, neue MD-Dateischreibfunktion, dynamische Sammlungen, neue Paperless-Metadaten-Schreib-/Synchronisationsfunktion, Banking oder KI. Diese Anforderungen bleiben im Zielbild erhalten. Kein Push, Deployment, Versand oder Änderung anderer Jinkendo-Produkte.
|
||||
@@ -0,0 +1,84 @@
|
||||
# Sent Items und MIME-Aufbereitung: Befund und gezielter Cursor-Auftrag
|
||||
|
||||
**Stand:** 20.10.2026. Geprüft: `C:/Dev/tsumugu`. Keine Änderung an Anwendung oder Repository; keine echte Quelle und keine Datenbank angesprochen.
|
||||
|
||||
## Nutzerbeobachtung und Grenzen
|
||||
|
||||
Der Ordner „Sent Items“ enthält laut Outlook mehr als 4.000 Nachrichten, erscheint in Tsumugu aber leer. Einige E-Mails mit großen Anlagen wirken in Anzeige und Export verändert; die EML-Datei wird in Outlook korrekt dargestellt.
|
||||
|
||||
**Nutzerpräzisierung:** Betroffen sind Dateiname beziehungsweise Anzeige. Eine Veränderung heruntergeladener Dateiinhalte oder fehlende Anlagen wurde vom Nutzer nicht berichtet. Entsprechend liegt der Schwerpunkt auf korrekten Namen und Darstellung; die Byteprüfung ist eine zusätzliche Integritätskontrolle. Der unten separat reproduzierte Verlust angehängter EML-Dateien ist ein zusätzlicher Parserbefund, keine nachträgliche Umdeutung der Nutzerbeobachtung.
|
||||
|
||||
Diese beiden Beobachtungen sind ernst zu nehmen. Sie beweisen noch nicht, dass Outlook und Tsumugu denselben serverseitigen Ordner sehen oder dass extrahierte Binäranlagen verändert wurden. Die konkrete Nutzerquelle wurde hier nicht geprüft. Es wurden aber die folgenden Codefehler unabhängig reproduziert.
|
||||
|
||||
## Belegte Befunde
|
||||
|
||||
### 1. IMAP-Ordnernamen mit Leerzeichen sind nicht korrekt geschützt
|
||||
|
||||
`backend/app/sources.py:730` und `:798` übergeben den entquoteten Ordnernamen direkt an `client.select`. Die tatsächlich installierte Python-Bibliothek setzt diesen Parameter in den Befehl ein, ohne ihn automatisch zu quotieren.
|
||||
|
||||
Eine Prüfung ohne Socket mit dem tatsächlichen IMAP-Befehlsencoder ergab für `Sent Items`:
|
||||
|
||||
```text
|
||||
T1 EXAMINE Sent Items
|
||||
```
|
||||
|
||||
Für diesen Namen ist eine korrekte IMAP-Stringdarstellung erforderlich, beispielsweise `"Sent Items"`, einschließlich richtigem Escaping. Das ist ein belegter Protokollfehler, aber noch kein Nachweis, dass genau diese Serverantwort beim Nutzer zum Leerzustand führt. Ein strikt ablehnender Server sollte einen Fehler erzeugen; warum der Nutzer „leer“ sieht, muss zusätzlich entlang Serverantwort und UI verfolgt werden.
|
||||
|
||||
### 2. Der Sonderweg für große Mailvorschauen verliert den MIME-Kontext
|
||||
|
||||
`_fetch_message` wechselt bei mehr als 8.000.000 Rohbytes in `_oversized_message`. `_partial_text` holt einen Ausschnitt von `BODY.PEEK[TEXT]` und parst ihn mit einem künstlichen Subject-Header, aber ohne die ursprünglichen MIME-Header und Multipart-Grenzinformationen.
|
||||
|
||||
Ein synthetischer Multipart-Test an der echten `_partial_text`-Funktion zeigte MIME-Header und Base64-Anlageninhalt als Nachrichtentext. Dieser Befund erklärt eine größenabhängig kaputte Vorschau sehr konkret. Er beweist keine Veränderung der Originalanlage im Export; dessen vollständiger Abruf läuft anders.
|
||||
|
||||
### 3. Anzeige und Export verwenden eine verlustbehaftete Textfassung
|
||||
|
||||
`backend/app/mailpack.py::_html_text` entfernt HTML-Tags mit regulären Ausdrücken. Tabellenstruktur, Layout und Inline-Bilder bleiben dabei nicht erhalten; HTML-Entities werden nicht zuverlässig als Zeichen ausgegeben. Ein Test mit einer HTML-Mail lieferte `A & B` statt `A & B` und eine flache Zeichenfolge statt der Tabelle.
|
||||
|
||||
Der Export schreibt `mail.raw` als EML, die Lesefassung aber aus `mail.parsed.text`. Deshalb können EML und Lesefassung unterschiedlich aussehen. Das erklärt die Beobachtung einer Umformatierung, ohne daraus bereits einen Defekt der extrahierten PDF-/Bilddateien abzuleiten.
|
||||
|
||||
### 4. Angefügte EML-Nachrichten können unbemerkt fehlen
|
||||
|
||||
`parse_mail` überspringt alle Parts mit `is_multipart()`. Das trifft auch auf `message/rfc822` zu. Der anschließende Baumdurchlauf kann dafür den inneren Text einer angehängten E-Mail dem äußeren Nachrichtentext zuschlagen.
|
||||
|
||||
Eigener Test: Eine Nachricht mit `weitergeleitet.eml` als Anlage wurde mit **null Anlagen**, **keinem Fehlhinweis** und einer Mischung aus äußerem und innerem Text aufbereitet. Das betrifft auch den Export und seine Vollständigkeitsbehauptung.
|
||||
|
||||
### 5. Große Anlagen sind nicht grundsätzlich beschädigt
|
||||
|
||||
Eine synthetische gewöhnliche Base64-Anlage mit 9.000.000 Bytes wurde von `parse_mail` mit gleicher Länge und identischem SHA-256 extrahiert. Die konkrete Anlage des Nutzers muss deshalb anhand ihrer tatsächlichen MIME-Struktur und der heruntergeladenen Bytes geprüft werden; „groß“ allein ist noch keine Ursache.
|
||||
|
||||
### 6. MIME-kodierte Dateinamen werden je nach Zugriff verschieden angezeigt
|
||||
|
||||
Die Vorschau nutzt `_decode`, der vollständige Parser dagegen `_header_text`, das solche Header nicht dekodiert. Mit derselben synthetischen E-Mail wurde reproduziert:
|
||||
|
||||
- Vorschau: `Buero Uebergabe.pdf`.
|
||||
- Reader/Export: `=?utf-8?q?Buero_Uebergabe=2Epdf?=`.
|
||||
|
||||
Das passt unmittelbar zur Nutzerpräzisierung. MIME-/Headerdekodierung für Anzeigename und Exportnamen vereinheitlichen, einschließlich RFC-2231-Parametern. Einen sicheren Archiv-Dateinamen vom angezeigten Originalnamen trennen; notwendige Pfadbereinigung und Kollisionsbehandlung erhalten.
|
||||
|
||||
## Umsetzungsauftrag an Cursor
|
||||
|
||||
Erhalte die bestehende Connector-Architektur und die übrige Nacharbeit. Schließe gezielt diese Fehler, ohne neue Grundlagenanalyse oder zusätzliche Produktfunktionen.
|
||||
|
||||
1. Ordnernamen an allen IMAP-Auswahl-/Abrufstellen korrekt als Protokollstrings behandeln. Leerzeichen, Anführungszeichen, Backslash und erforderliche Zeichenkodierung testen. CR/LF weiter ablehnen. Rohname für die Protokolladresse und lesbares Label getrennt halten.
|
||||
2. Den echten betroffenen Ordner ausschließlich lesend diagnostizieren, soweit eine bestehende autorisierte Verbindung zugänglich ist: Konto/Host und vollständigen Ordnerpfad vergleichen, LIST-Zuordnung, EXAMINE-Status und EXISTS, UIDNEXT/UIDVALIDITY und begrenzte Suchantwort erfassen. Keine Credentials oder privaten Inhalte protokollieren. Outlook-Cache beziehungsweise ein anderer Ordner ist eine zu prüfende Möglichkeit, keine feststehende Erklärung.
|
||||
3. Wenn EXAMINE einen befüllten Ordner meldet, aber die Aufbereitung keine Einträge ergibt, Leerzustand nicht ungeprüft behaupten. Fehler, nicht abgeschlossene Suche, widersprüchliche Antworten und wirklich leer unterscheiden. Das große-Folder-Paging erhalten; nicht unbegrenzt alle Nachrichten laden.
|
||||
4. Die große Vorschau über korrekt ausgewählte Text-/HTML-MIME-Parts und deren Transfer-Encoding/Charset aufbauen. Keine beliebig abgeschnittene Multipart-Rohstruktur als fertigen Mailtext ausgeben. Falls eine vollständige Vorschau nicht möglich ist, klar als begrenzt kennzeichnen; MIME-Fragmente und Base64-Blöcke nicht als Nutztext ausgeben.
|
||||
5. Einen gemeinsamen MIME-Baum für Vorschau, Lesen, Anlagenabruf und Export auswerten. Alternative Körperdarstellungen, related/Inline-Ressourcen und echte Anlagen trennen. Angehängte E-Mails als eigene vollständige Anlage erhalten; deren Inhalt nicht in die äußere Nachricht einmischen. Doppelte Namen bleiben getrennt.
|
||||
6. EML-Originalbytes unverändert erhalten. Originalanlagen als korrekt transferdekodierte Nutzbytes liefern; keine Bild-/PDF-Neuerzeugung und keine Textdekodierung binärer Nutzdaten. Unbekannte oder nicht sicher dekodierbare MIME-Parts ausdrücklich als Grenze melden, statt unbemerkt Vollständigkeit zu behaupten.
|
||||
MIME-kodierte Dateinamen in Vorschau, Reader, Download und Export konsistent dekodieren. Anzeigename und sicherer Archiv-Dateiname bleiben unterscheidbar; technische Sicherheitsbereinigung darf keinen unverständlichen MIME-Header als Namen hinterlassen.
|
||||
7. Für HTML-Mails eine sichere formatierte Ansicht mit vorhandenen lokalen Inline-Ressourcen vorsehen. Skripte, aktive Inhalte und automatische externe Nachladezugriffe sperren. Eine vereinfachte Textfassung darf zusätzlich bestehen, muss als solche erkennbar sein. Keine Zusage pixelgleicher Outlook-Darstellung. Im Export Original-EML und Originalanlagen erhalten; eine formatierte Lesefassung sicher bereitstellen oder verbleibende Darstellungsgrenzen klar benennen. Nicht das unveränderte EML durch eine neu serialisierte Mail ersetzen.
|
||||
|
||||
## Konkrete Abnahme
|
||||
|
||||
- Sent Items mit Leerzeichen und mehr als 4.000 Nachrichten: derselbe serverseitige Ordner liefert erste Seite und spätere Treffer; Suche findet einen bekannten Treffer. Serverantwort und Anzeige passen zusammen. Zusätzlich Ordnernamen mit Quote/Backslash und ein echter leerer Ordner.
|
||||
- Dieselbe synthetische MIME-Struktur unterhalb und oberhalb der Vorschaugrenze: gleicher lesbarer Körper und gleiche Anlagenliste, abgesehen von einer ausdrücklich angegebenen Textkürzung. Kein sichtbarer MIME-/Base64-Rest.
|
||||
- HTML-Tabelle, Entities, Unicode-/kodierte Header und Dateinamen, quoted-printable und Base64, Inline-CID-Bild und angehängte EML prüfen. Innere EML bleibt als Anlage vollständig und getrennt. Nicht unterstützte Sonderformate als solche behandeln.
|
||||
- Für eine betroffene Nutzer-Mail EML lokal vergleichen. Danach jede extrahierte Anlage zwischen Tsumugu-Download, ZIP-Export und der aus derselben EML korrekt gespeicherten Anlage vergleichen: Bytezahl und SHA-256. Bericht trennt Dateiname, Darstellung und tatsächliche Byteabweichung.
|
||||
- Export meldet eine ausgelassene oder fehlerhafte Anlage; kein stiller Verlust. Die bestehende Regel „vollständige E-Mail einschließlich aller Anlagen trotz separat abgewähltem Vorkommen“ erhalten.
|
||||
- Tests synthetisch und an echten Quellen getrennt berichten. Nicht verfügbare Nutzerfälle bleiben offen. Keine produktive DB für Regressionstests, kein Push und kein Deployment.
|
||||
|
||||
## Primärquellen
|
||||
|
||||
- [RFC 9051 – IMAP4rev2](https://www.rfc-editor.org/rfc/rfc9051.html): Mailboxnamen, Protokollstrings, Auswahl und Identität. Weiterhin bestehende IMAP4rev1-Server unterstützen.
|
||||
- [Python – email.message](https://docs.python.org/3/library/email.message.html): MIME-Baum und `is_multipart()`, insbesondere `message/rfc822`. Details mit der eingesetzten Python-Version abgleichen.
|
||||
- [RFC 2045 – MIME](https://www.rfc-editor.org/rfc/rfc2045.html): Content-Type und Transfer-Encoding.
|
||||
@@ -0,0 +1,129 @@
|
||||
# Korrekturauftrag an Cursor: Connectoren, IMAP, Mailaufbereitung und Markdown
|
||||
|
||||
**Stand:** 20.10.2026
|
||||
**Repository:** `C:/Dev/tsumugu`
|
||||
**Zielort:** `docs/product/TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md`
|
||||
**Umfang:** Die nachstehend gebündelten Korrekturen und ihre lokale Abnahme sind beauftragt. Kein Push und kein Deployment.
|
||||
|
||||
## 1. Führender Auftrag und Befundquellen
|
||||
|
||||
Dieser Auftrag bündelt beide Prüfberichte vom 20.10.2026. Er ist der gemeinsame Umsetzungseinstieg; die Einzelberichte bleiben die Quellen für Reproduktion, Fundstellen und Nachweisgrenzen. Doppelte Aufgaben nur einmal lösen. Frühere bereits korrekt umgesetzte Funktionen erhalten.
|
||||
|
||||
**R – vorherige Prüfung:** [Connector-Nacharbeit: Review vom 20.10.2026](TSUMUGU_CONNECTOR_NACHARBEIT_REVIEW_2026-10-20.md)
|
||||
|
||||
- R1 = Abschnitt 1: externe Abrufe und Fachtransaktionen.
|
||||
- R2 = Abschnitt 2: unterschiedlicher Markdown-Umfang in Editor und Leser.
|
||||
- R3 = Abschnitt 3: nur nominelle Leser-/Editor-Registrierung.
|
||||
- R4 = Abschnitt 4: verspätete Paperless-Antworten.
|
||||
- R-N = Abschnitt „Nachweisgrenzen“: echte Filterwirkung und Bediennachweis des dritten Connectors.
|
||||
|
||||
**M – ergänzende Mailprüfung:** [Sent Items und MIME: Befund und Fixauftrag](TSUMUGU_IMAP_SENT_ITEMS_MIME_BEFUND_UND_FIXAUFTRAG_2026-10-20.md)
|
||||
|
||||
- M1 = Befund 1: ungeschützte IMAP-Ordnernamen mit Leerzeichen.
|
||||
- M2 = Befund 2: verlorener MIME-Kontext in großen Vorschauen.
|
||||
- M3 = Befund 3: verlustbehaftete HTML-Textfassung.
|
||||
- M4 = Befund 4: ausgelassene angehängte EML und vermischte Nachrichtentexte.
|
||||
- M5 = Befund 5: synthetischer Integritätsnachweis für eine normale große Anlage.
|
||||
- M6 = Befund 6: unterschiedliche Dekodierung von Dateinamen.
|
||||
|
||||
Die Berichte liegen bei Übergabe gemeinsam mit diesem Auftrag unter:
|
||||
|
||||
`C:/Users/lars/Documents/Codex/2026-10-17/lies-zuerst-c-dev-tsumugu-docs/outputs/`
|
||||
|
||||
Übernimm die drei Dokumente nach `docs/product`, damit die relativen Verweise dort funktionieren. Verlinke den gemeinsamen Auftrag in `docs/README.md` und der Planungsübergabe. Keine Änderungen an den historischen Befundbehauptungen, um inzwischen erfolgte Korrekturen zu verdecken; neue Ergebnisse ergänzen.
|
||||
|
||||
Lies außerdem `AGENTS.md`, die betroffenen bestätigten Entscheidungen in `docs/product/TSUMUGU_PRODUCT_SPEC.md`, die bisherigen Connector-Abschlusskriterien und den Source-/Storage-Vertrag. Die Architekturvorlagen liegen unter **`docs/reference/`**. Bestehende Gestaltung, Fachmodell und Fremdänderungen erhalten. Kein Neustart der Grundlagenarbeit.
|
||||
|
||||
## 2. Beobachtung, Befund und offene Ursache
|
||||
|
||||
- „Sent Items“ ist laut Nutzer in Outlook mit mehr als 4.000 Nachrichten befüllt, erscheint in Tsumugu aber leer. Die ungeschützte Übermittlung des Namens ist reproduziert; die tatsächliche Ursache des Leerzustands an dieser Nutzerquelle ist noch nicht abschließend nachgewiesen.
|
||||
- Der Nutzer hat die Anlagenbeobachtung präzisiert: **Dateiname beziehungsweise Anzeige verändert**. Er hat keine beschädigten heruntergeladenen Dateiinhalte und keine fehlenden Anlagen berichtet.
|
||||
- Die Auslassung angehängter EML ist ein zusätzlicher synthetisch reproduzierter Parserfehler. Sie ist keine Umdeutung der Nutzerbeobachtung.
|
||||
- Eine gewöhnliche Base64-Anlage mit 9.000.000 Bytes wurde synthetisch bytegleich extrahiert. Das beweist weder einen generellen Defekt großer Anlagen noch die Korrektheit aller MIME-Sonderfälle.
|
||||
- Die bisherigen 82 Tests und der Build sind gemeldete historische Ergebnisse. Sie ersetzen die gezielte Abnahme der folgenden Korrekturen nicht.
|
||||
|
||||
## 3. Gebündelte Korrekturen und Abnahme
|
||||
|
||||
### K1 – Sent Items und andere IMAP-Ordner korrekt öffnen
|
||||
|
||||
**Quellen:** M1, Nutzerbeobachtung im Mailbericht.
|
||||
|
||||
- Ordnernamen in allen Auswahl-/Abrufpfaden als korrekte IMAP-Protokollstrings behandeln: Leerzeichen, Quotes, Backslash und notwendige Zeichenkodierung. Rohname und sichtbares Label getrennt halten. CR/LF weiter ablehnen.
|
||||
- Den betroffenen Ordner über eine vorhandene autorisierte Verbindung lesend diagnostizieren, soweit erreichbar: Konto/Host und vollständigen Ordnerpfad, LIST-Zuordnung, EXAMINE-Status/EXISTS, UIDNEXT/UIDVALIDITY sowie begrenzte Suchantwort vergleichen. Keine privaten Inhalte oder Credentials protokollieren. Gleichen Ordner in Outlook und IMAP prüfen; nicht ungeprüft Outlook-Cache oder Ordnergröße zur Ursache erklären.
|
||||
- Bei widersprüchlichen Antworten, fehlgeschlagenem Abruf oder nicht abgeschlossener Suche keinen endgültigen Leerzustand melden. Begrenztes Paging erhalten.
|
||||
|
||||
**Abnahme:** Ordner mit Leerzeichen und mehr als 4.000 Nachrichten liefert die erste Seite und einen bekannten späteren Suchtreffer. Zusätzlich echte Leere, Suchfehler, UID-Lücken und Namen mit Quote/Backslash prüfen. Ist die echte Quelle nicht verfügbar, synthetischen Nachweis liefern und die reale Nutzerabnahme ausdrücklich offen lassen.
|
||||
|
||||
### K2 – MIME-Aufbereitung, Namen und Maildarstellung vereinheitlichen
|
||||
|
||||
**Quellen:** M2, M3, M4, M5, M6.
|
||||
|
||||
- Vorschau, vollständiges Lesen, Anlagenabruf und Export verwenden dieselbe fachlich korrekte MIME-Auswertung. Unterschiedliche Größenlimits dürfen keinen Wechsel zu einer falsch interpretierten Rohstruktur erzeugen.
|
||||
- Große Vorschauen gezielt aus passenden Text-/HTML-Parts und deren Transfer-Encoding/Charset gewinnen. Abgeschnittene Multipart-Fragmente nicht mit künstlichen Headern als fertige Mail parsen. Bei Begrenzung einen klaren Zustand liefern; keine MIME-Header oder Base64-Anlagen als Nachrichtentext anzeigen.
|
||||
- MIME-kodierte Header und Dateinamen in allen Ansichten konsistent dekodieren, einschließlich RFC-2231-Parametern. Angezeigten Originalnamen von sicherem Archiv-Dateinamen trennen; Pfadbereinigung und Kollisionsbehandlung erhalten.
|
||||
- Echte Anlagen, HTML-/Textalternativen und lokale Inline-Ressourcen unterscheiden. Angehängte `message/rfc822`-Nachrichten vollständig als eigene Anlage erhalten. Deren Text nicht in die äußere Nachricht mischen. Doppelte Dateinamen bleiben getrennt.
|
||||
- Eine sichere formatierte HTML-Mailansicht mit lokalen Inline-Ressourcen bereitstellen. Keine Skripte, aktiven Inhalte oder automatischen externen Nachladezugriffe. Eine zusätzliche vereinfachte Textfassung bleibt als solche erkennbar. Keine Zusage pixelgleicher Outlook-Darstellung.
|
||||
- Original-EML unverändert erhalten. Anlagen als korrekt transferdekodierte Original-Nutzbytes ausgeben, keine PDF-/Bild-Neuerzeugung. Export enthält weiterhin die vollständige EML und alle Anlagen; eine formatierte Lesefassung sicher bereitstellen oder verbleibende Darstellungsgrenzen klar benennen. Fehlerhafte oder ausgelassene Teile nicht still als vollständig melden.
|
||||
|
||||
**Abnahme:** Dieselbe MIME-Struktur unter und über der bisherigen 8-MB-Vorschaugrenze; konsistente Körperdarstellung und Anlagenliste. Zusätzlich kodierte Dateinamen, HTML-Tabelle/Entities, Unicode, Base64/quoted-printable, Inline-CID-Bild, doppelte Namen und angehängte EML. Für eine betroffene Nutzer-Mail die Namen und Darstellung direkt vergleichen. Bytezahl und SHA-256 der extrahierten Anlagen zwischen Download, ZIP und korrekt aus derselben EML gespeicherter Anlage als Integritätskontrolle vergleichen. Separat abgewählte Anlage-Vorkommen dürfen weiterhin nicht die Anlagen der exportierten E-Mail entfernen.
|
||||
|
||||
### K3 – Externe Arbeit und Fachtransaktion wirklich trennen
|
||||
|
||||
**Quelle:** R1.
|
||||
|
||||
- Verbindungsdaten vor dem externen Abruf vollständig auflösen. Im externen Abschnitt keine DB-Nachfrage einbauen, die unmittelbar wieder eine Transaktion eröffnet.
|
||||
- IMAP-Lesen, Quellenexport und Abruf für Versandfassungen über dieselben belastbaren Zugriffsgrenzen führen. Nach externer Arbeit erforderliche aktuelle Rechte, Instanz und Version erneut prüfen.
|
||||
- Upload-/Snapshot-Veröffentlichung mit sicheren vorbereitenden und abschließenden DB-Phasen sowie nachvollziehbarer Bereinigung ausführen. Ein pauschales Zwischen-Commit ersetzt keinen korrekten Schreibablauf. Bestandsreferenzen, Generationen und gesicherte Versandbytes erhalten.
|
||||
|
||||
**Abnahme:** An den tatsächlichen Transport-/Speichergrenzen nachweisen, dass keine Fachtransaktion offen ist; nicht nur prüfen, ob eine Hilfsfunktion vorher `commit` aufruft. Entzug, konkurrierende Änderung, externer Fehler und abschließender DB-Fehler führen zu keiner unberechtigten Ausgabe oder scheinbar vollständig gespeicherten Teilfassung. Keine neue Kryptografie.
|
||||
|
||||
### K4 – Gespeicherte Markdown-Ansicht entspricht dem Editor
|
||||
|
||||
**Quelle:** R2.
|
||||
|
||||
- Einen sicheren, zum Editor passenden Markdown-Renderer einsetzen. Keine weiteren Regex-Sonderfälle als Ersatz für korrekte Markdown-Struktur.
|
||||
- Vom Editor angebotene Überschriften, verschachtelte Listen und Anfangswerte geordneter Listen im Leser korrekt darstellen. Quelltext außerhalb des unterstützten visuellen Umfangs verlustfrei erhalten.
|
||||
- Notiz öffnet gerendert; Bearbeiten, Speichern, Abbrechen und Konflikterhalt funktionieren weiterhin. Gemeinsamer Notizinhalt bleibt gemeinsam, lokale Anmerkungen lokal.
|
||||
|
||||
**Abnahme:** Überschriften 1–6, verschachtelte Listen, Liste ab 5, Zitate, Links und Code im Editor, nach Speichern, nach Wiederöffnung und nach Quelltextwechsel vergleichen. Quelltext/Export ohne Inhaltsverlust, schädliches HTML/Links und externe Medien weiterhin geschützt.
|
||||
|
||||
### K5 – Ausführbare Leser und Editoren registrieren
|
||||
|
||||
**Quelle:** R3; ergänzend R-N.
|
||||
|
||||
- Tatsächliche Anzeige-/Editorkomponenten mit gemeinsamen Lade-, Speicher-, Abbruch- und Konfliktverträgen registrieren. Die allgemeine Leserhülle ruft die registrierte Komponente auf.
|
||||
- Eine Zuordnung neuer Mediennamen auf weiterhin fest eingebaute Leserzweige genügt nicht. Neue Leser-/Editorbausteine dürfen keine Änderung an Akten-/Vorgangsseiten oder am allgemeinen Reader verlangen.
|
||||
- Interne Notizen behalten ihren bisherigen Speicherweg und ihre Identität. Kein künstlicher externer Notiz-Connector und keine neue MD-Dateischreibfunktion.
|
||||
|
||||
**Abnahme:** Eine zusätzliche Testdarstellung und einen Testeditor nur durch ihre Module und Registrierung integrieren und tatsächlich über die Leserhülle bedienen. Vorhandenen dritten Test-Connector in der Testoberfläche einrichten, suchen, öffnen, einbinden, erneut öffnen und exportieren. Keine weiteren produktiven Dienste erforderlich; ein reiner Registry-Test in Node genügt nicht.
|
||||
|
||||
### K6 – Paperless-Antworten an die aktuelle Anfrage binden
|
||||
|
||||
**Quelle:** R4.
|
||||
|
||||
- Überholte Such-, Vorschau- und Stammdatenantworten beim Instanz-/Suchwechsel ignorieren oder abbrechen. Sie dürfen weder Ergebnisse noch Instanzauswahl zurücksetzen.
|
||||
- Fremde Filter-IDs beim Instanzwechsel zurücksetzen oder ausdrücklich neu validieren. Bewusste Auswahl weiterhin unter gespeicherter Instanz und Ressourcen-ID erhalten.
|
||||
|
||||
**Abnahme:** Antwort A verzögern, zu Instanz beziehungsweise Suche B wechseln, danach A zustellen. Ergebnisse, Vorschau, Filter und Zugang bleiben bei B. Dasselbe für mehrfache schnelle Wechsel und Schließen der Ansicht prüfen.
|
||||
|
||||
### K7 – Noch fehlende Nachweise sauber schließen
|
||||
|
||||
**Quelle:** R-N; reale Abnahme im Mailbericht.
|
||||
|
||||
- Paperless-Tests müssen Filterwirkung auf unterscheidbaren Testdaten belegen, zusätzlich zur Parameterübertragung: Suchwort nur im Inhalt, getrennte Titeleingrenzung, kombinierte Metadaten-/Datumsfilter und mehrere Seiten. Ein Fake, der unabhängig von den Parametern dieselben Treffer liefert, belegt keine Suchsemantik.
|
||||
- Reale Paperless-Abnahme an der vorhandenen autorisierten Instanz lesend ausführen, soweit verfügbar. Schemaauslesen und tatsächliche Dokumentabfrage sind verschiedene Nachweise.
|
||||
- Reale IMAP-Abnahme aus K1 und konkrete problematische Mail aus K2 prüfen, soweit verfügbar. Nicht verfügbare Anschlüsse oder fehlende konkrete Beispieldaten als offen benennen; keine Credentials beschaffen oder Inhalte extern veröffentlichen.
|
||||
|
||||
**Abnahme:** Der Abschlussbericht trennt je Punkt Umsetzung, synthetischen Funktionsnachweis, Bediennachweis und tatsächlichen Quellencheck. Ein nicht ausgeführter Realtest erhält keinen Status „bestanden“.
|
||||
|
||||
## 4. Durchführung und Abschluss
|
||||
|
||||
1. Aktuellen Code gezielt gegen K1–K7 prüfen. Bereits behobene Punkte mit ihrem konkreten Nachweis übernehmen; keine Änderungen nur zum Nachbauen alter Fundstellen. Zeilenangaben in den Berichten beziehen sich auf den damaligen Stand.
|
||||
2. Mit den unmittelbar störenden Mailproblemen K1/K2 beginnen und die nötigen gemeinsamen Änderungen aus K3/K5 einbeziehen. Bestehende Funktionen weiterverwenden. Die übrigen Korrekturen gehören zum selben Auftrag und werden nicht still zurückgestellt.
|
||||
3. Passende Regressionstests gezielt ergänzen, dann relevante Gesamttests und Frontend-Build ausführen. Bestandene breite Läufe ohne neue Änderung oder offene Sorge nicht ständig wiederholen. Keine produktive DB für automatisierte Tests.
|
||||
4. Betroffene UI auf Desktop und bei 390/360 px prüfen: Fokus, Tastatur, Fehler, Laden, Leerzustand und Abbruch. Gewählte Gestaltung und kompakte Inhaltslisten erhalten.
|
||||
5. Bestehende Abschlussmatrix und betroffene API-/Architekturdokumentation gezielt nachführen. Keine neue vollständige Grundlagen-Spezifikation.
|
||||
|
||||
Liefere abschließend eine kurze Matrix mit **K1–K7, geändertem Verhalten, konkretem Nachweis, Ergebnis und verbleibender Grenze**. Bei Blockern deren Auswirkung benennen, während unabhängige Korrekturen weiterlaufen. Ein funktionierender Zwischenstand darf als solcher übergeben werden; den gesamten Auftrag erst bei erfüllten Kriterien als abgeschlossen melden.
|
||||
|
||||
Weiterhin außerhalb dieses Auftrags: Finanzfunktionen, KI, bidirektionale Paperless-Synchronisation, neue SaaS-/Runtime-/Kryptografieplattform und produktive weitere Speicheranbieter. Kein Push, Deployment, externer Versand oder Eingriff in andere Produkte.
|
||||
@@ -19,6 +19,10 @@ Diese Datei sichert bestätigte Anforderungen, den Quellenabgleich und das näch
|
||||
|
||||
**Kennzeichnung in dieser Datei:** Bestätigt = aktueller Nutzerauftrag oder direkt lesbare ursprüngliche Nutzeraussage; Rekonstruktion = nur durch Recovery belegt; Vorschlag = neue Empfehlung ohne Freigabe; Offen = noch zu entscheiden. Technische Discovery-Vorschläge werden nicht zu Fachanforderungen erhoben.
|
||||
|
||||
**Implementierungsnachweis 19.10.2026, ohne neue Fachversion:** Die lesende Connector-/Storage-Grundlage ist lokal umgesetzt. Das ist ein Implementierungsnachweis zum Vertrag v0.1, keine neue bestätigte Produktentscheidung und keine Aufhebung von F-02b oder F-02c. Die erste Source-Lieferung bleibt lesend. Bidirektionale Feldsynchronisation bleibt der spätere Ausbau. Die Nacharbeit an großen IMAP-Fächern, der Paperless-Suche und der internen Markdown-Notiz ist beauftragt und lokal umgesetzt: [TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md](TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md). Eine Notiz bleibt ein interner Gegenstand. Beim Öffnen erscheint zuerst die gesetzte Markdown-Fassung. Mit Bearbeitungsrecht folgt eine formatierte Bearbeitung mit Formatierungsleiste und umschaltbarem Markdown-Quelltext. Weicht die formatierte Ansicht vom gespeicherten Markdown ab, bleibt der Quelltext maßgeblich. Die Abschlusskriterien in [TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md](TSUMUGU_CONNECTOR_ABSCHLUSSKRITERIEN_2026-10-19.md) haben Vorrang vor einem nur teilweise integrierten Zwischenstand. Nachweis, Grenzen und die Matrix stehen in [TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md](TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md). Der frühere Zwischenstand bleibt in [TSUMUGU_CONNECTOR_BASIS_ERGEBNIS_2026-10-19.md](TSUMUGU_CONNECTOR_BASIS_ERGEBNIS_2026-10-19.md).
|
||||
|
||||
**Implementierungsnachweis 20.10.2026, ohne neue Fachversion:** Die Korrektur K1–K7 ist lokal umgesetzt: [TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md](TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md). IMAP-Fachnamen mit Leerzeichen, Anführungszeichen oder Backslash gehen als gequotete Protokollargumente an den Server. Die gemeinsame MIME-Auswertung trennt Anzeigenamen und Archivnamen und liefert eine bereinigte HTML-Ansicht neben einer gekennzeichneten Textfassung. Externe Abrufe und die Veröffentlichung von Dateibytes laufen außerhalb der offenen Fachtransaktion; der fachliche Abschluss folgt danach. Der Markdown-Leser stellt die Ebenen 1–6, verschachtelte Listen und den Listenstart dar. Neue Leser hängen an der Registrierung. Verspätete Paperless-Antworten ändern nicht die inzwischen gewählte Instanz. F-02b und F-02c bleiben offen. Eine echte Postfach- und Dokumentprüfung an den bestehenden Zugängen ist nicht erfolgt.
|
||||
|
||||
## 2. Gesicherter fachlicher Kern
|
||||
|
||||
**Bestätigt durch aktuellen Auftrag und/oder ursprüngliche Nutzeraussagen:**
|
||||
@@ -432,6 +436,18 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G
|
||||
|
||||
**Lieferung und Grenzen zu F-08b/c:** Der gemeinsame [Anforderungs- und Cursor-Auftrag vom 18.10.2026](TSUMUGU_SCHREIBEN_ANLAGEN_VERSAND_AUFTRAG_2026-10-18.md) konkretisiert Anlage-/Nachweisrollen, gesicherte Fassungen, Listen-/Chronologiedarstellung, Bestandsübergang, Kontextrechte und Export einschließlich vollständiger EML gemäß F-07c. Er ersetzt die historische Zurückstellung eines Hauptdokuments/Dokumentpakets für diese neue Lieferung; F-08a bleibt als Kapitelmodell erhalten. Detailregeln des Auftrags sind die aktuelle Umsetzungsausgestaltung, keine Behauptung bereits implementierter oder früher einzeln bestätigter Funktionen. Dieses Dokumentationspaket ändert keine Anwendung, Datenbank oder Bereitstellung.
|
||||
|
||||
### R-01 – Datenräume als Teams, Raum-Eigentümer und Raumfreigabe: bestätigt am 20.10.2026
|
||||
|
||||
**Beschluss:** Der Nutzer bestätigt: (1) Ein Datenraum ist ein **Team**, kein Ablageort einer Akte. Jede Person kann mehrere Räume anlegen. Ein Raum ist privat, solange nur der Eigentümer Mitglied ist, und wird durch Aufnehmen von Personen zum Mehrbenutzer-Raum. Der persönliche Raum bleibt unverändert. (2) Der Ersteller ist Eigentümer, solange er die Rolle innehat. Er verwaltet Mitglieder, Rollen, Name, Archivierung und Übertragung, liest aber über diese Rolle keine fremden Inhalte. Der Raum ist übertragbar; der Betreiber kann protokolliert einspringen. (3) **Raumfreigabe:** Der Owner einer Akte, Unterakte oder eines Vorgangs teilt sie mit einem oder mehreren seiner Räume, unabhängig davon, wo der Eintrag abgelegt ist. Die Mitglieder erhalten Rechte nach ihrer Rolle im Raum: Leser lesen, Mitglied und Verwalter bearbeiten. Die Freigabe kann auf „nur lesen“ begrenzt werden. Der Owner kann einzelne Personen ausnehmen. Weitergeben, Löschen und Eigentum bleiben beim Owner. Ein Vorgang lässt sich einzeln teilen, ohne dass die Akte oder die übrigen Vorgänge sichtbar werden. (4) Der Owner sieht seine Einträge unabhängig von jedem Raum.
|
||||
|
||||
**Begründung und Auswirkungen:** Die Akte bleibt der Rechteanker (F-01, S-01); die Raumfreigabe ist eine zweite, dynamische Rechtequelle neben den Einzelfreigaben je Person. Der Heimatraum eines Eintrags ist nur noch Ablage und Mandantengrenze (Technische Spezifikation 4.1) und bestimmt keine Rechte. Bestehende Freigaben der ersten Fassung (Freigabe an den Heimatraum) wurden in Raumfreigaben übernommen; Einträge ohne Freigabe bleiben privat. Quellzugänge des Owners (Paperless, Mail) werden durch die Raumfreigabe nicht automatisch mitgegeben. Seit dem 04.11.2026 (Änderung durch den Nutzer) kann der Owner sie aber im Raum je Person ausdrücklich freigeben („Originale über meine Zugänge“): Die Freigabe gilt dann für alle seine mit diesem Raum geteilten Akten und Vorgänge, solange die Person dort aktives Mitglied mit Leserecht ist. Damit bleibt die Quellenfreigabe eine Entscheidung je Person, ohne sie an jeder Akte einzeln setzen zu müssen. Die Einzelfreigabe mit der Option bleibt daneben bestehen. Elemente und Aufgaben ohne Akte oder Vorgang bleiben beim Owner. Verlässt eine Person ein Team oder wird sie Leser, enden ihre Freigaben an dieses Team. Umsetzungsstand: [BENUTZERVERWALTUNG.md](../architecture/BENUTZERVERWALTUNG.md).
|
||||
|
||||
### R-02 – Betreiber, Hauptnutzer und Mitarbeiter: bestätigt am 22.10.2026
|
||||
|
||||
**Beschluss:** Der Nutzer bestätigt das SaaS-Zielbild. (1) Der **Betreiber** ist der Superadmin des Dienstes. Er verwaltet die Hauptnutzer, sieht alle Datenräume (Konten, Rollen, Zustand, keine Inhalte) und eine Übersicht aller Teammitglieder, um seiner Rechenschaftspflicht nachzukommen. (2) Ein **Hauptnutzer** erhält später über ein Subscription-Modell seinen eigenen Arbeitsbereich. Er hat einen privaten Raum und beliebig viele Team-Räume, ist deren Eigentümer, lädt Mitarbeiter ein und verwaltet sie und ihre Rechte je Raum. (3) Ein **Mitarbeiter** arbeitet nur in den Räumen, in die er eingeladen wurde, nach der zugewiesenen Rolle. Er legt keine Räume an und führt keinen eigenen privaten Arbeitsbereich. Eine Einladung erzeugt immer ein Mitarbeiter-Konto; vollwertig wird ein Konto nur durch den Betreiber. (4) Die Subscription begrenzt später die Zahl der Mitarbeiter je Hauptnutzer und gegebenenfalls je Raum.
|
||||
|
||||
**Begründung und Auswirkungen:** Ohne diese Trennung könnte jeder Raum-Verwalter unbegrenzt vollwertige Konten erzeugen, und der Betreiber hätte keinen Überblick. Umgesetzt sind Kontoart, Förderer, Mein Team, die Team-Übersicht des Betreibers und eine zentrale Prüfstelle für Grenzen ohne Tarife (`access/limits.py`). Offen und für das Sicherheits- und Tarifkonzept vorgesehen: Pläne und Zahlung, die Grenzen selbst, Quellzugänge von Mitarbeitern. Umsetzungsstand: [BENUTZERVERWALTUNG.md](../architecture/BENUTZERVERWALTUNG.md).
|
||||
|
||||
## 6. Fortschreibung
|
||||
|
||||
16.10.2026, Arbeitsstand 0.1: Recovery vollständig gelesen, Repository-Unterlagen gezielt abgeglichen, ursprüngliche Nutzernachrichten geprüft und Ergänzungen gesichert. Historische Baseline unverändert übernommen.
|
||||
|
||||
@@ -0,0 +1,65 @@
|
||||
# Auftrag: Release-Gate, Backup und Restore für Produktion (P7, Review R-21)
|
||||
|
||||
**Stand:** 22.10.2026 · **Status:** Vorbereiteter Umsetzungsauftrag für eine eigene Sitzung, getrennt von der Fachentwicklung. Kein Push auf `main`, kein Eingriff in die laufende Produktion ohne ausdrückliche Freigabe.
|
||||
|
||||
## 1. Ziel
|
||||
|
||||
Bevor echte personenbezogene Daten in Produktion liegen, muss ein Merge nach `main` sicher sein. Heute baut `deploy-prod.yml` bei jedem Push auf `main` auf dem Host neu und startet die Produktion, ohne Test davor, ohne Backup und ohne Rückweg. Die Migrationen laufen beim Start des Backends und sind teils nicht umkehrbar (zum Beispiel entfernt `20261021T150000Z_room_shares.sql` die Spalten `visibility`).
|
||||
|
||||
Gewünscht ist die Reihenfolge des Release-Blueprints: `develop → Dev → Tests → Freigabe → main → Prüfung des Kandidaten → Prod`.
|
||||
|
||||
## 2. Lieferumfang
|
||||
|
||||
1. **Release-Gate vor Produktion:** `deploy-prod` läuft nur, wenn die Tests für genau diesen Stand grün sind. Zusätzlich eine menschliche Freigabe (Gitea-`environment` allein ersetzt sie nicht, siehe Technische Spezifikation 8.2). Ein roter oder übersprungener Test gilt nie als Erfolg.
|
||||
2. **Isolierter Testlauf:** Die Tests laufen gegen eine kurzlebige Datenbank je Lauf, nicht gegen die gemeinsame `tsumugu_test`, und nicht doppelt parallel (Review R-27). Der Testlauf prüft das gebaute Image, nicht einen Checkout im Laufzeitcontainer.
|
||||
3. **Backup vor jeder Migration in Produktion:** konsistente Sicherung von PostgreSQL und Medien (`tsumugu-media`) zu einem gemeinsamen Zeitpunkt, mit Prüfsumme und dokumentiertem Zustand. Das Deploy bricht ab, wenn die Sicherung fehlschlägt.
|
||||
4. **Aufbewahrung und unabhängige Kopie:** Startprofil laut Blueprint und Spezifikation: RPO 24 h, RTO 4 h, Sicherung alle zwölf Stunden, sieben tägliche, vier wöchentliche, drei monatliche Stände. Mindestens eine Kopie außerhalb des Hosts. Verschlüsselung der Sicherungen, der Schlüssel liegt getrennt vom Backup.
|
||||
5. **Restore, geprobt:** Wiederherstellung in eine neue Umgebung (nicht über die laufende), zuerst mit synthetischen Daten auf Dev. Nach einem Restore sind alle Sitzungen ungültig, und die Konten werden vor der Freigabe geprüft (Auth-Blueprint 12).
|
||||
6. **Rückweg bei fehlgeschlagenem Deploy:** Der Ablauf bei einer fehlgeschlagenen Migration oder einem nicht gesunden Start ist beschrieben und getestet: Prod bleibt auf dem alten Stand oder wird aus dem Backup zurückgeholt.
|
||||
7. **Dokumentation:** `docs/DEPLOYMENT.md` und die Betriebsgrenzen werden fortgeschrieben, ein kurzes Runbook für Backup, Restore und Rückweg ergänzt.
|
||||
|
||||
Nicht Teil: Fachfunktionen, ein Umbau der Anwendung, Hybrid- oder Cloud-Betrieb, ein externer Registry-Dienst (R1 mit Imageablage ist bevorzugt, bis dahin ein kontrollierter getrennter Build mit eigenem Gate für genau diesen Kandidaten).
|
||||
|
||||
## 3. Grundlagen (zuerst lesen)
|
||||
|
||||
- `AGENTS.md`, `docs/DEPLOYMENT.md`, `docs/ENTWICKLUNG_UND_TESTS.md`.
|
||||
- `docs/reference/Jinkendo_Release_Betrieb_Recovery_Blueprint.md`, insbesondere Abschnitte 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 und 15. Der Verzeichnisname ist `reference`, Singular.
|
||||
- `docs/architecture/TSUMUGU_TECHNICAL_SPEC.md`, Paket P7 und Abschnitt 8.2.
|
||||
- `docs/review/06_BEFUNDE.md` (R-21, R-23, R-27, R-09) und `docs/review/10_NACHPRUEFUNG_2026-10-20.md`.
|
||||
|
||||
## 4. Ausgangslage im Repository
|
||||
|
||||
- Workflows in `.gitea/workflows/`: `deploy-dev.yml` (Push auf `develop`), `deploy-prod.yml` (Push auf `main`), `test.yml` (Push auf `develop` und nach dem Dev-Deploy, gegen die feste Datenbank `tsumugu_test` der Dev-Postgres).
|
||||
- Compose: `docker-compose.yml` (Produktion, Volumes `tsumugu-media` und Postgres) und `docker-compose.dev-env.yml` (Dev). Der Host ist ein Raspberry Pi; der Runner läuft dort.
|
||||
- Migrationen führt das Backend beim Start aus (`backend/app/entrypoint.py`, `backend/app/db/migrate.py`): Ledger mit Prüfsumme, aber ohne Advisory-Lock, ohne Fehlend-Prüfung und mit denselben Zugangsdaten für Migration und Laufzeit (R-09).
|
||||
- Tests: `powershell -File <lokales Skript> tests` laufen lokal gegen eine eigene PostgreSQL 16 (siehe Abschnitt 6). Zahl der Tests Stand 22.10.2026: 143.
|
||||
- Es gibt kein Backup, keinen Restore und keinen Rückweg.
|
||||
|
||||
## 5. Vorgehen und Grenzen
|
||||
|
||||
1. Zuerst eine kurze Bestandsaufnahme: Was kann der Gitea-Server auf `192.168.2.144` an Branch-Schutz, Environments und Freigaben, und wie isoliert ist der Runner? Das ist laut Spezifikation ungeprüft. Ergebnis als kurze Notiz, bevor gebaut wird.
|
||||
2. Reihenfolge der Arbeit: Testlauf isolieren → Backup und Restore auf Dev bauen und proben → Gate und Freigabe → Anbindung an `deploy-prod` → Rückweg → Runbook.
|
||||
3. Produktion nicht anhalten und nicht verändern, bevor Backup und Restore auf Dev nachweislich funktionieren. Eine Änderung an `deploy-prod.yml` wird erst nach Freigabe auf `main` wirksam; bis dahin auf `develop` arbeiten.
|
||||
4. Keine Zugangsdaten, Schlüssel oder Passwörter ins Repository. Secrets liegen in der Betriebsbereitstellung.
|
||||
5. Vor jedem Push `git pull --rebase`. Die Fachentwicklung läuft parallel auf `develop` in `backend/app`, `frontend/src` und `docs/architecture`. Dieser Auftrag fasst vor allem `.gitea/workflows/`, `docker-compose*.yml`, Betriebsskripte und `docs/DEPLOYMENT.md` an.
|
||||
6. Kein Push auf `main` und kein Merge ohne ausdrückliche Anweisung des Nutzers. Jede Aktion am Raspberry Pi (Anlegen von Verzeichnissen, Cron/Timer, Schlüssel) ist vorher zu benennen und freizugeben.
|
||||
|
||||
## 6. Lokale Testumgebung
|
||||
|
||||
Auf dem Entwicklungsrechner liegt eine isolierte Umgebung unter `C:\dev\tsumugu-local` (portable PostgreSQL 16 auf `127.0.0.1:55432`, Python 3.12, virtuelle Umgebung). Der Aufruf `powershell -File C:\dev\tsumugu-local\run-tests.ps1 tests` startet die Datenbank und führt die Suite aus (rund vier Minuten). Sie berührt keine Server. Die Testdatenbank muss auf `_test` enden; das erzwingt die Suite.
|
||||
|
||||
## 7. Abnahme
|
||||
|
||||
| Nr. | Nachweis |
|
||||
|---|---|
|
||||
| 1 | Ein roter Test oder ein fehlendes Backup verhindert das Produktions-Deploy; der Ablauf bricht ab und meldet den Grund. |
|
||||
| 2 | Zwei gleichzeitige Testläufe stören sich nicht (eigene Datenbank je Lauf). |
|
||||
| 3 | Eine Sicherung von Datenbank und Medien entsteht vor der Migration, mit Prüfsumme; Restore in eine neue Umgebung stellt beide wieder her. Das Ergebnis wird mit synthetischen Daten geprüft. |
|
||||
| 4 | Nach dem Restore sind Sitzungen ungültig und Konten gesperrt, bis sie freigegeben sind. |
|
||||
| 5 | Ein absichtlich fehlerhafter Migrationsstand auf Dev lässt die Umgebung nicht halb migriert zurück; der Rückweg ist beschrieben und geprobt. |
|
||||
| 6 | Aufbewahrung und die Kopie außerhalb des Hosts sind eingerichtet und überprüft. |
|
||||
| 7 | Runbook und `docs/DEPLOYMENT.md` sind aktuell. Reale Prod-Aktionen sind vom Nutzer freigegeben und im Bericht von synthetischen Nachweisen getrennt. |
|
||||
|
||||
## 8. Übergabe
|
||||
|
||||
Kurzer Abschlussbericht: je Lieferpunkt Ergebnis, ausgeführte Tests, was nur synthetisch nachgewiesen und was an Prod noch offen ist. Neue Dokumente in `docs/README.md` verlinken und die Befunde R-21 und R-27 im Review fortschreiben.
|
||||
@@ -1,5 +1,9 @@
|
||||
# Tsumugu – Übergabe zur fachlichen Weiterplanung
|
||||
|
||||
**Nachtrag 20.10.2026:** Der Korrekturauftrag K1–K7 ist lokal umgesetzt und nicht deployed. Auftrag, Mailbefund und Review stehen in [TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md](TSUMUGU_KORREKTURAUFTRAG_CONNECTOREN_MAIL_MARKDOWN_2026-10-20.md). Die Nachweise und die offenen echten Quellenprüfungen stehen am Ende der [Abschlussmatrix](TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md). Ein lebendes Postfach und eine echte Paperless-Dokumentabfrage bleiben offen.
|
||||
|
||||
**Nachtrag 19.10.2026:** Die Connector-/Storage-Grundlage ist gegen die Abschlusskriterien geschlossen. Die Matrix steht in [TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md](TSUMUGU_CONNECTOR_ABSCHLUSSMATRIX_2026-10-19.md). Die Nacharbeit an großen IMAP-Fächern, der Paperless-Suche und der internen Markdown-Notiz ist lokal umgesetzt; Auftrag und Grenzen stehen in [TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md](TSUMUGU_CONNECTOR_NACHARBEIT_IMAP_PAPERLESS_MARKDOWN_AUFTRAG_2026-10-19.md). F-02b und F-02c bleiben erhalten; eine bidirektionale Paperless-Schreibsynchronisation startet dieser Auftrag nicht. Der übrige Text dieser Übergabe beschreibt den Stand vom 17. und 18.10.2026.
|
||||
|
||||
**Stand:** 17.10.2026 · **Zweck:** Einstieg in einen neuen fachlichen Planungschat nach Auswahl des Designkonzepts. Keine neue Produktentscheidung und kein zusätzlicher Implementierungsauftrag.
|
||||
|
||||
## 1. Aktueller Auftrag und Arbeitsweise
|
||||
|
||||
@@ -0,0 +1,602 @@
|
||||
# Jinkendo – KI-Gateway, Providerzugriff & Privacy Blueprint
|
||||
|
||||
**v0.1 · 16.10.2026 · Spezial-Blueprint 2 nach Phase 3.3 · technischer Entwurf, keine Implementierung**
|
||||
|
||||
## 1. Geltung und Nachweis
|
||||
|
||||
Dieser Blueprint beschreibt den produktlokalen Übergang von autorisiertem Anwendungskontext zu einem KI-Modell und zurück. Er konkretisiert Providerrollen, Datenminimierung, vollständige Egressprüfung, Maskierung, Transport, Antwortvalidierung und Fehlerbehandlung. Primäres Vorbild ist Kanshōs Privacy Gateway. Mitais Prompt-/Platzhalter-/Workflow-System bleibt die primäre vorgelagerte Laufzeit; dessen eigener Spezial-Blueprint folgt gesondert.
|
||||
|
||||
Grundlage sind [Referenzarchitektur A v0.3](C:/Dev/jinkendo-phase3-2-technical-reference-architecture-v0.3-2026-10-16/A_Jinkendo_Technical_Reference_Architecture.md), [Foundation B v0.3](C:/Dev/jinkendo-phase3-2-technical-reference-architecture-v0.3-2026-10-16/B_Implementation_Blueprint_Application_Foundation.md), [Entscheidungen C v0.3](C:/Dev/jinkendo-phase3-2-technical-reference-architecture-v0.3-2026-10-16/C_Technical_Decisions_Open_Issues.md), [Auth-/Session-/Scope-Blueprint](C:/Dev/jinkendo-phase3-3-auth-session-scope-blueprint-2026-10-16/Jinkendo_Auth_Session_Scope_Blueprint.md) und [Release-/Betrieb-/Recovery-Blueprint](C:/Dev/jinkendo-release-betrieb-recovery-blueprint-2026-10-16/Jinkendo_Release_Betrieb_Recovery_Blueprint.md).
|
||||
|
||||
Beschlossene ADRs bleiben maßgeblich, besonders ADR-02/04/09/10/12/13/14. [ADR-09](C:/Dev/jinkendo-architecture-consolidation-phase2-v0.2-2026-10-15/05_Architecture_Decision_Register.md) erlaubt produktbezogen lokale Verarbeitung oder autorisierte minimierte Weitergabe an geeignete Anbieter. Er erteilt keine pauschale Providerfreigabe und schwächt Kanshōs eigene Privacy-Invarianten nicht ab. Dieser Blueprint trifft keine neue rechtliche Bewertung und aktiviert keinen Anbieter.
|
||||
|
||||
**Nachweis:** V = vorgeschlagene technische Ausgestaltung; I = vorhandene statisch nachgelesene Implementierungsreferenz; T = tatsächlich bestandener Test mit Stand, Umfang und Umgebung; K = noch nicht integrierte/getestete Kombination. Dieses Dokument samt Code-/Payloadbeispielen ist **V/K**. Produktquellen und Testassertionen sind I; es wurden keine Anwendungstests oder Modellaufrufe ausgeführt. Keine Produktionsreife und keine vollständige semantische Erkennung werden behauptet.
|
||||
|
||||
Es entstehen keine gemeinsame KI-Plattform, zentrale Tenant-Datenbank, SSO-, Billing- oder Worker-Infrastruktur. Bestehende Anwendungen bleiben unverändert. Die tatsächliche spätere Umsetzung betrifft nur ein ausdrücklich benanntes Zielrepository.
|
||||
|
||||
### 1.1 Verträge und Defaults
|
||||
|
||||
| Verbindlicher Vertrag | Bevorzugter technischer Default |
|
||||
|---|---|
|
||||
| Nur aktuell autorisierte Daten aus dem expliziten Scope, für registrierten Zweck | Produktlokaler `ModelGateway`; pro Anfrage materialisierter unveränderlicher Kontext |
|
||||
| Class-A-/Local-only-Inhalte verlassen ihre erlaubte Vertrauenszone nicht | Externe Generate-Aufrufe mit Klasse A verweigern; B minimieren/maskieren; C kontrolliert generisch |
|
||||
| Persönlicher Egress durchläuft die vollständige Pipeline; kein Direktaufruf oder Ausfallbypass | Kanshō-Manifest, lokale semantische Detection, bestätigte Registry und Prüfung des endgültigen Payloads |
|
||||
| Detect, Generate und Tools sind getrennte Empfänger-/Zweckverträge | Lokaler explizit registrierter Detect-Endpunkt; externer Generate-Adapter nur bei geeigneter Route |
|
||||
| Kein ungeprüftes Downgrade, kein Export lokaler Mappings oder Sessiondaten | Kein automatischer Modell-/Providerfallback, kein Remote-Klartext-Detect im neuen Standard |
|
||||
| Anbieterfähigkeit wird belegt und technisch erzwungen, nicht aus einem Boolean geraten | Versionierte Providerprofile und Policybelege; OpenRouter als vorhandener Adapterkandidat |
|
||||
| Kein Netzaufruf in offener Fachtransaktion; Audit und fachlicher Ergebniswrite atomar | Drei kurze DB-Phasen um lokale Verarbeitung/HTTP herum |
|
||||
| Antwort bleibt untrusted; keine selbstständigen Tools/DBwrites | Vollständig gepufferte Text-/JSONantwort; lokale Validierung und Rehydration |
|
||||
| Ressourcen und Mehrfachausführung begrenzt; unbekannte Kosten nicht null | Ein Generate-Versuch pro Call; persistente lokale Call-ID/Idempotenz; Verbrauchsport für nächsten Blueprint |
|
||||
|
||||
Timeouts, Größen, Dateinamen, Transportadapter und Chunkgrößen sind begründet anpassbare Defaults. Datenraum-/Privacy-/Releaseverträge bleiben bestehen. Eine begründete lokale Anpassung mit passenden Tests erfordert keinen neuen ADR oder zusätzlichen allgemeinen Freigabezyklus.
|
||||
|
||||
## 2. Vorhandene Mechanismen und gezielte Anpassung
|
||||
|
||||
Ausgangspunkt sind [Phase-3.1-Wissenselemente](C:/Dev/jinkendo-phase3-1-technical-knowledge-inventory-2026-10-15/A01_knowledge_elements.json), [Quellen](C:/Dev/jinkendo-phase3-1-technical-knowledge-inventory-2026-10-15/sources.json), [Tests](C:/Dev/jinkendo-phase3-1-technical-knowledge-inventory-2026-10-15/tests.jsonl) und Kanshōs führende [Guardrails](C:/Dev/Kansho/docs/architecture/functional/guardrails.md:175). Nachgelesen wurden gezielt die relevanten Funktionen; keine neue Gesamtanalyse der Repositories.
|
||||
|
||||
| Referenz I | Wiederverwenden | Erforderliche Zielanpassung V/K |
|
||||
|---|---|---|
|
||||
| Kanshō KI-KAN-09: [Gateway](C:/Dev/Kansho/backend/privacy_gateway.py:1044), [Maskierung](C:/Dev/Kansho/backend/privacy_gateway.py:705), [Pre-Egress-Gate](C:/Dev/Kansho/backend/privacy_gateway.py:1257) | Reihenfolge vor Modellaufruf, requestbezogenes Manifest, spanbasierte Ersetzungen und lokale Rückübersetzung | Alle tatsächlich versandten Nachrichten/Felder erfassen; keine nachträglichen ungescannten Ergänzungen; Snapshot-/Payloadbindung für vorab geprüfte Mappings |
|
||||
| Kanshō: [Manifesttypen](C:/Dev/Kansho/backend/privacy_gateway.py:149), [Antwortprüfung](C:/Dev/Kansho/backend/privacy_gateway.py:897) | Aktive Ersetzungen, Alias-/Oberflächenformtrennung und interne Prüffassung | Mappings nur im lokalen Callkontext; ausschließlich tatsächlich ausgegebene/aktive Tokens rehydrieren, keine fremden/inaktiven Tokens nachschlagen |
|
||||
| Kanshō KI-KAN-10: [Providerrollen](C:/Dev/Kansho/backend/providers.py:160), [Transport](C:/Dev/Kansho/backend/providers.py:242), [Profilprüfung](C:/Dev/Kansho/backend/provider_settings.py:48) | Getrennte Detect-/Generate-Konfiguration, kleiner HTTP-Adapter, Usage/Finishreason | Keine pauschale Vertrauensannahme für private IPs/`.local`; keine ZDR-Zusage aus lokalem Default; exakte Endpunkt-/Routenprüfung; keine Providerfehlertexte an Clients |
|
||||
| Kanshō KI-KAN-11: [Kontextaufbau](C:/Dev/Kansho/backend/context_builder.py:67), [Budgetprüfung](C:/Dev/Kansho/backend/prompt_budget.py:243) | Zweckbezogene Materialisierung und explizite Größen-/Kontextgrenze | Zugriffs- und Quellenrevisionen binden; Zeichenschätzung nicht als exakten Tokenizer oder Privacybeweis behandeln |
|
||||
| Mitai KI-MIT-09/10: [Promptausführung](C:/Dev/mitai-jinkendo/backend/prompt_executor.py:166), [Modellcallback](C:/Dev/mitai-jinkendo/backend/prompt_executor.py:290) | Übergabepunkt nach vollständiger Platzhalterauflösung/Frageergänzung | Callback ruft ausschließlich Gateway auf; keine direkte Providerclosure, aufgelösten Werte/Promptvolltexte nicht automatisch debuggen; JSONschema tatsächlich validieren statt nur JSON parsen |
|
||||
| Shinkan KI-SHK-08: [REST-Client](C:/Dev/shinkan-jinkendo/backend/openrouter_chat.py:95), [Textblöcke](C:/Dev/shinkan-jinkendo/backend/openrouter_chat.py:50) | Kleiner Adapter statt zusätzlichem Agentenframework; bekannte Textvarianten | Refusal/Tool-/Reasoningblöcke unterscheiden; unbekannte Formen verweigern; keine Raw-HTTP-/Providerfehlerschnipsel weiterreichen |
|
||||
| Kairo KI-KAI-14: [Secretreferenzprüfung](C:/Dev/kairo-jinkendo/backend/config_service.py:17) | Konfiguration ohne rohe Secretwerte | Produktlokaler Providerprofiladapter, keine eigene zweite Connection innerhalb der Fach-UoW übernehmen |
|
||||
|
||||
Kanshō dokumentiert ausdrücklich, dass technische Detectionabdeckung keine semantische Vollständigkeitsgarantie ist und neue unbekannte Identitäten ungelöste Fälle erzeugen können. [Guardrails 22.2](C:/Dev/Kansho/docs/architecture/functional/guardrails.md:682). Bestehende Remote-Detect-/Lernmodusübergänge sind produktlokal dokumentierte Ausnahmen; der neue Standard übernimmt sie nicht automatisch. Er ändert sie im Bestand auch nicht. Kein `KANSHO_ALLOW_REMOTE_DETECT`- oder Fake-Provider-Runtimeflag wird als allgemeiner Familienmechanismus eingeführt.
|
||||
|
||||
## 3. Komponenten und Schnitt zur Prompt-/Workflow-Laufzeit
|
||||
|
||||
```text
|
||||
Fachroute → Fachservice / ContextMaterializer → Prompt-/Workflow-Renderer
|
||||
→ ModelGateway
|
||||
→ PurposePolicy / aktuelle Accessprüfung
|
||||
→ vollständige Textinventur / Minimierung / Detect / Registry
|
||||
→ MaskingManifest / finale Payloadprüfung / DispatchPermit
|
||||
→ genau ein registrierter ProviderTransport
|
||||
→ Envelope-/Inhalts-/Schema-/Privacyprüfung / lokale Rehydration
|
||||
→ frische Autorisierung / Fachservice-Ergebniswrite oder sichere Ausgabe
|
||||
```
|
||||
|
||||
| Baustein | Aufgabe |
|
||||
|---|---|
|
||||
| `modules/ai_gateway/service.py` | Gesamtablauf und Phasensteuerung; keine Prompt-DB-/Workflowengine neu entwickeln |
|
||||
| `contracts.py`, `policies.py` | Typisierte Calls/Ergebnisse, Zweck-/Datenklassen-/Ausgabeverträge |
|
||||
| `privacy/inventory.py` | Alle endgültigen Textkanäle und kontrollierten technischen Felder erfassen |
|
||||
| `privacy/detect.py`, `mask.py`, `response.py` | Kanshō-Mechanismen angepasst an unveränderliche Calls und vollständige Abdeckung |
|
||||
| `profiles.py`, `routing.py` | Aktuelle Profil-/Policyrevision, Empfängerrolle, Eignung und Capabilityprüfung |
|
||||
| `transports/openrouter.py`, optional `local_detect.py` | Protokolladapter mit strengem Endpoint, Secretinjektion und begrenztem HTTP |
|
||||
| `repository.py` | Callledger und Audit auf explizitem Transaktionshandle |
|
||||
| Fach-/Promptadapter | Scoped Quellen materialisieren, Vorlage rendern, Outputtyp registrieren; Gateway konsumieren |
|
||||
|
||||
`create_app(settings, providers)`/Lifespan der Foundation verdrahten diese Adapter. Nur Transportmodule dürfen Modell-HTTP ausführen. Direkte Provider-SDK-/HTTP-Aufrufe in Renderern, Feature-Routern, Diagnosen, Lern-/Precomputejobs oder Workflownodes sind kein zulässiger zweiter KI-Pfad. Andere fachliche HTTP-Integrationen werden dadurch nicht zu Modelladaptern erklärt.
|
||||
|
||||
Mitai liefert nach Auflösung aller Variablen und Augmentierungen `RenderedPrompt`, nicht bereits einen externen Call. Das Gateway darf vor Versand keinen fachlichen Promptteil auslassen. Ergebnis-/Formatinstruktionen werden **vor** der vollständigen Egressinventur ergänzt. Der nachfolgende Workflow-Blueprint muss dieselben DTOs und Fehler-/Idempotenzverträge verwenden. Jeder Modellnode und jeder erneute Aufruf erhält eine eigene Call-ID und durchläuft erneut das Gateway; eine alte Maskierungsfreigabe gilt nicht für neue Nodeinputs.
|
||||
|
||||
Erster Implementierungsschnitt: Textnachrichten, keine externen Tools/Plugins, keine Bilder/Audio-/Dateiuploads oder Remote-URLs, keine autonomen Agenten. Nicht registrierte Modalitäten werden verweigert. Spätere Erweiterungen benötigen denselben Empfänger-, Inhalts-, Test- und Datenschutzvertrag; sie werden nicht durch `dict[str, Any]` still akzeptiert.
|
||||
|
||||
## 4. Datenklassen, Identität und Quellenvertrag
|
||||
|
||||
`RequestContext` kommt unverändert aus Phase 3.3: geprüfter Principal, expliziter Scope und Request-ID. `profile_id`, Rollen, Policyklasse, Provider-URL und `privacy_checked=true` aus einem Browserbody sind keine Autorität. Ein Fachzweck ist in einer immutable Registry registriert und bestimmt Mindestschutz, erlaubte Quellen, Modellprofil und Ausgabeschema serverseitig.
|
||||
|
||||
| Klasse | Anwendung im Gateway |
|
||||
|---|---|
|
||||
| A / Local only | Externer Generate verweigert; Geheimnisse, vollständige Identityregistry/Mapping und nicht erforderliche Rohdaten gehören nicht in den externen Kontext. Ein lokaler Fachfallback ist eine eigene registrierte Funktion. |
|
||||
| B / persönlicher Kontext | Nur notwendige autorisierte Daten, vollständige lokale Detection/Registry-/Maskierungsprüfung, geeignete externe Route. Pseudonymisierung ist keine behauptete Anonymisierung. |
|
||||
| C / generischer Kontext | Nur tatsächlich nicht persönliche freigegebene Inhalte. Gemeinsamer Gateway-/Endpoint-/Fehlerpfad bleibt bestehen; C ist kein Umbenennen persönlicher Daten. |
|
||||
|
||||
Materialisierung klassifiziert Quellen/Felder anhand des Produktvertrags. Enthält eine Anfrage erforderliche Local-only-Bestandteile, darf sie nicht durch bloße Gesamtkennzeichnung B/C passieren. A-Felder müssen vor externem Rendering begründet ausgeschlossen sein; sonst Blockade. Bekannter Personenbezug in vermeintlichem C führt zur strengeren B-Prüfung, sofern für den Zweck zugelassen, andernfalls Ablehnung. Fehlende/unklare Klassifikation wird nicht C.
|
||||
|
||||
Im ersten Schnitt ist C auf registrierte generische Vorlagen-/Katalogquellen begrenzt. Freier Usertext, persönliche Historie oder materialisierte Personendaten sind mindestens B; ein generischer Zweckname stuft sie nicht herunter. Ein lokaler vorgelagerter ForbiddenContentGuard verweigert bekannte Secrets, Private-Keyblöcke, credentialhaltige URLs/DSNs und als Local-only definierte direkte Identifikatorfelder vor Weiterverarbeitung. Dafür werden konkrete Struktur-/Secretregeln verwendet, keine Food-/Namensheuristiken als Ersatz für semantische Detection. Auch diese Prüfung behauptet keine vollständige Erkennung unbekannter Geheimnisse in beliebigem Freitext.
|
||||
|
||||
`SourceBinding` enthält lokal Objekttyp/-ID, erwartete Version, Owner-/Scopebindung und ausgewählte Felder. Alle Quellen werden mit derselben AccessPolicy und scoped Repositoryabfragen geladen, einschließlich RAG-/Graph-/Memory-/Toolresultatquellen. Öffentlicher/globaler Katalog ist eine ausdrücklich erlaubte Quellenart, kein Join auf fremde private Daten. Bereits erzeugter Modelltext bleibt untrusted Eingabe und erhält keine höhere Anweisungspriorität.
|
||||
|
||||
Der Dispatcher lädt niemals „alle Profile“ als Kontext. Minimierung ist eine Produktfeld-/Quellenauswahl, kein bloßes `strip()` oder pauschales Abschneiden. Bei Budgetüberschreitung wird abgebrochen oder im Fachadapter ein ausdrücklich anderer kompakter Kontext neu erzeugt; dieser durchläuft erneut die gesamte Pipeline. Keine unsichtbare providerseitige Kontextkompression.
|
||||
|
||||
## 5. Python-Verträge und lokale Identitäten
|
||||
|
||||
Illustrative Schnittstellen V/K. Importpfade für `RequestContext`, `ScopeRef` und Foundation-UoW werden im Zielprojekt aus den vorhandenen Verträgen übernommen. Inhalte sind im Speicher vertraulich, auch wenn `repr=False` ihre versehentliche Repräsentation reduziert.
|
||||
|
||||
```python
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Literal, Protocol
|
||||
from app.core.context import RequestContext
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SourceBinding:
|
||||
kind: str
|
||||
source_id: str
|
||||
version: str
|
||||
selected_fields: tuple[str, ...]
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class PromptMessage:
|
||||
role: Literal["system", "developer", "user", "assistant", "tool"]
|
||||
content: str = field(repr=False)
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class RenderedPrompt:
|
||||
template_id: str
|
||||
template_revision: str
|
||||
messages: tuple[PromptMessage, ...] = field(repr=False)
|
||||
sources: tuple[SourceBinding, ...]
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class GatewayCall:
|
||||
call_id: str
|
||||
execution_id: str
|
||||
node_key: str
|
||||
purpose: str
|
||||
rendered: RenderedPrompt = field(repr=False)
|
||||
result_spec_id: str
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class UsageReport:
|
||||
input_tokens: int | None
|
||||
output_tokens: int | None
|
||||
reported_cost: str | None
|
||||
currency: str | None
|
||||
status: Literal["reported", "estimated", "unknown"]
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ModelResult:
|
||||
call_id: str
|
||||
content: str = field(repr=False)
|
||||
result_spec_id: str
|
||||
usage: UsageReport
|
||||
|
||||
class ModelGateway(Protocol):
|
||||
async def complete(self, context: RequestContext,
|
||||
call: GatewayCall) -> ModelResult: ...
|
||||
```
|
||||
|
||||
Ein `RenderedPrompt` ist ein internes Ergebnis des autorisierten Render-/Materialisierungsadapters, kein frei deserialisiertes APIobjekt. `purpose`, ResultSpec und Vorlagenrevision werden gegen registrierte serverseitige Definitionen geprüft. ResultSpec legt `text` oder ein konkretes Pydanticmodell, maximale Länge, erlaubte Werte und rehydrierbare Textpfade fest. `ModelResult.content` ist bei JSON eine validierte kanonische JSONzeichenkette; Fachadapter erhält anschließend das explizite lokale DTO. Keine rohen Providerdicts.
|
||||
|
||||
Providertransport erhält **weder** `RequestContext` noch `SourceBinding` oder Manifest. Er bekommt eine interne `SealedEgress`-Struktur: Call-ID, registrierte Route-/Profil-/Policyrevision, unveränderliche Bodybytes, Bytehash, Größenlimit, Deadline und eine kurzlebige interne `DispatchPermit`. Diese Objekte werden ausschließlich durch die Gatewaypipeline erstellt, nicht aus einem Clientflag. Sie sind lokale Programmgrenzen, kein Kryptografiebeweis gegen kompromittierten Servercode.
|
||||
|
||||
Hier bezeichnet `SealedEgress` den **Generate**-Ausgang. Die vorgelagerte lokale Detection verwendet einen getrennten typisierten `LocalDetectInput(call_id,inventory_revision,text_fields)` und `LocalDetectTransport`: nur nach T1/ForbiddenContentGuard, nur zum eligible lokalen Detectprofil, ohne Registry-/Rehydrationstabelle und ohne externe Generate-Permit. Der lokale Detectadapter validiert Ziel, Größen, Rolle und Antwortschema, bevor er Coverage liefert. Er kann keine Generate-Route auswählen. So entsteht kein zirkuläres „vor Detection bereits vollständig maskiert“-Erfordernis und kein als Detect getarnter externer Klartextpfad.
|
||||
|
||||
Der kleine Detect-Port präzisiert die Rückgabe. Coveragebereiche werden **lokal vom Adapter** aus tatsächlich erfolgreich verarbeiteten Chunks aufgebaut, nicht aus einer Modellbehauptung übernommen. Spans werden am exakt gebundenen Text validiert.
|
||||
|
||||
```python
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class TextField:
|
||||
path: str
|
||||
revision: str
|
||||
text: str = field(repr=False)
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class LocalDetectInput:
|
||||
call_id: str
|
||||
inventory_revision: str
|
||||
text_fields: tuple[TextField, ...] = field(repr=False)
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DetectedSpan:
|
||||
field_path: str
|
||||
start: int
|
||||
end: int
|
||||
observed: str = field(repr=False)
|
||||
entity_type: Literal["PERSON", "PLACE", "ORG", "PROJECT"]
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DetectionCoverage:
|
||||
inventory_revision: str
|
||||
detector_profile_revision: str
|
||||
processed_ranges: tuple[tuple[str, int, int], ...]
|
||||
spans: tuple[DetectedSpan, ...] = field(repr=False)
|
||||
|
||||
class SemanticDetector(Protocol):
|
||||
async def detect(self, request: LocalDetectInput) -> DetectionCoverage: ...
|
||||
```
|
||||
|
||||
Die lokale `MaskingManifest`-Variante übernimmt Kanshōs aktive Ersetzungen, Typen, Vorkommen und Rehydrationstabelle, ergänzt aber zwingend Call-ID, Subject/Scope-Namespace, genaue Inventur-/Payloadrevision, Detection-/Registry-/Reviewrevision und technische Coverage. Keine dieser Zuordnungen wird in externe Metadaten oder globale mutable Variablen gelegt. Gleichzeitige A-/B-Calls besitzen getrennte Manifeste; kein globales `last_trace` als Quelle persönlicher Ergebnisse.
|
||||
|
||||
## 6. Providerprofile, Trust Zones und Eignung
|
||||
|
||||
Ein Profil ist produktlokal versioniert und enthält ausschließlich Konfiguration/Secretreferenzen. Konkrete erforderliche Felder:
|
||||
|
||||
| Gruppe | Felder / Regel |
|
||||
|---|---|
|
||||
| Identität | `profile_id`, `revision`, `adapter_kind`, Rolle `detect|generate`, Status `disabled|unverified|eligible` |
|
||||
| Ziel | Exakte erlaubte Scheme/Host/Port/Path-Kombination, TLS-/CAprofil, explizite Netzwerk-/Adressgrenze, `trust_zone_id` |
|
||||
| Modell | Registrierte Modell-ID, erlaubte Rollen/Modalitäten, Contextwindow/Tokenizer bzw. Schätzverfahren, Ausgabegrenze, unterstützte Formate |
|
||||
| Privacy | Policy-ID/-revision, erlaubte Zwecke/Datenklassen, erforderlicher ZDR-/No-training-/Region-/Loggingzustand, Belegreferenzen und `checked_at`/`valid_until` |
|
||||
| Adapter | Erzwungene Requestparameter, erlaubte Upstreamprovider/Endpoints, Redirect-/Retry-/Transformverhalten, Transportlimitprofil |
|
||||
| Secret | Ausschließlich `credential_ref`; Rohwert nur im Secret-/Transportadapter, nicht im Profil-Response oder Log |
|
||||
|
||||
Ein Boolean `zdr=true` ohne Beleg/Adapterfähigkeit reicht nicht. Eignung erfordert passende aktuelle Policy, dokumentierte tatsächliche Account-/Endpointkonfiguration und technische Erzwingbarkeit der geforderten Einschränkungen. Unbekannt/abgelaufen → Route nicht eligible. Default für erneute technische Belegprüfung sieben Tage und bei Profil-/Provideränderung; lokale Gründe können andere Fristen verlangen. Dies ist ein veränderbarer technischer Prüfzyklus, keine neue Familienfreigabe.
|
||||
|
||||
Aktuelle Bedingungen des konkret gewählten Empfängers sind gemäß ADR-09 vor realer persönlicher Nutzung zu prüfen. Diese Lieferung aktiviert keinen Provider und liest keine Account-/Keyeinstellungen. Tests verwenden synthetische Profile/Keys. Fehlt ein realer Beleg, bleibt der betreffende Pfad geschlossen; andere Appfunktionen können weiterlaufen.
|
||||
|
||||
### 6.1 Detect, Generate und lokale Empfänger
|
||||
|
||||
**Detect:** bevorzugt ein bereits vorhandener lokaler, ausdrücklich registrierter semantischer Detector. Er sieht nur den für Detection notwendigen finalen Text, keine vollständige Identityregistry, Sessioncredentials oder DBsecrets. Bestätigte lokale Identitäten werden im Gateway angewendet. Eine lokale IP oder `.local` beweist keine Vertrauenszone: Betreiber-/Zugriffs-/Logginggrenze, konkretes Ziel und Netzweg müssen zum Profil passen.
|
||||
|
||||
**Generate:** nur maskierter/minimierter B-Kontext bzw. kontrolliertes C, passendes Modell und Providerpolicy. Kein derselbe Key als stiller Fallback zwischen Rollen. **Tools/Websuche/Embeddings/Transkription:** eigene spätere Zweck-/Empfängerpfade; im ersten Schnitt nicht aktiviert. OpenRouter-ZDR ist keine Freigabe aller zusätzlich einschaltbaren Tools.
|
||||
|
||||
Neuer Standard: kein externer Klartext-Detect, auch nicht allein wegen `APP_ENV=development`. Persönliche Development-/Testdaten bleiben persönlich; CI arbeitet synthetisch. Kanshōs ausdrücklich beschriebene Übergänge bleiben dortige Bestandsregeln und werden im Reuseadapter als Abweichung dokumentiert. Es entsteht kein neuer Runtime-„Privacy aus“-Schalter und kein notwendiger neuer Detectdienst in diesem Auftrag. Ohne vorhandenen geeigneten Detect-/Reviewadapter bleibt B-Egress geschlossen.
|
||||
|
||||
### 6.2 Endpunkt- und Secretgrenze
|
||||
|
||||
Keine URL, Base-URL, Proxyadresse oder Callbackadresse aus Fach-/Browserinput. Nur registrierte Adapterziele; HTTPS mit Zertifikatsprüfung extern, HTTP ausschließlich für explizit erlaubte kontrollierte lokale Empfänger. Keine Userinfo/Secrets in URLs, keine frei wählbaren Header, keine Redirects. `openrouter.ai` wird exakt geprüft; ein Anzeigename oder `endswith('openrouter.ai')` ist keine Zielautorität.
|
||||
|
||||
DNS-Auflösung und tatsächlicher Verbindungsweg müssen die registrierte Zielgrenze einhalten. Netzwerkregeln des vorhandenen Containers/Hosts begrenzen den Adapter zusätzlich; DNS-Rebinding auf Loopback/Metadata-/fremde private Ziele darf kein neues Ziel öffnen. Eine pauschale Freigabe aller RFC1918-/Link-local-Adressen ist ausgeschlossen. Erforderliche lokale Adressen werden ausdrücklich registriert. Kann ein Adapter seine Verbindungsgrenze nicht gewährleisten, wird er nicht als eligible markiert.
|
||||
|
||||
HTTPX verwendet `trust_env=False`, keine impliziten Proxy-/CAumgebungswechsel, und ein ausdrücklich konfiguriertes TLS-/CAprofil. Client wird im Lifespan wiederverwendet und geschlossen; Keys werden nur für das konkrete legitime Authheaderziel injiziert. Provider-APIkeys sind notwendige Transportcredentials dieses Empfängers, keine erlaubten Modellkontextfelder. App-/DB-/Sessionsecrets und Mappingdaten gehen niemals in Payload, Attribution oder URL. [HTTPX Umgebungsvariablen](https://www.python-httpx.org/environment_variables/).
|
||||
|
||||
### 6.3 Konkreter OpenRouter-Adapter
|
||||
|
||||
OpenRouter ist ein vorhandener Adapterkandidat, kein Architekturzwang. Für entsprechend freigegebenen B-Egress setzt der Adapter insbesondere:
|
||||
|
||||
```json
|
||||
{
|
||||
"model": "registered-model-id",
|
||||
"messages": [{"role": "user", "content": "Freigegebener maskierter Text"}],
|
||||
"max_tokens": 2048,
|
||||
"stream": false,
|
||||
"provider": {
|
||||
"only": ["registered-upstream-slug"],
|
||||
"allow_fallbacks": false,
|
||||
"require_parameters": true,
|
||||
"data_collection": "deny",
|
||||
"zdr": true
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Platzhalter-IDs werden aus dem passenden eligible Profil eingesetzt; keine aktuelle Modell-/Providerempfehlung oder bereits erteilte Freigabe. Keine Modellfallbackliste, Auto-Router, Tools, Plugins oder dynamischen Presets. Providerseitige Kontextkompression/zusätzliche Transformation ist für persönliche Payloads nicht zugelassen; die konkrete Deaktivierung muss der eingesetzte Adapter nachweisen. Der Gatewayadapter setzt Filter selbst; ein Renderer darf sie nicht überschreiben.
|
||||
|
||||
Die Parameter `only`, `allow_fallbacks`, `require_parameters` und `data_collection` werden in der [OpenRouter-Routingdokumentation](https://openrouter.ai/docs/guides/routing/provider-selection) beschrieben. Bei fehlender geeigneter Route wird abgebrochen. Ein Providername allein belegt keine verlangte Region; wenn Region verpflichtend ist, braucht das Profil einen passenden tatsächlich erzwingbaren Endpoint-/Routingnachweis.
|
||||
|
||||
`provider.zdr=true` ist separat erforderlich; ein lokaler No-training-Boolean bzw. `data_collection` allein wird nicht als vollständiger Retentionsnachweis dargestellt. OpenRouter beschreibt ZDR für Inferenzrouting, weist Tools/Plugins eigene Policies zu und zählt bestimmte In-memory-Caches nicht als Retention. Daher bleibt die konkret benötigte Schutzwirkung zu prüfen. [OpenRouter ZDR](https://openrouter.ai/docs/guides/features/zdr). Das sind begrenzte technische Gegenprüfungen, keine Aussage, jeder aktuelle Endpoint erfülle Jinkendos Anforderungen.
|
||||
|
||||
## 7. Ablauf und sichere Transaktionsgrenzen
|
||||
|
||||
### 7.1 Phase T1: autorisierte Aufnahme
|
||||
|
||||
In einer kurzen Foundation-UoW: aktuelle Session/Principal, Scope, Fachcapability und gegebenenfalls Entitlement prüfen; alle ausgewählten Quellen samt Version/Owner-/Scopegrenze materialisieren; unveränderlichen lokalen Snapshot erzeugen. Call-ID/Idempotenz registrieren und sicheren Auditmetadatensatz schreiben. Kein Modell-/Detector-/HTTP-Aufruf in dieser Transaktion. Der Renderer verarbeitet nur diesen autorisierten Snapshot und freigegebene Vorlagen-/Formatinstruktionen.
|
||||
|
||||
Die Berechtigung wird nicht aus den später vom Renderer eingetragenen `SourceBinding`-Strings geglaubt. Der Materialisierungsadapter erzeugt und bindet sie serverseitig. Nicht benötigte Felder werden vor Rendering ausgeschlossen. Eine nachträglich hinzugefügte Quelle verlangt erneute autorisierte Aufnahme.
|
||||
|
||||
### 7.2 Lokale Verarbeitung ohne offene DB-Transaktion
|
||||
|
||||
Vollständige Vorlage inklusive System-/Developer-/Historien-/Userteilen und statischem Outputvertrag fertigstellen. Inventur/Minimierung/Budgetprüfung durchführen. Für B den gesamten endgültigen Text lokal untersuchen, bestätigte eigene Registry ergänzen, offene Konflikte behandeln, requestbezogen maskieren. Payload einschließlich Adapterparameter fertigstellen und final validieren/sealen. Reihenfolge und Bindung stehen in Abschnitt 8/9.
|
||||
|
||||
Ein Reviewbedarf wird als `privacy_review_required` an den Fachadapter zurückgegeben. Generate wurde dann nicht aufgerufen. Vorhandene lokale Reviewmechanismen dürfen verwendet werden; fehlt ein geeigneter Adapter, bleibt dieser Fall geschlossen. Dieser Blueprint baut kein neues allgemeines Reviewportal und verlangt keine pauschale Bestätigung jeder Anfrage.
|
||||
|
||||
### 7.3 Phase T2: aktueller Dispatchentscheid
|
||||
|
||||
Unmittelbar vor Transport erneut unter kurzer UoW prüfen: aktueller Principal/Sessionsgeneration/Kontostatus, Scope/Mitgliedschaft, Fachrecht, alle Quellenversionen, Vorlagenrevision, aktive Policy-/Registry-/Providerprofilrevision und gegebenenfalls genau gebundene Reviewentscheidung. Weicht benötigter Kontext ab, `context_changed` statt Versand eines alten Snapshots. Keine stillschweigende Neuzusammenstellung nach der Privacyprüfung.
|
||||
|
||||
Bei Erfolg Dispatchintent samt Call-/Payload-/Routenbindung und erforderlichem Audit committen; kurzlebige interne Permit erzeugen, Default zwei Sekunden bis Beginn des Sendens. Hat das Warten auf Transportkapazität diese Frist überschritten, erneute T2-Prüfung vor Senden. Wiederholungen dieser kurzen **lokalen Prüfung** sind keine weiteren Modellversuche. Widerruf vor dem Dispatchentscheid sperrt den Call.
|
||||
|
||||
Zwischen DBcommit und externem Netzwerk besteht keine verteilte Transaktion. Eine Sperre unmittelbar nach dem Dispatchentscheid kann bereits freigegebene Bytes nicht zuverlässig zurückholen. Der Vertrag benennt deshalb diesen Autorisierungszeitpunkt, bindet den exakten Snapshot, hält das Zeitfenster klein und prüft nachher erneut. Es wird keine unmögliche Atomarität mit dem Provider behauptet.
|
||||
|
||||
### 7.4 Transport und Phase T3
|
||||
|
||||
Genau ein Generate-Versuch mit den geprüften Bytes; Antwort begrenzt einlesen, validieren und lokal rehydrieren. Danach erneut aktuelles Konto/Scope/Objekt-/Ausgaberecht prüfen. Bei Entzug oder Quellenkonflikt keine persönliche Antwort anzeigen oder als Fachergebnis speichern. Verbrauchs-/Fehlermetadaten des bereits erfolgten Aufrufs dürfen der Server unter eigenem engen Auditvertrag abschließen; sie geben keine Fachrechte zurück.
|
||||
|
||||
Wenn ein Fachergebnis gespeichert wird, verwenden Ausgaberecht, erwartete Objektversion, Ergebniswrite, Callabschluss und Audit dieselbe Foundation-Transaktion. Erst nach Commit Erfolg zurückgeben. Für reine Anzeige erhält T3 einen atomaren Metadatenabschluss plus aktuelle Lesefreigabe; das Ergebnis lebt nur im Antwortspeicher. Ein danach erfolgter Scopewechsel wird zusätzlich durch die Frontend-epoch abgefangen.
|
||||
|
||||
Fachservice/Workflow hält über den Gatewayawait keine DB-UoW offen. Der Gateway-HTTPpfad ist tatsächlich asynchron (`httpx.AsyncClient`); synchrone Psycopg-UoWs laufen über klar abgegrenzte Threadbridge-Funktionen, beispielsweise `anyio.to_thread.run_sync`. Kein blockierender SQLaufruf direkt im Eventloop und keine Connection über `await` weiterreichen. Abbruch beendet lokale Arbeit/Transport soweit möglich; ein bereits angestoßener Providercall kann trotzdem verarbeitet/berechnet worden sein.
|
||||
|
||||
## 8. Vollständige Detection und Maskierung
|
||||
|
||||
### 8.1 Inventur vor Detection
|
||||
|
||||
Der Adapter definiert eine geschlossene Payloadschema-Version. Für den ersten Schnitt enthält sie Modell-ID, erlaubte Textnachrichten, begrenzte numerische Parameter, Streamflag, kontrollierte Providerfilter und gegebenenfalls einen registrierten statischen Outputschema-Vertrag. Keine frei ergänzbaren `metadata`, `user`, Promptsuffixe, Plugins oder Tools.
|
||||
|
||||
Die Textinventur enumeriert **alle** endgültigen Nachrichtentexte: System, gegebenenfalls unterstützter Developerkanal, User, frühere Assistanttexte sowie jeder neu zusammengesetzte Kontext/Formattext. Tooltexte und weitere Felder sind entweder ausdrücklich unterstützt und vollständig inventarisiert oder verweigert; unbekannte Kanäle werden nicht ignoriert. Statische JSONschemabeschreibungen sind ebenfalls im Textinventar. Technische Schlüssel/Modell-/Provider-IDs stammen ausschließlich aus einer kontrollierten nicht persönlichen Registry; keine dynamischen persönlichen JSONkeys oder Schemas vom Browser. Externe `$ref`-/URLauflösung ist nicht erlaubt.
|
||||
|
||||
Inventareintrag: stabiler lokaler Feldpfad, Textrevision, lokale Quellenbindung, UTF-8-Bytegröße und Coveragebereiche. Derselbe Textstand wird für Detection und Maskierung verwendet. Unicode-/Zeilenendenaufbereitung findet, falls überhaupt nötig, **vor** dieser Bindung statt. Danach keine Normalisierung, die Spans verschiebt.
|
||||
|
||||
### 8.2 Semantische Detection, Registry und Review
|
||||
|
||||
Kanshōs requestbezogene Span-/Registrytrennung wird übernommen. Jeder notwendige Detect-Chunk muss tatsächlich erfolgreich verarbeitet und sein Ergebnis lokal am Originaltext geerdet sein: Feldpfad, Start/Ende als Python-Codepointindizes, beobachteter Text und Typ passen exakt. Schemafehler, abgeschnittene Antwort, Lücken oder Timeout verweigern B-Generate. Überlappende Chunks werden mit lokalen Offsets zusammengeführt; Randfälle dürfen weder verschwinden noch doppelt Identitäten bestätigen.
|
||||
|
||||
`PERSON`, `PLACE`, `ORG`, `PROJECT` sind die vorhandenen Ausgangstypen. Erweiterung nur bei konkretem Produktbedarf. Bestätigte eigene Identitäten/Aliase bleiben lokale Autorität. Ein Detect-Ergebnis erzeugt keine dauerhaft bestätigte Identität. Homonyme werden pro Vorkommen behandelt; keine neuen globalen Food-/Wetter-/Großschreibungswortlisten und kein Regexfallback, der einen semantischen Detectausfall als erfolgreich ausgibt.
|
||||
|
||||
`coverage_complete=true` bedeutet ausschließlich vollständige technische Verarbeitung des gebundenen Inventars. `semantic_identity_guaranteed=false` bleibt ausdrücklich erhalten. Ein Nulltreffer beweist nicht Identitätsfreiheit. Bekannte offene Konflikte oder erforderliche unbestätigte Entscheidungen blockieren bis zur gebundenen lokalen Klärung. Falls die konkrete Produktpolicy darüber hinaus eine geprüfte vollständige Freigabe persönlicher Eingabe verlangt, muss dieser Review-/Prüfadapter vorhanden sein; ein Fake „alles sicher“ ist unzulässig. Diese Grenze wird nicht durch neue Heuristiken verdeckt.
|
||||
|
||||
Vorab berechnete Treffer/Reviews sind nur wiederverwendbar, wenn Subject/Scope, sämtliche Feld-/Payloadrevisionen, Quellen, Registry-/Detector-/Policyrevision und Ablauf exakt passen. Ein Boolean `full_detection_coverage=true` aus dem Aufrufer reicht nicht. Ein bloßer Review des letzten Nutzersatzes deckt nicht automatisch Systemtext, Historie, RAG und spätere Renderergänzungen ab. Nicht abgedeckte Felder durchlaufen weiterhin Detection. Ändert sich die Vorlage oder ein nachgelagerter Nodeinput, gilt der alte Nachweis nicht.
|
||||
|
||||
### 8.3 Pseudonyme und lokales Manifest
|
||||
|
||||
Spanersetzungen aus Kanshō werden von hinten nach vorne auf den gebundenen Text angewandt. Überlappungen werden deterministisch aufgelöst oder als unklar verweigert; bestätigte Alias-/Identitätsregeln bleiben getrennt von unbestätigten Treffern. Nur tatsächlich eingesetzte Ersetzungen werden aktiv. Der Manifestnamespace ist mindestens Produkt + Scope + Subject + Call; ein Token aus B wird nie über A aufgelöst.
|
||||
|
||||
Vorhandenes Syntaxmuster `[[PERSON:01]]` bleibt als lokaler Adapterdefault möglich. Tokens sind innerhalb des Calls konsistent. Bestätigte lokale Identität kann intern über Calls stabil sein; extern wird standardmäßig pro Call neu zugeordnet, damit kein globales Personenkennzeichen entsteht. Kontextübergreifende stabile externe Pseudonyme sind keine Foundationpflicht. Aliase enthalten keine zusätzlichen Krankheiten, Herkunfts- oder Beziehungsinformationen.
|
||||
|
||||
Untrusted Eingabe darf die reservierte Identitätstokensyntax nicht selbst als Mappingbefehl einschleusen. Default: entsprechende rohe Tokens in neuen Quell-/Usertexten mit `reserved_identity_syntax` verweigern. Ein später tatsächlich benötigter Literaladapter kann sie eindeutig getrennt kodieren und muss getestet sein; kein stilles Verschlucken legitimen Inhalts. Vertrauenswürdige Vorlagen erzeugen konkrete aktive Tokens nur über den Manifestadapter.
|
||||
|
||||
Rehydrationstabelle enthält nur autorisierte **aktive** Tokens des Calls, nicht die ganze Profilregistry. Bestätigte Aliase können kanonisch, unbestätigte Requesttreffer in beobachteter Schreibweise rehydriert werden, entsprechend Kanshō. Kein Provider, Debugclient oder fremder Scope erhält diese Tabelle. Standardlebensdauer ist die Anfrage; nach Abschluss/Abbruch Referenzen freigeben. Persistente Quelldaten/Registries bleiben lokale Produktdaten und werden nicht als temporäre Diagnose gelöscht.
|
||||
|
||||
## 9. Finales Egress-Gate und unveränderlicher Transport
|
||||
|
||||
Nach Maskierung werden alle erlaubten Provider-/Formatparameter ergänzt, ein striktes endgültiges Payloadschema validiert und sämtliche ausgehenden Textfelder gegen das Manifest geprüft. Bekannte zu maskierende Identitätsvorkommen müssen ersetzt, technische Felder kontrolliert, Class-A-Felder entfernt und alle notwendigen Coverage-/Reviewbindungen gültig sein. Fehlender Beleg oder eine nicht unterstützte Zusatzoption sperrt den Versand.
|
||||
|
||||
Der Registry-Safety-Net-Adapter prüft die erwarteten zu schützenden Vorkommen im vollständigen Inventar, nicht ausschließlich bereits erfolgreich als `manifest.replacements` eingetragene Treffer. Eine zuvor ausgelassene bekannte Identität darf nicht dadurch unsichtbar werden, dass sie nie als aktive Ersetzung registriert wurde. Vorkommensbezogene Homonym-/Reviewregeln bleiben dabei bestehen; unbekannte semantisch übersehene Identitäten werden weiterhin nicht als garantiert erkannt dargestellt.
|
||||
|
||||
Serialisierung: deterministische JSONbytes in UTF-8, `ensure_ascii=False`, kompakte Separatoren, stabile Schlüsselreihenfolge, `allow_nan=False`; ungültige Surrogate oder nicht erlaubte Werte verweigern. Der interne Bytehash bindet **genau** diese Bytes an Route/Profil/Policy/Manifest/Call. Der Transport sendet `content=sealed.body` mit festem JSON-Content-Type, nicht erneut `json=<veränderliches dict>`. Keine SDK-/Middleware, die anschließend Promptteile/Tools/Metadaten anhängt.
|
||||
|
||||
Die einzige anschließende Ergänzung sind kontrollierte Transportheader, insbesondere der für genau diesen Empfänger benötigte Provider-Authheader. Keine Principal-/Profil-IDs, Cookie-/Sessionheader, freie Useragentzusätze oder rohe Quellnamen als Attribution. Request-ID/Call-ID bleibt lokal, sofern kein explizit geprüfter Transportvertrag eine nicht persönliche Korrelation benötigt. Finaler Endpoint und tatsächlicher Verbindungsweg sind Teil des Gates.
|
||||
|
||||
Vor `.send` verlangt der Adapter gültige Permit, passende Profil-/Policyrevision, Hash/Größe und freie Kapazität. Re-Rendering oder Änderung an Body, Schema, Modell, Route, Schlüsselzuordnung oder Prompt nach dem Gate macht den Seal ungültig. Ein Sendversuch konsumiert die interne Permit. Ein zweiter Generate benötigt eine neue explizite Callentscheidung; der Workflow kann nicht dieselbe Permit beliebig wiederverwenden.
|
||||
|
||||
Secretreferenzen liefern eine begrenzte Credentialversion zusätzlich zum Rohwert; die Version ist an die Route/Permit gebunden, der Rohwert bleibt nur im Transport. Eine zwischenzeitlich geänderte Zuordnung darf nicht denselben geprüften Call an ein anderes Konto/Ziel schicken. Der interne Status `sent_or_unknown` und ein begrenzter Providerrequestbezug können lokal gespeichert werden; ein möglicherweise vom Provider gelieferter Freitextbezug wird nicht ungeprüft als ID übernommen.
|
||||
|
||||
Eine spätere Antwortprüfung kann einen bereits erfolgten Datenversand nicht rückgängig machen. Deshalb müssen Canary-/Wiretests den tatsächlichen Adapterausgang untersuchen und nicht nur prüfen, dass eine Maskierungsfunktion aufgerufen wurde.
|
||||
|
||||
## 10. Transportgrenzen, Abbruch und Wiederholungen
|
||||
|
||||
### 10.1 Ressourcenprofil
|
||||
|
||||
| Einstellung | Technischer Ausgangswert |
|
||||
|---|---|
|
||||
| Gesamter Gatewaylauf einschließlich Detect/Queue/Generate | 90 Sekunden monotone Deadline; Fachzwecke dürfen begründet andere begrenzte Werte wählen |
|
||||
| HTTP connect / pool / write / read inactivity | 5 / 2 / 10 / 30 Sekunden, jeweils zusätzlich zur verbleibenden Gesamtdauer |
|
||||
| Parallelität | Zwei Gatewayläufe je Backendprozess, begrenzte Warteschlange 16; voller Eingang 503 |
|
||||
| Eingabepayload | Maximal 64 KiB UTF-8 über sämtliche Textteile; Modellkontext zusätzlich prüfen |
|
||||
| Detect-Chunks | Default 4.000 Codepoints mit begrenzter Überlappung 200; maximal 32 Chunks; vollständige Coverage Pflicht |
|
||||
| Ausgabe | Default maximal 2.048 Outputtokens; tatsächliches Modellprofil und Zweck können kleinere Grenzen setzen |
|
||||
| Providerresponse | Maximal 2 MiB decodierte Bodybytes und begrenzte Message-/Textlänge; Chunks zählen statt erst unbeschränkt `.json()` zu laden |
|
||||
| Idempotenz-/Callmetadaten | Default sieben Tage, an produktbezogene Audit-/Abrechnungszwecke anpassen |
|
||||
|
||||
HTTPX unterscheidet Connect-/Read-/Write-/Pooltimeouts; Readtimeout ist eine Inaktivitätsgrenze pro empfangenem Chunk und keine Gesamtlaufzeit. Die zusätzliche monotone Deadline wird z. B. mit `anyio.fail_after` umgesetzt; Netzwerkressourcen werden bei Abbruch geschlossen. [HTTPX Timeouts](https://www.python-httpx.org/advanced/timeouts/). Ein langsamer kontinuierlicher Bytestrom darf das Gesamtbudget nicht unbegrenzt verlängern.
|
||||
|
||||
Connectionpool und Admissionlimit sind explizit begrenzt. Bei mehreren Prozessen werden Limits budgetiert; ein Prozesslimit ist keine zugesicherte globale Kontenquote. Tokenbudget nutzt Modellprofil, reservierte Ausgabe und Sicherheitsmarge. Wenn nur eine konservative Zeichenschätzung verfügbar ist, wird sie so bezeichnet; unbekanntes Modellfenster oder Grenzverletzung führt zu lokalem Abbruch, nicht zu blindem Versand. Automatische Kürzung/Kompression nach dem Egress-Gate ist verboten.
|
||||
|
||||
### 10.2 Fehlerzustand und Kostenunsicherheit
|
||||
|
||||
Kein automatischer Generate-Retry, Reparaturprompt oder Modell-/Providerwechsel. Das gilt für 429/5xx, ungültiges JSON, Refusal, Verbindungsabbruch und Antwortvalidierungsfehler. Die erste erzeugte Antwort bleibt nicht durch eine heimliche zweite ersetzt. Eine bewusst angeforderte neue fachliche Ausführung erhält eine neue Call-ID und durchläuft Autorisierung/Privacy/Budget erneut.
|
||||
|
||||
`not_sent` ist nur zulässig, wenn der eigene Adapter sicher keinen Sendversuch begonnen hat. Nach Eintritt in den Transport ist bei Timeout/Abbruch der konservative Zustand `sent_or_unknown`, sofern kein engerer Nachweis existiert. Eine Exception oder Clientdisconnect bedeutet nicht „Provider hat nichts verarbeitet/keine Kosten“. Der Adapter speichert bekannte Usage, ansonsten `unknown`; keine erfundene Nullbuchung oder stille Freigabe einer möglichen Verbrauchsreservierung.
|
||||
|
||||
Bekannte HTTP-429-Antwort wird in ein sicheres begrenztes Retry-After übersetzt; der Client erhält keine automatische Wiederholungsanweisung für denselben Write. SDK-/Transportretrys werden ausdrücklich deaktiviert (Default null); kein versteckter `HTTPTransport(retries=...)` oder aus Providerbibliotheken übernommener Retry. Reine lokale T2-Neuprüfung und spätere lesende Statusabfrage sind davon getrennt.
|
||||
|
||||
## 11. Antwortvalidierung, JSON und Streaming
|
||||
|
||||
1. Envelope streng prüfen: HTTPstatus, Content-Type, Bodylimit, eine erwartete Choice, bekannte Contentblöcke und Finishreason. Unbekanntes Format, versteckte Toolcalls oder `finish_reason=length` bei erforderlichem vollständigem Ergebnis werden nicht als erfolgreiches Fachresultat behandelt. Refusal ist ein eigenes Ergebnis/Fehlercode, kein normaler Textblock.
|
||||
2. Reasoning-/Thinking-/Toolblöcke werden nicht als sichtbarer Text ausgegeben oder in spätere Prompts übernommen. Nur ausdrücklich unterstützte Textblocktypen normalisieren; keine generische Rekursion durch alle Dictionarywerte.
|
||||
3. Für JSON: vollständige strikte JSONsyntax und das registrierte Pydantic-Ausgabemodell einschließlich Grenzen/Enums/`extra='forbid'` tatsächlich validieren. Kein bloßes `json.loads(schema_ignored)` und kein automatischer Repaircall. Default keine Markdown-Codefenceheuristik; ein bewusst benötigter Wrapperadapter ist eine getestete begrenzte Variante.
|
||||
4. Privacy-/Tokenintegrität prüfen. Unbekannte, fremde oder inaktive Identitätstokens verweigern; keine freie Registryauflösung. Erkennbare unzulässige Identitätsvermutung/PII gemäß Produktpolicy blockiert die Antwort, ohne erneuten Generate. Homonyme bleiben vorkommensbezogen, keine globale Wortersetzung.
|
||||
5. Nur bekannte aktive Tokens lokal rehydrieren. Eine interne normalisierte Prüffassung ist nicht die sichtbare Fassung. Akzeptierter modellseitiger Klartext behält seine Oberflächenform; nach Demasking keine semantische/grammatische Umschreibung des Journaltextes. Das folgt Kanshōs bestehender Trennung. JSONkeys, IDs, URLs, Datum-/Zahlenwerte oder später gedachte Toolargumente werden nicht unkontrolliert rehydriert; ResultSpec nennt erlaubte Textpfade.
|
||||
6. Nach Rehydration erneut Ausgabelänge/JSONschema/zulässige Struktur prüfen und gemäß T3 autorisieren. Fachliche Plausibilität gehört zum konkreten Fachadapter; „valides JSON“ beweist weder Wahrheit noch aktuelle Gültigkeit. Kein Vorgriff auf ADR-16.
|
||||
|
||||
Das Gateway validiert untrusted Ausgabe und verleiht ihr keine Befehlsgewalt. Quellen-/Modellanweisungen können weder Datenklasse, Endpoint, Scope, Zugriffspolitik noch Toolrechte erweitern. HTML/Markdown wird im Frontend nach vorhandenem sicherem Renderingvertrag behandelt; kein rohes `dangerouslySetInnerHTML` aus Modelltext. Links werden nicht serverseitig automatisch besucht.
|
||||
|
||||
Auch der Browser darf keine modellseitigen Remote-Bilder, eingebetteten Inhalte oder Linkpreview-/Prefetchrequests automatisch laden. Default ist sichere Textdarstellung bzw. ein Renderer mit registrierten internen Medienreferenzen; aktive URLschemata werden verweigert. Identitätstokens in URLs/Markdown-Linkzielen werden nicht zu privaten Klartext-URLs rehydriert. Ein Modell darf lokale Demaskierung nicht in eine spätere Browserausleitung verwandeln.
|
||||
|
||||
**Streamingdefault:** `stream=false`; vollständiges Ergebnis puffern und erst nach Validierung/Demaskierung freigeben. Falls ein konkretes Produkt Upstream-SSE benötigt, wird es begrenzt gesammelt und erst das vollständige geprüfte Ergebnis ausgegeben. Kein persönlicher Rohdelta-/Reasoningstream an Browser oder DebugUI. Fortschrittsanzeigen dürfen reine sichere Phasenereignisse senden, aber keine ungeprüften Tokens. Ein späteres echtes inkrementelles Freigabeverfahren braucht einen eigenen nachgewiesenen Vertrag; es wird hier nicht als bereits sicher angenommen.
|
||||
|
||||
Verbindung zum Browser bei Scopewechsel/Logout schließen, alte Ergebnisse/Fehler nach epoch verwerfen. Der Caller setzt für lange KI-Operationen bewusst größere begrenzte Zeitbudgets, Default Client 105 Sekunden/Proxy 110 Sekunden bei Gatewaydeadline 90; der allgemeine Foundation-15-Sekunden-Default wird nicht global entfernt. Produktlokale längere Jobs sind Gegenstand des folgenden Workflowblueprints, kein neuer Worker in diesem Dokument.
|
||||
|
||||
## 12. Callledger, Idempotenz, Audit und Quotenport
|
||||
|
||||
Persistente lokale Metadaten verhindern unbemerkte doppelte Generate-Ausführung. Logischer Datensatz `ai_calls`:
|
||||
|
||||
| Feldgruppe | Inhalt |
|
||||
|---|---|
|
||||
| Identität/Owner | `call_id UUID PK`, `subject_id`, `scope_kind`, `scope_id`, `execution_id`, `node_key`, `purpose`; Owner-/Scopefilter bei jedem Lookup |
|
||||
| Inputbindung | Vorlagen-/ResultSpec-/Policy-/Profilrevisionen, Quellenversionsdigest und HMAC-Fingerprint der vollständigen semantischen Eingabe; keine Promptvolltexte |
|
||||
| Zustand | `prepared`, `awaiting_review`, `dispatching`, `validated`, `completed`, `blocked`, `failed_unsent`, `unknown`, `rejected_output`, `discarded_after_revoke` |
|
||||
| Versand/Nachweis | `dispatch_decided_at`, Beginn/Ende, sicherer Outcome-/Reasoncode, bekannte Modell-/Routen-ID, Technik-/Reviewcoverage und Maskierungszähler |
|
||||
| Ergebnis/Verbrauch | Optional erlaubte fachliche `result_ref`, validierter Usage-/Kostenzustand, optional späterer Reservierungsbezug; keine generelle Providerresponseablage |
|
||||
|
||||
Ein Unique-Constraint über Subject + Scope + `execution_id/node_key` bindet eine logische Ausführung. IDs sind begrenzt/validiert und nicht frei als Pfade verwendbar. Gleicher Schlüssel mit anderer Eingabe → 409 `call_conflict`. Während Dispatch oder bei `unknown` wird kein zweiter Call gestartet. `awaiting_review` kann nur mit derselben aktuellen Inputbindung und legitimer lokaler Reviewentscheidung fortgesetzt werden; inhaltlich geänderte Anfrage ist eine neue Ausführung. Keine HTTPbody-Flags als Freigabe.
|
||||
|
||||
Fingerprints werden mit einem separaten produktlokalen `AI_FINGERPRINT_KEY` als HMAC berechnet, damit gespeicherte Hashes kurzer persönlicher Texte kein einfaches Wörterbuchorakel bilden. Rohes Payload-SHA dient nur intern zur unmittelbaren Bytebindung und wird nicht als öffentlicher Debugwert persistiert. Fingerprint bindet Subject/Scope/Zweck, Input-/Vorlagen-/Quellen-/Policy-/Profilstand und Ergebnisformat, nicht die Cookiegeneration; spätere legitime Sessionerneuerung erzeugt keine neue logische Facheingabe. Aktuelle Autorisierung bleibt trotzdem bei jedem Lookup Pflicht.
|
||||
|
||||
Der Ledger speichert die Fingerprint-Key-ID; benötigte alte Keyversionen bleiben über die Idempotenz-/Aufbewahrungsfrist verfügbar bzw. werden kontrolliert migriert. Fehlt nach Rotation/Restore eine benötigte Version, wird ein bestehender unbekannter Call nicht als neue freie Ausführung behandelt. Der Recovery-Schlüsselvertrag aus dem vorherigen Blueprint umfasst diesen Bedarf, ohne den Key in Datenarchiv oder Logs zu schreiben.
|
||||
|
||||
Schema/Fremdschlüssel nutzen die lokalen Account-/Scope-IDtypen der Zielanwendung; für einen neuen Foundationaufbau die in Phase 3.3 vorgesehenen Konten. Kein universeller Tenantstore. Callabschluss/Ergebniswrite/Audit committen zusammen. Netzcall und DB können nicht atomar sein: Prozessabbruch nach Dispatchintent wird konservativ als ungeklärter Aufruf behandelt, nie automatisch erneut gesendet. Nach Neustart sind offene `dispatching`-Zeilen zu klären bzw. `unknown`; ein Ablaufdatum erteilt keine neue Generate-Erlaubnis.
|
||||
|
||||
Die siebentägige Standardretention betrifft abgeschlossene ungebundene Metadaten. Laufende/ungeklärte Calls und durch Fach-/Workflowausführungen referenzierte Call-IDs behalten mindestens ihren gesperrten Idempotenz-/Outcometombstone; Cleanup darf sie nicht zu unbekannten „neuen“ Ausführungen machen. Für abgeschlossene Calls außerhalb des ausdrücklich zugesicherten Idempotenzfensters wird keine unbegrenzte Wiederabrufgarantie behauptet. Eine bewusst neue Generierung verwendet eine neue Ausführungs-ID.
|
||||
|
||||
Ein bereits abgeschlossenes persistiertes Fachergebnis kann nach aktueller Autorisierung per `result_ref` erneut gelesen werden. Bei reiner Anzeige ohne gespeichertes Resultat gibt es keinen langlebigen Antwortcache; Wiederabruf desselben Calls liefert `result_unavailable`, keine kostenpflichtige Neugenerierung. Der Fachauftrag kann ausdrücklich eine neue Ausführung anfordern. Keine personenbezogenen globalen Antwort-/Promptcaches.
|
||||
|
||||
### 12.1 Auditgrenzen und Speicherung
|
||||
|
||||
Pflichtmetadaten: Call-/Request-ID, lokale Subject-/Scopebindung, Zweck, verwendete Profil-/Policy-/Vorlagenrevision, lokale Dispatchentscheidung, Coverageart, `semantic_identity_guaranteed=false`, Zähler/Größen/Dauer, bekannter Usagezustand, Ausgabestatus und sicherer Reasoncode. Keine echten Labels, Aliase, Mappings, Cookie-/Provider-/DBsecrets, System-/Userpromptvolltexte oder Modellantworten in Log/APM/Exceptions/DebugUI. Providerfehlertexte können Eingaben spiegeln und werden daher nicht durch bloßes Abschneiden sicher.
|
||||
|
||||
Der Gateway speichert standardmäßig keine Rohprompts, Rohantworten oder Manifestmappings. Fachlich bewusst bewahrte Originalquellen und akzeptierte Ergebnisse bleiben normale lokale Produktdaten mit eigener Autorisierung/Retention; Kanshōs Quellbewahrung wird dadurch nicht abgeschafft. Diagnoseberechtigung ist keine pauschale Freigabe privater Texte. Tests dürfen Wirebodies ausschließlich mit synthetischen Inhalten und für den Testlauf aufzeichnen.
|
||||
|
||||
Fehlt der erforderliche Auditspeicher vor Dispatch, kein Versand. Scheitert der Abschluss nach möglichem Versand, wird kein zweiter Call zur „Reparatur“ erzeugt; Fehler und späterer Reconcile bleiben sichtbar. Das Release-/Recoveryverfahren aus dem vorherigen Blueprint muss auch Callledger und ungeklärte Zustände erhalten; Restore macht alte `dispatching`-Zeilen nicht erneut ausführbar.
|
||||
|
||||
### 12.2 Anschluss an Entitlements und Verbrauch
|
||||
|
||||
`EntitlementPolicy` ist zusätzlich zur AccessPolicy erforderlich, soweit das Produkt die Funktion begrenzt. Für spätere harte Kontingente gilt der kleine lokale Port:
|
||||
|
||||
```python
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class BudgetEnvelope:
|
||||
call_count: int
|
||||
upper_input_tokens: int | None
|
||||
upper_output_tokens: int | None
|
||||
maximum_cost: str | None
|
||||
cost_basis_revision: str | None
|
||||
|
||||
class UsageBudgetPort(Protocol):
|
||||
def reserve(self, tx: object, context: RequestContext,
|
||||
call_id: str, upper_bound: BudgetEnvelope) -> str: ...
|
||||
def settle(self, tx: object, reservation_id: str,
|
||||
actual: UsageReport) -> None: ...
|
||||
def mark_unknown(self, tx: object, reservation_id: str) -> None: ...
|
||||
def release_unsent(self, tx: object, reservation_id: str) -> None: ...
|
||||
```
|
||||
|
||||
Dieser Port ist noch keine Billing-/Quotenimplementierung. Der folgende Entitlements-/Quota-Blueprint konkretisiert Atomarität, Perioden und Buchungsregeln. Ein Produkt ohne harte Quoten braucht nur die technischen Limits und Usageerfassung; es darf deshalb keine zugesicherte Kontingentgarantie behaupten. Ein Produkt **mit** harter Grenze bleibt ohne passenden echten Adapter geschlossen. Mitais heutiges „nach Erfolg hochzählen“ wird nicht als sichere parallele Reservierung oder Abrechnung unbekannter Ergebnisse ausgegeben. Fehlende Usage ist `unknown`, nicht kostenfrei.
|
||||
|
||||
Eine Schätzung ist keine zugesicherte Obergrenze. Der Adapter erhält im `BudgetEnvelope` nur tatsächlich belastbare obere Schranken, ansonsten `None`; er darf eine verpflichtende harte Token-/Kostengrenze dann nicht durch einen Schätzwert freigeben. Die Generate-Callanzahl kann für diesen Schnitt eindeutig mit eins begrenzt werden. Detect-/Toolverbräuche erhalten gegebenenfalls eigene Budgetzwecke und werden nicht unsichtbar in einen Generateerfolg eingerechnet.
|
||||
|
||||
## 13. Fach-API, Fehler und Frontendanschluss
|
||||
|
||||
Es entsteht kein öffentliches „beliebigen Prompt an beliebige URL senden“-API. Fachmodule registrieren konkrete Operationen mit festem Zweck, ResultSpec und serverseitiger Quellenauflösung. Beispiel: `POST /api/v1/<feature>/{resource_id}/generate` mit `{expected_version, instruction?}`; Session, CSRF/Origin und Scopeheader folgen Phase 3.3. `instruction` ist begrenzter untrusted Eingabetext und Bestandteil der Privacyinventur, keine übergeordnete Policy.
|
||||
|
||||
`Idempotency-Key` ist eine begrenzte kanonische UUID des Fachauftrags; `node_key` setzt der Server. Die Call-ID wird serverseitig erzeugt. Bodyfelder wie `provider_url`, `api_key`, `data_class`, `profile_id`, `privacy_checked`, `precomputed_mappings`, `tools` und frei gewählte `model`-IDs sind im Fach-DTO nicht erlaubt. Ein zugelassener Modellwunsch wäre höchstens ein registrierter serverseitig erneut geprüfter Variantenbezeichner.
|
||||
|
||||
FastAPI-Anschluss als Illustration V/K; das eigentliche Fachmodul implementiert den benannten Service. Synchrone DBphasen liegen innerhalb dessen expliziter Threadbridge, der Gatewayawait enthält keine offene DBverbindung:
|
||||
|
||||
```python
|
||||
from typing import Annotated
|
||||
from uuid import UUID
|
||||
from fastapi import APIRouter, Depends, Header, Request
|
||||
from pydantic import BaseModel, ConfigDict, Field
|
||||
from app.api.dependencies import scoped_context
|
||||
from app.core.context import RequestContext
|
||||
|
||||
class GenerateInput(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid", strict=True)
|
||||
expected_version: int = Field(ge=1)
|
||||
instruction: str | None = Field(default=None, max_length=2000)
|
||||
|
||||
class GenerateOutput(BaseModel):
|
||||
call_id: str
|
||||
content: str
|
||||
|
||||
router = APIRouter(prefix="/api/v1/feature")
|
||||
|
||||
@router.post("/{resource_id}/generate", response_model=GenerateOutput)
|
||||
async def generate(
|
||||
resource_id: str, body: GenerateInput, request: Request,
|
||||
context: Annotated[RequestContext, Depends(scoped_context)],
|
||||
idempotency_key: Annotated[UUID, Header(alias="Idempotency-Key")],
|
||||
):
|
||||
return await request.app.state.providers.feature_service.generate(
|
||||
context, resource_id, body, str(idempotency_key),
|
||||
)
|
||||
```
|
||||
|
||||
Eine optionale reine Statusroute `GET /api/v1/ai/calls/{call_id}` liefert nur `call_id,status,usage_status,result_ref?` nach aktuellem Recht und Subject-/Scopefilter. Fremder oder unsichtbarer Call: 404. Sie gibt keine Prompts/Manifestlabels/Providerfehler zurück und löst keinen neuen Modellaufruf aus. Ein Review-/Fortsetzungsendpunkt ist produktlokal; er verwendet einen serverseitig gebundenen kurzlebigen Reviewbeleg, nicht `confirmed=true` aus dem Client. Er ändert keinen bestehenden Datenstand ohne den entsprechenden Fach-/CSRF-/Versionsvertrag.
|
||||
|
||||
| HTTP / stabiler Code | Bedeutung und Wirkung |
|
||||
|---|---|
|
||||
| 401 `session_invalid` | Kein aktueller Principal; kein Dispatch oder keine Ergebnisfreigabe |
|
||||
| 403 `capability_denied`, `scope_forbidden`, `ai_policy_denied` | Zugriff/Zweck/Datenklasse/Privacy nicht erlaubt; keine Daten nach außen |
|
||||
| 404 `not_found` | Fachquelle/Call fremd, unsichtbar oder fehlend |
|
||||
| 409 `context_changed`, `call_conflict`, `call_in_progress`, `call_outcome_unknown`, `result_unavailable` | Kontext oder Ausführungszustand benötigt bewusste neue Entscheidung; kein automatischer Callretry |
|
||||
| 409 `privacy_review_required` | Generate noch nicht gesendet; Produkt kann seinen bestehenden lokalen Reviewpfad öffnen |
|
||||
| 422 `validation_failed`, `prompt_budget_exceeded`, `reserved_identity_syntax`, `unsupported_modality` | Eingabe/Format/Limit vor Versand verweigert |
|
||||
| 429 `ai_rate_limited` | Explizites Kontolimit bzw. sichere normalisierte Providerbegrenzung; Retry-After begrenzt, keine automatische Mutation |
|
||||
| 502 `provider_invalid_response`, `output_invalid`, `model_refused` | Upstreamantwort/ResultSpec/Integrität nicht nutzbar; kein Repaircall |
|
||||
| 503 `ai_unavailable`, `privacy_detection_unavailable`, `ai_busy`, `policy_unavailable` | Fehlende Pflichtadapter/Eignung/Kapazität; keine unsichere Fallbackroute |
|
||||
| 504 `ai_deadline_exceeded` | Zeitlimit; Outcome kann bereits `sent_or_unknown` sein, kein Erfolg/keine Nullkostenbehauptung |
|
||||
|
||||
RFC-9457-Problemformat mit sicheren Maschinen-/Requestcodes gemäß Foundation. Insbesondere keine Rohwerte in Feldfehlern, keine Unknown-Tokenlabels oder Providerantwortschnipsel in `detail`. Für alle persönlichen Erfolgs-/Fehler-/Statusantworten `Cache-Control: no-store`. Fach-DTOs nennen keine Authcredentials oder Backendproviderprofile.
|
||||
|
||||
Frontend nutzt zentralen Cookie-/CSRF-/Scopeclient, setzt begrenzten KI-Timeout ausdrücklich, zeigt sichere Phasen-/Fehlermeldungen und verwirft alte Resultate/Fehler nach epoch. Ein 403/503 ist kein Logout; ein 504 löst keinen automatischen zweiten Generate aus. Kein persönliches Ergebnis im Service Worker, LocalStorage oder gemeinsamem Modellcache. Ausgabe wird mit dem jeweiligen sicheren Text-/Markdown-/Rich-Textadapter angezeigt.
|
||||
|
||||
## 14. Automatisierte Negativ- und Sicherheitsprüfungen
|
||||
|
||||
Die Matrix ist ein Testauftrag, kein Ergebnisbericht. Verwendet werden synthetische Personen-/Orgdaten, eigene Call-/Providerprofile, Fakedetectoren, Wire-Capture-Transport und isoliertes echtes PostgreSQL mit begrenzter Runtime-Rolle. Keine realen Providerkeys, privaten Textbestände oder Live-Modellaufrufe. Testfakes werden nur über Testproviderverdrahtung bereitgestellt; der Runtimeaufbau kann sie nicht per Flag auswählen.
|
||||
|
||||
Canaries erscheinen in **jedem erlaubten Textkanal**: System-/Developertext soweit unterstützt, User, Historie, Kontext/RAG, Registryalias und JSONschemabeschreibung. Unbekannte Zusatzfelder/Modalitäten erhalten eigene Ablehnungstests. Tests prüfen die an den Providertransport übergebenen endgültigen Bytes und alle erlaubten Transportmetadaten. Nicht nur den Aufruf einer Maskierungsfunktion mocken. Synthetische Wireaufzeichnung bleibt lokal im Test; keine Produktionsdebugfunktion daraus ableiten.
|
||||
|
||||
| ID / Suite | Testfall | Zwingende Assertions |
|
||||
|---|---|---|
|
||||
| A01 `test_gateway_access.py` | Keine/abgelaufene Session, falscher Scope, fremdes Profil/Objekt, fehlende Capability | 401/403/404 vor jedem Detect-/Generatezugriff auf fremde Inhalte; keine Cross-Profilequelle |
|
||||
| A02 | Gemischte eigene/fremde RAG-/Eltern-/Memoryquellen | Jede Quelle scoped geprüft; keine fremden Inhalte/Counts in Kontext, Wire oder Fehler |
|
||||
| A03 | Sitzung/Mitgliedschaft/Recht nach T1 entzogen, Quelle/Vorlage geändert | T2 verhindert alten Dispatch; kein unverifizierter Neuaufbau |
|
||||
| A04 | Rechte-/Objektänderung während Generate | Keine unautorisierte Anzeige/Fachspeicherung; Callusage sicher abgeschlossen, kein zweiter Call |
|
||||
| A05 | Class A, unbekannte Klasse, persönlicher Text als C, vom Client behauptete Klasse | Local-only extern nie gesendet; C nicht als Bypass; Klassifikation serverseitig |
|
||||
| A06 | Bekannter Providerkey/Private-Keyblock oder credentialhaltige URL im Input | ForbiddenContentGuard blockiert vor Detect/Generate; keine Secretwerte in Fehlern oder Logs |
|
||||
| I01 `test_egress_inventory.py` | Canaries in sämtlichen Textkanälen und statischer Schema-/Formatinstruktion | Vollständige Inventur/Maskierung/Prüfung; erwarteter endgültiger Body ohne zu schützenden Canaryklartext |
|
||||
| I02 | Aufgelöster Platzhalter/Frageergänzung erst nach Nutzertextreview | Alte Coverage reicht nicht; fehlende finale Felder neu prüfen oder blockieren |
|
||||
| I03 | Geänderte Template-/Source-/Registry-/Policyrevision bei precomputed Mappings/Review | Alte Belege zurückweisen; bloßes `full_detection_coverage=true` reicht nicht |
|
||||
| I04 | Abgeschnittener/fehlender Detectchunk, UTF-8-/Unicodeoffset, Randüberlappung | Coverage-/Spangrounding korrekt; kein Generate bei technischer Lücke; kein stilles Truncation |
|
||||
| I05 | Detect-Timeout, Nulltreffer, ungültiges Detectschema, unbekannter Typ | Ausfall blockiert; Nulltreffer nicht als semantische Garantie; keine Heuristik-/Wortlistenrettung |
|
||||
| M01 `test_masking.py` | Vorkommensbezogener Homonymfall, Alias, überlappende Namen, Projektname | Nur passende geerdete Spans; bestätigte/unbestätigte Herkunft getrennt; kein globales Ersetzen aller gleichen Wörter |
|
||||
| M02 | Zwei parallele Subjects/Scopes mit gleich aussehenden Tokens | Getrennte Manifeste/Antworten, keine globalen Traces oder Cross-Profile-Rehydration |
|
||||
| M03 | Inaktives Mapping, fremder/erratener Token, reservierte Syntax aus Userquelle | Nur tatsächlich aktive eigene Tokens auflösbar; Injection/unknown Token verweigert |
|
||||
| M04 | Bekannter Alias vs. unbestätigter Treffer, akzeptierter Modellklartext | Kanonisch/beobachtet korrekt; Prüffassung nicht sichtbare Ausgabe; keine grammatische Umformung |
|
||||
| P01 `test_provider_policy.py` | Fehlendes/abgelaufenes Eignungsdokument, Boolean-ZDR ohne Beleg, ungeeignete Region/Endpoint | Nicht eligible, keine Generierung; keine pauschale Providerfreigabe |
|
||||
| P02 | OpenRouter-Payload, ungeeigneter Fallback, nur `data_collection` gesetzt | Gültiger vollständiger Profilvertrag setzt erforderliche Filter; kein Modell-/Providerfallback oder unerlaubter Transform |
|
||||
| P03 | URL aus Userinput, Suffixtrick, Redirect, DNS-Rebinding, Metadata-/fremde interne IP | Vor bzw. am Connect verweigert; kein Secret an fremdes Ziel; private IP allein ist keine Vertrauenszone |
|
||||
| P04 | Impliziter Proxy/CA aus Umgebung, falsches Zertifikat, fremder Authheader | `trust_env=False`/explizite CA wirksam; falsches TLS abgelehnt; nur richtiger Profilkey am Ziel |
|
||||
| P05 | Remote-Klartext-Detect per Devmodus/Flag, Fakeprovider im Runtimeaufbau | Kein Standardbypass; ungeeigneter B-Pfad geschlossen; Tests injecten Fakes ausschließlich lokal |
|
||||
| P06 | LocalDetectInput gegen Generate-/externes Detectprofil oder mit Registrydaten | Typ-/Rollen-/Trust-Zone-Grenze verweigert; lokaler Detect erhält nur erlaubte Textfelder |
|
||||
| T01 `test_transport.py` | Body/Modell/Profil/Policy nach Seal verändert, abgelaufene Permit | Kein Versand; Bytehash-/Revisions-/Zeitbindung greift |
|
||||
| T02 | Genau ein erlaubter Send, danach erneute Permitverwendung | Keine zweite Sendung; Wirebytes entsprechen finaler Prüfung, keine nachträglichen SDKfelder |
|
||||
| T03 | Connect-/Pool-/Read-/Writefehler, langsam kontinuierlicher Stream | Einzel-/Gesamtlaufzeitgrenzen; Ressourcen frei; nach möglichem Versand Outcome unknown statt kostenfrei |
|
||||
| T04 | 429/5xx, ungültiges JSON, Refusal, Disconnect nach Providerannahme | Kein versteckter Retry/Repaircall; sichere Fehler; keine Behauptung „Provider hat abgebrochen“ |
|
||||
| T05 | Queue/Pool voll, mehrere Prozesse, riesige Input-/Responsebody | Begrenzte Ablehnung und gemessene Limits; keine Poolumgehung oder unbeschränkte `.json()`-Allokation |
|
||||
| O01 `test_model_output.py` | Falsche Envelope/Choice/Finishreason, Reasoning/Toolblocks | Nur erlaubte Formate; keine versteckten Tools/Reasoninginhalte in Ergebnis/Historie |
|
||||
| O02 | Valides JSON mit falschem Schema/extra Feldern/NaN/Grenzwerten | Lokales striktes ResultSpec tatsächlich geprüft; keine TODO-Schemaannahme oder Repairgenerierung |
|
||||
| O03 | Unbekannter/inaktiver Token, unzulässige Identitätsvermutung | Ausgabe verworfen, keine fremde Lookupauflösung; Egress nicht nachträglich als ungeschehen erklärt |
|
||||
| O04 | Rehydration in JSONtext gegenüber Keys/IDs/Zahlen/URLs | Nur erlaubte Textpfade; Schema nach Rehydration nochmals gültig |
|
||||
| O05 | Persönlicher Upstreamdelta-/Fehlerstream vor Validierung | Kein Rohdelta an Browser/Debug; begrenztes Puffern bzw. Ablehnung, nur sichere Fortschrittsereignisse |
|
||||
| O06 | Modellantwort mit Remote-Bild/HTML/aktivem Link oder Identitätstoken in URL | Kein automatisches Browser-/Serverfetch und keine private Rehydration in Linkziele; sicherer Renderer |
|
||||
| C01 `test_gateway_calls.py` | Parallele gleiche Idempotenz, geänderter Fingerprint, alter Scope | Ein Send höchstens, 409 bei Konflikt; jeder Lookup aktuell autorisiert |
|
||||
| C02 | Prozessabbruch vor/nach Dispatchintent bzw. nach Ergebnis, vor Abschlusscommit | Keine automatische erneute Sendung; unknown/persistierte Resultreferenz korrekt |
|
||||
| C03 | Metadaten-/Auditfehler vor Dispatch vs. danach | Vorher kein Versand; nachher sichtbarer ungeklärter Zustand, keine Erfolgsausgabe oder heimliche Wiederholung |
|
||||
| C04 | Usage fehlt, echte Nullusage, abgeschätzte statt oberer Budgetgrenze | Unknown von null getrennt; harte Quoten nicht durch unbewiesene Schätzung freigeben |
|
||||
| C05 | Restore alter offener Calls, Fingerprintkeywechsel | Alte dispatching/unknown Calls werden nicht automatisch ausführbar; Idempotenz-/Key-ID-Vertrag bleibt nachvollziehbar |
|
||||
| L01 `test_ai_diagnostics.py` | Providerfehler enthält Canary/Prompt/Key, Exception/Repr/Log/APM | Keine sensitiven Spiegelungen in HTTP/Logs/DTOs; Maskierungszähler statt Labels |
|
||||
| L02 | Debugberechtigung, gespeicherte Fachquelle, temporäres Mapping | Debug exportiert keine Volltexte/Mapping; Fachquellbewahrung unverändert; Callmapping nur lokal |
|
||||
| F01 Frontend-/APItests | Fehlende CSRF/Scope, fremde Call-ID, extra Providerbodyfelder | Phase-3.3-/DTO-Verträge wirksam; keine generische freie Proxyroute |
|
||||
| F02 | Scopewechsel/Logout mit verspäteter KIantwort/401/504 | epoch verwirft alte Antworten/Fehler; kein Autoretry, 403/503 kein Logout |
|
||||
|
||||
### 14.1 Anschluss an vorhandene Testquellen I
|
||||
|
||||
- [Kanshō Manifestfälle](C:/Dev/Kansho/backend/tests/test_privacy_manifest.py:70): aktive/inaktive Mappings, Homonyme, Alias-/Prüffassung und Rehydration übernehmen; um komplette Payload-/Scoped-/Wirebindung erweitern.
|
||||
- [Kanshō Span-/Pre-Egress-Test](C:/Dev/Kansho/backend/tests/test_privacy_response_integrity.py:102): Spangrounding, Überlappung und Blockade vor Provider als Ausgangsfälle.
|
||||
- [Kanshō Detectionverträge](C:/Dev/Kansho/backend/tests/test_privacy_detect.py:1): Fakes belegen Schema/Fail-Closed-Verhalten, ausdrücklich keine Livequalität.
|
||||
- Kanshō verwendet einen [eigenen pytest-Collector](C:/Dev/Kansho/backend/tests/conftest.py:49), der Testskripte über `main()` als je einen Fall sammelt. Eine Testdatei oder gefundene Hilfsfunktion beweist deshalb weder einzelne pytest-Coverage noch Erfolg. Im neuen Zielaufbau diese Fälle als einzeln benannte native pytest-Tests mit konkreter Pflichtcollection anlegen; Bestandscollector nicht pauschal kopieren.
|
||||
|
||||
Integrationstests verwenden echten isolierten PostgreSQLzustand nach dem Releaseblueprint. Reine Transformationen laufen ohne DB/Netz, Transporttests mit Fake-/Wireadapter. Nach Einführung eines tatsächlichen lokalen Detectors ist eine separate synthetische Qualitätsauswertung mit benanntem Modell/Stand nötig; sie wird nicht aus Mocktest-Erfolg abgeleitet. Reale persönliche Providererprobung ist nicht Teil dieser Lieferung oder Pflicht-CI.
|
||||
|
||||
## 15. Implementierungsauftrag für Cursor und nachfolgende Blueprints
|
||||
|
||||
**Dieser Abschnitt wird hier nicht ausgeführt.** Der spätere Auftrag benennt das Zielrepository und die erste tatsächliche KI-Funktion. Ohne konkrete Zielfunktion keine bestehende App als allgemeines Gatewayframework umbauen.
|
||||
|
||||
1. Foundation v0.3, Phase-3.3-Kontext/Access/UoW und Releaseblueprint beibehalten. Lokales Gatewaymodul mit explizitem Composition Root/Ports aufbauen; keine Cross-Repoimporte oder neue zentrale Inferenzplattform.
|
||||
2. Kanshōs Maskierungsmanifest, Span-/Alias-/Registryregeln und Pre-Egress-Reihenfolge gezielt übertragen. Aktuelle Source-/Profil-/Policy-/Inventurbindung und Callisolation ergänzen. Vorhandene Globaldiagnose, Fake-Runtimeflags und pauschale Local-URL-Vertrauensprüfung nicht übernehmen.
|
||||
3. Den einen Fachzweck mit erlaubten Quellen/Feldern, B/C-Regel, Vorlage und lokalem ResultSpec registrieren. Scoped Materialisierung über vorhandene Repositories; keine neue Prompt-/Workflowengine. Mitais späteren Adapter an `RenderedPrompt`/`ModelGateway.complete` binden.
|
||||
4. Echte lokale Detect-/Reviewadapter und Profil-/Secret-/Eligibilityadapter anbinden, soweit vorhanden. Für Tests ausschließlich synthetische Fakes. Fehlende reale Eignung/Detection lässt persönlichen Egress geschlossen und wird als offen dokumentiert; keine echten Keys/privaten Texte zu „Smokezwecken“ verwenden. Kein neuer Detectdienst wird automatisch installiert.
|
||||
5. Payloadinventur, technische Coverage, Spangrounding, aktive Manifestmaske und den finalen Byte-Seal implementieren. Unbekannte Zusatzfelder, Klasse A, reservierte Tokeninjektion und ungeklärte Konflikte sperren. Keine ungescannten Format-/Systemtexte nachreichen.
|
||||
6. Async-HTTPadapter im Lifespan mit expliziten Endpunkten/TLS/Proxygrenzen, null Retries, Pool-/Admission-/Bodylimits und monotoner Gesamtdauer implementieren. Synchrone DBphasen in getrennten Threadbridge-UoWs; kein SQL-/HTTPmix in einer offenen Transaktion. OpenRouterparameter nur bei tatsächlich entsprechend eligible Profil verwenden.
|
||||
7. Callledger/Uniqueconstraints und T1/T2/T3 mit aktuellem Recht, Quellen-/Profilrevision, Dispatchintent, Audit und konservativem unknown-Zustand implementieren. Ergebniswrite atomar mit fachlichem Audit. Reviewfortsetzung exakt binden; keinen booleschen Clientnachweis akzeptieren.
|
||||
8. Envelope-, JSON-/Pydantic-, Token-/Privacyprüfung und lokale Rehydration implementieren. Kein Live-Rohstream oder Repaircall. Akzeptierten Journaltext nicht nachträglich umschreiben. Usage unbekannt korrekt erhalten, Quotenport nur bei realer Anforderung verdrahten.
|
||||
9. Fachrouter/Statusroute mit Auth-/CSRF-/Scope-/Idempotenzvertrag und sicheren Problemcodes anbinden. Zentralen Frontendclient/epoch beibehalten, begrenzten KI-Timeout lokal setzen, Ausgabe sicher rendern; keine persönlichen Webcaches oder Providerkeys im Frontend.
|
||||
10. Native Tests aus Abschnitt 14 tatsächlich sammeln/ausführen, Wirecanaries über alle Kanäle und negative Nebenpfade prüfen. In beiden Releasevarianten blockieren fehlende/rote KI-Pflicht-Gates vor Produktion. Produktionsmodus ebenfalls isoliert mit synthetischen Profilen prüfen; kein Devflag lockert Privacy. Ergebnisbericht nennt Commit, Image-/Policy-/Profil-/Detectorstand, Tests/Umgebung und offene Adapter. Nur tatsächliche bestandene Tests als T kennzeichnen.
|
||||
|
||||
Der **nächste Prompt-/Platzhalter-/Workflow-Blueprint** konkretisiert Vorlagenversionierung, Registrierungen, Graph-/Nodezustände und Wiederaufnahme. Er konsumiert diesen Gatewayvertrag; jeder Modellnode erhält ihn, ohne Privacy und Providertransport nochmals zu erfinden. Der **anschließende Entitlements-/Verbrauch-/Quota-Blueprint** konkretisiert Reservierung/Abrechnung, insbesondere parallele und unbekannte Ergebnisse. Beide werden durch dieses Dokument nicht automatisch gestartet.
|
||||
|
||||
Abnahme eines späteren ersten vertikalen Slices: autorisierte synthetische Quelle → vollständig gerenderter Prompt → lokale Detection/Maskierung → nachweislich geprüfte Wirebytes zum Fakeprovider → valides maskiertes Ergebnis → nur eigene lokale Rehydration → aktuell autorisierte Ausgabe/atomarer Fachwrite. Cross-Scope-Daten, Direct-HTTP-Bypass, unbekannter Outcome und ungültige Antwort müssen dabei sichtbar verweigert werden. Ein grüner Slice bleibt ein begrenzter Integrationsnachweis, keine universelle Detektions-/Produktreifezusage.
|
||||
|
||||
## 16. Prüfstand dieser Lieferung
|
||||
|
||||
Erstellt wurde ausschließlich dieses neue Blueprintdokument. Produktrepos, Foundation, Auth- und Releaseblueprint blieben unverändert. Keine Codeimplementierung, Modell-/Live-APIaufrufe, produktiven Credentials/Datenbanken, privaten Testtexte, Paketinstallationen, Migrationen, Deployments oder Anwendungstestläufe.
|
||||
|
||||
Dokumentprüfung umfasst lokale Referenzen/Zeilen, Python-/JSONbeispielsyntax und Konsistenz von Context-/Provider-/Payload-/Call-/Fehler-/Testverträgen. Das ist kein T-Nachweis für die geplante Lösung. Technische Providerdetails wurden begrenzt gegen offizielle OpenRouter-/HTTPX-Dokumentation geprüft; konkrete Account-/Endpointbedingungen und lokale Detectorqualität wurden nicht erhoben oder freigegeben.
|
||||
|
||||
### 16.1 Lokaler Quellstand
|
||||
|
||||
Lesestand 16.10.2026. Hashes über vollständige Dateien; Git-HEAD allein ist kein Beleg eines sauberen Checkouts.
|
||||
|
||||
- `Kansho`: Git-HEAD `89d149684eab9211d6ef21181d018de097a61783`
|
||||
- `shinkan-jinkendo`: Git-HEAD `f10c28e5cdcef52cc44e953a8494b4bbe35b77fe`
|
||||
- `mitai-jinkendo`: Git-HEAD `95453d548a2113555cd7e8f01fbbf267cbe34f3f`
|
||||
- `kairo-jinkendo`: Git-HEAD `ea0aa18b8dd9a55f663a996d74e63b7e3ee0dc16`
|
||||
|
||||
| Gezielt verwendete Produktquelle | SHA-256 |
|
||||
|---|---|
|
||||
| [Kansho/backend/privacy_gateway.py](C:/Dev/Kansho/backend/privacy_gateway.py) | `0e729287b6a87ba1a8ef92c6dce27cc3c3e1e829b6958130e59b4e90ff2a3d74` |
|
||||
| [Kansho/backend/providers.py](C:/Dev/Kansho/backend/providers.py) | `86b6924d680ce8fe35e723f82226ac5c76bb7abe900fbdec1c20250de7af069f` |
|
||||
| [Kansho/backend/provider_settings.py](C:/Dev/Kansho/backend/provider_settings.py) | `c38b352b289bbe6cce46d5d8482f26aabc4af8e29b8e3e6cd8f16460f98a122f` |
|
||||
| [Kansho/backend/engine.py](C:/Dev/Kansho/backend/engine.py) | `79b86c6ff69ff87ea4e02c26203ac39beebccf2cce7078ed246ae73971488159` |
|
||||
| [Kansho/backend/context_builder.py](C:/Dev/Kansho/backend/context_builder.py) | `712cb720267b57ac7fe471d7ec2a7cb25d9cd41cf8a19d63a8b083599c96586a` |
|
||||
| [Kansho/backend/prompt_budget.py](C:/Dev/Kansho/backend/prompt_budget.py) | `b95a36a6cd9e0ee704cd88b495bf9475230cdf5f0a2cb711458f27382af2be78` |
|
||||
| [Kansho/backend/tests/test_privacy_manifest.py](C:/Dev/Kansho/backend/tests/test_privacy_manifest.py) | `b48e16b901668efcd31f1534575400836cd3f68e5bd658d711ac7429c23526c5` |
|
||||
| [Kansho/backend/tests/test_privacy_response_integrity.py](C:/Dev/Kansho/backend/tests/test_privacy_response_integrity.py) | `b98035d558007b84c268b6d1b03e28d5b3b35f1984f821b6bbce9e9e84e6ae38` |
|
||||
| [Kansho/backend/tests/test_privacy_detect.py](C:/Dev/Kansho/backend/tests/test_privacy_detect.py) | `7b1043509fbe173f02e6ef050e2527a7adb27919dfbc1265832533e5c9d50347` |
|
||||
| [Kansho/docs/architecture/functional/guardrails.md](C:/Dev/Kansho/docs/architecture/functional/guardrails.md) | `deadd95b5019fe807026616f6ff74a2467d9d951702c032573d59f27c125dc4b` |
|
||||
| [Kansho/docs/architecture/technical/privacy_gateway.md](C:/Dev/Kansho/docs/architecture/technical/privacy_gateway.md) | `496c8661f645b8935edc8ce46214cfda3becca2588125eae345a7a860d9a07c5` |
|
||||
| [shinkan-jinkendo/backend/openrouter_chat.py](C:/Dev/shinkan-jinkendo/backend/openrouter_chat.py) | `606941440d7a7dd0a971cc0606e4ed8a5ad07f0b454374dc25dab8dd5c8a149a` |
|
||||
| [mitai-jinkendo/backend/prompt_executor.py](C:/Dev/mitai-jinkendo/backend/prompt_executor.py) | `7e0e97047fe16d7b5efb92ccbe573b6459c4d32b41931aa9e33d6f00f14028da` |
|
||||
| [kairo-jinkendo/backend/config_service.py](C:/Dev/kairo-jinkendo/backend/config_service.py) | `5d4f4b75216fe5915874ee9db1776354bdf91f233286f29ea71ff112e2f5555e` |
|
||||
| [Kansho/backend/tests/conftest.py](C:/Dev/Kansho/backend/tests/conftest.py) | `15c8a860538203e2dd63ee459b187cfb9fb586585e32a4c665ed74646c3f5ed8` |
|
||||
| [Kansho/backend/pytest.ini](C:/Dev/Kansho/backend/pytest.ini) | `cb919d485cff5f19a829ec584bf12019b4d7b6c4eb03e9254d690416b6e38a94` |
|
||||
|
||||
**Ende dieses Blueprintauftrags. Keine Implementierung und kein weiterer Blueprint werden automatisch gestartet.**
|
||||
Loaded 100 of 182 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user