Compare commits

...
34 Commits
Author SHA1 Message Date
StommerandClaude Sonnet 5.5 363ecdfd0a Starte test.yml wieder mit dem Push und warte auf den Checkout des Dev-Deploys, weil workflow_run hier nicht auslöst.
Deploy Development / deploy (push) Successful in 51s
Test Suite / pytest-backend (push) Successful in 6m22s
Test Suite / frontend-build (push) Successful in 25s
Test Suite / smoke-dev (push) Successful in 0s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 10:24:11 +01:00
StommerandClaude Sonnet 5.5 4bd2d047f5 Entferne den abgeschnittenen CSS-Block, der die Layout-Regeln der Bibliothek verschluckt hat.
Deploy Development / deploy (push) Successful in 47s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 10:20:49 +01:00
StommerandClaude Sonnet 5.5 f925661937 Warne vor bereits eingefügten Quelldokumenten und biete Nicht einfügen, erneut einfügen oder zusätzliches Einbinden an.
Deploy Development / deploy (push) Successful in 44s
Prüfstufen hier, darin, Umfeld stehen als Kontoeinstellung bereit. Der Server antwortet bei einem sicheren Treffer mit 409 und bindet auf Wunsch das vorhandene Element zusätzlich ein.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 10:06:52 +01:00
StommerandClaude Sonnet 5.5 a6dc24d8fe Lege Einstellungen je Konto mit Erbung vom Hauptnutzer an und biete die Prüfstufe für doppelte Dokumente in Mein Konto an.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 09:18:17 +01:00
StommerandClaude Sonnet 5.5 bee48bf4a5 Behebe die fehlschlagenden Paperless-Tests und lasse test.yml nur noch nach dem Dev-Deploy laufen.
Deploy Development / deploy (push) Successful in 52s
Der Hinweis zu Tags und Zusatzfeld sitzt wieder in paperless_documents, damit die Signatur von _paperless_get bleibt. Der Push-Trigger entfällt, weil er einen zweiten Lauf auf derselben Testdatenbank startete.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 07:29:45 +01:00
StommerandClaude Sonnet 5.5 6e1b0916a6 Erleichtere die Tag-Auswahl der Paperless-Suche mit Suchfeld, Alle-an-/abwählen und Chips für die gewählten Tags.
Deploy Development / deploy (push) Successful in 52s
Test Suite / pytest-backend (push) Failing after 6m4s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 23s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 07:13:59 +01:00
StommerandClaude Sonnet 5.5 ffdaf1c721 Weise bei einem Paperless-Fehler auf die Kombination aus allen Tags und Zusatzfeld hin, die Paperless selbst mit HTTP 500 beantwortet.
Deploy Development / deploy (push) Successful in 49s
Test Suite / pytest-backend (push) Failing after 6m4s
Test Suite / smoke-dev (push) Successful in 1s
Test Suite / frontend-build (push) Successful in 24s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 06:58:07 +01:00
StommerandClaude Sonnet 5.5 0f2b7a8fab Nenne in der Paperless-Fehlermeldung Statuscode, Pfad und Grund, damit sich eine abgelehnte Abfrage zuordnen lässt.
Deploy Development / deploy (push) Successful in 50s
Test Suite / pytest-backend (push) Failing after 7s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 26s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 22:53:46 +02:00
StommerandClaude Sonnet 5.5 38406d3293 Zeige die Zusatzfelder in der Trefferliste und erkenne Vorschaubilder am Inhalt statt am Antwort-Header.
Deploy Development / deploy (push) Successful in 43s
Test Suite / pytest-backend (push) Canceled after 5m58s
Test Suite / smoke-dev (push) Canceled after 0s
Test Suite / frontend-build (push) Canceled after 0s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 22:43:36 +02:00
StommerandClaude Sonnet 5.5 2f7de33049 Ziehe die Fähigkeiten von Paperless und IMAP in ihr Modul und entferne die unbenutzte Filterliste.
Deploy Development / deploy (push) Successful in 46s
Test Suite / pytest-backend (push) Successful in 5m58s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 22s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 22:23:46 +02:00
StommerandClaude Sonnet 5.5 5e32ba547d Verlege die Paperless-Suchparameter und das Vorschaubild in das Modul und korrigiere das Handy-Layout der großen Auswahl.
Deploy Development / deploy (push) Successful in 42s
Test Suite / pytest-backend (push) Successful in 5m50s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 22s
Die gemeinsame Suchroute kennt keine Filternamen mehr; das Modul deklariert sie und unbekannte Parameter werden abgewiesen. Unvollständige Zusatzfeld-Zeilen werden gemeldet statt weggelassen. Vorschaubilder nur als Rastergrafik. Abschlussmatrix und API-Referenz nachgeführt.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 22:10:54 +02:00
StommerandClaude Sonnet 5.5 f580fb282d Filtere Paperless-Dokumente nach Zusatzfeldern und öffne die Auswahl als großen Dialog mit Filtern links und Treffern rechts.
Deploy Development / deploy (push) Successful in 43s
Test Suite / pytest-backend (push) Successful in 5m37s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 22s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 21:23:29 +02:00
StommerandClaude Sonnet 5.5 9089d830b3 Erweitere die Paperless-Suche um Suchart, weitere Filter und eine Vorschau je Treffer, damit sich das richtige Dokument finden und erkennen lässt.
Deploy Development / deploy (push) Successful in 44s
Test Suite / pytest-backend (push) Successful in 6m5s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 22s
Standard ist jetzt Titel und Inhalt ohne Index; Titel, Inhalt und Volltextindex sind wählbar. Neue Filter: Speicherpfad, Tag-Verknüpfung (alle, eines, keines), "ohne" bei Korrespondent, Typ und Pfad, Hinzugefügt-Datum und Archivnummer. Treffer zeigen Vorschaubild, Textauszug, Tags, Typ und Seitenzahl; die Vorschaubilder laufen über den Server.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 20:41:06 +02:00
LarsandCursor 4327f5a434 Zeige PDF-Anlagen in der Mail wieder direkt an, statt nur einen Download anzubieten.
Deploy Development / deploy (push) Successful in 42s
Test Suite / pytest-backend (push) Successful in 5m58s
Test Suite / smoke-dev (push) Successful in 1s
Test Suite / frontend-build (push) Successful in 22s
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-23 13:25:24 +02:00
Stommer e2475555c0 Aktualisiere die Dokumentation für Download-Regel, HTML-Mail, Bilder und R-11.
Deploy Development / deploy (push) Successful in 41s
Test Suite / pytest-backend (push) Canceled after 3m21s
Test Suite / smoke-dev (push) Canceled after 0s
Test Suite / frontend-build (push) Canceled after 0s
2026-10-23 13:02:36 +02:00
LarsandCursor 7a1206b18c Speichere die neue Position einer verschobenen IMAP-Nachricht, damit der nächste Aufruf sie direkt öffnet.
Test Suite / pytest-backend (push) Canceled after 0s
Test Suite / smoke-dev (push) Canceled after 0s
Test Suite / frontend-build (push) Canceled after 0s
Deploy Development / deploy (push) Successful in 43s
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-23 13:00:25 +02:00
LarsandCursor cd239a3ab8 Zeige PDF-Anlagen in der Mail-Ansicht, damit der Browser sie nicht unter einem zufälligen Namen speichert.
Deploy Development / deploy (push) Successful in 47s
Test Suite / pytest-backend (push) Successful in 6m16s
Test Suite / smoke-dev (push) Successful in 1s
Test Suite / frontend-build (push) Successful in 22s
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-23 12:59:07 +02:00
StommerandClaude Sonnet 5.5 d0f09830bb Behebe R-11: Übersicht und Suche lesen in Blöcken und prüfen Rechte vor der Begrenzung.
Deploy Development / deploy (push) Successful in 42s
Test Suite / pytest-backend (push) Successful in 5m53s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 17:26:06 +02:00
StommerandClaude Sonnet 5.5 a3f328832e Lade Bilder aus E-Mails auf Wunsch über den Server nach und verkleinere den Kopf der Leseansicht auf dem Handy.
Deploy Development / deploy (push) Successful in 41s
Test Suite / pytest-backend (push) Successful in 5m32s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 16:47:24 +02:00
StommerandClaude Sonnet 5.5 075525ee17 Steuere das Herunterladen von Originalen je Rolle, benenne Dateien richtig und zeige HTML-Mails gesichert im Sandbox-Rahmen.
Deploy Development / deploy (push) Successful in 40s
Test Suite / pytest-backend (push) Successful in 5m35s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 22s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 14:22:35 +02:00
StommerandClaude Sonnet 5.5 0a5daf6713 Behebe die abgeschnittene Vorgangsansicht auf dem Handy: Der Rahmen der Ablage begrenzt jetzt die Höhe, die Liste scrollt.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 14:14:40 +02:00
StommerandClaude Sonnet 5.5 1d3c938def Aktualisiere den Ablagebaum nach dem Lösen eines Vorgangs aus einer Akte.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 13:39:52 +02:00
StommerandClaude Sonnet 5.5 07e46c77f1 Stelle PDFs auf iPhone und iPad seitenweise dar und nutze das Legacy-Build von pdf.js.
Deploy Development / deploy (push) Successful in 41s
Test Suite / pytest-backend (push) Successful in 5m40s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 13:29:23 +02:00
StommerandClaude Sonnet 5.5 7b2d0c298e Mache die Breite der Ablage ziehbar und merkbar, verdichte die Zeilen und löse Vorgänge aus einer Akte, ohne sie zu löschen.
Deploy Development / deploy (push) Successful in 42s
Test Suite / pytest-backend (push) Successful in 5m26s
Test Suite / smoke-dev (push) Successful in 1s
Test Suite / frontend-build (push) Successful in 22s
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 13:23:06 +02:00
LarsandClaude Sonnet 5.5 5f60e1fe40 Vereine Ablage, Akte und Vorgang in einem Navigationsbaum mit Fokus und Nachladen.
Deploy Development / deploy (push) Successful in 39s
Test Suite / pytest-backend (push) Successful in 5m24s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Der Baum Meine Ablage steht jetzt auch auf den Seiten von Akte und Vorgang und ersetzt die Spalte Struktur. Ein Klick öffnet den Eintrag und klappt seine Struktur auf: Überblick, Kapitel und Unterkapitel, Unterakten, Vorgänge und Teilvorgänge. Der Pfad bleibt offen, die aktuelle Zeile ist hervorgehoben und nach dem Neuladen stimmt der Fokus wieder. Ein Vorgang steht unter jeder Akte, in der er liegt, und unter Vorgänge; ein Klick unter einer Akte öffnet ihn in diesem Aktenkontext. So wechselt man direkt von Vorgang zu Vorgang. Kapitel anlegen und verschieben geht im Baum.

Die Struktur eines Knotens kommt aus neuen schlanken Endpunkten (cases und matters outline), die nur Lesbares liefern, und wird beim Aufklappen einmal nachgeladen. Die Zweispaltenansicht mit dem Lesebereich beginnt erst, wenn neben dem Baum genug Platz bleibt.

Im Browser gegen die lokale Umgebung durchgespielt (Akte, Vorgang unter der Akte, Wechsel zwischen Vorgängen, Kapitel anlegen, Neuladen, Vorgang ohne Akte, Handy, Hell und Dunkel). Die Backend-Suite läuft mit 149 Tests grün, der Frontend-Build und 37 Node-Tests ebenfalls.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 12:11:36 +02:00
LarsandClaude Sonnet 5.5 322ad491c1 Übertrage den Stil des Ordnerbaums auf die Struktur in Akte und Vorgang.
Die Strukturspalte der Detailseiten nutzt jetzt dieselben farbigen Symbole wie die Ablage: Ordner für Akten, Dokumentstapel für Vorgänge, Lesezeichen für Kapitel und Unterkapitel, Liste für Überblick und Inhalte, Kette für Querverweise. Zeilen, Hover, Auswahl, Auf- und Zuklappen und die Einrückung der Unterstrukturen entsprechen dem Ordnerbaum, in Hell und Dunkel.

Im Browser gegen die lokale Umgebung geprüft (Akte mit Kapiteln und Unterkapiteln, Vorgang, Hell und Dunkel). Der Frontend-Build und alle Node-Tests laufen grün.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 11:55:13 +02:00
LarsandClaude Sonnet 5.5 64dce6c20c Gestalte Akten, Vorgänge und Räume als Ablage mit Ordnerbaum und Kacheln.
Deploy Development / deploy (push) Successful in 41s
Test Suite / pytest-backend (push) Successful in 5m19s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Links steht ein Ordnerbaum mit Akten, Vorgängen und Räumen, rechts zeigen Kacheln den Inhalt als Ordner, Dokumentstapel und Teamordner, umschaltbar auf eine Liste. Räume sind virtuelle Ordner: Ein Eintrag kann in mehreren Räumen liegen, ohne verschoben zu werden. Zugeordnet wird über Hinzufügen im Raum, Ziehen auf einen Raum, den Knopf In Raum legen und die Raum-Marken auf der Kachel; jede Aktion nennt, wer Zugriff erhält. Neu anlegen fragt nicht mehr nach dem Heimatraum. Räume sind ein eigener Navigationspunkt; ihre Verwaltung liegt im Reiter Mitglieder und Rechte.

Der Ablauf wurde im Browser gegen eine lokale Umgebung durchgespielt (Menü, Ziehen, Hinzufügen, Ordneransicht) und in Hell und Dunkel sowie am Handy angesehen. Die Backend-Suite läuft mit 148 Tests grün, der Frontend-Build und 33 Node-Tests ebenfalls.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 11:49:02 +02:00
LarsandClaude Sonnet 5.5 d39c7d7999 Liefere Zähler, Rauminhalt und Teilen im Stapel für die neue Ablage.
Akten und Vorgänge melden Unterakten, Vorgänge und die Räume, mit denen sie geteilt sind, jeweils nur aus Lesbarem. Neue Endpunkte zeigen die Räume als Kacheln, den Inhalt eines Raums und teilen mehrere Einträge auf einmal oder gar nicht. Beim Anlegen lässt sich ein Eintrag gleich in einen Raum legen.

Die lokale Suite läuft mit 148 Tests grün.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 11:38:02 +02:00
LarsandClaude Sonnet 5.5 30b6544514 Korrigiere den Dark-Mode in der Strukturnavigation und zeige "Eigentümer einsetzen" nur, wenn es nötig ist.
Deploy Development / deploy (push) Successful in 43s
Test Suite / pytest-backend (push) Successful in 5m22s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Die Navigationsspalte der Akten und Vorgänge hatte einen festen hellen Hintergrund, im Dark-Mode stand darauf helle Schrift. Dasselbe galt für den Lesebereich, die Statusmarke und ein Auswahlfeld. Texte in der Markenfarbe sind im Dark-Mode jetzt hell, die gedämpfte Beschriftung ist besser lesbar, und zwei nicht definierte Farbvariablen sind ersetzt.

In der Betreiberübersicht der Datenräume steht der Eigentümer mit Hinweis, ob er noch handeln kann. Die Schaltfläche "Eigentümer einsetzen" erscheint nur, wenn der Eigentümer nicht mehr aktiv ist; bisher stand sie bei jedem Raum, und der Server lehnte sie bei aktivem Eigentümer ab.

Der Backend-Test der Raumrollen läuft grün, der Frontend-Build ebenfalls. Der Dark-Mode wurde nicht im Browser geprüft.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 09:42:00 +02:00
StommerandClaude Opus 5.5 1765714ccd Halte fest, was Gitea und der Runner für ein Release-Gate hergeben, damit P7 auf geprüften Annahmen aufbaut.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 09:39:26 +02:00
LarsandClaude Sonnet 5.5 1a2c959309 Beschreibe den Auftrag für Release-Gate, Backup und Restore, damit er in einer eigenen Sitzung umgesetzt werden kann.
Der Auftrag fasst Ziel, Lieferumfang, Ausgangslage, Vorgehen mit Grenzen und Abnahme für P7 und das Review R-21 zusammen und verweist auf den Release-Blueprint. Er ist in docs/README.md verlinkt.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 09:35:41 +02:00
LarsandClaude Sonnet 5.5 6d7b7c5f85 Führe Hauptnutzer und Mitarbeiter ein, damit der Betreiber Kunden und Hauptnutzer ihre Teams verwalten.
Deploy Development / deploy (push) Successful in 45s
Test Suite / pytest-backend (push) Successful in 5m20s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Eine Einladung erzeugt jetzt ein Mitarbeiter-Konto mit dem Eigentümer des Raums als Förderer. Mitarbeiter arbeiten nur in den eingeladenen Räumen nach ihrer Rolle, legen keine Räume und im persönlichen Raum nichts an und starten ihre Sitzung im Team-Raum. Einladen darf nur der Eigentümer als Hauptnutzer; nur ein Hauptnutzer kann Raum-Eigentümer sein. Hauptnutzer sehen unter Mein Team die Personen in ihren Räumen und verwalten ihre Mitarbeiter (deaktivieren, Einmal-Passwort, aus Räumen entfernen). Der Betreiber sieht die Team-Übersicht mit CSV-Export und macht einen Mitarbeiter zum Hauptnutzer.

Eine zentrale Prüfstelle für Grenzen (access/limits.py) wird beim Anlegen von Räumen und beim Aufnehmen und Einladen von Mitgliedern aufgerufen; Tarife folgen später.

Die lokale Suite läuft mit 143 Tests grün, der Frontend-Build und 24 Node-Tests ebenfalls. Die Oberfläche wurde noch nicht im Browser bedient.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-22 09:03:40 +02:00
LarsandClaude Sonnet 5.5 e47f50d513 Verhindere, dass Raum-Endpunkte verraten, welche Raum-IDs es gibt, und sichere sie mit einem Test gegen Außenstehende ab.
Deploy Development / deploy (push) Successful in 42s
Test Suite / pytest-backend (push) Successful in 4m57s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Unbekannte und fremde Räume antworten bei Mitglieder-, Einladungs-, Eigentümer- und Freigabe-Aktionen gleich mit 403. Der neue Test prüft alle Raum-Endpunkte als Außenstehender, Leser und Mitglied.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-21 14:44:30 +02:00
LarsandClaude Sonnet 5.5 ac3c3d81fe Vereinfache die Raumverwaltung und ergänze Ziehen zum Teilen.
Datenräume werden an einer Stelle verwaltet: Die Liste öffnet je Raum eine Verwaltungsseite für Mitglieder, Rollen, Einladungen, Voreinstellung, Übertragung und Archivieren, ohne den Raum wechseln zu müssen. Der Betreiber sieht die Übersicht aller Räume auf derselben Seite und kann Eigentümer oder Verwalter einsetzen. In den Listen für Akten und Vorgänge lassen sich eigene Einträge auf einen Datenraum ziehen, um sie zu teilen; die Liste zeigt, mit welchen Räumen ein Eintrag geteilt ist.

Die lokale Suite läuft mit 133 Tests grün, der Frontend-Build und 21 Node-Tests ebenfalls. Die Oberfläche wurde noch nicht im Browser bedient.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-21 14:37:20 +02:00
101 changed files with 7737 additions and 1311 deletions

No files matched your search

+38 -10
View File
@@ -1,16 +1,15 @@
name: Test Suite 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: on:
push: push:
branches: [develop] branches: [develop]
workflow_run:
workflows: ["Deploy Development"]
types: [completed]
workflow_dispatch: workflow_dispatch:
jobs: jobs:
pytest-backend: pytest-backend:
if: ${{ github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success' }}
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- name: pytest against Dev Postgres (tsumugu_test) - name: pytest against Dev Postgres (tsumugu_test)
@@ -19,6 +18,19 @@ jobs:
APP_DIR="/home/lars/docker/tsumugu-dev" APP_DIR="/home/lars/docker/tsumugu-dev"
COMPOSE_FILE="docker-compose.dev-env.yml" COMPOSE_FILE="docker-compose.dev-env.yml"
echo "pytest uses Dev Postgres (${APP_DIR}); event=${{ github.event_name }}" 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" cd "$APP_DIR"
for i in $(seq 1 60); do 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 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: 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 runs-on: ubuntu-latest
steps: steps:
- name: Non-destructive smoke against the running Dev app - name: Non-destructive smoke against the running Dev app
run: | run: |
set -e set -e
echo "live Dev API (tsumugu_dev), read-only health" echo "live Dev API (tsumugu_dev), read-only health"
curl -sf http://localhost:8094/api/health for url in http://localhost:8094/api/health http://localhost:3094/api/health; do
echo for i in $(seq 1 30); do
curl -sf http://localhost:3094/api/health if curl -sf "$url"; then echo; break; fi
echo 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" echo "LAN smoke OK. Public URL after TLS: https://dev.tsumugu.jinkendo.de"
frontend-build: frontend-build:
if: ${{ github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success' }}
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- name: Frontend production build on Dev checkout - name: Frontend production build on Dev checkout
run: | run: |
set -e set -e
APP_DIR="/home/lars/docker/tsumugu-dev" 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" cd "$APP_DIR/frontend"
npm ci npm ci
npm run build npm run build
+26
View File
@@ -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
+31 -6
View File
@@ -24,16 +24,18 @@ class Rights:
edit: bool = False edit: bool = False
share: bool = False share: bool = False
delete: 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 @classmethod
def full(cls) -> Rights: def full(cls) -> Rights:
return cls(True, True, True, True) return cls(True, True, True, True, True)
@classmethod @classmethod
def from_row(cls, row: dict | None) -> Rights: def from_row(cls, row: dict | None, download: bool = False) -> Rights:
if row is None: if row is None:
return cls() 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: def union(self, other: Rights) -> Rights:
return Rights( return Rights(
@@ -41,21 +43,24 @@ class Rights:
self.edit or other.edit, self.edit or other.edit,
self.share or other.share, self.share or other.share,
self.delete or other.delete, self.delete or other.delete,
self.download or other.download,
) )
def without(self, blocked: Rights) -> Rights: def without(self, blocked: Rights) -> Rights:
# An exception that takes away reading takes away downloading too.
return Rights( return Rights(
self.read and not blocked.read, self.read and not blocked.read,
self.edit and not blocked.edit, self.edit and not blocked.edit,
self.share and not blocked.share, self.share and not blocked.share,
self.delete and not blocked.delete, self.delete and not blocked.delete,
self.download and not blocked.read,
) )
def allows(self, need: str) -> bool: def allows(self, need: str) -> bool:
return bool(getattr(self, need)) return bool(getattr(self, need))
def as_dict(self) -> dict[str, bool]: 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. # The room share: what a room role may do with a case or matter that is shared with the room.
@@ -206,7 +211,25 @@ def _direct_grant(conn, actor: UUID, kind: str, resource_id: UUID) -> Rights:
""", """,
(actor, kind, resource_id), (actor, kind, resource_id),
).fetchone() ).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: def _exceptions(conn, actor: UUID, kind: str, resource_id: UUID, context: Ctx | None) -> Rights:
@@ -249,7 +272,7 @@ def room_default(conn, actor: UUID, kind: str, resource_id: UUID) -> Rights:
""" """
rows = conn.execute( rows = conn.execute(
""" """
SELECT m.role, s.access SELECT m.role, s.access, r.download_roles
FROM room_shares s 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 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 data_rooms r ON r.id = s.room_id AND r.kind = 'organization' AND r.status = 'active'
@@ -265,6 +288,8 @@ def room_default(conn, actor: UUID, kind: str, resource_id: UUID) -> Rights:
rights = Rights(read=rights.read) rights = Rights(read=rights.read)
elif row["access"] != "edit": elif row["access"] != "edit":
rights = Rights() 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) result = result.union(rights)
return result return result
+12
View File
@@ -19,6 +19,17 @@ ROOM_ROLE_LABELS = {
} }
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: def is_operator(conn, account_id: UUID) -> bool:
row = conn.execute( row = conn.execute(
"SELECT is_superadmin FROM auth_accounts WHERE id = %s AND status = 'active'", "SELECT is_superadmin FROM auth_accounts WHERE id = %s AND status = 'active'",
@@ -58,6 +69,7 @@ def require_room_write(conn, account_id: UUID, room: dict) -> None:
if room["kind"] == "personal": if room["kind"] == "personal":
if room["id"] != account_id: if room["id"] != account_id:
raise forbidden("Der persönliche Datenraum gehört zu einem anderen Konto.") raise forbidden("Der persönliche Datenraum gehört zu einem anderen Konto.")
require_main_user(conn, account_id)
return return
role = room_role(conn, account_id, room["id"]) role = room_role(conn, account_id, room["id"])
if role in {"member", "manager"}: if role in {"member", "manager"}:
+26 -3
View File
@@ -13,6 +13,7 @@ from app.access.roles import require_operator
from app.api.deps import Principal, get_conn, get_principal, get_session from app.api.deps import Principal, get_conn, get_principal, get_session
from app.api.schemas import AccountIn, AccountPatchIn, PasswordChangeIn from app.api.schemas import AccountIn, AccountPatchIn, PasswordChangeIn
from app.auth.accounts import ( from app.auth.accounts import (
promote_to_main,
change_own_password, change_own_password,
create_account, create_account,
generate_password, generate_password,
@@ -40,6 +41,9 @@ def _account_item(row) -> dict:
"must_change_password": row["must_change_password"], "must_change_password": row["must_change_password"],
"created_at": dump_dt(row["created_at"]), "created_at": dump_dt(row["created_at"]),
"last_login_at": dump_dt(row["last_login_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"),
} }
@@ -54,7 +58,9 @@ def accounts(
raise unprocessable("Der Statusfilter ist ungültig.") raise unprocessable("Der Statusfilter ist ungültig.")
rows = conn.execute( rows = conn.execute(
""" """
SELECT id, email, display_name, is_superadmin, status, must_change_password, created_at, last_login_at 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 FROM auth_accounts
WHERE origin = 'operator' AND (%s::text IS NULL OR status = %s::text) WHERE origin = 'operator' AND (%s::text IS NULL OR status = %s::text)
ORDER BY status, display_name, email ORDER BY status, display_name, email
@@ -69,7 +75,9 @@ def account_detail(account_id: UUID, principal: Principal = Depends(get_principa
require_operator(conn, principal.account_id) require_operator(conn, principal.account_id)
row = conn.execute( row = conn.execute(
""" """
SELECT id, email, display_name, is_superadmin, status, must_change_password, created_at, last_login_at 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' FROM auth_accounts WHERE id = %s AND origin = 'operator'
""", """,
(account_id,), (account_id,),
@@ -98,6 +106,16 @@ def account_detail(account_id: UUID, principal: Principal = Depends(get_principa
{"id": str(room["id"]), "name": room["name"], "status": room["status"], "role": room["role"]} for room in rooms {"id": str(room["id"]), "name": room["name"], "status": room["status"], "role": room["role"]} for room in rooms
] ]
body["active_sessions"] = sessions["n"] 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) return JSONResponse(body, headers=_NO_STORE)
@@ -123,6 +141,7 @@ def post_account(body: AccountIn, principal: Principal = Depends(get_principal),
"is_superadmin": account["is_superadmin"], "is_superadmin": account["is_superadmin"],
"status": account["status"], "status": account["status"],
"must_change_password": True, "must_change_password": True,
"account_kind": account["account_kind"],
} }
if not body.password: if not body.password:
payload["temporary_password"] = password payload["temporary_password"] = password
@@ -146,13 +165,17 @@ def patch_account(
raise not_found() raise not_found()
if body.display_name is not None: if body.display_name is not None:
set_display_name(conn, principal.account_id, account_id, body.display_name) 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: if body.is_operator is not None:
set_operator(conn, principal.account_id, account_id, body.is_operator) set_operator(conn, principal.account_id, account_id, body.is_operator)
if body.status is not None: if body.status is not None:
set_status(conn, principal.account_id, account_id, body.status) set_status(conn, principal.account_id, account_id, body.status)
row = conn.execute( row = conn.execute(
""" """
SELECT id, email, display_name, is_superadmin, status, must_change_password, created_at, last_login_at 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 FROM auth_accounts WHERE id = %s
""", """,
(account_id,), (account_id,),
+82
View File
@@ -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 -2
View File
@@ -8,10 +8,10 @@ from uuid import UUID
from fastapi import APIRouter, Depends, Request, Response from fastapi import APIRouter, Depends, Request, Response
from psycopg import Connection 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.deps import Principal, get_conn, get_principal
from app.api.schemas import ExportIn 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 from app.exporting import build_export, export_tree, review_export
router = APIRouter() router = APIRouter()
@@ -79,6 +79,12 @@ def post_export(
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
): ):
selected, assignments = _selection(body) 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( filename, payload = build_export(
conn, conn,
principal.account_id, principal.account_id,
+52
View File
@@ -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"})
+119
View File
@@ -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)
+41
View File
@@ -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)
+37 -9
View File
@@ -10,9 +10,12 @@ from fastapi.responses import JSONResponse
from psycopg import Connection from psycopg import Connection
from app.access.policy import account_by_email, audit 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 ( from app.access.roles import (
ROOM_ROLES, ROOM_ROLES,
account_kind,
count_active_managers, count_active_managers,
require_main_user,
require_operator, require_operator,
require_room_manager, require_room_manager,
room_role, room_role,
@@ -46,8 +49,11 @@ def _created(path: str, payload: dict) -> JSONResponse:
def _require_owner(conn, account_id: UUID, room_id: UUID) -> dict: def _require_owner(conn, account_id: UUID, room_id: UUID) -> dict:
room = _room(conn, room_id) # An unknown room and a room owned by someone else answer alike: no way to probe ids.
if room["owner_id"] != account_id: 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.") raise forbidden("Das darf nur der Eigentümer des Datenraums.")
return room return room
@@ -170,14 +176,22 @@ def rooms(
@router.post("/api/v1/rooms") @router.post("/api/v1/rooms")
def create_room(body: RoomIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): 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() room_id = uuid4()
name = body.name.strip() name = body.name.strip()
conn.execute( conn.execute(
""" """
INSERT INTO data_rooms (id, kind, name, created_by, owner_id, default_visibility) INSERT INTO data_rooms (id, kind, name, created_by, owner_id, default_visibility, download_roles)
VALUES (%s, 'organization', %s, %s, %s, %s) 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), (room_id, name, principal.account_id, principal.account_id, body.default_visibility, principal.account_id),
) )
conn.execute( conn.execute(
"INSERT INTO room_memberships (room_id, subject_id, role) VALUES (%s, %s, 'manager')", "INSERT INTO room_memberships (room_id, subject_id, role) VALUES (%s, %s, 'manager')",
@@ -278,6 +292,8 @@ def transfer_owner(
account = conn.execute("SELECT status FROM auth_accounts WHERE id = %s", (body.subject_id,)).fetchone() 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": 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.") 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"]: if body.subject_id == room["owner_id"]:
raise unprocessable("Diese Person ist bereits Eigentümer.") raise unprocessable("Diese Person ist bereits Eigentümer.")
_set_owner(conn, principal.account_id, room_id, body.subject_id, room["owner_id"]) _set_owner(conn, principal.account_id, room_id, body.subject_id, room["owner_id"])
@@ -287,7 +303,6 @@ def transfer_owner(
@router.get("/api/v1/rooms/{room_id}/exposure") @router.get("/api/v1/rooms/{room_id}/exposure")
def exposure(room_id: UUID, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): 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`).""" """Own cases and matters: shared with this room (`room`) or filed here but not shared (`private`)."""
_room(conn, room_id)
if room_role(conn, principal.account_id, room_id) is None: if room_role(conn, principal.account_id, room_id) is None:
raise forbidden() raise forbidden()
result: dict = {} result: dict = {}
@@ -318,7 +333,6 @@ def set_my_content(
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
): ):
"""`room`: share every own entry filed in this room with it. `private`: end all own shares to it.""" """`room`: share every own entry filed in this room with it. `private`: end all own shares to it."""
_room(conn, room_id)
role = room_role(conn, principal.account_id, room_id) role = room_role(conn, principal.account_id, room_id)
if role is None: if role is None:
raise forbidden() raise forbidden()
@@ -410,6 +424,8 @@ def add_member(
if count_active_managers(conn, room_id, lock=True) <= 1: if count_active_managers(conn, room_id, lock=True) <= 1:
raise unprocessable("Der letzte Verwalter bleibt Verwalter.") raise unprocessable("Der letzte Verwalter bleibt Verwalter.")
was_active = bool(existing and existing["status"] == "active") 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) _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} return {"subject_id": str(account["id"]), "role": body.role}
@@ -475,8 +491,10 @@ def invite(
principal: Principal = Depends(get_principal), principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
): ):
room = _room(conn, body.room_id) # Only the owner, a main user, brings new people in; they become employee accounts.
require_room_manager(conn, principal.account_id, room["id"]) 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) email = normalize_email(body.email)
if account_by_email(conn, email): if account_by_email(conn, email):
raise unprocessable("Es gibt bereits ein Konto. Füge die Person als Mitglied hinzu.") raise unprocessable("Es gibt bereits ein Konto. Füge die Person als Mitglied hinzu.")
@@ -554,6 +572,12 @@ def admin_rooms(principal: Principal = Depends(get_principal), conn: Connection
rows = conn.execute( rows = conn.execute(
""" """
SELECT r.id, r.name, r.status, r.created_at, 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, (SELECT count(*) FROM room_memberships m WHERE m.room_id = r.id AND m.status = 'active') AS members,
COALESCE(( COALESCE((
SELECT json_agg(a.display_name ORDER BY a.display_name) SELECT json_agg(a.display_name ORDER BY a.display_name)
@@ -572,6 +596,8 @@ def admin_rooms(principal: Principal = Depends(get_principal), conn: Connection
"name": row["name"], "name": row["name"],
"status": row["status"], "status": row["status"],
"members": row["members"], "members": row["members"],
"owner": row["owner_name"],
"owner_active": row["owner_active"],
"managers": row["managers"], "managers": row["managers"],
"has_manager": bool(row["managers"]), "has_manager": bool(row["managers"]),
"created_at": dump_dt(row["created_at"]), "created_at": dump_dt(row["created_at"]),
@@ -626,6 +652,8 @@ def admin_set_owner(
account = account_by_email(conn, body.email) account = account_by_email(conn, body.email)
if account is None or account["status"] != "active": if account is None or account["status"] != "active":
raise not_found() 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"]) _set_owner(conn, principal.account_id, room_id, account["id"], room["owner_id"])
return {"owner_id": str(account["id"])} return {"owner_id": str(account["id"])}
+4 -1
View File
@@ -12,6 +12,7 @@ from psycopg import Connection
from app.access.policy import ROOM_RIGHTS, Rights from app.access.policy import ROOM_RIGHTS, Rights
from app.api.deps import Principal, get_conn, get_principal from app.api.deps import Principal, get_conn, get_principal
from app.api.schemas import ExclusionIn, RoomShareIn 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 from app.ops import _shareable, set_person_exclusion, share_with_room, unshare_from_room
router = APIRouter() router = APIRouter()
@@ -108,7 +109,9 @@ def _register(kind: str, plural: str) -> None:
principal: Principal = Depends(get_principal), principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
): ):
return share_with_room(conn, principal.account_id, kind, resource_id, room_id, body.access) 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") @router.delete(base + "/rooms/{room_id}", status_code=204, name=f"delete_{kind}_room_share")
def delete_share( def delete_share(
+78 -52
View File
@@ -32,7 +32,9 @@ from app.access.policy import (
require_matter, require_matter,
task_rights, 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.deps import Principal, get_conn, get_principal, get_session
from app.api.externals import place_external
from app.api.schemas import ( from app.api.schemas import (
AcceptInviteIn, AcceptInviteIn,
AnnotationIn, AnnotationIn,
@@ -82,6 +84,7 @@ from app.api.schemas import (
from app.auth.accounts import ( from app.auth.accounts import (
clear_login_attempts, clear_login_attempts,
create_account, create_account,
initial_scope,
list_rooms, list_rooms,
login_blocked, login_blocked,
normalize_email, normalize_email,
@@ -99,7 +102,7 @@ from app.auth.security import (
verify_password, verify_password,
verify_unknown_account, 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.core.timeutil import dump_date, dump_dt, utcnow
from app.media.port import read_clear_bytes from app.media.port import read_clear_bytes
from app.media.storage import content_disposition from app.media.storage import content_disposition
@@ -111,7 +114,6 @@ from app.ops import (
create_chapter, create_chapter,
create_cross_link, create_cross_link,
create_deadline, create_deadline,
create_external,
create_file, create_file,
create_matter, create_matter,
create_note, create_note,
@@ -165,6 +167,8 @@ from app.present import (
note_update_payload, note_update_payload,
task_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 from app.seed import demo_public
router = APIRouter() router = APIRouter()
@@ -199,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: def _session_body(conn, account_id: UUID, scope_kind: str, scope_id: UUID, csrf: str, epoch: int) -> dict:
account = conn.execute( account = conn.execute(
"SELECT id, email, display_name, is_superadmin, must_change_password 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,), (account_id,),
).fetchone() ).fetchone()
room = conn.execute("SELECT id, kind, name FROM data_rooms WHERE id = %s", (scope_id,)).fetchone() room = conn.execute("SELECT id, kind, name FROM data_rooms WHERE id = %s", (scope_id,)).fetchone()
@@ -210,6 +214,7 @@ def _session_body(conn, account_id: UUID, scope_kind: str, scope_id: UUID, csrf:
"display_name": account["display_name"], "display_name": account["display_name"],
"is_superadmin": account["is_superadmin"], "is_superadmin": account["is_superadmin"],
"must_change_password": account["must_change_password"], "must_change_password": account["must_change_password"],
"account_kind": account["account_kind"],
}, },
"scope": {"kind": scope_kind, "id": str(room["id"]), "name": room["name"]}, "scope": {"kind": scope_kind, "id": str(room["id"]), "name": room["name"]},
"rooms": list_rooms(conn, account_id), "rooms": list_rooms(conn, account_id),
@@ -240,7 +245,8 @@ def login(body: LoginIn, request: Request, conn: Connection = Depends(get_conn))
clear_login_attempts(conn, bucket) clear_login_attempts(conn, bucket)
settings = request.app.state.settings settings = request.app.state.settings
token, csrf = start_session(conn, settings, account["id"], device_label(request.headers.get("user-agent"))) 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) scope_kind, scope_id = initial_scope(conn, account["id"])
payload = _session_body(conn, account["id"], scope_kind, scope_id, csrf, 1)
response = JSONResponse(payload) response = JSONResponse(payload)
set_session_cookie(response, request, settings, token) set_session_cookie(response, request, settings, token)
return response return response
@@ -336,7 +342,19 @@ def accept_invite(
raise not_found() raise not_found()
if row["token_hash"] != hash_secret(body.token): if row["token_hash"] != hash_secret(body.token):
raise not_found() 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( conn.execute(
""" """
INSERT INTO room_memberships (room_id, subject_id, role) INSERT INTO room_memberships (room_id, subject_id, role)
@@ -348,7 +366,8 @@ def accept_invite(
audit(conn, account["id"], row["room_id"], "invitation_accepted", "invitation", invitation_id) audit(conn, account["id"], row["room_id"], "invitation_accepted", "invitation", invitation_id)
settings = request.app.state.settings settings = request.app.state.settings
token, csrf = start_session(conn, settings, account["id"], device_label(request.headers.get("user-agent"))) 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) 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) response = JSONResponse(status_code=201, content=payload)
set_session_cookie(response, request, settings, token) set_session_cookie(response, request, settings, token)
return response return response
@@ -364,18 +383,7 @@ def find_principal(email: str, principal: Principal = Depends(get_principal), co
@router.get("/api/v1/cases") @router.get("/api/v1/cases")
def cases(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): def cases(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
items = [] return {"items": case_items(conn, principal.account_id, list_cases(conn, principal.account_id)), "next_cursor": None}
for case, rights in list_cases(conn, principal.account_id):
summary = case_summary(case, rights)
summary["home_scope_name"] = room_name(conn, case["home_scope_id"])
summary["kind_label"] = "Unterakte" if case["parent_case_id"] else "Akte"
summary["parent_title"] = None
if case["parent_case_id"]:
parent = get_case(conn, case["parent_case_id"])
if parent is not None and case_rights(conn, principal.account_id, parent).read:
summary["parent_title"] = parent["title"]
items.append(summary)
return {"items": items, "next_cursor": None}
@router.post("/api/v1/cases") @router.post("/api/v1/cases")
@@ -388,6 +396,8 @@ def post_case(body: CaseIn, principal: Principal = Depends(get_principal), conn:
body.parent_case_id, body.parent_case_id,
body.rights_mode, 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) rights = case_rights(conn, principal.account_id, case)
return _created(f"/api/v1/cases/{case['id']}", case_summary(case, rights)) return _created(f"/api/v1/cases/{case['id']}", case_summary(case, rights))
@@ -472,8 +482,7 @@ def post_case_grant(
@router.get("/api/v1/matters") @router.get("/api/v1/matters")
def matters(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): 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": matter_items(conn, principal.account_id, list_matters(conn, principal.account_id)), "next_cursor": None}
return {"items": items, "next_cursor": None}
@router.post("/api/v1/matters") @router.post("/api/v1/matters")
@@ -486,6 +495,8 @@ def post_matter(body: MatterIn, principal: Principal = Depends(get_principal), c
body.parent_matter_id, body.parent_matter_id,
_ctx_model(body.context), _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)) return _created(f"/api/v1/matters/{matter['id']}", matter_summary(conn, principal.account_id, matter))
@@ -849,21 +860,7 @@ def post_annotation(
@router.post("/api/v1/external-refs") @router.post("/api/v1/external-refs")
def post_external(body: ExternalIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): def post_external(body: ExternalIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
element = create_external( element = place_external(conn, principal, body)
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,
)
return _created(f"/api/v1/elements/{element['id']}", {"id": str(element["id"]), "title": element["title"]}) return _created(f"/api/v1/elements/{element['id']}", {"id": str(element["id"]), "title": element["title"]})
@@ -921,6 +918,7 @@ def download_file(
request: Request, request: Request,
context_kind: str | None = None, context_kind: str | None = None,
context_id: str | None = None, context_id: str | None = None,
save: bool = False,
principal: Principal = Depends(get_principal), principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
): ):
@@ -931,6 +929,8 @@ def download_file(
rights = element_rights(conn, principal.account_id, element, context) rights = element_rights(conn, principal.account_id, element, context)
if not rights.read: if not rights.read:
raise not_found() raise not_found()
if save and not rights.download:
raise forbidden(DOWNLOAD_REFUSED)
asset = conn.execute( asset = conn.execute(
""" """
SELECT id, original_filename, content_type, sha256, status, SELECT id, original_filename, content_type, sha256, status,
@@ -1168,37 +1168,61 @@ def post_fulfill(
return deadline_payload(conn, principal.account_id, deadline) 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") @router.get("/api/v1/views/open-tasks")
def open_tasks(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): 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 SELECT * FROM tasks
WHERE deleted_at IS NULL AND task_status = 'open' WHERE deleted_at IS NULL AND task_status = 'open'
ORDER BY due_on NULLS LAST, created_at, id 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): if _task_visible(conn, principal.account_id, task):
items.append(task_payload(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} return {"items": items, "next_cursor": None}
@router.get("/api/v1/views/open-deadlines") @router.get("/api/v1/views/open-deadlines")
def open_deadlines(principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): 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 SELECT * FROM deadlines
WHERE deleted_at IS NULL AND deadline_status = 'open' WHERE deleted_at IS NULL AND deadline_status = 'open'
ORDER BY due_on, created_at, id ORDER BY due_on, created_at, id
LIMIT 200 """,
""" ):
).fetchall()
items = []
for deadline in rows:
if _deadline_visible(conn, principal.account_id, deadline): if _deadline_visible(conn, principal.account_id, deadline):
items.append(deadline_payload(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} return {"items": items, "next_cursor": None}
@@ -1252,19 +1276,21 @@ def search(q: str, principal: Principal = Depends(get_principal), conn: Connecti
], ],
} }
) )
elements = conn.execute( elements = _scan(
conn,
""" """
SELECT e.* SELECT e.*
FROM elements e FROM elements e
LEFT JOIN note_bodies n ON n.element_id = e.id LEFT JOIN note_bodies n ON n.element_id = e.id
WHERE e.deleted_at IS NULL WHERE e.deleted_at IS NULL
AND (e.title ILIKE %s ESCAPE '\\' OR COALESCE(n.document_json::text, '') ILIKE %s ESCAPE '\\') AND (e.title ILIKE %s ESCAPE '\\' OR COALESCE(n.document_json::text, '') ILIKE %s ESCAPE '\\')
ORDER BY e.updated_at DESC ORDER BY e.updated_at DESC, e.id
LIMIT 100
""", """,
(pattern, pattern), (pattern, pattern),
).fetchall() )
for element in elements: for element in elements:
if len(items) >= SEARCH_LIMIT:
break
from app.access.policy import visible_bindings_for_element from app.access.policy import visible_bindings_for_element
bindings = visible_bindings_for_element(conn, principal.account_id, element) bindings = visible_bindings_for_element(conn, principal.account_id, element)
@@ -1292,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") @router.patch("/api/v1/cases/{case_id}/content-order")
+49
View File
@@ -39,6 +39,11 @@ class AccountPatchIn(APIModel):
display_name: str | None = Field(default=None, min_length=1, max_length=120) display_name: str | None = Field(default=None, min_length=1, max_length=120)
is_operator: bool | None = None is_operator: bool | None = None
status: Literal["active", "disabled"] | None = None status: Literal["active", "disabled"] | None = None
account_kind: Literal["main"] | None = None
class TeamPatchIn(APIModel):
status: Literal["active", "disabled"]
class PasswordChangeIn(APIModel): class PasswordChangeIn(APIModel):
@@ -72,6 +77,16 @@ class VisibilityIn(APIModel):
visibility: Literal["private", "room"] 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): class RoomShareIn(APIModel):
access: Literal["read", "edit"] = "edit" access: Literal["read", "edit"] = "edit"
@@ -117,6 +132,7 @@ class CaseIn(APIModel):
parent_case_id: UUID | None = None parent_case_id: UUID | None = None
rights_mode: Literal["inherit_parent", "explicit"] = "inherit_parent" rights_mode: Literal["inherit_parent", "explicit"] = "inherit_parent"
home_scope_id: UUID | None = None home_scope_id: UUID | None = None
share_with_room_id: UUID | None = None
class CasePatch(APIModel): class CasePatch(APIModel):
@@ -192,6 +208,7 @@ class MatterIn(APIModel):
parent_matter_id: UUID | None = None parent_matter_id: UUID | None = None
context: ContextIn | None = None context: ContextIn | None = None
home_scope_id: UUID | None = None home_scope_id: UUID | None = None
share_with_room_id: UUID | None = None
class MatterPatch(APIModel): class MatterPatch(APIModel):
@@ -335,6 +352,22 @@ class ExternalIn(APIModel):
chapter_id: UUID | None = None chapter_id: UUID | None = None
dates: DatesIn = DatesIn() dates: DatesIn = DatesIn()
detail: ExternalDetail | None = None 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): class ConnectorIn(APIModel):
@@ -502,3 +535,19 @@ class DispatchCorrectIn(APIModel):
clear_sent_on: bool = False clear_sent_on: bool = False
counterpart: str | None = Field(default=None, max_length=200) counterpart: str | None = Field(default=None, max_length=200)
clear_counterpart: bool = False 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
+86 -122
View File
@@ -4,18 +4,19 @@ from __future__ import annotations
from uuid import UUID from uuid import UUID
from fastapi import APIRouter, Depends from fastapi import APIRouter, Depends, Request
from fastapi.responses import JSONResponse, Response from fastapi.responses import JSONResponse, Response
from psycopg import Connection from psycopg import Connection
from app.access.policy import Ctx, element_rights, get_element, parse_query_context 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.deps import Principal, get_conn, get_principal
from app.api.routes import _created, _ctx_model from app.api.routes import _created
from app.api.schemas import ConnectorIn, ExternalIn, SourceAssignmentIn from app.api.schemas import ConnectorIn, ExternalIn, SourceAssignmentIn
from app.core.errors import not_found, unprocessable, unsupported from app.core.errors import DOWNLOAD_REFUSED, forbidden, not_found, unprocessable, unsupported
from app.mailpack import parse_mail from app.mailpack import _inline_images, parse_mail, sanitize_html
from app.remoteimages import RemoteImages
from app.media.storage import content_disposition 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.retrieval import RetrievalFailure
from app.sourcebind import assign_reference from app.sourcebind import assign_reference
from app.sourceport import capability_payload, with_capabilities from app.sourceport import capability_payload, with_capabilities
@@ -94,21 +95,23 @@ def view_external_content(
element_id: UUID, element_id: UUID,
context_kind: str | None = None, context_kind: str | None = None,
context_id: str | None = None, context_id: str | None = None,
save: bool = False,
principal: Principal = Depends(get_principal), principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
): ):
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id) element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
if save:
_require_download(conn, principal, element, context)
module = get_source(ref["source"]) if ref is not None else None module = get_source(ref["source"]) if ref is not None else None
if module is None or module.open_original is None: if module is None or module.open_original is None:
raise unprocessable("Für diese Quelle ist kein Dateiabruf vorgesehen.") raise unprocessable("Für diese Quelle ist kein Dateiabruf vorgesehen.")
data, media_type, filename = module.open_original(conn, principal.account_id, element, context, ref) data, media_type, filename = module.open_original(conn, principal.account_id, element, context, ref)
safe_name = (filename or "dokument.pdf").replace('"', "")
return Response( return Response(
content=data, content=data,
media_type=media_type, media_type=media_type,
headers={ headers={
**_PRIVATE, **_PRIVATE,
"Content-Disposition": f'inline; filename="{safe_name}"', "Content-Disposition": content_disposition(filename or "dokument.pdf").replace("attachment;", "inline;", 1),
}, },
) )
@@ -131,6 +134,7 @@ def view_mail(
"message_cc": parsed.copy, "message_cc": parsed.copy,
"text": parsed.text, "text": parsed.text,
"html": parsed.html, "html": parsed.html,
"remote_images": len(parsed.remote_images),
"text_truncated": parsed.text_truncated, "text_truncated": parsed.text_truncated,
"complete": not parsed.missing, "complete": not parsed.missing,
"notices": parsed.notices, "notices": parsed.notices,
@@ -150,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): def _opened_ref(conn, principal: Principal, element_id: UUID, context_kind: str | None, context_id: str | None):
element = get_element(conn, element_id) element = get_element(conn, element_id)
if element is None or element["kind"] != "external_ref": if element is None or element["kind"] != "external_ref":
@@ -183,6 +192,25 @@ def _complete_mail(conn, principal: Principal, element, context, ref):
return parsed, raw 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") @router.get("/api/v1/external-refs/{element_id}/mail/original")
def download_mail( def download_mail(
element_id: UUID, element_id: UUID,
@@ -192,8 +220,9 @@ def download_mail(
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
): ):
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id) element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
_parsed, raw = _complete_mail(conn, principal, element, context, ref) _require_download(conn, principal, element, context)
return _mail_bytes(raw, "message/rfc822", "nachricht.eml") 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}") @router.get("/api/v1/external-refs/{element_id}/mail/attachments/{index}")
@@ -202,21 +231,29 @@ def download_mail_attachment(
index: int, index: int,
context_kind: str | None = None, context_kind: str | None = None,
context_id: str | None = None, context_id: str | None = None,
save: bool = False,
principal: Principal = Depends(get_principal), principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
): ):
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id) 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) parsed, _raw = _complete_mail(conn, principal, element, context, ref)
if index < 0 or index >= len(parsed.attachments): if index < 0 or index >= len(parsed.attachments):
raise not_found() raise not_found()
item = parsed.attachments[index] 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: def _mail_bytes(data: bytes, media_type: str, filename: str, inline: bool = False) -> Response:
disposition = content_disposition(filename) disposition = content_disposition(filename, inline=inline)
if inline:
disposition = disposition.replace("attachment;", "inline;", 1)
return Response( return Response(
content=data, content=data,
media_type=media_type, media_type=media_type,
@@ -227,40 +264,23 @@ 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") @router.get("/api/v1/sources/paperless/documents")
def search_paperless( def search_paperless(
request: Request,
q: str = "", q: str = "",
connector_id: UUID | None = None, connector_id: UUID | None = None,
title: str = "",
correspondent: str = "",
document_type: str = "",
tag: str = "",
document_from: str = "",
document_to: str = "",
sort: str = "",
cursor: str = "",
principal: Principal = Depends(get_principal), principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
): ):
return _run_search( return _run_search("paperless", conn, principal.account_id, q.strip(), connector_id, "", None, _filters(request))
"paperless",
conn,
principal.account_id,
q.strip(),
connector_id,
"",
None,
{
"title": title,
"correspondent": correspondent,
"document_type": document_type,
"tag": tag,
"document_from": document_from,
"document_to": document_to,
"sort": sort,
"cursor": cursor,
},
)
@router.get("/api/v1/sources/{kind}/facets") @router.get("/api/v1/sources/{kind}/facets")
@@ -291,6 +311,21 @@ def preview_paperless_document(
) )
@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") @router.get("/api/v1/sources/imap/mailboxes")
def list_mailboxes( def list_mailboxes(
connector_id: UUID, connector_id: UUID,
@@ -302,18 +337,11 @@ def list_mailboxes(
@router.get("/api/v1/sources/imap/messages") @router.get("/api/v1/sources/imap/messages")
def search_mail( def search_mail(
request: Request,
connector_id: UUID, connector_id: UUID,
q: str = "", q: str = "",
mailbox: str = "", mailbox: str = "",
before: int | None = None, before: int | None = None,
title: str = "",
correspondent: str = "",
document_type: str = "",
tag: str = "",
document_from: str = "",
document_to: str = "",
sort: str = "",
cursor: str = "",
uidvalidity: int | None = None, uidvalidity: int | None = None,
principal: Principal = Depends(get_principal), principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
@@ -321,24 +349,7 @@ def search_mail(
if before is not None and before < 1: if before is not None and before < 1:
raise unprocessable("Die Seitenangabe ist ungültig.") raise unprocessable("Die Seitenangabe ist ungültig.")
return _run_search( return _run_search(
"imap", "imap", conn, principal.account_id, q.strip(), connector_id, mailbox.strip(), before, _filters(request), uidvalidity
conn,
principal.account_id,
q.strip(),
connector_id,
mailbox.strip(),
before,
{
"title": title,
"correspondent": correspondent,
"document_type": document_type,
"tag": tag,
"document_from": document_from,
"document_to": document_to,
"sort": sort,
"cursor": cursor,
},
uidvalidity,
) )
@@ -359,21 +370,7 @@ def read_mail(
def link_source(body: ExternalIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)): def link_source(body: ExternalIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
if get_source(body.source) is None: if get_source(body.source) is None:
raise unprocessable("Verknüpft werden registrierte Quellen.") raise unprocessable("Verknüpft werden registrierte Quellen.")
element = create_external( element = place_external(conn, principal, body)
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,
)
return _created(f"/api/v1/elements/{element['id']}", {"id": str(element["id"]), "title": element["title"]}) return _created(f"/api/v1/elements/{element['id']}", {"id": str(element["id"]), "title": element["title"]})
@@ -394,22 +391,14 @@ def _connector_parts(body: ConnectorIn, current: dict | None) -> tuple[str, dict
return parse_connector(body.kind, body.name, flat, body.config, current) return parse_connector(body.kind, body.name, flat, body.config, current)
_SEARCH_FLAGS = {
"title": "title",
"correspondent": "correspondent",
"document_type": "document_type",
"tag": "tags",
"document_from": "document_range",
"document_to": "document_range",
"sort": "sort",
"cursor": "continuation",
}
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: 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) module = require_source(kind)
search = module.capabilities["search"] search = module.capabilities["search"]
refused = [name for name, value in filters.items() if str(value or "").strip() and not search.get(_SEARCH_FLAGS.get(name, name))] 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"): if before is not None and not search.get("continuation"):
refused.append("before") refused.append("before")
if refused: if refused:
@@ -432,43 +421,18 @@ def _run_navigate(kind: str, conn, owner, connector_id: UUID) -> dict:
@router.get("/api/v1/sources/{kind}/search") @router.get("/api/v1/sources/{kind}/search")
def search_source( def search_source(
request: Request,
kind: str, kind: str,
q: str = "", q: str = "",
connector_id: UUID | None = None, connector_id: UUID | None = None,
mailbox: str = "", mailbox: str = "",
before: int | None = None, before: int | None = None,
title: str = "",
correspondent: str = "",
document_type: str = "",
tag: str = "",
document_from: str = "",
document_to: str = "",
sort: str = "",
cursor: str = "",
principal: Principal = Depends(get_principal), principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn), conn: Connection = Depends(get_conn),
): ):
if before is not None and before < 1: if before is not None and before < 1:
raise unprocessable("Die Seitenangabe ist ungültig.") raise unprocessable("Die Seitenangabe ist ungültig.")
return _run_search( return _run_search(kind, conn, principal.account_id, q.strip(), connector_id, mailbox.strip(), before, _filters(request))
kind,
conn,
principal.account_id,
q.strip(),
connector_id,
mailbox.strip(),
before,
{
"title": title,
"correspondent": correspondent,
"document_type": document_type,
"tag": tag,
"document_from": document_from,
"document_to": document_to,
"sort": sort,
"cursor": cursor,
},
)
@router.get("/api/v1/sources/{kind}/navigate") @router.get("/api/v1/sources/{kind}/navigate")
+245
View File
@@ -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)
+42 -6
View File
@@ -46,11 +46,15 @@ def create_account(
is_superadmin: bool = False, is_superadmin: bool = False,
origin: str = "operator", origin: str = "operator",
must_change_password: bool = False, must_change_password: bool = False,
account_kind: str = "main",
sponsor_id: UUID | None = None,
) -> dict: ) -> dict:
email = normalize_email(email) email = normalize_email(email)
display_name = display_name.strip() display_name = display_name.strip()
if origin not in {"operator", "fixture"}: if origin not in {"operator", "fixture"}:
raise unprocessable("Die Kontenherkunft ist ungültig.") 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) check_password_policy(password)
if conn.execute("SELECT 1 FROM auth_accounts WHERE email = %s", (email,)).fetchone(): 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.") raise unprocessable("Für diese E-Mail gibt es bereits ein Konto.")
@@ -60,11 +64,14 @@ def create_account(
""" """
INSERT INTO auth_accounts ( INSERT INTO auth_accounts (
id, email, display_name, password_hash, is_superadmin, origin, id, email, display_name, password_hash, is_superadmin, origin,
must_change_password, password_changed_at must_change_password, password_changed_at, account_kind, sponsor_id
) )
VALUES (%s, %s, %s, %s, %s, %s, %s, now()) VALUES (%s, %s, %s, %s, %s, %s, %s, now(), %s, %s)
""", """,
(account_id, email, display_name, password_hash, is_superadmin, origin, must_change_password), (
account_id, email, display_name, password_hash, is_superadmin, origin,
must_change_password, account_kind, sponsor_id,
),
) )
conn.execute( conn.execute(
""" """
@@ -75,25 +82,54 @@ def create_account(
) )
return conn.execute( return conn.execute(
""" """
SELECT id, email, display_name, is_superadmin, status, must_change_password SELECT id, email, display_name, is_superadmin, status, must_change_password, account_kind
FROM auth_accounts WHERE id = %s FROM auth_accounts WHERE id = %s
""", """,
(account_id,), (account_id,),
).fetchone() ).fetchone()
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]: def start_session(conn, settings: Settings, account_id: UUID, label: str | None = None) -> tuple[str, str]:
token = new_secret() token = new_secret()
csrf = new_secret() csrf = new_secret()
scope_kind, scope_id = initial_scope(conn, account_id)
session = conn.execute( session = conn.execute(
""" """
INSERT INTO auth_sessions ( INSERT INTO auth_sessions (
account_id, secret_hash, csrf_token, scope_kind, scope_id, expires_at, label, last_seen_at account_id, secret_hash, csrf_token, scope_kind, scope_id, expires_at, label, last_seen_at
) )
VALUES (%s, %s, %s, 'personal', %s, %s, %s, now()) VALUES (%s, %s, %s, %s, %s, %s, %s, now())
RETURNING id RETURNING id
""", """,
(account_id, hash_secret(token), csrf, account_id, session_expiry(settings), (label or None) and label[:80]), (account_id, hash_secret(token), csrf, scope_kind, scope_id, session_expiry(settings), (label or None) and label[:80]),
).fetchone() ).fetchone()
conn.execute("UPDATE auth_accounts SET last_login_at = now() WHERE id = %s", (account_id,)) 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"]) audit(conn, account_id, None, "session_started", "session", session["id"])
+3
View File
@@ -33,6 +33,9 @@ def forbidden(detail: str = "Diese Aktion ist im gewählten Kontext nicht erlaub
return Problem(403, "Keine Berechtigung", detail, "forbidden") 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: def not_found() -> Problem:
return Problem(404, "Nicht gefunden", "Der Eintrag ist nicht vorhanden.", "not_found") return Problem(404, "Nicht gefunden", "Der Eintrag ist nicht vorhanden.", "not_found")
+166
View File
@@ -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",
)
+170
View File
@@ -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}
+110 -12
View File
@@ -6,6 +6,7 @@ The same tree feeds preview, reading, attachment download and export.
from __future__ import annotations from __future__ import annotations
import base64
import hashlib import hashlib
import html import html
import re import re
@@ -23,8 +24,21 @@ _ALLOWED_TAGS = {
"a", "p", "br", "div", "span", "strong", "em", "b", "i", "u", "a", "p", "br", "div", "span", "strong", "em", "b", "i", "u",
"ul", "ol", "li", "table", "thead", "tbody", "tr", "th", "td", "ul", "ol", "li", "table", "thead", "tbody", "tr", "th", "td",
"blockquote", "pre", "code", "h1", "h2", "h3", "h4", "h5", "h6", "img", "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"} _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) _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) _DATA_IMAGE = re.compile(r"^data:image/(?:png|jpeg|gif|webp);base64,[a-z0-9+/=\s]+$", re.IGNORECASE)
@@ -57,6 +71,8 @@ class ParsedMail:
attachments: list[AttachmentBytes] = field(default_factory=list) attachments: list[AttachmentBytes] = field(default_factory=list)
missing: list[str] = field(default_factory=list) missing: list[str] = field(default_factory=list)
html: str = "" html: str = ""
html_source: str = ""
remote_images: list[str] = field(default_factory=list)
notices: list[str] = field(default_factory=list) notices: list[str] = field(default_factory=list)
text_truncated: bool = False text_truncated: bool = False
document_on: str | None = None document_on: str | None = None
@@ -149,13 +165,19 @@ def parse_mail(raw: bytes) -> ParsedMail:
missing.append(label or f"Anlage {index}") missing.append(label or f"Anlage {index}")
notices.append(f"Die Anlage {label or index} ließ sich nicht vollständig lesen.") notices.append(f"Die Anlage {label or index} ließ sich nicht vollständig lesen.")
continue 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) name = _unique_filename(label or f"anlage-{index}.bin", used)
inline = disposition == "inline" or bool(content_id) inline = disposition == "inline" or bool(content_id)
attachments.append(_attachment(part, name, label or name, data, inline=inline)) attachments.append(_attachment(part, name, label or name, data, inline=inline, media=media))
simplified = "\n".join(chunk for chunk in plain if chunk).strip() simplified = "\n".join(chunk for chunk in plain if chunk).strip()
rendered = "" rendered = ""
if html_parts: if html_parts:
rendered = sanitize_html("\n".join(html_parts), _inline_images(attachments)) source = "\n".join(html_parts)
remote_found: list[str] = []
rendered = sanitize_html(source, _inline_images(attachments), found=remote_found)
if not simplified: if not simplified:
simplified = simplified_text("\n".join(html_parts)) simplified = simplified_text("\n".join(html_parts))
if missing: if missing:
@@ -170,6 +192,8 @@ def parse_mail(raw: bytes) -> ParsedMail:
attachments=attachments, attachments=attachments,
missing=missing, missing=missing,
html=rendered, html=rendered,
html_source=source if html_parts else "",
remote_images=remote_found if html_parts else [],
notices=notices, notices=notices,
document_on=_message_date(message.get("Date")), document_on=_message_date(message.get("Date")),
) )
@@ -222,8 +246,11 @@ def simplified_text(value: str) -> str:
return text.strip() return text.strip()
def sanitize_html(value: str, images: dict[str, str] | None = None) -> str: def sanitize_html(value: str, images: dict[str, str] | None = None, *, remote=None, found: list[str] | None = None) -> str:
"""Keep a formatted reading. Scripts, active content and remote loads stay out.""" """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 {} images = images or {}
class Cleaner(HTMLParser): class Cleaner(HTMLParser):
@@ -239,7 +266,7 @@ def sanitize_html(value: str, images: dict[str, str] | None = None) -> str:
return return
if self.skip or name not in _ALLOWED_TAGS: if self.skip or name not in _ALLOWED_TAGS:
return return
rendered = _clean_attrs(name, attrs, images) rendered = _clean_attrs(name, attrs, images, remote, found)
if rendered is None: if rendered is None:
return return
self.parts.append(f"<{name}{rendered}>") self.parts.append(f"<{name}{rendered}>")
@@ -275,22 +302,54 @@ def sanitize_html(value: str, images: dict[str, str] | None = None) -> str:
return "".join(cleaner.parts).strip() return "".join(cleaner.parts).strip()
def _clean_attrs(tag: str, attrs, images: dict[str, str]) -> str | None: 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] = [] kept: list[str] = []
for key, value in attrs: for key, value in attrs:
name = (key or "").lower() name = (key or "").lower()
if name.startswith("on") or name in {"style", "srcset"}: 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 continue
if tag == "a" and name == "href": if tag == "a" and name == "href":
target = (value or "").strip() target = (value or "").strip()
if not _SAFE_LINK.match(target): if not _SAFE_LINK.match(target):
continue continue
kept.append(f' href="{html.escape(target, quote=True)}"') kept.append(f' href="{html.escape(target, quote=True)}" title="{html.escape(target, quote=True)}"')
elif tag == "img" and name == "src": elif tag == "img" and name == "src":
source = (value or "").strip() source = (value or "").strip()
if source.lower().startswith("cid:"): if source.lower().startswith("cid:"):
token = source[4:].strip().strip("<>") token = source[4:].strip().strip("<>")
source = images.get(token.casefold(), "") 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): if not _DATA_IMAGE.match(source):
continue continue
kept.append(f' src="{source}"') kept.append(f' src="{source}"')
@@ -301,7 +360,7 @@ def _clean_attrs(tag: str, attrs, images: dict[str, str]) -> str | None:
if tag == "img" and not any(item.startswith(" src=") for item in kept): if tag == "img" and not any(item.startswith(" src=") for item in kept):
return None return None
if tag == "a": if tag == "a":
kept.append(' rel="noreferrer"') kept.append(' rel="noreferrer noopener" target="_blank"')
return "".join(kept) return "".join(kept)
@@ -356,10 +415,49 @@ def _content_id(part: EmailMessage) -> str:
return token return token
def _attachment(part: EmailMessage, filename: str, label: str, data: bytes, inline: bool) -> AttachmentBytes: 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( return AttachmentBytes(
filename=filename, filename=filename,
media_type=(part.get_content_type() or "application/octet-stream")[:120], media_type=(resolved or "application/octet-stream")[:120],
data=data, data=data,
sha256=hashlib.sha256(data).hexdigest(), sha256=hashlib.sha256(data).hexdigest(),
display_name=label or filename, display_name=label or filename,
+10
View File
@@ -11,9 +11,14 @@ from fastapi.responses import JSONResponse
from app.api.accounts import router as accounts_router from app.api.accounts import router as accounts_router
from app.api.correspondence import router as correspondence_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.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.rooms import router as rooms_router
from app.api.roomshare import router as roomshare_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.routes import router
from app.api.sources import router as sources_router from app.api.sources import router as sources_router
from app.core.errors import Problem, problem_response from app.core.errors import Problem, problem_response
@@ -120,10 +125,15 @@ def create_app() -> FastAPI:
app.include_router(router) app.include_router(router)
app.include_router(accounts_router) app.include_router(accounts_router)
app.include_router(library_router)
app.include_router(rooms_router) app.include_router(rooms_router)
app.include_router(roomshare_router) app.include_router(roomshare_router)
app.include_router(team_router)
app.include_router(sources_router) app.include_router(sources_router)
app.include_router(export_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) app.include_router(correspondence_router)
return app return app
+15 -3
View File
@@ -4,6 +4,7 @@ from __future__ import annotations
import hashlib import hashlib
from pathlib import Path from pathlib import Path
from urllib.parse import quote
from uuid import UUID from uuid import UUID
from app.core.errors import storage_unavailable, unprocessable from app.core.errors import storage_unavailable, unprocessable
@@ -66,6 +67,17 @@ def display_filename(name: str) -> str:
return text[:240] return text[:240]
def content_disposition(filename: str) -> str: def content_disposition(filename: str, *, inline: bool = False) -> str:
safe = display_filename(filename).replace('"', "") """The real name goes along in UTF-8 (RFC 5987), with a plain ASCII fallback for old clients."""
return f'attachment; filename="{safe}"' 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='')}"
+55 -1
View File
@@ -36,6 +36,8 @@ from app.access.policy import (
from app.content.documents import clean_document from app.content.documents import clean_document
from app.core.errors import forbidden, not_found, unprocessable, unsupported from app.core.errors import forbidden, not_found, unprocessable, unsupported
from app.core.timeutil import utcnow from app.core.timeutil import utcnow
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.port import LEGACY_PROFILE, StoredHandle, adapter_for, instance_for_write, publish, removal_for
from app.media.storage import display_filename, sha256, sniff from app.media.storage import display_filename, sha256, sniff
@@ -1142,7 +1144,7 @@ def add_annotation(conn, actor: UUID, binding_id: UUID, body: str, context: Ctx
return row 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) ensure_can_create(conn, actor, scope_id)
from app.sourceregistry import accepts_reference from app.sourceregistry import accepts_reference
@@ -1150,6 +1152,13 @@ def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str,
raise unprocessable("Diese Quelle ist nicht registriert.") raise unprocessable("Diese Quelle ist nicht registriert.")
target, rights_context = _placement(context, placement) target, rights_context = _placement(context, placement)
require_container_edit(conn, actor, target, rights_context) 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") element = _new_element(conn, actor, scope_id, title, "external_ref")
conn.execute( conn.execute(
"INSERT INTO external_references (element_id, source, external_id, detail) VALUES (%s, %s, %s, %s)", "INSERT INTO external_references (element_id, source, external_id, detail) VALUES (%s, %s, %s, %s)",
@@ -1167,6 +1176,51 @@ def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str,
return element | {"binding_id": binding["id"]} 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: 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) ensure_can_create(conn, actor, scope_id)
if not data or len(data) > max_bytes: if not data or len(data) > max_bytes:
+112
View File
@@ -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)
+24
View File
@@ -747,8 +747,23 @@ def matter_contexts(conn, actor: UUID, matter: dict) -> list[dict]:
return contexts 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: def matter_summary(conn, actor: UUID, matter: dict) -> dict:
owner = matter["owner_subject_id"] == actor
return { return {
"is_owner": owner,
"shared_with": _shared_rooms(conn, "matter", matter["id"]) if owner else [],
"id": str(matter["id"]), "id": str(matter["id"]),
"title": matter["title"], "title": matter["title"],
"status": matter["record_status"], "status": matter["record_status"],
@@ -1053,6 +1068,11 @@ LABELS = {
"invitation_revoked": "Einladung widerrufen", "invitation_revoked": "Einladung widerrufen",
"invitation_accepted": "Einladung angenommen", "invitation_accepted": "Einladung angenommen",
"visibility_changed": "Raumfreigabe geändert", "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_shared": "Mit Datenraum geteilt",
"room_share_changed": "Freigabe an Datenraum geändert", "room_share_changed": "Freigabe an Datenraum geändert",
"room_unshared": "Freigabe an Datenraum beendet", "room_unshared": "Freigabe an Datenraum beendet",
@@ -1060,4 +1080,8 @@ LABELS = {
"person_included": "Person wieder in die Raumfreigabe aufgenommen", "person_included": "Person wieder in die Raumfreigabe aufgenommen",
"room_owner_changed": "Eigentümer des Datenraums gewechselt", "room_owner_changed": "Eigentümer des Datenraums gewechselt",
"room_default_changed": "Voreinstellung des Datenraums geändert", "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",
} }
+133
View File
@@ -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
+1 -1
View File
@@ -44,7 +44,7 @@ def load_external(conn, actor_id: UUID, element_id: UUID, assigned: UUID | None)
ref = conn.execute( ref = conn.execute(
""" """
SELECT source, external_id, detail, connector_id, resolution SELECT element_id, source, external_id, detail, connector_id, resolution
FROM external_references WHERE element_id = %s FROM external_references WHERE element_id = %s
""", """,
(element_id,), (element_id,),
+39
View File
@@ -217,3 +217,42 @@ def assign_reference(conn, actor_id: UUID, element_id: UUID, connector_id: UUID)
detail = dict(ref["detail"] or {}) detail = dict(ref["detail"] or {})
detail["connector_id"] = str(connector_id) detail["connector_id"] = str(connector_id)
_set_binding(conn, element_id, connector_id, "bound", detail) _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)),
)
+2 -63
View File
@@ -1,72 +1,15 @@
"""Declared source and editor capabilities. """Declared editor capabilities and the payloads that carry them.
A common contract does not invent abilities the adapter does not have. The capabilities of a source belong to its module. A filter is offered only when that module implements it.
A filter is offered only when that module implements it.
""" """
from __future__ import annotations from __future__ import annotations
PAPERLESS_CAPABILITIES = {
"kind": "paperless",
"navigate": False,
"read_original": True,
"read_preview": True,
"read_attachment": False,
"edit_content": False,
"edit_metadata": False,
"search": {
"query": True,
"title": True,
"correspondent": True,
"document_type": True,
"tags": True,
"document_range": True,
"sort": True,
"continuation": True,
},
}
IMAP_CAPABILITIES = {
"kind": "imap",
"navigate": True,
"read_original": True,
"read_preview": True,
"read_attachment": True,
"edit_content": False,
"edit_metadata": False,
"search": {
"query": True,
"title": False,
"correspondent": False,
"document_type": False,
"tags": False,
"document_range": False,
"sort": False,
"continuation": True,
},
}
CAPABILITIES = {
"paperless": PAPERLESS_CAPABILITIES,
"imap": IMAP_CAPABILITIES,
}
EDITORS = { EDITORS = {
"note": True, "note": True,
"markdown_file": False, "markdown_file": False,
} }
UNSUPPORTED_SEARCH = (
"title",
"correspondent",
"document_type",
"tag",
"document_from",
"document_to",
"sort",
"cursor",
)
def capability_payload() -> dict: def capability_payload() -> dict:
from app.sourceregistry import registered_sources from app.sourceregistry import registered_sources
@@ -91,10 +34,6 @@ def capability_payload() -> dict:
} }
def unsupported_filters(values: dict[str, str]) -> list[str]:
return [name for name in UNSUPPORTED_SEARCH if str(values.get(name) or "").strip()]
def with_capabilities(kind: str, connector_id: str, payload: dict) -> dict: def with_capabilities(kind: str, connector_id: str, payload: dict) -> dict:
from app.sourceregistry import require_source from app.sourceregistry import require_source
+6 -1
View File
@@ -2,7 +2,7 @@
from __future__ import annotations from __future__ import annotations
from dataclasses import dataclass from dataclasses import dataclass, field
from typing import Callable from typing import Callable
from app.core.errors import unprocessable from app.core.errors import unprocessable
@@ -65,6 +65,11 @@ class SourceModule:
navigate: Callable | None = None navigate: Callable | None = None
preview: Callable | None = None preview: Callable | None = None
facets: 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] = {} _MODULES: dict[str, SourceModule] = {}
+524 -58
View File
@@ -3,13 +3,18 @@
from __future__ import annotations from __future__ import annotations
import base64 import base64
import hashlib
import imaplib import imaplib
import json import json
import re import re
import ssl import ssl
import threading
import time
from dataclasses import dataclass
from email.header import decode_header from email.header import decode_header
from email.parser import BytesParser from email.parser import BytesParser
from email.utils import parsedate_to_datetime from email.utils import parsedate_to_datetime
from html import unescape
from pathlib import Path from pathlib import Path
from urllib.error import HTTPError, URLError from urllib.error import HTTPError, URLError
from urllib.parse import urlencode, urlparse from urllib.parse import urlencode, urlparse
@@ -33,7 +38,7 @@ from app.mailpack import (
simplified_text, simplified_text,
) )
from app.media.storage import sniff from app.media.storage import sniff
from app.sourcebind import resolve_for_read from app.sourcebind import remember_imap_location, resolve_for_read
from app.sourceaccess import ( from app.sourceaccess import (
ORIGINAL_UNAVAILABLE, ORIGINAL_UNAVAILABLE,
assert_still_owned, assert_still_owned,
@@ -43,7 +48,6 @@ from app.sourceaccess import (
connector_owner as _connector_owner, connector_owner as _connector_owner,
release_for_external, release_for_external,
) )
from app.sourceport import CAPABILITIES
from app.sourceregistry import ConfigField, SourceModule, get_source, parse_fields, register_source, require_source from app.sourceregistry import ConfigField, SourceModule, get_source, parse_fields, register_source, require_source
@@ -182,10 +186,24 @@ def _record_probe(conn, connector_id: UUID, ok: bool, detail: str) -> None:
) )
def _paperless_choice(value, label: str) -> str | None: PAPERLESS_PAGE_SIZE = 20
_PAPERLESS_MODES = {
# Paperless-ngx offers these searches in its own filter bar. The first needs no search index.
"title_content": "title_content",
"title": "title__icontains",
"content": "content__icontains",
"index": "query",
}
_PAPERLESS_TAG_MODES = {"all": "tags__id__all", "any": "tags__id__in", "none": "tags__id__none"}
_PAPERLESS_SORTS = {"created", "-created", "added", "-added", "title", "-title", "score", "-score"}
def _paperless_choice(value, label: str, allow_none: bool = False) -> str | None:
text = str(value or "").strip() text = str(value or "").strip()
if not text: if not text:
return None return None
if allow_none and text == "none":
return text
if not text.isdigit() or len(text) > 12: if not text.isdigit() or len(text) > 12:
raise unprocessable(f"{label} ist keine Auswahl dieser Instanz.") raise unprocessable(f"{label} ist keine Auswahl dieser Instanz.")
return text return text
@@ -200,45 +218,166 @@ def _paperless_day(value, label: str) -> str | None:
return text return text
def _paperless_params(query: str, options: dict | None) -> dict: def _paperless_range(options: dict, prefix: str, field: str, label: str, params: dict) -> None:
start = _paperless_day(options.get(f"{prefix}_from"), f"{label}, von")
end = _paperless_day(options.get(f"{prefix}_to"), f"{label}, bis")
if start and end and start > end:
raise unprocessable(f"{label}: Der Beginn liegt nach dem Ende.")
if start:
params[f"{field}__date__gte"] = start
if end:
params[f"{field}__date__lte"] = end
_CUSTOM_KINDS = {
"string": "text",
"url": "text",
"longtext": "text",
"integer": "number",
"float": "number",
"monetary": "number",
"date": "date",
"boolean": "boolean",
"select": "select",
}
_CUSTOM_OPERATORS = {
"text": {"exact", "icontains", "istartswith", "iendswith"},
"number": {"exact", "gt", "gte", "lt", "lte", "range"},
"date": {"exact", "gt", "gte", "lt", "lte", "range"},
"boolean": {"exact"},
"select": {"exact"},
}
_CUSTOM_LIMIT = 5
def _custom_number(value, label: str):
text = str(value).strip().replace(",", ".")
try:
number = float(text)
except ValueError as exc:
raise unprocessable(f"{label}: Der Wert ist keine Zahl.") from exc
if number != number or number in (float("inf"), float("-inf")):
raise unprocessable(f"{label}: Der Wert ist keine Zahl.")
return int(number) if "." not in text else number
def _custom_value(kind: str, op: str, value, field: dict):
label = field["name"]
if op == "exists":
if not isinstance(value, bool):
raise unprocessable(f"{label}: Gesetzt oder leer ist ungültig.")
return value
if op == "range":
if not isinstance(value, (list, tuple)) or len(value) != 2:
raise unprocessable(f"{label}: Der Bereich braucht Anfang und Ende.")
low, high = (_custom_value(kind, "exact", item, field) for item in value)
if low > high:
raise unprocessable(f"{label}: Der Beginn liegt nach dem Ende.")
return [low, high]
if kind == "text":
text = " ".join(str(value or "").split())
if not text or len(text) > 200:
raise unprocessable(f"{label}: Der Text fehlt oder ist zu lang.")
return text
if kind == "number":
return _custom_number(value, label)
if kind == "date":
day = _paperless_day(value, label)
if not day:
raise unprocessable(f"{label}: Das Datum fehlt.")
return day
if kind == "boolean":
if not isinstance(value, bool):
raise unprocessable(f"{label}: Ja oder Nein ist ungültig.")
return value
allowed = {option["id"] for option in field.get("options") or []}
if str(value) not in allowed:
raise unprocessable(f"{label}: Das ist keine Auswahl dieses Feldes.")
return str(value)
def _paperless_custom_query(raw, fields: list[dict]) -> str | None:
"""Paperless-ngx custom_field_query, built only from fields and operators this instance offers."""
if raw in (None, "", []):
return None
if isinstance(raw, str):
try:
raw = json.loads(raw)
except json.JSONDecodeError as exc:
raise unprocessable("Die Filter der Zusatzfelder sind ungültig.") from exc
if not isinstance(raw, list) or len(raw) > _CUSTOM_LIMIT:
raise unprocessable(f"Es sind höchstens {_CUSTOM_LIMIT} Zusatzfeld-Filter möglich.")
known = {field["id"]: field for field in fields}
atoms = []
for row in raw:
if not isinstance(row, dict):
raise unprocessable("Die Filter der Zusatzfelder sind ungültig.")
field = known.get(str(row.get("field") or ""))
if field is None:
raise unprocessable("Das Zusatzfeld gibt es an diesem Zugang nicht.")
kind = _CUSTOM_KINDS[field["type"]]
op = str(row.get("op") or "")
if op != "exists" and op not in _CUSTOM_OPERATORS[kind]:
raise unprocessable(f"{field['name']}: Diese Bedingung gibt es für den Feldtyp nicht.")
atoms.append([field["name"], op, _custom_value(kind, op, row.get("value"), field)])
if not atoms:
return None
return json.dumps(atoms[0] if len(atoms) == 1 else ["AND", atoms], ensure_ascii=False)
def _paperless_params(query: str, options: dict | None, custom_fields: list[dict] | None = None) -> dict:
"""Paperless-ngx document date is the created field, not the upload or modified time.""" """Paperless-ngx document date is the created field, not the upload or modified time."""
options = options or {} options = options or {}
params = {"page_size": "20"} params = {"page_size": str(PAPERLESS_PAGE_SIZE)}
text = " ".join(str(query or "").split()) text = " ".join(str(query or "").split())
mode = str(options.get("mode") or "").strip() or "title_content"
if mode not in _PAPERLESS_MODES:
raise unprocessable("Diese Suchart gibt es nicht.")
if text: if text:
params["query"] = text params[_PAPERLESS_MODES[mode]] = text
title = " ".join(str(options.get("title") or "").split()) title = " ".join(str(options.get("title") or "").split())
if title: if title:
if "title__icontains" in params and params["title__icontains"] != title:
raise unprocessable("Die Suche nur im Titel und der Titelfilter sind beide gesetzt. Nutze eines davon.")
params["title__icontains"] = title params["title__icontains"] = title
correspondent = _paperless_choice(options.get("correspondent"), "Der Korrespondent") for name, field, label in (
if correspondent: ("correspondent", "correspondent", "Der Korrespondent"),
params["correspondent__id"] = correspondent ("document_type", "document_type", "Der Dokumenttyp"),
document_type = _paperless_choice(options.get("document_type"), "Der Dokumenttyp") ("storage_path", "storage_path", "Der Speicherpfad"),
if document_type: ):
params["document_type__id"] = document_type chosen = _paperless_choice(options.get(name), label, allow_none=True)
if chosen == "none":
params[f"{field}__isnull"] = "true"
elif chosen:
params[f"{field}__id"] = chosen
raw_tags = options.get("tag") or options.get("tags") or "" raw_tags = options.get("tag") or options.get("tags") or ""
if isinstance(raw_tags, (list, tuple)): if isinstance(raw_tags, (list, tuple)):
parts = [str(item) for item in raw_tags] parts = [str(item) for item in raw_tags]
else: else:
parts = str(raw_tags).split(",") parts = str(raw_tags).split(",")
tag_ids = [chosen for chosen in (_paperless_choice(part, "Ein Tag") for part in parts) if chosen] tag_ids = [chosen for chosen in (_paperless_choice(part, "Ein Tag") for part in parts) if chosen]
tag_mode = str(options.get("tag_mode") or "").strip() or "all"
if tag_mode not in _PAPERLESS_TAG_MODES:
raise unprocessable("Diese Tag-Verknüpfung gibt es nicht.")
if tag_ids: if tag_ids:
params["tags__id__all"] = ",".join(tag_ids) params[_PAPERLESS_TAG_MODES[tag_mode]] = ",".join(tag_ids)
start = _paperless_day(options.get("document_from"), "Das Dokumentdatum von") _paperless_range(options, "document", "created", "Dokumentdatum", params)
end = _paperless_day(options.get("document_to"), "Das Dokumentdatum bis") _paperless_range(options, "added", "added", "Hinzugefügt am", params)
if start and end and start > end: custom = _paperless_custom_query(options.get("custom"), custom_fields or [])
raise unprocessable("Das Dokumentdatum von liegt nach dem Dokumentdatum bis.") if custom:
if start: params["custom_field_query"] = custom
params["created__date__gte"] = start asn = str(options.get("asn") or "").strip()
if end: if asn:
params["created__date__lte"] = end if not asn.isdigit() or len(asn) > 10:
raise unprocessable("Die Archivnummer ist keine Zahl.")
params["archive_serial_number"] = asn
sort = str(options.get("sort") or "").strip() sort = str(options.get("sort") or "").strip()
if sort: if sort:
if sort not in {"created", "-created", "title", "-title", "score", "-score"}: if sort not in _PAPERLESS_SORTS:
raise unprocessable("Diese Sortierung gibt es nicht.") raise unprocessable("Diese Sortierung gibt es nicht.")
if sort in {"score", "-score"}: if sort in {"score", "-score"}:
if not text: if not text or mode != "index":
raise unprocessable("Die Relevanz gilt zusammen mit einem Suchtext.") raise unprocessable("Die Relevanz gilt nur für die Suche im Volltextindex.")
# Paperless-ngx 2.20.6 has no ordering field named score. A query without # Paperless-ngx 2.20.6 has no ordering field named score. A query without
# ordering is the relevance order of the full-text index. # ordering is the relevance order of the full-text index.
else: else:
@@ -275,45 +414,254 @@ def _paperless_row(conn, owner_id: UUID, connector_id: UUID | None):
def paperless_documents(conn, owner_id: UUID, query: str, connector_id: UUID | None = None, options: dict | None = None) -> dict: def paperless_documents(conn, owner_id: UUID, query: str, connector_id: UUID | None = None, options: dict | None = None) -> dict:
row = _paperless_row(conn, owner_id, connector_id) row = _paperless_row(conn, owner_id, connector_id)
base = row["settings"]["base_url"].rstrip("/") base = row["settings"]["base_url"].rstrip("/")
params = _paperless_params(query, options)
release_for_external(conn) release_for_external(conn)
payload = _paperless_get(base, row["secret"], "/api/documents/", params) names = _paperless_lookup(row["id"], base, row["secret"])
params = _paperless_params(query, options, names["custom_fields"])
# Observed on a real instance: all-tags together with a custom field makes Paperless answer 500.
try:
payload = _paperless_get(base, row["secret"], "/api/documents/", params)
except Problem as problem:
clash = "," in params.get("tags__id__all", "") and "custom_field_query" in params
if clash and "HTTP 5" in problem.detail:
raise unprocessable(f"{problem.detail} Das tritt auf, wenn „Alle gewählten Tags“ mit einem Zusatzfeld zusammentrifft. Wähle „Mindestens eines“ oder lass das Zusatzfeld weg.") from problem
raise
assert_still_owned(conn, row["id"], owner_id) assert_still_owned(conn, row["id"], owner_id)
terms = _search_terms(query, (options or {}).get("title"))
items = [] items = []
for doc in payload.get("results") or []: for doc in payload.get("results") or []:
created = str(doc.get("created") or "")[:10] created = str(doc.get("created") or "")[:10]
added = str(doc.get("added") or "")[:10]
title = (doc.get("title") or doc.get("original_file_name") or f"Dokument {doc.get('id')}").strip() title = (doc.get("title") or doc.get("original_file_name") or f"Dokument {doc.get('id')}").strip()
pages = doc.get("page_count")
asn = doc.get("archive_serial_number")
items.append( items.append(
{ {
"id": str(doc.get("id")), "id": str(doc.get("id")),
"title": title[:200], "title": title[:200],
"document_on": created if len(created) == 10 else None, "document_on": created if len(created) == 10 else None,
"correspondent": _correspondent(doc), "added_on": added if len(added) == 10 else None,
"correspondent": _correspondent(doc, names),
"document_type": _named(doc.get("document_type"), names["document_types"]),
"storage_path": _named(doc.get("storage_path"), names["storage_paths"]),
"tags": [name for name in (_named(tag, names["tags"]) for tag in doc.get("tags") or []) if name][:12],
"custom_fields": _custom_display(doc.get("custom_fields"), names["custom_fields"]),
"pages": pages if isinstance(pages, int) and pages > 0 else None,
"asn": asn if isinstance(asn, int) else None,
"snippet": _snippet(doc, terms),
"open_url": f"{base}/documents/{doc.get('id')}/", "open_url": f"{base}/documents/{doc.get('id')}/",
} }
) )
page = int(params.get("page") or 1) page = int(params.get("page") or 1)
count = payload.get("count") count = payload.get("count")
if isinstance(count, int): if isinstance(count, int):
next_page = str(page + 1) if page * 20 < count else None next_page = str(page + 1) if page * PAPERLESS_PAGE_SIZE < count else None
else: else:
next_page = str(page + 1) if len(items) == 20 else None next_page = str(page + 1) if len(items) == PAPERLESS_PAGE_SIZE else None
return {"items": items, "connector_id": str(row["id"]), "next_page": next_page, "incomplete": False} return {
"items": items,
"connector_id": str(row["id"]),
"next_page": next_page,
"previous_page": str(page - 1) if page > 1 else None,
"total": count if isinstance(count, int) else None,
"incomplete": False,
}
def paperless_facets(conn, owner_id: UUID, connector_id: UUID) -> dict: def paperless_facets(conn, owner_id: UUID, connector_id: UUID) -> dict:
row = _paperless_row(conn, owner_id, connector_id) row = _paperless_row(conn, owner_id, connector_id)
base = row["settings"]["base_url"].rstrip("/") base = row["settings"]["base_url"].rstrip("/")
token = row["secret"]
release_for_external(conn) release_for_external(conn)
body = { names = _paperless_lookup(row["id"], base, row["secret"])
assert_still_owned(conn, row["id"], owner_id)
return {
"correspondents": names["correspondents"],
"document_types": names["document_types"],
"storage_paths": names["storage_paths"],
"tags": names["tags"],
"custom_fields": names["custom_fields"],
"tag_mode": "all",
"tag_modes": list(_PAPERLESS_TAG_MODES),
"modes": list(_PAPERLESS_MODES),
}
_THUMBNAIL_MEDIA = frozenset({"image/png", "image/jpeg", "image/webp", "image/gif"})
PAPERLESS_SEARCH_PARAMS = {
"mode": "mode",
"title": "title",
"correspondent": "correspondent",
"document_type": "document_type",
"storage_path": "storage_path",
"tag": "tags",
"tag_mode": "tag_mode",
"document_from": "document_range",
"document_to": "document_range",
"added_from": "added_range",
"added_to": "added_range",
"asn": "asn",
"custom": "custom_fields",
"sort": "sort",
"cursor": "continuation",
}
def paperless_thumbnail(conn, owner_id: UUID, document_id: str, connector_id: UUID) -> tuple[bytes, str]:
if not document_id.isdigit() or len(document_id) > 12:
raise unprocessable("Die Paperless-Nummer ist ungültig.")
row = _paperless_row(conn, owner_id, connector_id)
base = row["settings"]["base_url"].rstrip("/")
release_for_external(conn)
fetched = _paperless_file(base, row["secret"], f"/api/documents/{document_id}/thumb/", 2 * 1024 * 1024)
assert_still_owned(conn, row["id"], owner_id)
if fetched is None:
raise not_found()
data, header, _name = fetched
return data, _thumbnail_media(data, header)
def _thumbnail_media(data: bytes, header: str) -> str:
"""Raster pictures only, told by their bytes. A vector file could carry markup, a header can be wrong."""
try:
media = sniff(data)
except Problem:
media = "image/gif" if data[:4] == b"GIF8" else ""
if media not in _THUMBNAIL_MEDIA:
raise unprocessable(f"Paperless hat kein Vorschaubild geliefert (Antworttyp {header or 'unbekannt'}).")
return media
_LOOKUP_TTL = 60.0
_LOOKUP_LIMIT = 32
_lookup_cache: dict[tuple, tuple[float, dict]] = {}
_lookup_lock = threading.Lock()
def _paperless_lookup(connector_id, base: str, token: str) -> dict:
"""Names behind the ids of a result list. Bound to the instance and key that asked, kept for a minute."""
key = (str(connector_id), base, hashlib.sha256(token.encode("utf-8")).hexdigest())
now = time.monotonic()
with _lookup_lock:
hit = _lookup_cache.get(key)
if hit and now - hit[0] < _LOOKUP_TTL:
return hit[1]
names = {
"correspondents": _paperless_names(base, token, "/api/correspondents/"), "correspondents": _paperless_names(base, token, "/api/correspondents/"),
"document_types": _paperless_names(base, token, "/api/document_types/"), "document_types": _paperless_names(base, token, "/api/document_types/"),
"tags": _paperless_names(base, token, "/api/tags/"), "tags": _paperless_names(base, token, "/api/tags/"),
"tag_mode": "all", # An instance without storage paths, or a key that may not read them, still searches.
"storage_paths": _paperless_names_or_none(base, token, "/api/storage_paths/"),
"custom_fields": _paperless_custom_fields(base, token),
} }
assert_still_owned(conn, row["id"], owner_id) with _lookup_lock:
return body if len(_lookup_cache) >= _LOOKUP_LIMIT:
_lookup_cache.clear()
_lookup_cache[key] = (now, names)
return names
def _paperless_custom_fields(base: str, token: str) -> list[dict]:
"""Custom fields the picker can filter on. Types it cannot query, such as document links, are left out."""
found = []
try:
for page in range(1, 6):
payload = _paperless_get(base, token, "/api/custom_fields/", {"page": str(page), "page_size": "100"})
rows = payload.get("results") or []
for item in rows:
kind = item.get("data_type")
if item.get("id") is None or kind not in _CUSTOM_KINDS:
continue
extra = item.get("extra_data") if isinstance(item.get("extra_data"), dict) else {}
options = [
{"id": str(option["id"]), "name": str(option.get("label") or option["id"])[:200]}
for option in extra.get("select_options") or []
if isinstance(option, dict) and option.get("id") is not None
]
found.append({"id": str(item["id"]), "name": str(item.get("name") or item["id"])[:200], "type": kind, "options": options})
if len(rows) < 100:
break
except Problem:
return []
return found
def _paperless_names_or_none(base: str, token: str, path: str) -> list[dict]:
try:
return _paperless_names(base, token, path)
except Problem:
return []
_CUSTOM_SHOWN = 8
def _custom_display(values, fields: list[dict]) -> list[dict]:
"""The custom fields of a hit as name, type and readable value. Empty values and unknown fields are left out."""
if not isinstance(values, list):
return []
known = {field["id"]: field for field in fields}
shown = []
for entry in values:
if not isinstance(entry, dict):
continue
field = known.get(str(entry.get("field")))
value = entry.get("value")
if field is None or value is None or value == "" or isinstance(value, list):
continue
if field["type"] == "boolean":
text = "Ja" if value else "Nein"
elif field["type"] == "select":
text = next((option["name"] for option in field["options"] if option["id"] == str(value)), "")
else:
text = str(value)
if text:
shown.append({"name": field["name"], "type": field["type"], "value": text[:200]})
return shown[:_CUSTOM_SHOWN]
def _named(value, entries: list[dict]) -> str | None:
if value is None or isinstance(value, bool):
return None
wanted = str(value)
for entry in entries:
if entry["id"] == wanted:
return entry["name"]
return None
_TAG_MARKUP = re.compile(r"<[^>]{0,200}>")
_SNIPPET_LENGTH = 260
def _search_terms(query: str, title) -> list[str]:
words = re.findall(r"[\w-]{3,}", f"{query or ''} {title or ''}".casefold())
return list(dict.fromkeys(words))[:8]
def _snippet(doc: dict, terms: list[str]) -> str | None:
"""A short plain-text excerpt: the index hit when Paperless sends one, else the text around the first match."""
hit = doc.get("__search_hit__")
if isinstance(hit, dict):
lines = hit.get("highlights")
if isinstance(lines, str) and lines.strip():
text = " ".join(unescape(_TAG_MARKUP.sub("", lines)).split())
if text:
return text[:_SNIPPET_LENGTH]
content = doc.get("content")
if not isinstance(content, str):
return None
text = " ".join(content.split())
if not text:
return None
folded = text.casefold()
at = min((index for index in (folded.find(term) for term in terms) if index >= 0), default=-1)
if at < 0:
return text[:_SNIPPET_LENGTH] + ("…" if len(text) > _SNIPPET_LENGTH else "")
first = max(0, at - 60)
if first:
first = text.rfind(" ", 0, first) + 1 or first
last = first + _SNIPPET_LENGTH
return ("…" if first else "") + text[first:last] + ("…" if last < len(text) else "")
def _paperless_names(base: str, token: str, path: str) -> list[dict]: def _paperless_names(base: str, token: str, path: str) -> list[dict]:
@@ -509,7 +857,8 @@ def read_linked_mail(conn, actor_id: UUID, element: dict, context: Ctx | None, r
def fetch(row): def fetch(row):
return pull_rfc822(row["settings"], row["secret"], mailbox, uid, external_id, COMPLETE_MAIL_LIMIT) return pull_rfc822(row["settings"], row["secret"], mailbox, uid, external_id, COMPLETE_MAIL_LIMIT)
return complete_borrow(conn, borrowed, fetch) found = complete_borrow(conn, borrowed, fetch)
return _keep_moved_mail(conn, element["id"], external_id, mailbox, uid, found)
def _uuid(value) -> UUID | None: def _uuid(value) -> UUID | None:
@@ -672,15 +1021,28 @@ def _paperless_get(base: str, token: str, path: str, params: dict) -> dict:
except HTTPError as exc: except HTTPError as exc:
if exc.code in {401, 403}: if exc.code in {401, 403}:
raise unprocessable("Paperless hat den Schlüssel abgelehnt.") from exc raise unprocessable("Paperless hat den Schlüssel abgelehnt.") from exc
raise unprocessable("Paperless hat die Anfrage nicht beantwortet.") from exc raise unprocessable(f"Paperless hat die Anfrage nicht beantwortet ({_refusal(exc, path)}).") from exc
except (URLError, TimeoutError, json.JSONDecodeError) as exc: except (URLError, TimeoutError, json.JSONDecodeError) as exc:
raise unprocessable("Paperless ist nicht erreichbar.") from exc raise unprocessable("Paperless ist nicht erreichbar.") from exc
def _correspondent(doc: dict) -> str | None: def _refusal(exc: HTTPError, path: str) -> str:
"""Status and, when Paperless names one, its reason. The body is the owner's own instance, cut short."""
reason = ""
try:
body = json.loads(exc.read(2000).decode("utf-8", "replace"))
reason = json.dumps(body, ensure_ascii=False)[:240] if isinstance(body, (dict, list)) else ""
except (ValueError, OSError):
reason = ""
return f"HTTP {exc.code} auf {path}" + (f": {reason}" if reason else "")
def _correspondent(doc: dict, names: dict | None = None) -> str | None:
value = doc.get("correspondent_name") or doc.get("correspondent") value = doc.get("correspondent_name") or doc.get("correspondent")
if isinstance(value, str) and value.strip(): if isinstance(value, str) and value.strip():
return value.strip()[:200] return value.strip()[:200]
if names is not None:
return _named(value, names["correspondents"])
return None return None
@@ -1470,11 +1832,33 @@ def load_imap_original(conn, owner_id: UUID, connector_id: UUID, mailbox: str, u
row = _owned(conn, owner_id, connector_id) row = _owned(conn, owner_id, connector_id)
if row["kind"] != "imap": if row["kind"] != "imap":
raise unprocessable("Das ist kein E-Mail-Konto.") raise unprocessable("Das ist kein E-Mail-Konto.")
return pull_rfc822(row["settings"], row["secret"], mailbox, uid, expected_id, COMPLETE_MAIL_LIMIT) found = pull_rfc822(row["settings"], row["secret"], mailbox, uid, expected_id, COMPLETE_MAIL_LIMIT)
return found.raw if isinstance(found, LocatedMail) else found
def pull_rfc822(settings: dict, secret: str, mailbox: str, uid: int, expected_id: str, max_bytes: int) -> bytes: @dataclass(frozen=True)
"""Fetch the referenced message. A different message at the old UID is not returned.""" class LocatedMail:
"""Bytes plus the folder they were read from. `relocated` is a complete, unique hit."""
raw: bytes
mailbox: str
uid: int
relocated: bool = False
@dataclass(frozen=True)
class _MailHit:
raw: bytes
mailbox: str
uid: int
def pull_rfc822(settings: dict, secret: str, mailbox: str, uid: int, expected_id: str, max_bytes: int) -> LocatedMail:
"""Fetch the referenced message. A different message at the old UID is not returned.
The stored folder is tried first. A single Message-ID hit elsewhere comes back
marked relocated; the caller stores that place after the access check.
"""
client = _imap_login(settings, secret) client = _imap_login(settings, secret)
try: try:
_select_mailbox(client, mailbox) _select_mailbox(client, mailbox)
@@ -1484,23 +1868,45 @@ def pull_rfc822(settings: dict, secret: str, mailbox: str, uid: int, expected_id
"Die vollständige Nachricht überschreitet die Exportgrenze. " "Die vollständige Nachricht überschreitet die Exportgrenze. "
"Eine gekürzte Vorschau wird nicht als Original übernommen." "Eine gekürzte Vorschau wird nicht als Original übernommen."
) )
alternates: list[bytes] = [] if candidate is not None and identities_match(header_message_id(candidate), expected_id):
if candidate is None or not identities_match(header_message_id(candidate), expected_id): return LocatedMail(candidate, mailbox, uid, relocated=False)
alternates = _search_rfc822(client, expected_id, max_bytes) hits, capped = _search_rfc822(client, expected_id, max_bytes)
try: try:
chosen = choose_message(candidate, alternates, expected_id) chosen = choose_message(None, [hit.raw for hit in hits], expected_id)
except MailIdentityError as exc: except MailIdentityError as exc:
raise unprocessable(exc.message) from exc raise unprocessable(exc.message) from exc
if len(chosen) > max_bytes: match = next(
hit for hit in hits
if hit.raw == chosen and identities_match(header_message_id(hit.raw), expected_id)
)
if len(match.raw) > max_bytes:
raise unprocessable( raise unprocessable(
"Die vollständige Nachricht überschreitet die Exportgrenze. " "Die vollständige Nachricht überschreitet die Exportgrenze. "
"Eine gekürzte Vorschau wird nicht als Original übernommen." "Eine gekürzte Vorschau wird nicht als Original übernommen."
) )
return chosen moved = not capped and (match.mailbox != mailbox or match.uid != uid)
return LocatedMail(match.raw, match.mailbox, match.uid, relocated=moved)
finally: finally:
_imap_logout(client) _imap_logout(client)
def _keep_moved_mail(conn, element_id, external_id: str, mailbox: str, uid: int | None, found) -> bytes:
"""Return the bytes. A unique new place is written only after the fetch has finished."""
if not isinstance(found, LocatedMail):
return found
if found.relocated and element_id is not None and uid is not None:
remember_imap_location(
conn,
element_id,
external_id,
mailbox,
uid,
found.mailbox,
found.uid,
)
return found.raw
def _fetch_rfc822(client: imaplib.IMAP4, uid: int) -> bytes | None: def _fetch_rfc822(client: imaplib.IMAP4, uid: int) -> bytes | None:
try: try:
status, fetched = client.uid("FETCH", str(uid), "(BODY.PEEK[])") status, fetched = client.uid("FETCH", str(uid), "(BODY.PEEK[])")
@@ -1511,11 +1917,12 @@ def _fetch_rfc822(client: imaplib.IMAP4, uid: int) -> bytes | None:
return _literal(fetched) return _literal(fetched)
def _search_rfc822(client: imaplib.IMAP4, expected_id: str, max_bytes: int) -> list[bytes]: def _search_rfc822(client: imaplib.IMAP4, expected_id: str, max_bytes: int) -> tuple[list[_MailHit], bool]:
"""Search every selectable folder. The second value is true when the scan stopped early."""
token = (expected_id or "").strip() token = (expected_id or "").strip()
if not token or token.casefold().startswith("uid:"): if not token or token.casefold().startswith("uid:"):
return [] return [], False
found: list[bytes] = [] found: list[_MailHit] = []
for folder in _imap_mailboxes(client): for folder in _imap_mailboxes(client):
if not folder["selectable"]: if not folder["selectable"]:
continue continue
@@ -1539,10 +1946,10 @@ def _search_rfc822(client: imaplib.IMAP4, expected_id: str, max_bytes: int) -> l
"Die vollständige Nachricht überschreitet die Exportgrenze. " "Die vollständige Nachricht überschreitet die Exportgrenze. "
"Eine gekürzte Vorschau wird nicht als Original übernommen." "Eine gekürzte Vorschau wird nicht als Original übernommen."
) )
found.append(blob) found.append(_MailHit(blob, folder["name"], uid))
if len(found) > 5: if len(found) > 5:
return found return found, True
return found return found, False
PAPERLESS_FIELDS = ( PAPERLESS_FIELDS = (
@@ -1667,13 +2074,15 @@ def _export_imap(conn, actor_id: UUID, external_id: str, detail: dict, assigned:
owner_id = resolved.row["owner_id"] owner_id = resolved.row["owner_id"]
release_for_external(conn) release_for_external(conn)
try: try:
raw = pull_rfc822(settings, secret, mailbox, uid, str(external_id), EXPORT_BYTE_LIMIT) found = pull_rfc822(settings, secret, mailbox, uid, str(external_id), EXPORT_BYTE_LIMIT)
except Problem as exc: except Problem as exc:
return failure_from_problem(exc) return failure_from_problem(exc)
try: try:
assert_still_owned(conn, connector_id, owner_id) assert_still_owned(conn, connector_id, owner_id)
except Problem as exc: except Problem as exc:
return failure_from_problem(exc) return failure_from_problem(exc)
element_id = ref["element_id"] if ref is not None and "element_id" in ref.keys() else None
raw = _keep_moved_mail(conn, element_id, str(external_id), mailbox, uid, found)
if len(raw) > EXPORT_BYTE_LIMIT: if len(raw) > EXPORT_BYTE_LIMIT:
return RetrievalFailure( return RetrievalFailure(
"too_large", "too_large",
@@ -1694,11 +2103,66 @@ def _imap_bytes(conn, actor_id: UUID, element: dict, context: Ctx | None, ref) -
return raw, "message/rfc822", "nachricht.eml" return raw, "message/rfc822", "nachricht.eml"
PAPERLESS_CAPABILITIES = {
"kind": "paperless",
"navigate": False,
"read_original": True,
"read_preview": True,
"read_attachment": False,
"edit_content": False,
"edit_metadata": False,
"search": {
"query": True,
"mode": True,
"title": True,
"correspondent": True,
"document_type": True,
"storage_path": True,
"tags": True,
"tag_mode": True,
"document_range": True,
"added_range": True,
"asn": True,
"custom_fields": True,
"sort": True,
"continuation": True,
"result_preview": True,
},
}
IMAP_CAPABILITIES = {
"kind": "imap",
"navigate": True,
"read_original": True,
"read_preview": True,
"read_attachment": True,
"edit_content": False,
"edit_metadata": False,
"search": {
"query": True,
"mode": False,
"title": False,
"correspondent": False,
"document_type": False,
"storage_path": False,
"tags": False,
"tag_mode": False,
"document_range": False,
"added_range": False,
"asn": False,
"custom_fields": False,
"sort": False,
"continuation": True,
"result_preview": False,
},
}
class _PaperlessAdapter: class _PaperlessAdapter:
kind = "paperless" kind = "paperless"
def capabilities(self) -> dict: def capabilities(self) -> dict:
return CAPABILITIES[self.kind] return PAPERLESS_CAPABILITIES
def probe(self, row) -> dict: def probe(self, row) -> dict:
count = _paperless_count(row["settings"]["base_url"], row["secret"]) count = _paperless_count(row["settings"]["base_url"], row["secret"])
@@ -1719,7 +2183,7 @@ class _ImapAdapter:
kind = "imap" kind = "imap"
def capabilities(self) -> dict: def capabilities(self) -> dict:
return CAPABILITIES[self.kind] return IMAP_CAPABILITIES
def probe(self, row) -> dict: def probe(self, row) -> dict:
_imap_login(row["settings"], row["secret"]) _imap_login(row["settings"], row["secret"])
@@ -1742,7 +2206,7 @@ def _install_sources() -> None:
kind="paperless", kind="paperless",
label="Paperless", label="Paperless",
representation="pdf", representation="pdf",
capabilities=CAPABILITIES["paperless"], capabilities=PAPERLESS_CAPABILITIES,
config_fields=PAPERLESS_FIELDS, config_fields=PAPERLESS_FIELDS,
normalize_config=_paperless_normalize, normalize_config=_paperless_normalize,
probe=paperless.probe, probe=paperless.probe,
@@ -1752,12 +2216,14 @@ def _install_sources() -> None:
navigate=None, navigate=None,
preview=None, preview=None,
facets=paperless.facets, facets=paperless.facets,
search_params=PAPERLESS_SEARCH_PARAMS,
thumbnail=lambda conn, owner, connector_id, item: paperless_thumbnail(conn, owner, str(item), connector_id),
)) ))
register_source(SourceModule( register_source(SourceModule(
kind="imap", kind="imap",
label="E-Mail", label="E-Mail",
representation="email", representation="email",
capabilities=CAPABILITIES["imap"], capabilities=IMAP_CAPABILITIES,
config_fields=IMAP_FIELDS, config_fields=IMAP_FIELDS,
normalize_config=_imap_normalize, normalize_config=_imap_normalize,
probe=imap.probe, probe=imap.probe,
@@ -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);
+1 -1
View File
@@ -216,7 +216,7 @@ def test_two_paperless_instances_stay_bound_when_order_changes(client, db, monke
) )
assert filtered["items"][0]["title"] == "Treffer" assert filtered["items"][0]["title"] == "Treffer"
assert calls[-1][3]["correspondent__id"] == "4" assert calls[-1][3]["correspondent__id"] == "4"
assert calls[-1][3]["query"] == "Treffer" assert calls[-1][3]["title_content"] == "Treffer"
def test_ambiguous_legacy_stays_until_assignment(client, db, monkeypatch): def test_ambiguous_legacy_stays_until_assignment(client, db, monkeypatch):
+325 -2
View File
@@ -10,6 +10,9 @@ import io
import zipfile import zipfile
from email.parser import BytesParser from email.parser import BytesParser
import pytest
from app.core.errors import unprocessable
from app.media.port import MemoryAdapter from app.media.port import MemoryAdapter
from app.sourceaccess import borrow_original, complete_borrow from app.sourceaccess import borrow_original, complete_borrow
from app.sourceregistry import SourceModule, unregister_source, register_source from app.sourceregistry import SourceModule, unregister_source, register_source
@@ -355,22 +358,34 @@ def test_paperless_filters_reach_the_api_and_cross_pages(client, db, monkeypatch
params={ params={
"connector_id": first["id"], "connector_id": first["id"],
"q": "nurinhalt", "q": "nurinhalt",
"mode": "index",
"title": "Vertrag", "title": "Vertrag",
"correspondent": "4", "correspondent": "4",
"document_type": "8", "document_type": "8",
"storage_path": "6",
"tag": "2,5", "tag": "2,5",
"tag_mode": "any",
"document_from": "2024-01-01", "document_from": "2024-01-01",
"document_to": "2024-12-31", "document_to": "2024-12-31",
"added_from": "2024-02-01",
"added_to": "2024-02-28",
"asn": "1042",
"sort": "-created", "sort": "-created",
"cursor": "3", "cursor": "3",
}, },
) )
sent = calls[-1]["params"] sent = calls[-1]["params"]
assert sent["query"] == "nurinhalt" assert sent["query"] == "nurinhalt"
assert "title_content" not in sent
assert sent["title__icontains"] == "Vertrag" assert sent["title__icontains"] == "Vertrag"
assert sent["correspondent__id"] == "4" assert sent["correspondent__id"] == "4"
assert sent["document_type__id"] == "8" assert sent["document_type__id"] == "8"
assert sent["tags__id__all"] == "2,5" assert sent["storage_path__id"] == "6"
assert sent["tags__id__in"] == "2,5"
assert "tags__id__all" not in sent
assert sent["added__date__gte"] == "2024-02-01"
assert sent["added__date__lte"] == "2024-02-28"
assert sent["archive_serial_number"] == "1042"
assert sent["created__date__gte"] == "2024-01-01" assert sent["created__date__gte"] == "2024-01-01"
assert sent["created__date__lte"] == "2024-12-31" assert sent["created__date__lte"] == "2024-12-31"
assert sent["ordering"] == "-created" assert sent["ordering"] == "-created"
@@ -378,9 +393,15 @@ def test_paperless_filters_reach_the_api_and_cross_pages(client, db, monkeypatch
ada.request( ada.request(
"GET", "GET",
"/api/v1/sources/paperless/documents", "/api/v1/sources/paperless/documents",
params={"connector_id": first["id"], "q": "nurinhalt", "sort": "-score"}, params={"connector_id": first["id"], "q": "nurinhalt", "mode": "index", "sort": "-score"},
) )
assert "ordering" not in calls[-1]["params"] assert "ordering" not in calls[-1]["params"]
ada.request(
"GET",
"/api/v1/sources/paperless/documents",
params={"connector_id": first["id"], "q": "nurinhalt", "sort": "-score"},
status=422,
)
assert found["items"][0]["id"] == "41" assert found["items"][0]["id"] == "41"
assert found["connector_id"] == first["id"] assert found["connector_id"] == first["id"]
preview = ada.client.get( preview = ada.client.get(
@@ -431,6 +452,308 @@ def test_paperless_filters_reach_the_api_and_cross_pages(client, db, monkeypatch
) )
def test_paperless_default_search_reads_title_and_content_and_shows_a_preview(client, db, monkeypatch):
import app.sources as sources
calls = []
body = "Vorspann " * 30 + "Die Kündigung des Mietvertrags erfolgt zum Jahresende. " + "Nachspann " * 30
def fake_get(base, token, path, params):
calls.append({"path": path, "params": dict(params)})
if path == "/api/documents/":
return {
"count": 1,
"results": [
{
"id": 7,
"title": "Schreiben",
"created": "2024-03-01T00:00:00+01:00",
"added": "2024-03-05T08:00:00Z",
"correspondent": 4,
"document_type": 8,
"storage_path": None,
"tags": [2, 5, 99],
"archive_serial_number": 1042,
"page_count": 3,
"custom_fields": [
{"field": 1, "value": "EUR100.50"},
{"field": 2, "value": "2024-03-09"},
{"field": 3, "value": "b"},
{"field": 4, "value": True},
{"field": 5, "value": None},
{"field": 99, "value": "fremd"},
],
"content": body,
}
],
}
if path == "/api/storage_paths/":
raise sources.unprocessable("Paperless hat die Anfrage nicht beantwortet.")
if path == "/api/tags/":
return {"results": [{"id": 2, "name": "Miete"}, {"id": 5, "name": "Wohnung"}]}
if path == "/api/correspondents/":
return {"results": [{"id": 4, "name": "Hausverwaltung"}]}
if path == "/api/custom_fields/":
return {
"results": [
{"id": 1, "name": "Rechnungsbetrag", "data_type": "monetary"},
{"id": 2, "name": "bezahlt_am", "data_type": "date"},
{"id": 3, "name": "Status", "data_type": "select", "extra_data": {"select_options": [{"id": "b", "label": "bezahlt"}]}},
{"id": 4, "name": "Geprüft", "data_type": "boolean"},
{"id": 5, "name": "Notiz", "data_type": "string"},
]
}
return {"results": [{"id": 8, "name": "Brief"}]}
monkeypatch.setattr(sources, "_paperless_get", fake_get)
ada = Actor(client, "ada-preview@example.test", "Ada Preview")
register(db, ada.email, ada.name)
ada.login()
first = ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "paperless", "name": "Archiv", "base_url": "https://paper.example.test", "token": "token-alpha"},
status=201,
)
found = ada.request(
"GET",
"/api/v1/sources/paperless/documents",
params={"connector_id": first["id"], "q": "kündigung", "correspondent": "none", "tag": "2", "tag_mode": "none"},
)
sent = [call for call in calls if call["path"] == "/api/documents/"][-1]["params"]
assert sent["title_content"] == "kündigung"
assert "query" not in sent
assert sent["correspondent__isnull"] == "true"
assert sent["tags__id__none"] == "2"
item = found["items"][0]
assert item["correspondent"] == "Hausverwaltung"
assert item["document_type"] == "Brief"
assert item["tags"] == ["Miete", "Wohnung"]
assert item["pages"] == 3
assert item["asn"] == 1042
assert item["document_on"] == "2024-03-01"
assert item["added_on"] == "2024-03-05"
assert "Kündigung des Mietvertrags" in item["snippet"]
assert len(item["snippet"]) <= 262
assert item["snippet"].startswith("…")
assert item["custom_fields"] == [
{"name": "Rechnungsbetrag", "type": "monetary", "value": "EUR100.50"},
{"name": "bezahlt_am", "type": "date", "value": "2024-03-09"},
{"name": "Status", "type": "select", "value": "bezahlt"},
{"name": "Geprüft", "type": "boolean", "value": "Ja"},
]
assert found["total"] == 1
assert found["previous_page"] is None
facets = ada.request("GET", "/api/v1/sources/paperless/facets", params={"connector_id": first["id"]})
assert facets["storage_paths"] == []
assert facets["tag_modes"] == ["all", "any", "none"]
# A filter of another source is refused, not ignored.
ada.request(
"GET",
"/api/v1/sources/imap/messages",
params={"connector_id": first["id"], "mailbox": "INBOX", "mode": "title"},
status=422,
)
for params in (
{"mode": "regex"},
{"tag_mode": "x"},
{"asn": "x1"},
{"storage_path": "a"},
{"q": "miete", "mode": "title", "title": "vertrag"},
{"bogus": "1"},
):
ada.request(
"GET",
"/api/v1/sources/paperless/documents",
params={"connector_id": first["id"], **params},
status=422,
)
def test_paperless_custom_field_filters_use_the_instance_fields(client, db, monkeypatch):
import json
import app.sources as sources
calls = []
def fake_get(base, token, path, params):
calls.append({"path": path, "params": dict(params)})
if path == "/api/custom_fields/":
return {
"results": [
{"id": 1, "name": "Rechnungsbetrag", "data_type": "monetary"},
{"id": 2, "name": "bezahlt_am", "data_type": "date"},
{
"id": 3,
"name": "Status",
"data_type": "select",
"extra_data": {"select_options": [{"id": "a", "label": "offen"}, {"id": "b", "label": "bezahlt"}]},
},
{"id": 4, "name": "Verweis", "data_type": "documentlink"},
]
}
if path == "/api/documents/":
if failing:
raise unprocessable(failing[0])
return {"count": 0, "results": []}
return {"results": []}
failing = []
monkeypatch.setattr(sources, "_paperless_get", fake_get)
ada = Actor(client, "ada-custom@example.test", "Ada Custom")
register(db, ada.email, ada.name)
ada.login()
first = ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "paperless", "name": "Archiv", "base_url": "https://paper.example.test", "token": "token-alpha"},
status=201,
)
facets = ada.request("GET", "/api/v1/sources/paperless/facets", params={"connector_id": first["id"]})
assert [item["name"] for item in facets["custom_fields"]] == ["Rechnungsbetrag", "bezahlt_am", "Status"]
assert facets["custom_fields"][2]["options"] == [{"id": "a", "name": "offen"}, {"id": "b", "name": "bezahlt"}]
def ask(rows, status=200):
return ada.request(
"GET",
"/api/v1/sources/paperless/documents",
params={"connector_id": first["id"], "custom": json.dumps(rows)},
status=status,
)
ask([{"field": "2", "op": "range", "value": ["2024-01-01", "2024-06-30"]}])
sent = [call for call in calls if call["path"] == "/api/documents/"][-1]["params"]
assert json.loads(sent["custom_field_query"]) == ["bezahlt_am", "range", ["2024-01-01", "2024-06-30"]]
ask(
[
{"field": "1", "op": "gte", "value": "100,5"},
{"field": "3", "op": "exact", "value": "a"},
{"field": "2", "op": "exists", "value": False},
]
)
sent = [call for call in calls if call["path"] == "/api/documents/"][-1]["params"]
assert json.loads(sent["custom_field_query"]) == [
"AND",
[["Rechnungsbetrag", "gte", 100.5], ["Status", "exact", "a"], ["bezahlt_am", "exists", False]],
]
ask([], 200)
assert "custom_field_query" not in [call for call in calls if call["path"] == "/api/documents/"][-1]["params"]
for rows in (
[{"field": "9", "op": "exact", "value": "x"}],
[{"field": "4", "op": "contains", "value": "1"}],
[{"field": "2", "op": "icontains", "value": "2024"}],
[{"field": "3", "op": "exact", "value": "z"}],
[{"field": "1", "op": "gt", "value": "viel"}],
[{"field": "2", "op": "range", "value": ["2024-06-30", "2024-01-01"]}],
[{"field": "2", "op": "exists", "value": "ja"}],
[{"field": "1", "op": "exact", "value": "1"}] * 6,
):
ask(rows, 422)
ada.request(
"GET",
"/api/v1/sources/paperless/documents",
params={"connector_id": first["id"], "custom": "kein json"},
status=422,
)
# Paperless answers 500 for all-tags together with a custom field: the message names that pairing.
failing.append("Paperless hat die Anfrage nicht beantwortet (HTTP 500 auf /api/documents/).")
row = json.dumps([{"field": "2", "op": "exists", "value": True}])
def refused(extra):
return ada.request(
"GET",
"/api/v1/sources/paperless/documents",
params={"connector_id": first["id"], "custom": row, **extra},
status=422,
)
assert "Alle gewählten Tags" in str(refused({"tag": "1,2"}))
assert "Alle gewählten Tags" not in str(refused({"tag": "1,2", "tag_mode": "any"}))
assert "Alle gewählten Tags" not in str(refused({"tag": "1"}))
def test_paperless_refusal_names_the_status_and_reason(monkeypatch):
import io
from urllib.error import HTTPError
import app.sources as sources
from app.core.errors import Problem
def refuse(code, body):
def fake(request, timeout=0):
raise HTTPError(request.full_url, code, "x", {}, io.BytesIO(body))
return fake
monkeypatch.setattr(sources, "urlopen", refuse(400, '{"custom_field_query": ["Ungültig"]}'.encode()))
with pytest.raises(Problem) as caught:
sources._paperless_get("https://paper.example.test", "token-alpha", "/api/documents/", {"page_size": "20"})
assert "HTTP 400 auf /api/documents/" in caught.value.detail
assert "custom_field_query" in caught.value.detail
assert "token-alpha" not in caught.value.detail
monkeypatch.setattr(sources, "urlopen", refuse(500, b"<html>Fehler</html>"))
with pytest.raises(Problem) as caught:
sources._paperless_get("https://paper.example.test", "token-alpha", "/api/documents/", {})
assert caught.value.detail.endswith("(HTTP 500 auf /api/documents/).")
monkeypatch.setattr(sources, "urlopen", refuse(403, b"{}"))
with pytest.raises(Problem) as caught:
sources._paperless_get("https://paper.example.test", "token-alpha", "/api/documents/", {})
assert "Schlüssel abgelehnt" in caught.value.detail
def test_paperless_thumbnail_is_bound_to_the_owners_instance(client, db, monkeypatch):
import app.sources as sources
seen = []
def fake_file(base, token, path, max_bytes=0):
seen.append((token, path))
if path.endswith("/9/thumb/"):
return b"RIFFxxxxWEBP", "image/webp", ""
if path.endswith("/8/thumb/"):
return b"<p>", "text/html", ""
if path.endswith("/6/thumb/"):
return b"\x89PNG\r\n\x1a\nxxxx", "application/octet-stream", ""
if path.endswith("/7/thumb/"):
return b"<svg xmlns='http://www.w3.org/2000/svg'/>", "image/svg+xml", ""
return None
monkeypatch.setattr(sources, "_paperless_file", fake_file)
ada = Actor(client, "ada-thumb@example.test", "Ada Thumb")
register(db, ada.email, ada.name)
ada.login()
first = ada.request(
"POST",
"/api/v1/connectors",
json={"kind": "paperless", "name": "Archiv", "base_url": "https://paper.example.test", "token": "token-alpha"},
status=201,
)
url = "/api/v1/sources/paperless/thumbnail"
def get(actor, item, kind_url=url):
return actor.client.get(kind_url, params={"connector_id": first["id"], "item": item}, headers=_headers(actor))
ok = get(ada, 9)
assert ok.status_code == 200
assert ok.headers["content-type"] == "image/webp"
assert ok.headers["cache-control"] == "private, no-store"
assert seen[-1] == ("token-alpha", "/api/documents/9/thumb/")
typed = get(ada, 6)
assert typed.status_code == 200 and typed.headers["content-type"] == "image/png"
assert get(ada, 8).status_code == 422
assert get(ada, 7).status_code == 422
assert get(ada, 5).status_code == 404
assert get(ada, "x1").status_code == 422
# IMAP declares no thumbnails, and the module must declare the capability.
assert get(ada, 9, "/api/v1/sources/imap/thumbnail").status_code == 422
ben = Actor(client, "ben-thumb@example.test", "Ben Thumb")
register(db, ben.email, ben.name)
ben.login()
assert get(ben, 9).status_code == 404
assert len(seen) == 5
def test_revoked_grant_hides_bytes_fetched_during_the_call(client, db, monkeypatch): def test_revoked_grant_hides_bytes_fetched_during_the_call(client, db, monkeypatch):
import app.sources as sources import app.sources as sources
+35 -1
View File
@@ -104,6 +104,40 @@ def test_parse_mail_keeps_names_html_and_attached_messages():
assert named.attachments[0].data == b"pdf" 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: class QuotedIMAP:
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
self.untagged_responses = {} self.untagged_responses = {}
@@ -395,7 +429,7 @@ def test_paperless_filters_change_the_hits(client, db, monkeypatch):
return {"count": 1, "results": [{"id": 4, "name": "Haus"}]} return {"count": 1, "results": [{"id": 4, "name": "Haus"}]}
matched = [] matched = []
for item in catalog: for item in catalog:
query = params.get("query") or "" query = params.get("title_content") or params.get("query") or ""
title = params.get("title__icontains") or "" title = params.get("title__icontains") or ""
if query and query.casefold() not in f"{item['title']} {item['content']}".casefold(): if query and query.casefold() not in f"{item['title']} {item['content']}".casefold():
continue continue
+126
View File
@@ -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)
+273
View File
@@ -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
+81
View File
@@ -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"
+192
View File
@@ -285,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) ada.request("GET", f"/api/v1/external-refs/{wrong['element']['id']}/mail", status=422)
ben.login() ben.login()
ben.request("GET", f"/api/v1/external-refs/{created['id']}/mail", status=404) 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
+79
View File
@@ -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"
+66 -3
View File
@@ -68,10 +68,10 @@ def test_a_new_entry_follows_the_room_preset_and_rights_follow_the_role(world, d
assert [(s["room_name"], s["access"]) for s in view["shares"]] == [("Werkstatt", "edit")] assert [(s["room_name"], s["access"]) for s in view["shares"]] == [("Werkstatt", "edit")]
assert ben.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == { assert ben.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == {
"read": True, "edit": True, "share": False, "delete": False, "read": True, "edit": True, "share": False, "delete": False, "download": True,
} }
assert cem.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == { assert cem.request("GET", f"/api/v1/cases/{shared['id']}")["rights"] == {
"read": True, "edit": False, "share": False, "delete": False, "read": True, "edit": False, "share": False, "delete": False, "download": True,
} }
dan.request("GET", f"/api/v1/cases/{shared['id']}", status=404) 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 "Gemeinsame Akte" in {item["title"] for item in ben.request("GET", "/api/v1/cases")["items"]}
@@ -180,7 +180,7 @@ def test_a_standalone_matter_is_shared_like_a_case(world, db):
matter = matter_of(ada, "Eigener Vorgang") matter = matter_of(ada, "Eigener Vorgang")
assert ben.request("GET", f"/api/v1/matters/{matter['id']}")["rights"]["edit"] is True 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"] == { assert cem.request("GET", f"/api/v1/matters/{matter['id']}")["rights"] == {
"read": True, "edit": False, "share": False, "delete": False, "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) ben.request("POST", f"/api/v1/matters/{matter['id']}/delete", json={"expected_version": matter["version"]}, status=403)
_unshare(ada, "matters", matter["id"], room) _unshare(ada, "matters", matter["id"], room)
@@ -312,3 +312,66 @@ def test_a_room_can_start_without_sharing(client, db):
other = ada.request("POST", "/api/v1/cases", json={"title": "Jetzt geteilt"}, status=201) other = ada.request("POST", "/api/v1/cases", json={"title": "Jetzt geteilt"}, status=201)
ben.request("GET", f"/api/v1/cases/{other['id']}") ben.request("GET", f"/api/v1/cases/{other['id']}")
ben.request("PATCH", f"/api/v1/rooms/{room['id']}", json={"default_visibility": "private"}, status=403) 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()
+1
View File
@@ -209,6 +209,7 @@ def test_operator_sees_rooms_without_content_and_fills_an_orphaned_room(client,
overview = operator.request("GET", "/api/v1/admin/rooms")["items"] overview = operator.request("GET", "/api/v1/admin/rooms")["items"]
row = next(item for item in overview if item["id"] == room) 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["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) assert "Nur für Ada" not in str(overview)
operator.request("GET", f"/api/v1/rooms/{room}/members", status=403) operator.request("GET", f"/api/v1/rooms/{room}/members", status=403)
ben.request("GET", "/api/v1/admin/rooms", status=403) ben.request("GET", "/api/v1/admin/rooms", status=403)
+220
View File
@@ -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()
+46
View File
@@ -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
+3 -3
View File
@@ -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-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` | | `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. 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.
@@ -50,11 +50,11 @@ Diese Punkte sind im [Code-Review](review/06_BEFUNDE.md) beschrieben. Sie stehen
|---|---|---|---| |---|---|---|---|
| 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 | | 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 | | 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` nach dem Dev-Deploy | Vor dem Merge nach `main` den grünen `test.yml`-Lauf zum selben Stand prüfen | R-21, R-27 | | 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 | | 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 | | 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 | | 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 zweimal auf derselben Datenbank `tsumugu_test` | Ein roter Lauf kann vom parallelen Lauf verursacht sein; Ergebnis des Einzellaufs prüfen | R-27 | | 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 |
--- ---
+3
View File
@@ -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. 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. 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. 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. 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.
+1
View File
@@ -33,6 +33,7 @@
| [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_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_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_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_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_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 | | [TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md](product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md) | Einstieg für die fachliche Weiterplanung | 17.10.2026 |
+31 -14
View File
@@ -1,6 +1,6 @@
# Tsumugu – API-Referenz (Ist-Stand) # Tsumugu – API-Referenz (Ist-Stand)
**Stand:** 18.10.2026, ergänzt am 19.10.2026 um Quelleninstanzen, Fähigkeiten und Zuordnung. 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. 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.
@@ -33,6 +33,8 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
|---|---|---|---| |---|---|---|---|
| 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/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 | | 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 | | 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 | | 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 | | GET | `/api/v1/auth/bootstrap` | – | `{available: true}`, solange kein Betreiber existiert, sonst 404 |
@@ -41,7 +43,7 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
| GET | `/api/v1/accounts` | S+R, B | Betreiberkonten (`origin='operator'`) mit Status, Rolle, letzter Anmeldung; Filter `status=active\|disabled` | | 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 | | 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 | | 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`). Letzter Betreiber und eigenes Konto sind geschützt | | 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}/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/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` | | POST | `/api/v1/auth/password` | S | eigenes Passwort ändern (`current_password`, `new_password`); beendet die anderen Sitzungen; 204. Erlaubt auch bei `must_change_password` |
@@ -59,6 +61,7 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
| GET | `/api/v1/rooms` | S+R | wählbare Räume; `include_archived=true` ergänzt die archivierten Räume der Person | | 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 | | POST | `/api/v1/rooms` | S+R | gemeinsamen Raum anlegen, Anlegende Person wird Verwalter |
| 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 | | 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 | | GET | `/api/v1/rooms/{id}/members` | S+R, M | Mitglieder mit Rolle und Kontostatus |
| POST | `/api/v1/rooms/{id}/members` | S+R, M | bestehendes Konto als `member`, `manager` oder `reader` aufnehmen oder dessen Rolle setzen | | 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 | | 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 |
@@ -69,9 +72,18 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
| 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`) | | 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 | | 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 | | 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}`, `/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 / 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`) | | 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) | | 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 | | 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 | | 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 | | GET | `/api/v1/admin/events` | S+R, B | Verwaltungsprotokoll (`cursor`, `limit`) für Konto, Sitzung, Raum, Mitgliedschaft, Einladung |
@@ -133,8 +145,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`) | | 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` | | 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 | | 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` | | 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` | | 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) | | 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) | | GET | `/api/v1/elements` | eigene, nicht eingebundene Elemente (max. 100) |
| POST | `/api/v1/elements/{id}/delete` | überall löschen; nur Element-Owner | | POST | `/api/v1/elements/{id}/delete` | überall löschen; nur Element-Owner |
@@ -165,8 +178,8 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
| POST | `/api/v1/deadlines` | Frist | | POST | `/api/v1/deadlines` | Frist |
| PATCH | `/api/v1/deadlines/{id}` | Titel, Datum | | PATCH | `/api/v1/deadlines/{id}` | Titel, Datum |
| POST | `/api/v1/deadlines/{id}/fulfill` | als erfüllt kennzeichnen | | 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-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 (siehe Review R-11) | | 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/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/placement-targets` | bearbeitbare Akten und Vorgänge als Ziele |
| GET | `/api/v1/search?q=` | Akten, Vorgänge, Elemente (Titel und Notiztext), max. 50 | | GET | `/api/v1/search?q=` | Akten, Vorgänge, Elemente (Titel und Notiztext), max. 50 |
@@ -182,17 +195,21 @@ Legende Spalte „Auth“: **–** öffentlich, **S** gültige Session, **S+R**
| DELETE | `/api/v1/connectors/{id}` | Zugang löschen; bestehende Referenzen bleiben und werden nicht umgehängt | | 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 | | 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/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; unbekannte Art und nicht erklärte Filter antworten `422` | | 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}/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/{kind}/preview` | Vorschau vor dem Übernehmen, wenn die Quelle sie erklärt |
| GET | `/api/v1/sources/paperless/documents?q=&connector_id=` | Kompatibilitätshülle der Paperless-Suche; delegiert an dieselbe Suche | | 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/mailboxes?connector_id=` | IMAP-Fächer |
| GET | `/api/v1/sources/imap/messages?connector_id=&mailbox=&q=&before=` | Nachrichtenliste, 30 je Seite, Fortsetzung über `before` | | 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/sources/imap/message?connector_id=&mailbox=&uid=` | Vorschau vor dem Übernehmen |
| GET | `/api/v1/external-refs/{id}/content` | Original der gebundenen Instanz über das registrierte Modul (`inline`) | | 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 | | 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/original` | EML | | 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/attachments/{index}` | Anlage (`inline`, siehe Review R-03) | | 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 | | POST | `/api/v1/external-refs/{id}/assignment` | Owner ordnet eine mehrdeutige oder ungebundene Referenz bewusst einer eigenen Instanz zu |
Quelleninhalte einer eigenen Referenz laufen über die gebundene Instanz. Eine freigegebene Referenz mit `use_owner_sources` 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). Quelleninhalte einer eigenen Referenz laufen über die gebundene Instanz. Eine freigegebene Referenz mit `use_owner_sources` 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).
@@ -203,7 +220,7 @@ Quelleninhalte einer eigenen Referenz laufen über die gebundene Instanz. Eine f
|---|---|---| |---|---|---|
| GET | `/api/v1/matters/{id}/export-tree` | Auswahlbaum mit `exportable` und Grund | | 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/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 ## Anlagen und Versand
+58
View File
@@ -58,3 +58,61 @@ Alle schreibenden Aktionen schreiben in `domain_events`, ohne E-Mail, Passwort u
## Bewusst nicht enthalten (Sicherheitskonzept) ## 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. 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.
+5 -2
View File
@@ -1,6 +1,6 @@
# Tsumugu – Datenmodell (Ist-Stand) # Tsumugu – Datenmodell (Ist-Stand)
**Stand:** 19.10.2026, nach den Migrationen in `backend/migrations/` (letzte: `20261021T150000Z_room_shares.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. **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. 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,14 @@ Die Sollfassung steht in der [technischen Spezifikation, Abschnitt 4](TSUMUGU_TE
| Tabelle | Wesentliche Spalten | Regeln | | Tabelle | Wesentliche Spalten | Regeln |
|---|---|---| |---|---|---|
| `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` | Konten mit `origin='fixture'` entfernt der Start in jeder Umgebung | | `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_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 | | `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` | | `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`/`reader`), `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` | | `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_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 |
| `auth_login_attempts` | `bucket` (SHA-256 aus Adresse und E-Mail), `attempted_at` | zählt Fehlversuche; erfolgreicher Login löscht den Bucket | | `auth_login_attempts` | `bucket` (SHA-256 aus Adresse und E-Mail), `attempted_at` | zählt Fehlversuche; erfolgreicher Login löscht den Bucket |
+3 -2
View File
@@ -14,7 +14,7 @@ Der Datenraum bestimmt, **wo neue Objekte entstehen**. Er ist nicht der Rechtepf
## 2. Rechte und Antwortcodes ## 2. Rechte und Antwortcodes
Ein Ergebnis `Rights(read, edit, share, delete)` entsteht je Objekt und Handlungskontext. `_require` übersetzt: 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` fehlt → **404** (das Objekt existiert für diese Person nicht)
- `read` vorhanden, verlangte Fähigkeit fehlt → **403** - `read` vorhanden, verlangte Fähigkeit fehlt → **403**
@@ -94,9 +94,10 @@ Danach Abzug der jeweiligen Ausnahme.
- Breadcrumbs nennen nur lesbare Stationen. Bei mehreren lesbaren Aktenzuordnungen ohne gewählten Kontext erscheint keine Hauptakte. - 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. - 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). - **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).
- 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. - 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. - 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 ## 6. Bekannte Abweichungen
Siehe [Review-Befunde](../review/06_BEFUNDE.md): R-01 (Behälter löschen), R-02 (Detach/Anmerkung), R-07 (Vorgangsausnahme), R-11 (Übersicht/Suche), R-12 (Teilvorgangstiefe), R-15 (Fristen im Elternkontext). 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,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 |
@@ -99,3 +99,20 @@ Die Konfiguration einer Instanz gehört dem Modul. Ein Modul deklariert `config_
Neuer Connector: Modul mit `config_fields` in `register_source` eintragen, UI-Modul mit `registerSourceModule` registrieren. Kein Eingriff in `ConnectorIn`, `Sources.jsx` oder die Fachseiten. 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. 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.
+6
View File
@@ -442,6 +442,12 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G
**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 mitgegeben, sondern brauchen weiter die ausdrückliche Freigabe. 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). **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 mitgegeben, sondern brauchen weiter die ausdrückliche Freigabe. 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 ## 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. 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.
+4 -2
View File
@@ -16,7 +16,7 @@ Schweregrade siehe [01](01_METHODIK_UND_QUELLEN.md#schweregrade-der-befunde). Fu
| R-08 | Hoch | Auth | Session- und Login-Härtung unter dem Blueprint-Vertrag | | R-08 | Hoch | Auth | Session- und Login-Härtung unter dem Blueprint-Vertrag |
| R-09 | Mittel | Datenbank | Gemeinsame Zugangsdaten für Runtime und Migration, Migrator ohne Lock | | R-09 | Mittel | Datenbank | Gemeinsame Zugangsdaten für Runtime und Migration, Migrator ohne Lock |
| R-10 | Mittel | Quellen | Quelleninhalte werden über den Zugang des Betrachters geladen | | R-10 | Mittel | Quellen | Quelleninhalte werden über den Zugang des Betrachters geladen |
| R-11 | Hoch | Korrektheit | `LIMIT` vor der Rechteprüfung in Übersicht und Suche | | R-11 | Hoch | Korrektheit | `LIMIT` vor der Rechteprüfung in Übersicht und Suche (behoben am 23.10.2026) |
| R-12 | Mittel | Korrektheit | Verschieben erzeugt eine zweite Teilvorgangsebene | | R-12 | Mittel | Korrektheit | Verschieben erzeugt eine zweite Teilvorgangsebene |
| R-13 | Mittel | Export | Gelöschte oder unsichtbare Bezugsziele blockieren das Übergabepaket | | R-13 | Mittel | Export | Gelöschte oder unsichtbare Bezugsziele blockieren das Übergabepaket |
| R-14 | Mittel | Daten | Gelöschte Akte oder gelöschter Vorgang lässt Inhalte unauffindbar zurück | | R-14 | Mittel | Daten | Gelöschte Akte oder gelöschter Vorgang lässt Inhalte unauffindbar zurück |
@@ -133,7 +133,9 @@ Die Paperless-Vorschau lädt mit dem zuletzt angelegten Paperless-Zugang **der a
**Empfehlung:** Zugang fest an die Referenz binden (`connector_id` als Spalte, wie im Connectoren-Befund vorgeschlagen). Den Abruf über den Zugang des Element-Owners führen, nachdem das Leserecht im Kontext geprüft ist. Bis dahin die Grenze in der Oberfläche benennen. **Empfehlung:** Zugang fest an die Referenz binden (`connector_id` als Spalte, wie im Connectoren-Befund vorgeschlagen). Den Abruf über den Zugang des Element-Owners führen, nachdem das Leserecht im Kontext geprüft ist. Bis dahin die Grenze in der Oberfläche benennen.
## R-11 – `LIMIT` vor der Rechteprüfung (Hoch) ## R-11 – `LIMIT` vor der Rechteprüfung (Hoch) – behoben am 23.10.2026
**Stand:** Übersicht (offene Aufgaben und Fristen) und Suche lesen die Kandidaten jetzt in Blöcken von 200 in der Reihenfolge der Abfrage, prüfen je Zeile die Rechte und hören auf, sobald genug sichtbare Einträge da sind (`_scan` in `routes.py`). Fremde Zeilen verdrängen eigene nicht mehr. Die Arbeit ist bei sehr großen Beständen auf 20 000 gelesene Zeilen begrenzt; eine Vorfilterung im SQL und Cursor-Seiten bleiben eine spätere Optimierung. Test: `tests/test_views_scan.py`. Der Befund unten beschreibt den früheren Zustand.
**Fundstelle:** [routes.py:1328–1359](../../backend/app/api/routes.py#L1328-L1359), [routes.py:1412–1423](../../backend/app/api/routes.py#L1412-L1423) **Fundstelle:** [routes.py:1328–1359](../../backend/app/api/routes.py#L1328-L1359), [routes.py:1412–1423](../../backend/app/api/routes.py#L1412-L1423)
+1 -1
View File
@@ -52,7 +52,7 @@ Nichts davon verlangt einen Umbau. Die meisten Punkte lassen sich gezielt im Bes
| R-02 | Hoch | `DELETE /bindings/{id}` prüft die Zugehörigkeit der Einbindung zum Handlungskontext nicht | | R-02 | Hoch | `DELETE /bindings/{id}` prüft die Zugehörigkeit der Einbindung zum Handlungskontext nicht |
| R-03 | Hoch | E-Mail-Anlagen und Paperless-Bilder (auch SVG) werden `inline` aus dem App-Origin ausgeliefert | | R-03 | Hoch | E-Mail-Anlagen und Paperless-Bilder (auch SVG) werden `inline` aus dem App-Origin ausgeliefert |
| R-04 | Hoch | Betreiberkonto über eine öffentliche Web-Route, ohne MFA (Abweichung von ADR-05 und Auth-Blueprint 11.3) | | R-04 | Hoch | Betreiberkonto über eine öffentliche Web-Route, ohne MFA (Abweichung von ADR-05 und Auth-Blueprint 11.3) |
| R-11 | Hoch | Offene Aufgaben, Fristen und Suche: `LIMIT` vor der Rechteprüfung. Sichtbare Treffer fallen weg | | R-11 | Hoch | **Behoben am 23.10.2026.** Offene Aufgaben, Fristen und Suche lesen in Blöcken und prüfen die Rechte vor der Begrenzung (Vorfilterung im SQL bleibt eine spätere Optimierung) |
| R-08 | Hoch | Sessions 14 Tage ohne Leerlaufablauf und Rotation, Login-Begrenzung nur im Prozessspeicher, kein Passwortwechsel | | R-08 | Hoch | Sessions 14 Tage ohne Leerlaufablauf und Rotation, Login-Begrenzung nur im Prozessspeicher, kein Passwortwechsel |
| R-31 | Hoch | Hochgeladene Fotos behalten EXIF- und GPS-Metadaten, es gibt keine Normalisierung | | R-31 | Hoch | Hochgeladene Fotos behalten EXIF- und GPS-Metadaten, es gibt keine Normalisierung |
+17 -10
View File
@@ -5,15 +5,17 @@ import { SessionContext } from "./session.js";
import { Login } from "./pages/Login.jsx"; import { Login } from "./pages/Login.jsx";
import { Shell } from "./pages/Shell.jsx"; import { Shell } from "./pages/Shell.jsx";
import { Overview } from "./pages/Overview.jsx"; import { Overview } from "./pages/Overview.jsx";
import { CaseList, CaseDetail } from "./pages/Cases.jsx"; import { CaseDetail } from "./pages/Cases.jsx";
import { MatterList, MatterDetail } from "./pages/Matters.jsx"; import { MatterDetail } from "./pages/Matters.jsx";
import { Rooms } from "./pages/Rooms.jsx"; import { LibraryLayout } from "./library/LibraryLayout.jsx";
import { EntryPage, RoomPage, RoomsPage } from "./library/Pages.jsx";
import { Search } from "./pages/Search.jsx"; import { Search } from "./pages/Search.jsx";
import { Sources } from "./pages/Sources.jsx"; import { Sources } from "./pages/Sources.jsx";
import { ConnectorConfig } from "./sources/connector-config.jsx"; import { ConnectorConfig } from "./sources/connector-config.jsx";
import { Account, ForcedPasswordChange } from "./admin/Account.jsx"; import { Account, ForcedPasswordChange } from "./admin/Account.jsx";
import { AdminEvents, AdminRooms } from "./admin/Admin.jsx"; import { AdminEvents } from "./admin/Admin.jsx";
import { InviteAccept } from "./admin/InviteAccept.jsx"; import { InviteAccept } from "./admin/InviteAccept.jsx";
import { AdminTeam, Team } from "./admin/Team.jsx";
import { UserDetail, Users } from "./admin/Users.jsx"; import { UserDetail, Users } from "./admin/Users.jsx";
import { Work } from "./pages/Work.jsx"; import { Work } from "./pages/Work.jsx";
import { Settings } from "./pages/Settings.jsx"; import { Settings } from "./pages/Settings.jsx";
@@ -129,21 +131,26 @@ export function App() {
<Route path="/invite/:id" element={<InviteAccept />} /> <Route path="/invite/:id" element={<InviteAccept />} />
<Route element={session ? <Shell /> : <Navigate to="/login" replace />}> <Route element={session ? <Shell /> : <Navigate to="/login" replace />}>
<Route index element={<Overview />} /> <Route index element={<Overview />} />
<Route path="cases" element={<CaseList />} /> <Route element={<LibraryLayout />}>
<Route path="cases/:id" element={<CaseDetail />} /> <Route path="cases" element={<EntryPage kind="case" />} />
<Route path="matters" element={<MatterList />} /> <Route path="matters" element={<EntryPage kind="matter" />} />
<Route path="matters/:id" element={<MatterDetail />} /> <Route path="rooms" element={<RoomsPage />} />
<Route path="rooms/:id" element={<RoomPage />} />
<Route path="cases/:id" element={<CaseDetail />} />
<Route path="matters/:id" element={<MatterDetail />} />
</Route>
<Route path="matters/:id/items/:bindingId" element={<Reader />} /> <Route path="matters/:id/items/:bindingId" element={<Reader />} />
<Route path="cases/:id/items/:bindingId" element={<Reader />} /> <Route path="cases/:id/items/:bindingId" element={<Reader />} />
<Route path="work" element={<Work />} /> <Route path="work" element={<Work />} />
<Route path="settings" element={<Settings />} /> <Route path="settings" element={<Settings />} />
<Route path="rooms" element={<Rooms />} />
<Route path="sources" element={<Sources />} /> <Route path="sources" element={<Sources />} />
<Route path="sources/:connectorId" element={<ConnectorConfig />} /> <Route path="sources/:connectorId" element={<ConnectorConfig />} />
<Route path="users" element={<Users />} /> <Route path="users" element={<Users />} />
<Route path="users/:id" element={<UserDetail />} /> <Route path="users/:id" element={<UserDetail />} />
<Route path="account" element={<Account />} /> <Route path="account" element={<Account />} />
<Route path="admin/rooms" element={<AdminRooms />} /> <Route path="team" element={<Team />} />
<Route path="admin/team" element={<AdminTeam />} />
<Route path="admin/rooms" element={<Navigate to="/rooms" replace />} />
<Route path="admin/events" element={<AdminEvents />} /> <Route path="admin/events" element={<AdminEvents />} />
<Route path="search" element={<Search />} /> <Route path="search" element={<Search />} />
</Route> </Route>
+48 -1
View File
@@ -3,10 +3,38 @@ import { api } from "../api.js";
import { SessionContext } from "../session.js"; import { SessionContext } from "../session.js";
import { ErrorNote } from "../pages/widgets.jsx"; import { ErrorNote } from "../pages/widgets.jsx";
import { formatWhen } from "./admin-core.js"; import { formatWhen } from "./admin-core.js";
import { DownloadPolicy } from "./DownloadPolicy.jsx";
import { DuplicatePreference } from "./DuplicatePreference.jsx";
import { deviceClass, readImageChoice, writeImageChoice } from "../mail-images.js";
import { isEmployee } from "./admin-core.js";
import { PasswordForm } from "./widgets.jsx"; import { PasswordForm } from "./widgets.jsx";
function MailImages() {
const [choice, setChoice] = useState(() => ({ desktop: readImageChoice("desktop"), touch: readImageChoice("touch") }));
const here = deviceClass();
const rows = [["desktop", "Am Computer"], ["touch", "Auf Handy und Tablet"]];
return (
<section className="card stack" aria-label="Bilder in E-Mails">
<h2>Bilder in E-Mails</h2>
<p className="muted">
Bilder liegen beim Absender. Beim Nachladen holt unser Server sie für dich (nur öffentliche https-Adressen, nur echte Bilddateien), dein Gerät nimmt keinen Kontakt auf.
Der Absender kann trotzdem erkennen, dass die Nachricht geöffnet wurde. Die Wahl gilt nur für diesen Browser; dieses Gerät zählt als „{here === "touch" ? "Handy und Tablet" : "Computer"}“.
</p>
{rows.map(([key, label]) => (
<label key={key}>
{label}
<select value={choice[key]} onChange={(event) => setChoice((current) => ({ ...current, [key]: writeImageChoice(key, event.target.value) }))}>
<option value="ask">Nur auf Klick nachladen</option>
<option value="auto">Automatisch nachladen</option>
</select>
</label>
))}
</section>
);
}
export function Account() { export function Account() {
const { session } = useContext(SessionContext); const { session, logout } = useContext(SessionContext);
const [sessions, setSessions] = useState([]); const [sessions, setSessions] = useState([]);
const [notice, setNotice] = useState(""); const [notice, setNotice] = useState("");
const [error, setError] = useState(""); const [error, setError] = useState("");
@@ -54,11 +82,30 @@ export function Account() {
</header> </header>
<ErrorNote error={error} /> <ErrorNote error={error} />
{notice ? <p className="notice" role="status">{notice}</p> : null} {notice ? <p className="notice" role="status">{notice}</p> : null}
<MailImages />
<DuplicatePreference />
{isEmployee(session) ? null : (
<section className="card stack" aria-label="Herunterladen">
<h2>Herunterladen von Originalen</h2>
<DownloadPolicy
path="/api/v1/auth/download-defaults"
editable
withDirect
intro="Diese Regel übernehmen neue Räume. Bestehende Räume ändert ihr Eigentümer in der Raumverwaltung. Die Regel für direkt freigegebene Personen gilt sofort für alle deine Einträge."
/>
</section>
)}
<section className="card stack" aria-label="Passwort"> <section className="card stack" aria-label="Passwort">
<h2>Passwort ändern</h2> <h2>Passwort ändern</h2>
<p className="muted">Beim Ändern werden deine anderen Sitzungen beendet.</p> <p className="muted">Beim Ändern werden deine anderen Sitzungen beendet.</p>
<PasswordForm onDone={async () => { setNotice("Das Passwort ist geändert."); await load(); }} /> <PasswordForm onDone={async () => { setNotice("Das Passwort ist geändert."); await load(); }} />
</section> </section>
<section className="card stack" aria-label="Abmelden">
<h2>Abmelden</h2>
<div className="row">
<button type="button" className="quiet" onClick={logout}>Von diesem Gerät abmelden</button>
</div>
</section>
<section className="card stack" aria-label="Sitzungen"> <section className="card stack" aria-label="Sitzungen">
<h2>Angemeldete Geräte</h2> <h2>Angemeldete Geräte</h2>
<ul className="index"> <ul className="index">
+33 -23
View File
@@ -4,12 +4,12 @@ import { api } from "../api.js";
import { ErrorNote } from "../pages/widgets.jsx"; import { ErrorNote } from "../pages/widgets.jsx";
import { formatWhen } from "./admin-core.js"; import { formatWhen } from "./admin-core.js";
// Operator overview of shared rooms. It shows names and managers, never content. // Operator overview of shared rooms: names, state and managers, never content.
export function AdminRooms() { export function AdminRoomsPanel() {
const [items, setItems] = useState([]); const [items, setItems] = useState([]);
const [error, setError] = useState(""); const [error, setError] = useState("");
const [notice, setNotice] = useState(""); const [notice, setNotice] = useState("");
const [assign, setAssign] = useState({ room: "", email: "" }); const [assign, setAssign] = useState({ room: "", email: "", kind: "managers" });
function load() { function load() {
return api("/api/v1/admin/rooms") return api("/api/v1/admin/rooms")
@@ -26,9 +26,9 @@ export function AdminRooms() {
setError(""); setError("");
setNotice(""); setNotice("");
try { try {
await api(`/api/v1/admin/rooms/${assign.room}/managers`, { method: "POST", body: { email: assign.email } }); await api(`/api/v1/admin/rooms/${assign.room}/${assign.kind}`, { method: "POST", body: { email: assign.email } });
setNotice("Der Verwalter ist eingesetzt."); setNotice(assign.kind === "owner" ? "Der Eigentümer ist eingesetzt." : "Der Verwalter ist eingesetzt.");
setAssign({ room: "", email: "" }); setAssign({ room: "", email: "", kind: "managers" });
await load(); await load();
} catch (err) { } catch (err) {
setError(err.message); setError(err.message);
@@ -36,14 +36,12 @@ export function AdminRooms() {
} }
return ( return (
<main className="page"> <section className="card stack" aria-label="Alle Datenräume (Betreiber)">
<header className="page-head"> <h2>Alle Datenräume (Betreiber)</h2>
<div> <p className="muted">
<p className="muted"><Link to="/settings">Verwaltung</Link></p> Der Betreiber sieht Namen, Zustand, Eigentümer und Verwalter, aber keine Inhalte. Einen Eigentümer setzt er nur ein, wenn der bisherige nicht mehr
<h1>Datenräume aller Konten</h1> handeln kann. Sonst überträgt ihn der Eigentümer selbst.
<p className="muted">Der Betreiber sieht Namen, Zustand und Verwalter, aber keine Inhalte.</p> </p>
</div>
</header>
<ErrorNote error={error} /> <ErrorNote error={error} />
{notice ? <p className="notice" role="status">{notice}</p> : null} {notice ? <p className="notice" role="status">{notice}</p> : null}
<ul className="index"> <ul className="index">
@@ -52,30 +50,42 @@ export function AdminRooms() {
<strong>{room.name}</strong> <strong>{room.name}</strong>
<span> <span>
{room.status === "archived" ? "Archiviert · " : ""} {room.status === "archived" ? "Archiviert · " : ""}
{room.members} Mitglied(er) · {room.has_manager ? `Verwalter: ${room.managers.join(", ")}` : "Kein aktiver Verwalter"} {room.members} Mitglied(er) · Eigentümer: {room.owner || "unbekannt"}{room.owner_active ? "" : " (nicht mehr aktiv)"} ·{" "}
{room.has_manager ? `Verwalter: ${room.managers.join(", ")}` : "Kein aktiver Verwalter"}
</span> </span>
{room.has_manager ? null : ( {!room.has_manager ? (
<button type="button" className="quiet" onClick={() => setAssign({ room: room.id, email: "" })}>Verwalter einsetzen</button> <button type="button" className="quiet" onClick={() => setAssign({ room: room.id, email: "", kind: "managers" })}>
)} Verwalter einsetzen
</button>
) : !room.owner_active ? (
<button type="button" className="quiet" onClick={() => setAssign({ room: room.id, email: "", kind: "owner" })}>
Eigentümer einsetzen
</button>
) : null}
</li> </li>
))} ))}
</ul> </ul>
{!items.length ? <p className="muted">Es gibt noch keinen gemeinsamen Datenraum.</p> : null} {!items.length ? <p className="muted">Es gibt noch keinen gemeinsamen Datenraum.</p> : null}
{assign.room ? ( {assign.room ? (
<form onSubmit={submit} className="card stack" aria-label="Verwalter einsetzen"> <form onSubmit={submit} className="stack" aria-label="Eigentümer oder Verwalter einsetzen">
<h2>Verwalter einsetzen</h2> <h3>{assign.kind === "owner" ? "Eigentümer einsetzen" : "Verwalter einsetzen"}</h3>
<p className="muted">Nur für Räume ohne aktiven Verwalter. Die Aktion wird protokolliert.</p> <p className="muted">
{assign.kind === "owner"
? "Nur möglich, wenn der bisherige Eigentümer nicht mehr handeln kann (Konto deaktiviert oder nicht mehr Mitglied)."
: "Nur für Räume ohne aktiven Verwalter."}{" "}
Die Aktion wird protokolliert.
</p>
<label> <label>
E-Mail eines aktiven Kontos E-Mail eines aktiven Kontos
<input type="email" value={assign.email} onChange={(event) => setAssign({ ...assign, email: event.target.value })} required /> <input type="email" value={assign.email} onChange={(event) => setAssign({ ...assign, email: event.target.value })} required />
</label> </label>
<div className="row"> <div className="row">
<button type="submit">Einsetzen</button> <button type="submit">Einsetzen</button>
<button type="button" className="quiet" onClick={() => setAssign({ room: "", email: "" })}>Abbrechen</button> <button type="button" className="quiet" onClick={() => setAssign({ room: "", email: "", kind: "managers" })}>Abbrechen</button>
</div> </div>
</form> </form>
) : null} ) : null}
</main> </section>
); );
} }
+62
View File
@@ -0,0 +1,62 @@
import { useEffect, useState } from "react";
import { api } from "../api.js";
import { ErrorNote } from "../pages/widgets.jsx";
const ROLES = [
["manager", "Verwalter"],
["member", "Mitglieder"],
["reader", "Leser"],
];
// Who may save a document or mail to their device. Reading in Tsumugu stays possible for everyone.
// The rule applies to saving and opening the original, not to what the screen shows.
export function DownloadPolicy({ path, editable, withDirect = false, intro }) {
const [roles, setRoles] = useState(null);
const [canChange, setCanChange] = useState(editable);
const [error, setError] = useState("");
const [notice, setNotice] = useState("");
useEffect(() => {
let alive = true;
api(path).then((data) => {
if (!alive) return;
setRoles(data.roles);
if (data.can_change !== undefined) setCanChange(data.can_change);
}).catch((err) => alive && setError(err.message));
return () => {
alive = false;
};
}, [path]);
async function change(key, value) {
setError("");
setNotice("");
const next = { ...roles, [key]: value };
try {
const saved = await api(path, { method: "PUT", body: next });
setRoles(saved.roles);
setNotice("Die Regel ist gespeichert.");
} catch (err) {
setError(err.message);
}
}
if (!roles) return error ? <ErrorNote error={error} /> : null;
const items = withDirect ? [...ROLES, ["direct", "Direkt freigegebene Personen"]] : ROLES;
return (
<fieldset className="pick-group">
<legend>Herunterladen erlaubt für</legend>
{intro ? <p className="muted">{intro}</p> : null}
{items.map(([key, label]) => (
<label key={key} className="check">
<input type="checkbox" checked={Boolean(roles[key])} disabled={!canChange} onChange={(event) => change(key, event.target.checked)} />
{label}
</label>
))}
<span className="muted">Lesen in Tsumugu bleibt für alle Rollen möglich. Die Regel betrifft das Speichern und Öffnen der Originale sowie das Übergabepaket. Was auf dem Bildschirm erscheint, lässt sich damit nicht gegen Abfotografieren schützen.</span>
{canChange ? null : <span className="muted">Nur der Eigentümer kann die Regel ändern.</span>}
<ErrorNote error={error} />
{notice ? <p className="notice" role="status">{notice}</p> : null}
</fieldset>
);
}
@@ -0,0 +1,77 @@
import { useEffect, useState } from "react";
import { api } from "../api.js";
import { ErrorNote } from "../pages/widgets.jsx";
const PATH = "/api/v1/auth/preferences/duplicate_check";
export const DUPLICATE_LEVELS = {
off: "Keine Prüfung",
here: "Nur hier (direkt in diesem Vorgang oder dieser Akte)",
inside: "Hier und was darin angezeigt wird (Teilvorgänge, zugeordnete Vorgänge)",
around: "Zusätzlich dort, wo es liegt (übergeordneter Vorgang, zugeordnete Akten)",
};
// Where a document that is inserted again counts as already present. Only a warning, never a block.
// An employee inherits the value of the main user and may change it unless the main user made it binding.
export function DuplicatePreference() {
const [state, setState] = useState(null);
const [error, setError] = useState("");
const [notice, setNotice] = useState("");
useEffect(() => {
let alive = true;
api(PATH).then((data) => alive && setState(data)).catch((err) => alive && setError(err.message));
return () => {
alive = false;
};
}, []);
async function save(body) {
setError("");
setNotice("");
try {
setState(await api(PATH, { method: "PUT", body }));
setNotice("Die Einstellung ist gespeichert.");
} catch (err) {
setError(err.message);
}
}
if (!state) return error ? <ErrorNote error={error} /> : null;
const ownChoice = state.can_lock ? state.own || state.default : state.own || "";
return (
<section className="card stack" aria-label="Doppelte Dokumente">
<h2>Doppelte Dokumente</h2>
<p className="muted">
Beim Einfügen eines Dokuments aus einer Quelle warnt Tsumugu, wenn es an der gewählten Stelle schon vorhanden ist. Du kannst es trotzdem
einfügen oder das vorhandene Element zusätzlich einbinden. Dasselbe Dokument in verschiedenen Vorgängen bleibt immer erlaubt.
</p>
<label>
Prüfen in
<select
value={ownChoice}
disabled={state.locked}
onChange={(event) => save({ value: event.target.value || null })}
>
{state.can_lock ? null : <option value="">Wie beim Hauptnutzer ({DUPLICATE_LEVELS[state.inherited]})</option>}
{state.allowed.map((level) => (
<option key={level} value={level}>{DUPLICATE_LEVELS[level]}</option>
))}
</select>
</label>
{state.locked ? <p className="muted">Der Hauptnutzer hat diese Einstellung für das Team vorgegeben: {DUPLICATE_LEVELS[state.value]}.</p> : null}
{state.can_lock ? (
<label className="check">
<input
type="checkbox"
checked={state.team_mode === "locked"}
onChange={(event) => save({ value: state.own, team_mode: event.target.checked ? "locked" : "free" })}
/>
Für Mitarbeiter verbindlich
</label>
) : null}
<ErrorNote error={error} />
{notice ? <p className="notice" role="status">{notice}</p> : null}
</section>
);
}
+172
View File
@@ -0,0 +1,172 @@
import { useEffect, useState } from "react";
import { Link } from "react-router-dom";
import { api, fetchBlob } from "../api.js";
import { ErrorNote } from "../pages/widgets.jsx";
import { accountKindLabel, formatWhen, personRoomsText } from "./admin-core.js";
import { OneTimeSecret } from "./widgets.jsx";
// "Mein Team": the people in the rooms of a main user. He manages the employees he invited.
export function Team() {
const [items, setItems] = useState(null);
const [error, setError] = useState("");
const [notice, setNotice] = useState("");
const [issued, setIssued] = useState(null);
const [confirm, setConfirm] = useState("");
async function load() {
const data = await api("/api/v1/team");
setItems(data.items);
}
useEffect(() => {
load().catch((err) => setError(err.message));
}, []);
async function run(action, message = "") {
setError("");
setNotice("");
setConfirm("");
try {
await action();
if (message) setNotice(message);
await load();
} catch (err) {
setError(err.message);
}
}
return (
<main className="page">
<header className="page-head">
<div>
<h1>Mein Team</h1>
<p className="muted">
Alle Personen in deinen Datenräumen. Rollen je Raum ändern und neue Mitarbeiter einladen kannst du unter{" "}
<Link to="/rooms">Datenräume</Link>. Mitarbeiter, die du eingeladen hast, verwaltest du hier.
</p>
</div>
</header>
<ErrorNote error={error} />
{notice ? <p className="notice" role="status">{notice}</p> : null}
{issued ? (
<OneTimeSecret
title={`Einmal-Passwort für ${issued.name}`}
value={issued.password}
hint="Alle Sitzungen der Person sind beendet. Beim nächsten Anmelden legt sie ein eigenes Passwort fest. Der Wert wird nicht wieder angezeigt."
onDone={() => setIssued(null)}
/>
) : null}
{items === null ? <p className="muted">Wird geladen …</p> : null}
{items && !items.length ? <p className="muted">In deinen Datenräumen sind noch keine weiteren Personen.</p> : null}
<ul className="index">
{(items || []).map((person) => (
<li key={person.id}>
<strong>{person.display_name}</strong>
<span>
{accountKindLabel(person.account_kind)}{person.status === "disabled" ? " · deaktiviert" : ""} · {person.email} · zuletzt angemeldet {formatWhen(person.last_login_at)}
</span>
<span>{person.rooms.length ? personRoomsText(person.rooms) : "Aktuell in keinem deiner Räume."}</span>
{person.mine ? (
<span className="row">
{person.status === "disabled" ? (
<button type="button" className="quiet" onClick={() => run(() => api(`/api/v1/team/${person.id}`, { method: "PATCH", body: { status: "active" } }), "Das Konto ist wieder aktiv.")}>
Aktivieren
</button>
) : (
<button type="button" className="quiet" onClick={() => run(() => api(`/api/v1/team/${person.id}`, { method: "PATCH", body: { status: "disabled" } }), "Das Konto ist deaktiviert.")}>
Deaktivieren
</button>
)}
<button
type="button"
className="quiet"
disabled={person.status === "disabled"}
onClick={() => run(async () => {
const result = await api(`/api/v1/team/${person.id}/password-reset`, { method: "POST" });
setIssued({ name: person.display_name, password: result.temporary_password });
})}
>
Passwort zurücksetzen
</button>
</span>
) : null}
{person.rooms.length ? (
confirm === person.id ? (
<span className="row">
<button type="button" className="danger" onClick={() => run(() => api(`/api/v1/team/${person.id}/memberships`, { method: "DELETE" }), "Die Person ist aus deinen Räumen entfernt.")}>
Wirklich aus allen meinen Räumen entfernen
</button>
<button type="button" className="quiet" onClick={() => setConfirm("")}>Abbrechen</button>
</span>
) : (
<button type="button" className="quiet" onClick={() => setConfirm(person.id)}>Aus allen meinen Räumen entfernen</button>
)
) : null}
</li>
))}
</ul>
</main>
);
}
// Operator overview of all teams: main users, their employees, rooms and roles. No content.
export function AdminTeam() {
const [items, setItems] = useState(null);
const [error, setError] = useState("");
useEffect(() => {
api("/api/v1/admin/team")
.then((data) => setItems(data.items))
.catch((err) => setError(err.message));
}, []);
async function download() {
setError("");
try {
const blob = await fetchBlob("/api/v1/admin/team?format=csv");
const url = URL.createObjectURL(blob);
const link = document.createElement("a");
link.href = url;
link.download = "team-uebersicht.csv";
link.click();
URL.revokeObjectURL(url);
} catch (err) {
setError(err.message);
}
}
return (
<main className="page">
<header className="page-head">
<div>
<p className="muted"><Link to="/settings">Verwaltung</Link></p>
<h1>Team-Übersicht</h1>
<p className="muted">Hauptnutzer mit ihren Mitarbeitern, Räumen und Rollen. Der Betreiber sieht Konten und Rollen, keine Inhalte.</p>
</div>
<button type="button" className="quiet" onClick={download}>Als CSV laden</button>
</header>
<ErrorNote error={error} />
{items === null ? <p className="muted">Wird geladen …</p> : null}
{items && !items.length ? <p className="muted">Noch keine Mitarbeiter-Konten.</p> : null}
{(items || []).map((owner) => (
<section key={owner.id} className="card stack" aria-label={`Team von ${owner.display_name}`}>
<h2>{owner.display_name}</h2>
<p className="muted">{owner.email}{owner.status === "disabled" ? " · deaktiviert" : ""}</p>
{owner.employees.length ? (
<ul className="index">
{owner.employees.map((employee) => (
<li key={employee.id}>
<Link to={`/users/${employee.id}`}><strong>{employee.display_name}</strong></Link>
<span>{employee.email}{employee.status === "disabled" ? " · deaktiviert" : ""} · zuletzt angemeldet {formatWhen(employee.last_login_at)}</span>
<span>{employee.rooms.length ? personRoomsText(employee.rooms) : "In keinem Raum."}</span>
</li>
))}
</ul>
) : (
<p className="muted">Keine Mitarbeiter.</p>
)}
</section>
))}
</main>
);
}
+30 -5
View File
@@ -4,7 +4,7 @@ import { api, markDirty } from "../api.js";
import { Modal } from "../pages/Modal.jsx"; import { Modal } from "../pages/Modal.jsx";
import { ErrorNote } from "../pages/widgets.jsx"; import { ErrorNote } from "../pages/widgets.jsx";
import { SessionContext } from "../session.js"; import { SessionContext } from "../session.js";
import { accountRole, accountState, formatWhen, roleLabel } from "./admin-core.js"; import { accountKindLabel, accountRole, accountState, formatWhen, roleLabel } from "./admin-core.js";
import { OneTimeSecret } from "./widgets.jsx"; import { OneTimeSecret } from "./widgets.jsx";
export function Users() { export function Users() {
@@ -63,9 +63,9 @@ export function Users() {
<header className="page-head"> <header className="page-head">
<div> <div>
<h1>Nutzer</h1> <h1>Nutzer</h1>
<p className="muted">Neue Konten legt der Betreiber an. Jedes Konto erhält einen eigenen persönlichen Datenraum.</p> <p className="muted">Der Betreiber legt Hauptnutzer an und verwaltet sie. Mitarbeiter lädt der Hauptnutzer in seinen Datenräumen ein.</p>
</div> </div>
<button type="button" onClick={() => { setError(""); setIssued(null); setOpen(true); }}>Nutzer anlegen</button> <button type="button" onClick={() => { setError(""); setIssued(null); setOpen(true); }}>Hauptnutzer anlegen</button>
</header> </header>
<ErrorNote error={open ? "" : error} /> <ErrorNote error={open ? "" : error} />
{issued ? ( {issued ? (
@@ -89,9 +89,10 @@ export function Users() {
const state = accountState(account); const state = accountState(account);
return ( return (
<Link key={account.id} to={`/users/${account.id}`} className="tile"> <Link key={account.id} to={`/users/${account.id}`} className="tile">
<span className="tile__kind">{accountRole(account)} · {state.label}</span> <span className="tile__kind">{accountRole(account)} · {accountKindLabel(account.account_kind)} · {state.label}</span>
<strong>{account.display_name}</strong> <strong>{account.display_name}</strong>
<span>{account.email}</span> <span>{account.email}</span>
{account.sponsor_name ? <span>Mitarbeiter von {account.sponsor_name}</span> : null}
<span>Letzte Anmeldung: {formatWhen(account.last_login_at)}</span> <span>Letzte Anmeldung: {formatWhen(account.last_login_at)}</span>
</Link> </Link>
); );
@@ -176,7 +177,7 @@ export function UserDetail() {
<div> <div>
<p className="muted"><Link to="/users">Nutzer</Link></p> <p className="muted"><Link to="/users">Nutzer</Link></p>
<h1>{account?.display_name || "Konto"}</h1> <h1>{account?.display_name || "Konto"}</h1>
{account ? <p className="muted">{account.email} · {accountRole(account)} · {accountState(account).label}</p> : null} {account ? <p className="muted">{account.email} · {accountKindLabel(account.account_kind)} · {accountState(account).label}{account.sponsor_name ? ` · Mitarbeiter von ${account.sponsor_name}` : ""}</p> : null}
</div> </div>
</header> </header>
<ErrorNote error={error} /> <ErrorNote error={error} />
@@ -206,6 +207,30 @@ export function UserDetail() {
<p className="muted">Letzte Anmeldung: {formatWhen(account.last_login_at)} · Aktive Sitzungen: {account.active_sessions}</p> <p className="muted">Letzte Anmeldung: {formatWhen(account.last_login_at)} · Aktive Sitzungen: {account.active_sessions}</p>
</section> </section>
{account.account_kind === "employee" ? (
<section className="card stack" aria-label="Kontoart">
<h2>Mitarbeiter-Konto</h2>
<p className="muted">Dieses Konto arbeitet nur in Räumen, in die {account.sponsor_name || "ein Hauptnutzer"} es eingeladen hat. Vollwertig wird es nur durch den Betreiber.</p>
<div className="row">
<button type="button" className="quiet" onClick={() => run(() => patch({ account_kind: "main" }), "Das Konto ist jetzt ein Hauptnutzer. Die Person meldet sich neu an.")}>
Zum Hauptnutzer machen
</button>
</div>
</section>
) : account.employees?.length ? (
<section className="card stack" aria-label="Mitarbeiter">
<h2>Mitarbeiter</h2>
<ul className="index">
{account.employees.map((employee) => (
<li key={employee.id}>
<Link to={`/users/${employee.id}`}><strong>{employee.display_name}</strong></Link>
<span>{employee.email}{employee.status === "disabled" ? " · deaktiviert" : ""}</span>
</li>
))}
</ul>
</section>
) : null}
<section className="card stack" aria-label="Betreiberrolle"> <section className="card stack" aria-label="Betreiberrolle">
<h2>Betreiberrolle</h2> <h2>Betreiberrolle</h2>
<p className="muted">Betreiber verwalten Konten und Räume. Sie erhalten dadurch keinen Zugriff auf Akten anderer.</p> <p className="muted">Betreiber verwalten Konten und Räume. Sie erhalten dadurch keinen Zugriff auf Akten anderer.</p>
+40
View File
@@ -75,3 +75,43 @@ export function exposureSummary(exposure) {
const matters = exposure?.matters?.room || 0; const matters = exposure?.matters?.room || 0;
return { cases, matters, total: cases + matters }; return { cases, matters, total: cases + matters };
} }
// Dragging a case or matter onto a room shares it with that room.
export const SHARE_DRAG_TYPE = "application/x-tsumugu-share";
export function parseShareDrag(text, kind) {
try {
const value = JSON.parse(text || "");
if (value && value.kind === kind && typeof value.id === "string" && value.id) return value;
} catch {
/* A foreign drag carries no usable payload. */
}
return null;
}
// Rooms an entry can be shared with: organization rooms where the person may write.
export function shareTargets(rooms) {
return (rooms || []).filter((room) => room.kind === "organization" && (room.role === "member" || room.role === "manager"));
}
// Main user (full account) or employee (works in the rooms he was invited to).
export function accountKindLabel(kind) {
return kind === "employee" ? "Mitarbeiter" : "Hauptnutzer";
}
export function isEmployee(session) {
return session?.account?.account_kind === "employee";
}
// Rooms where the person may create entries. An employee has no personal workspace.
export function writableRooms(session) {
return (session?.rooms || []).filter((room) => {
if (room.kind === "personal") return !isEmployee(session);
return room.role === "member" || room.role === "manager";
});
}
export function personRoomsText(rooms) {
if (!rooms?.length) return "in keinem deiner Räume";
return rooms.map((room) => `${room.name} (${roleLabel(room.role)})`).join(", ");
}
+47
View File
@@ -1,7 +1,12 @@
import assert from "node:assert/strict"; import assert from "node:assert/strict";
import test from "node:test"; import test from "node:test";
import { import {
accountKindLabel,
accountState, accountState,
personRoomsText,
writableRooms,
parseShareDrag,
shareTargets,
exposureSummary, exposureSummary,
isPrivateRoom, isPrivateRoom,
roomRightsText, roomRightsText,
@@ -75,3 +80,45 @@ test("the exposure summary counts only what is shared with the room", () => {
}); });
assert.equal(exposureSummary(null).total, 0); assert.equal(exposureSummary(null).total, 0);
}); });
test("a drag payload is accepted only for the matching kind", () => {
const text = JSON.stringify({ kind: "case", id: "abc", title: "Akte" });
assert.equal(parseShareDrag(text, "case").id, "abc");
assert.equal(parseShareDrag(text, "matter"), null);
assert.equal(parseShareDrag("kein json", "case"), null);
assert.equal(parseShareDrag("", "case"), null);
assert.equal(parseShareDrag(JSON.stringify({ kind: "case", id: "" }), "case"), null);
});
test("only rooms where the person writes are drop targets", () => {
const rooms = [
{ id: "p", kind: "personal", role: "owner" },
{ id: "a", kind: "organization", role: "manager" },
{ id: "b", kind: "organization", role: "member" },
{ id: "c", kind: "organization", role: "reader" },
];
assert.deepEqual(shareTargets(rooms).map((room) => room.id), ["a", "b"]);
assert.deepEqual(shareTargets(undefined), []);
});
test("account kinds have German labels", () => {
assert.equal(accountKindLabel("employee"), "Mitarbeiter");
assert.equal(accountKindLabel("main"), "Hauptnutzer");
assert.equal(accountKindLabel(undefined), "Hauptnutzer");
});
test("an employee has no personal workspace to create entries in", () => {
const rooms = [
{ id: "p", kind: "personal", role: "owner" },
{ id: "a", kind: "organization", role: "member" },
{ id: "b", kind: "organization", role: "reader" },
];
assert.deepEqual(writableRooms({ account: { account_kind: "main" }, rooms }).map((r) => r.id), ["p", "a"]);
assert.deepEqual(writableRooms({ account: { account_kind: "employee" }, rooms }).map((r) => r.id), ["a"]);
assert.deepEqual(writableRooms(null), []);
});
test("the rooms of a person are listed with their roles", () => {
assert.equal(personRoomsText([]), "in keinem deiner Räume");
assert.equal(personRoomsText([{ name: "Kanzlei", role: "reader" }, { name: "Büro", role: "member" }]), "Kanzlei (Leser), Büro (Mitglied)");
});
+34 -24
View File
@@ -92,18 +92,48 @@ export async function fetchMailPart(elementId, context, suffix) {
return response.blob(); return response.blob();
} }
export async function downloadMailPart(elementId, context, suffix, filename) { // The name the server gave the file (RFC 5987 form first), so a saved file keeps its real name.
const blob = await fetchMailPart(elementId, context, suffix); export function nameFromDisposition(header, fallback) {
const text = header || "";
const star = /filename\*\s*=\s*UTF-8''([^;]+)/i.exec(text);
if (star) {
try {
return decodeURIComponent(star[1].trim());
} catch {
/* fall through to the plain name */
}
}
const plain = /filename\s*=\s*"([^"]+)"/i.exec(text) || /filename\s*=\s*([^;]+)/i.exec(text);
return plain ? plain[1].trim() : fallback;
}
export function saveBlob(blob, filename) {
const url = URL.createObjectURL(blob); const url = URL.createObjectURL(blob);
const link = document.createElement("a"); const link = document.createElement("a");
link.href = url; link.href = url;
link.download = filename || "nachricht.eml"; link.download = filename;
document.body.appendChild(link); document.body.appendChild(link);
link.click(); link.click();
link.remove(); link.remove();
setTimeout(() => URL.revokeObjectURL(url), 60000); setTimeout(() => URL.revokeObjectURL(url), 60000);
} }
// Saves a document to the device. The server checks the download right of the role.
export async function saveDocument(path, context, fallbackName) {
const params = mailQuery(context);
params.set("save", "true");
const response = await fetch(`${path}?${params}`, { credentials: "include", headers: scopeHeaders() });
if (!response.ok) {
const data = await response.json().catch(() => null);
throw new Error(data?.detail || "Die Datei ist nicht verfügbar.");
}
saveBlob(await response.blob(), nameFromDisposition(response.headers.get("Content-Disposition"), fallbackName));
}
export async function downloadMailPart(elementId, context, suffix, filename) {
await saveDocument(`/api/v1/external-refs/${elementId}/mail/${suffix}`, context, filename || "nachricht.eml");
}
export async function fetchExternal(elementId, context) { export async function fetchExternal(elementId, context) {
const params = new URLSearchParams(); const params = new URLSearchParams();
if (context?.kind && context?.id) { if (context?.kind && context?.id) {
@@ -140,27 +170,7 @@ export async function fetchFile(elementId, context) {
} }
export async function downloadFile(elementId, context, filename) { export async function downloadFile(elementId, context, filename) {
const params = new URLSearchParams(); await saveDocument(`/api/v1/files/${elementId}/content`, context, filename || "datei");
if (context?.kind && context?.id) {
params.set("context_kind", context.kind);
params.set("context_id", context.id);
}
const response = await fetch(`/api/v1/files/${elementId}/content?${params}`, {
credentials: "include",
headers: scopeHeaders(),
});
if (!response.ok) {
throw new Error("Die Datei ist nicht verfügbar.");
}
const blob = await response.blob();
const url = URL.createObjectURL(blob);
const link = document.createElement("a");
link.href = url;
link.download = filename || "datei";
document.body.appendChild(link);
link.click();
link.remove();
URL.revokeObjectURL(url);
} }
export async function fetchBlob(path) { export async function fetchBlob(path) {
+110
View File
@@ -0,0 +1,110 @@
import { useEffect, useRef, useState } from "react";
import { Link } from "react-router-dom";
import { SHARE_DRAG_TYPE, parseShareDrag } from "../admin/admin-core.js";
import { KIND_LABELS, roomMarks, statusLabel, tileKind, tileLines } from "./library-core.js";
import { MiniIcon } from "./MiniIcon.jsx";
import { TileIcon } from "./TileIcon.jsx";
// A small popover that closes on outside click and Escape.
function Popover({ label, className = "", children, align = "left" }) {
const [open, setOpen] = useState(false);
const ref = useRef(null);
useEffect(() => {
if (!open) return undefined;
function close(event) {
if (!ref.current?.contains(event.target)) setOpen(false);
}
function key(event) {
if (event.key === "Escape") setOpen(false);
}
document.addEventListener("mousedown", close);
document.addEventListener("keydown", key);
return () => {
document.removeEventListener("mousedown", close);
document.removeEventListener("keydown", key);
};
}, [open]);
return (
<span className={`popover ${className}`} ref={ref}>
<button type="button" className="quiet popover__button" aria-haspopup="menu" aria-expanded={open} onClick={() => setOpen((value) => !value)}>
{label}
</button>
{open ? (
<div role="menu" className={`popover__panel popover__panel--${align}`} onClick={() => setOpen(false)}>
{children}
</div>
) : null}
</span>
);
}
// One entry as a tile: a folder for a case, a stack of documents for a matter, a team folder for a room.
// A case or matter can be dragged onto a room (tile or tree), put into a room from the menu,
// and shows the rooms it lies in as marks.
export function FolderTile({ kind, item, href, enterHref, rooms = [], onShare, onUnshare, onDropEntry }) {
const tk = tileKind(item, kind);
const [over, setOver] = useState(false);
const owned = (kind === "case" || kind === "matter") && item.is_owner;
const marks = owned ? roomMarks(item) : [];
const targets = owned ? rooms.filter((room) => !marks.some((mark) => mark.id === room.id)) : [];
const status = statusLabel(item);
function dragStart(event) {
event.dataTransfer.setData(SHARE_DRAG_TYPE, JSON.stringify({ kind, id: item.id, title: item.title }));
event.dataTransfer.effectAllowed = "link";
}
const dropProps = onDropEntry
? {
onDragOver: (event) => {
if (!Array.from(event.dataTransfer?.types || []).includes(SHARE_DRAG_TYPE)) return;
event.preventDefault();
event.dataTransfer.dropEffect = "link";
setOver(true);
},
onDragLeave: () => setOver(false),
onDrop: (event) => {
event.preventDefault();
setOver(false);
const payload = parseShareDrag(event.dataTransfer.getData(SHARE_DRAG_TYPE), "case") || parseShareDrag(event.dataTransfer.getData(SHARE_DRAG_TYPE), "matter");
if (payload) onDropEntry(payload);
},
}
: {};
return (
<article
className={`folder-tile folder-tile--${tk}${over ? " is-over" : ""}`}
draggable={owned ? true : undefined}
onDragStart={owned ? dragStart : undefined}
{...dropProps}
>
<Link className="folder-tile__main" to={href} title={owned ? "Öffnen. Zum Teilen auf einen Datenraum ziehen." : "Öffnen"}>
<span className="folder-tile__icon"><TileIcon kind={tk} /></span>
<span className="folder-tile__text">
<span className="folder-tile__kind">{KIND_LABELS[tk]}{status ? ` · ${status}` : ""}</span>
<strong className="folder-tile__title">{item.title}</strong>
{tileLines(item, kind).map((line) => <span key={line} className="folder-tile__meta">{line}</span>)}
</span>
</Link>
{marks.length || targets.length || enterHref ? (
<div className="folder-tile__foot">
{marks.map((mark) => (
<Popover key={mark.id} label={<><MiniIcon kind="room" /> {mark.name}{mark.readOnly ? " · lesen" : ""}</>} className="chip-popover">
<p className="popover__note">Diese {KIND_LABELS[tk]} liegt in „{mark.name}“. Das Original bleibt bei dir.</p>
<button type="button" role="menuitem" onClick={() => onUnshare?.(item, mark)}>Aus „{mark.name}“ nehmen</button>
</Popover>
))}
{targets.length ? (
<Popover label="In Raum legen" className="put-popover">
{targets.map((room) => (
<button key={room.id} type="button" role="menuitem" onClick={() => onShare?.(item, room)}>{room.name}</button>
))}
</Popover>
) : null}
{enterHref ? <Link className="quiet folder-tile__enter" to={enterHref}>Inhalt ›</Link> : null}
</div>
) : null}
</article>
);
}
+216
View File
@@ -0,0 +1,216 @@
import { createContext, useCallback, useContext, useEffect, useRef, useState } from "react";
import { Outlet, useLocation } from "react-router-dom";
import { api } from "../api.js";
import { isEmployee, shareTargets } from "../admin/admin-core.js";
import { ErrorNote } from "../pages/widgets.jsx";
import { SessionContext } from "../session.js";
import { clampTreeWidth, effectText, readTreeWidth, writeTreeWidth } from "./library-core.js";
import { NavTree } from "./NavTree.jsx";
export const LibraryContext = createContext(null);
export function useLibrary() {
return useContext(LibraryContext);
}
const PLURAL = { case: "cases", matter: "matters" };
const outlineKey = (kind, id, contextId = "") => `${kind}:${id}:${contextId || ""}`;
// A detail page tells the tree which entry is open and what can be done there.
// `actions` are read when a row is clicked, so they may close over the latest state.
export function useLibraryFocus(focus, actions) {
const library = useLibrary();
const signature = JSON.stringify(focus || null);
useEffect(() => {
library?.setFocus(focus || null);
return () => library?.setFocus(null);
}, [signature]);
if (library) library.actionsRef.current = actions || {};
}
// Frame of the library: one navigation tree on the left, the page on the right.
export function LibraryLayout() {
const { session } = useContext(SessionContext);
const employee = isEmployee(session);
const [data, setData] = useState({ cases: null, matters: null, rooms: null });
const [outlines, setOutlines] = useState(() => new Map());
const [focus, setFocus] = useState(null);
const [error, setError] = useState("");
const [message, setMessage] = useState("");
const [treeOpen, setTreeOpen] = useState(false);
const [treeWidth, setTreeWidth] = useState(readTreeWidth);
const timer = useRef(null);
const actionsRef = useRef({});
const pending = useRef(new Set());
const location = useLocation();
const reload = useCallback(async () => {
try {
const [cases, matters, rooms] = await Promise.all([
api("/api/v1/cases"),
api("/api/v1/matters"),
api("/api/v1/rooms/overview"),
]);
setData({ cases: cases.items, matters: matters.items, rooms: rooms.items });
} catch (err) {
setError(err.message);
}
}, []);
useEffect(() => {
reload();
setOutlines(new Map());
}, [reload, session.scope.id]);
// Outlines come on demand and stay in memory. `force` fetches again after a change.
const loadOutline = useCallback(async (kind, id, contextId = "", force = false) => {
const key = outlineKey(kind, id, contextId);
if (pending.current.has(key)) return;
if (!force && outlines.has(key)) return;
pending.current.add(key);
try {
const query = kind === "matter" && contextId ? `?context_kind=case&context_id=${contextId}` : "";
const outline = await api(`/api/v1/${PLURAL[kind]}/${id}/outline${query}`);
setOutlines((current) => new Map(current).set(key, outline));
} catch {
setOutlines((current) => new Map(current).set(key, { chapters: [], subcases: [], matters: [], submatters: [] }));
} finally {
pending.current.delete(key);
}
}, [outlines]);
// After a change elsewhere (a matter detached): fetch the lists and every outline held in memory again.
const held = useRef(outlines);
held.current = outlines;
const refreshAll = useCallback(() => {
reload();
for (const key of held.current.keys()) {
const [kind, id, contextId] = key.split(":");
loadOutline(kind, id, contextId, true);
}
}, [reload, loadOutline]);
// The open entry changed (a chapter added, a matter moved): fetch its outline and the lists again.
const stamp = focus?.stamp || "";
useEffect(() => {
if (!focus) return;
loadOutline(focus.kind, focus.id, focus.contextId || "", true);
reload();
}, [stamp]);
useEffect(() => {
setTreeOpen(false);
}, [location.pathname, location.search]);
// Dragging the edge resizes the tree. The width is stored and the page layout is told to measure again.
function startResize(event) {
event.preventDefault();
const startX = event.clientX;
const startWidth = treeWidth;
let latest = startWidth;
const move = (moveEvent) => {
latest = clampTreeWidth(startWidth + moveEvent.clientX - startX);
setTreeWidth(latest);
};
const stop = () => {
window.removeEventListener("pointermove", move);
window.removeEventListener("pointerup", stop);
document.body.classList.remove("is-resizing");
writeTreeWidth(latest);
window.dispatchEvent(new Event("resize"));
};
document.body.classList.add("is-resizing");
window.addEventListener("pointermove", move);
window.addEventListener("pointerup", stop);
}
function resizeByKey(event) {
const step = event.shiftKey ? 48 : 16;
let next = null;
if (event.key === "ArrowLeft") next = treeWidth - step;
else if (event.key === "ArrowRight") next = treeWidth + step;
else if (event.key === "Home" || event.key === "Enter") next = undefined;
if (next === null) return;
event.preventDefault();
setTreeWidth(writeTreeWidth(next));
window.dispatchEvent(new Event("resize"));
}
const notify = useCallback((text) => {
setMessage(text);
clearTimeout(timer.current);
timer.current = setTimeout(() => setMessage(""), 9000);
}, []);
async function share(kind, item, room) {
setError("");
try {
const result = await api(`/api/v1/${PLURAL[kind]}/${item.id}/room-share/rooms/${room.id}`, { method: "PUT", body: { access: "edit" } });
notify(effectText(room.name, result.effect, item.title));
await reload();
} catch (err) {
setError(err.message);
}
}
async function unshare(kind, item, mark) {
setError("");
try {
await api(`/api/v1/${PLURAL[kind]}/${item.id}/room-share/rooms/${mark.id}`, { method: "DELETE" });
notify(`„${item.title}“ liegt nicht mehr in „${mark.name}“. Das Original bleibt bei dir.`);
await reload();
} catch (err) {
setError(err.message);
}
}
const value = {
...data,
reload,
refreshAll,
notify,
share,
unshare,
focus,
setFocus,
outlines,
loadOutline,
actionsRef,
dropOnRoom: (payload, room) => share(payload.kind, { id: payload.id, title: payload.title }, room),
targets: shareTargets(session.rooms),
employee,
};
return (
<LibraryContext.Provider value={value}>
<div className="library" style={{ "--tree-width": `${treeWidth}px` }}>
<button type="button" className="quiet library__toggle" aria-expanded={treeOpen} onClick={() => setTreeOpen((open) => !open)}>
{treeOpen ? "Ordner ausblenden" : "Ordner anzeigen"}
</button>
<aside className={`library__tree${treeOpen ? " is-open" : ""}`}>
<NavTree cases={data.cases} matters={data.matters} rooms={data.rooms} employee={employee} onDropOnRoom={value.dropOnRoom} />
<div
className="library__resizer"
role="separator"
aria-orientation="vertical"
aria-label="Breite der Ablage ändern"
aria-valuenow={treeWidth}
aria-valuemin={200}
aria-valuemax={560}
tabIndex={0}
onPointerDown={startResize}
onKeyDown={resizeByKey}
onDoubleClick={() => { setTreeWidth(writeTreeWidth(264)); window.dispatchEvent(new Event("resize")); }}
title="Ziehen zum Ändern der Breite, Doppelklick setzt zurück"
/>
</aside>
<div className="library__main">
<ErrorNote error={error} />
{message ? <p className="toast" role="status">{message}</p> : null}
<Outlet />
</div>
</div>
</LibraryContext.Provider>
);
}
+55
View File
@@ -0,0 +1,55 @@
// Small symbols for the folder tree and the room marks. They take the kind color from the theme.
export function MiniIcon({ kind }) {
const common = { viewBox: "0 0 24 24", width: 16, height: 16, "aria-hidden": "true", focusable: "false", className: `mini-icon mini-icon--${kind}` };
if (kind === "matter") {
return (
<svg {...common}>
<path d="M7 3h8l4 4v13a1 1 0 0 1-1 1H7a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1z" fill="currentColor" />
<path d="M9.5 12h6M9.5 15.5h6" stroke="var(--surface)" strokeWidth="1.6" strokeLinecap="round" />
</svg>
);
}
if (kind === "plus") {
return (
<svg {...common}>
<path d="M12 5v14M5 12h14" fill="none" stroke="currentColor" strokeWidth="2.6" strokeLinecap="round" />
</svg>
);
}
if (kind === "chapter") {
return (
<svg {...common}>
<path d="M6 3h11a1 1 0 0 1 1 1v17l-6.5-4L5 21V4a1 1 0 0 1 1-1z" fill="currentColor" />
</svg>
);
}
if (kind === "contents") {
return (
<svg {...common}>
<rect x="3" y="3" width="18" height="18" rx="3" fill="currentColor" />
<path d="M7 9h10M7 12.5h10M7 16h6" stroke="var(--surface)" strokeWidth="1.7" strokeLinecap="round" />
</svg>
);
}
if (kind === "link") {
return (
<svg {...common}>
<path d="M10 14a4 4 0 0 0 5.7 0l3-3a4 4 0 0 0-5.7-5.7l-1 1M14 10a4 4 0 0 0-5.7 0l-3 3a4 4 0 0 0 5.7 5.7l1-1" fill="none" stroke="currentColor" strokeWidth="2.2" strokeLinecap="round" />
</svg>
);
}
if (kind === "room") {
return (
<svg {...common}>
<path d="M3 7a2 2 0 0 1 2-2h4l2 2.5h8a2 2 0 0 1 2 2V18a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z" fill="currentColor" />
<circle cx="10" cy="12.5" r="1.9" fill="var(--surface)" />
<circle cx="15.5" cy="13" r="1.5" fill="var(--surface)" />
</svg>
);
}
return (
<svg {...common}>
<path d="M3 7a2 2 0 0 1 2-2h4l2 2.5h8a2 2 0 0 1 2 2V18a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z" fill="currentColor" />
</svg>
);
}
+274
View File
@@ -0,0 +1,274 @@
import { useEffect, useState } from "react";
import { Link, NavLink } from "react-router-dom";
import { SHARE_DRAG_TYPE, parseShareDrag } from "../admin/admin-core.js";
import { useLibrary } from "./LibraryLayout.jsx";
import { MiniIcon } from "./MiniIcon.jsx";
import {
caseHref,
caseKey,
chapterTree,
focusKeys,
folderTree,
matterHref,
matterKey,
rowState,
} from "./library-core.js";
// One row of the navigation tree. A row with `load` fetches its outline when it opens.
function Row({ node, tree }) {
const library = useLibrary();
const open = tree.isOpen(node.key);
const expandable = Boolean(node.expandable);
useEffect(() => {
if (open && node.load) library.loadOutline(node.load.kind, node.load.id, node.load.contextId);
}, [open, node.key]);
const className = `library-tree__link${node.current ? " is-current" : ""}${node.ancestor ? " is-ancestor" : ""}`;
const inner = (
<>
<span className="library-tree__icon"><MiniIcon kind={node.icon} /></span>
<span className="library-tree__title">{node.title}</span>
{node.count !== undefined ? <span className="library-tree__count">{node.count}</span> : null}
</>
);
return (
<li className={node.className || ""}>
<div className="library-tree__row">
{expandable ? (
<button
type="button"
className="library-tree__toggle"
aria-expanded={open}
aria-label={`${node.title} ${open ? "einklappen" : "ausklappen"}`}
onClick={() => tree.toggle(node.key)}
>
{open ? "▾" : "▸"}
</button>
) : <span className="library-tree__toggle is-empty" aria-hidden="true" />}
{node.href ? (
<Link className={className} to={node.href} aria-current={node.current ? "page" : undefined} title={node.title}>{inner}</Link>
) : (
<button type="button" className={className} onClick={node.onClick} title={node.title}>{inner}</button>
)}
{node.moves ? (
<span className="library-tree__moves">
<button type="button" aria-label={`${node.title} nach oben`} disabled={node.moves.first} onClick={() => library.actionsRef.current.moveChapter?.(node.moves.id, -1)}>↑</button>
<button type="button" aria-label={`${node.title} nach unten`} disabled={node.moves.last} onClick={() => library.actionsRef.current.moveChapter?.(node.moves.id, 1)}>↓</button>
</span>
) : null}
</div>
{open && node.children ? <List nodes={node.children()} tree={tree} /> : null}
</li>
);
}
function List({ nodes, tree }) {
if (!nodes.length) return null;
return (
<ul className="library-tree__list">
{nodes.map((node) => <Row key={node.key} node={node} tree={tree} />)}
</ul>
);
}
// Builds the node descriptions from the lists, the loaded outlines and the focus of the page.
function buildNodes({ cases, matters, library, isOpen }) {
const { focus, outlines } = library;
const caseTree = folderTree(cases || [], "parent_case_id");
const matterTreeAll = folderTree(matters || [], "parent_matter_id");
const chapterNodes = (tree, base, owner, ownerKind, contextId) =>
tree.map(({ chapter, first, last, children }) => {
const state = rowState(focus, ownerKind, owner, contextId);
const href = ownerKind === "case" ? caseHref(owner, { kapitel: chapter.id }) : matterHref(owner, contextId, { kapitel: chapter.id });
return {
key: `k:${chapter.id}:${contextId || ""}`,
icon: "chapter",
title: chapter.title,
href,
current: state.here && state.chapter === chapter.id,
expandable: children.length > 0,
moves: state.here && focus.canReorder ? { id: chapter.id, first, last } : null,
children: () => chapterNodes(children, base, owner, ownerKind, contextId),
};
});
const addChapter = (owner, ownerKind, contextId) => {
const state = rowState(focus, ownerKind, owner, contextId);
if (!state.here || !focus.canEdit) return [];
return [{
key: `add:${owner}:${contextId || ""}`,
icon: "plus",
title: state.chapter ? "Neues Unterkapitel" : "Neues Kapitel",
className: "library-tree__add",
onClick: () => library.actionsRef.current.addChapter?.(state.chapter),
}];
};
function matterNode(item, contextId, subs) {
const key = matterKey(item.id, contextId);
const state = rowState(focus, "matter", item.id, contextId);
return {
key,
icon: "matter",
title: item.title,
href: matterHref(item.id, contextId),
current: state.whole && !isOpen(key),
ancestor: state.here,
expandable: true,
load: { kind: "matter", id: item.id, contextId },
children: () => {
const outline = outlines.get(`matter:${item.id}:${contextId || ""}`);
if (!outline) return [{ key: `${key}:loading`, icon: "contents", title: "Wird geladen …", className: "library-tree__hint", onClick: () => {} }];
const submatters = (outline.submatters || []).map((child) => matterNode(child, contextId, null));
return [
{ key: `${key}:all`, icon: "contents", title: "Alle Inhalte", href: matterHref(item.id, contextId), current: state.whole },
...chapterNodes(chapterTree(outline.chapters || []), "", item.id, "matter", contextId),
...submatters,
...addChapter(item.id, "matter", contextId),
];
},
};
}
function caseNode(item) {
const key = caseKey(item.id);
const state = rowState(focus, "case", item.id);
const kids = caseTree.children.get(item.id) || [];
return {
key,
icon: "case",
title: item.title,
href: caseHref(item.id),
current: state.whole && !isOpen(key),
ancestor: state.here,
expandable: true,
load: { kind: "case", id: item.id },
children: () => {
const outline = outlines.get(`case:${item.id}:`);
if (!outline) return [{ key: `${key}:loading`, icon: "contents", title: "Wird geladen …", className: "library-tree__hint", onClick: () => {} }];
const hasParts = (outline.subcases || []).length > 0 || (outline.matters || []).length > 0;
const rows = [];
if (hasParts) rows.push({ key: `${key}:over`, icon: "contents", title: "Überblick", href: caseHref(item.id, { bereich: "ueberblick" }), current: state.overview });
rows.push({ key: `${key}:direct`, icon: "contents", title: "Direkt in dieser Akte", href: caseHref(item.id), current: state.whole });
rows.push(...chapterNodes(chapterTree(outline.chapters || []), "", item.id, "case", ""));
rows.push(...kids.map(caseNode));
rows.push(...(outline.matters || []).map((matter) => matterNode(matter, item.id, matter.children)));
rows.push(...addChapter(item.id, "case", ""));
return rows;
},
};
}
return {
cases: caseTree.roots.map(caseNode),
matters: matterTreeAll.roots.map((item) => matterNode(item, "", null)),
};
}
function Section({ id, icon, label, count, nodes, tree, to }) {
const open = tree.isOpen(id);
return (
<div className="library-tree__section">
<div className="library-tree__row">
<button type="button" className="library-tree__toggle" aria-expanded={open} aria-label={`${label} ${open ? "einklappen" : "ausklappen"}`} onClick={() => tree.toggle(id)}>
{open ? "▾" : "▸"}
</button>
<NavLink to={to} end className={({ isActive }) => `library-tree__root${isActive ? " is-current" : ""}`}>
<span className="library-tree__icon"><MiniIcon kind={icon} /></span> {label}
<span className="library-tree__count">{count}</span>
</NavLink>
</div>
{open ? <List nodes={nodes} tree={tree} /> : null}
</div>
);
}
export function NavTree({ cases, matters, rooms, employee, onDropOnRoom }) {
const library = useLibrary();
const [opened, setOpened] = useState(() => new Set(["sec:cases", "sec:matters"]));
const [closed, setClosed] = useState(() => new Set());
const [over, setOver] = useState("");
const auto = focusKeys(library.focus, cases || [], matters || []);
const tree = {
isOpen: (key) => {
if (closed.has(key)) return false;
return opened.has(key) || auto.has(key);
},
toggle: (key) => {
const currently = tree.isOpen(key);
setOpened((current) => {
const next = new Set(current);
if (currently) next.delete(key);
else next.add(key);
return next;
});
setClosed((current) => {
const next = new Set(current);
if (currently) next.add(key);
else next.delete(key);
return next;
});
},
};
// A new focus opens its path again, even if the person closed it before.
const focusId = library.focus ? `${library.focus.kind}:${library.focus.id}:${library.focus.contextId || ""}` : "";
useEffect(() => {
if (!focusId) return;
setClosed((current) => {
const next = new Set(current);
for (const key of auto) next.delete(key);
return next;
});
}, [focusId]);
const nodes = buildNodes({ cases, matters, library, isOpen: tree.isOpen });
return (
<nav className="library-tree" aria-label="Ablage">
{employee ? null : (
<>
<h2 className="library-tree__heading">Meine Ablage</h2>
<Section id="sec:cases" icon="case" label="Akten" count={(cases || []).length} nodes={nodes.cases} tree={tree} to="/cases" />
<Section id="sec:matters" icon="matter" label="Vorgänge" count={(matters || []).length} nodes={nodes.matters} tree={tree} to="/matters" />
</>
)}
<h2 className="library-tree__heading">Räume</h2>
<NavLink to="/rooms" end className={({ isActive }) => `library-tree__root${isActive ? " is-current" : ""}`}>
<span className="library-tree__icon"><MiniIcon kind="room" /></span> Alle Räume
</NavLink>
<ul className="library-tree__list">
{(rooms || []).map((room) => (
<li key={room.id}>
<NavLink
to={`/rooms/${room.id}`}
className={({ isActive }) => `library-tree__link library-tree__room${isActive ? " is-current" : ""}${over === room.id ? " is-over" : ""}`}
onDragOver={(event) => {
if (!Array.from(event.dataTransfer?.types || []).includes(SHARE_DRAG_TYPE)) return;
event.preventDefault();
event.dataTransfer.dropEffect = "link";
setOver(room.id);
}}
onDragLeave={() => setOver((current) => (current === room.id ? "" : current))}
onDrop={(event) => {
event.preventDefault();
setOver("");
const text = event.dataTransfer.getData(SHARE_DRAG_TYPE);
const payload = parseShareDrag(text, "case") || parseShareDrag(text, "matter");
if (payload) onDropOnRoom(payload, room);
}}
>
<span className="library-tree__icon"><MiniIcon kind="room" /></span>
<span className="library-tree__title">{room.name}</span>
<span className="library-tree__count">{room.case_count + room.matter_count}</span>
</NavLink>
</li>
))}
</ul>
</nav>
);
}
+473
View File
@@ -0,0 +1,473 @@
import { useContext, useEffect, useState } from "react";
import { Link, useNavigate, useParams, useSearchParams } from "react-router-dom";
import { api, markDirty } from "../api.js";
import { AdminRoomsPanel } from "../admin/Admin.jsx";
import { roleLabel } from "../admin/admin-core.js";
import { Modal } from "../pages/Modal.jsx";
import { ErrorNote } from "../pages/widgets.jsx";
import { RoomAdmin, RoomTools } from "../pages/Rooms.jsx";
import { SessionContext } from "../session.js";
import { FolderTile } from "./FolderTile.jsx";
import { MiniIcon } from "./MiniIcon.jsx";
import { useLibrary } from "./LibraryLayout.jsx";
import { addable, breadcrumb, effectText, folderContents, roomMarks, tileLines } from "./library-core.js";
const VIEW_KEY = "tsumugu-library-view";
function readView() {
try {
return window.localStorage.getItem(VIEW_KEY) === "list" ? "list" : "tiles";
} catch {
return "tiles";
}
}
function ViewToggle({ view, onChange }) {
function set(next) {
onChange(next);
try {
window.localStorage.setItem(VIEW_KEY, next);
} catch {
/* The choice only lasts for this visit. */
}
}
return (
<div className="view-toggle" role="group" aria-label="Darstellung">
<button type="button" className={view === "tiles" ? "" : "quiet"} aria-pressed={view === "tiles"} onClick={() => set("tiles")}>Kacheln</button>
<button type="button" className={view === "list" ? "" : "quiet"} aria-pressed={view === "list"} onClick={() => set("list")}>Liste</button>
</div>
);
}
// Tiles or the compact list for the same entries.
function Entries({ kind, items, view, hrefFor, enterFor, rooms, onShare, onUnshare, empty }) {
if (!items.length) return <p className="muted library-empty">{empty}</p>;
if (view === "list") {
return (
<ul className="tile-list">
{items.map((item) => (
<li key={item.id}>
<Link to={hrefFor(item)}><strong>{item.title}</strong></Link>
<span className="muted">{tileLines(item, kind).join(" · ")}</span>
<span className="tile-list__marks">
{item.is_owner ? roomMarks(item).map((mark) => <span key={mark.id} className="mark"><MiniIcon kind="room" /> {mark.name}</span>) : null}
</span>
</li>
))}
</ul>
);
}
return (
<div className="tile-grid">
{items.map((item) => (
<FolderTile
key={item.id}
kind={kind}
item={item}
href={hrefFor(item)}
enterHref={enterFor ? enterFor(item) : undefined}
rooms={rooms}
onShare={(entry, room) => onShare(kind, entry, room)}
onUnshare={(entry, mark) => onUnshare(kind, entry, mark)}
/>
))}
</div>
);
}
export function CreateEntry({ kind, parentId = "", roomId = "", open, onClose, onCreated }) {
const [title, setTitle] = useState("");
const [error, setError] = useState("");
const [pending, setPending] = useState(false);
const label = kind === "case" ? (parentId ? "Unterakte" : "Akte") : (parentId ? "Teilvorgang" : "Vorgang");
async function submit(event) {
event.preventDefault();
setPending(true);
setError("");
try {
const body = { title };
if (parentId) body[kind === "case" ? "parent_case_id" : "parent_matter_id"] = parentId;
if (kind === "case" && parentId) body.rights_mode = "inherit_parent";
if (roomId) body.share_with_room_id = roomId;
const created = await api(kind === "case" ? "/api/v1/cases" : "/api/v1/matters", { method: "POST", body });
setTitle("");
markDirty(false);
await onCreated?.(created);
} catch (err) {
setError(err.message);
} finally {
setPending(false);
}
}
return (
<Modal open={open} title={`${label} anlegen`} onClose={onClose}>
<form onSubmit={submit} className="stack">
<label>
Titel
<input value={title} onChange={(event) => { setTitle(event.target.value); markDirty(true); }} required maxLength={200} />
</label>
{roomId ? <p className="muted">Der Eintrag liegt gleich in diesem Datenraum.</p> : null}
<ErrorNote error={error} />
<button type="submit" disabled={pending}>{pending ? "Wird angelegt …" : `${label} anlegen`}</button>
</form>
</Modal>
);
}
// Akten and Vorgänge as tiles with the folder tree next to them.
export function EntryPage({ kind }) {
const library = useLibrary();
const navigate = useNavigate();
const [params] = useSearchParams();
const [view, setView] = useState(readView);
const [creating, setCreating] = useState(false);
const [detail, setDetail] = useState(null);
const folder = params.get("ordner") || "";
const isCase = kind === "case";
const items = (isCase ? library.cases : library.matters) || [];
const parentKey = isCase ? "parent_case_id" : "parent_matter_id";
const base = isCase ? "/cases" : "/matters";
const title = isCase ? "Akten" : "Vorgänge";
const trail = folder ? breadcrumb(items, parentKey, folder) : [];
const current = folder ? items.find((item) => item.id === folder) : null;
const contents = folderContents(items, parentKey, folder);
useEffect(() => {
setDetail(null);
if (!isCase || !folder) return undefined;
let alive = true;
api(`/api/v1/cases/${folder}`)
.then((record) => {
if (alive) setDetail(record);
})
.catch(() => {});
return () => {
alive = false;
};
}, [isCase, folder, library.matters]);
const folderMatters = isCase && folder && detail
? (detail.matters || []).map((matter) => (library.matters || []).find((item) => item.id === matter.id) || { ...matter, contexts: [] })
: [];
const hrefFor = (item) => `${base}/${item.id}`;
const matterHref = (item) => (folder ? `/matters/${item.id}?context_kind=case&context_id=${folder}` : `/matters/${item.id}`);
const ready = (isCase ? library.cases : library.matters) !== null;
return (
<main className="page library-page">
<header className="page-head">
<div>
{folder ? <nav className="crumbs" aria-label="Pfad">
<Link to={base}>{title}</Link>
{trail.map((step, index) => (
<span key={step.id}>
{" › "}
{index === trail.length - 1 ? <strong>{step.title}</strong> : <Link to={`${base}?ordner=${step.id}`}>{step.title}</Link>}
</span>
))}
</nav> : null}
<h1>{current ? current.title : title}</h1>
<p className="muted">
{isCase
? "Eine Akte sammelt Unterakten und Vorgänge. Teile sie mit Datenräumen, ohne sie zu verschieben."
: "Ein Vorgang kann eigenständig sein und mehreren Akten und Datenräumen zugeordnet werden."}
</p>
</div>
<div className="page-actions">
<ViewToggle view={view} onChange={setView} />
{current ? <Link className="button quiet" to={hrefFor(current)}>{isCase ? "Akte öffnen" : "Vorgang öffnen"}</Link> : null}
{library.employee ? null : (
<button type="button" onClick={() => setCreating(true)}>
{current ? (isCase ? "Neue Unterakte" : "Neuer Teilvorgang") : (isCase ? "Neue Akte" : "Neuer Vorgang")}
</button>
)}
</div>
</header>
{!ready ? <p className="muted">Wird geladen …</p> : null}
{ready ? (
<>
{isCase && folder ? <h2 className="library-section">Unterakten</h2> : null}
<Entries
kind={kind}
items={contents}
view={view}
hrefFor={isCase ? hrefFor : matterHref}
enterFor={(item) => ((isCase ? item.child_cases || item.matter_count : item.child_matters) ? `${base}?ordner=${item.id}` : "")}
rooms={library.targets}
onShare={library.share}
onUnshare={library.unshare}
empty={folder ? (isCase ? "Keine Unterakten." : "Keine Teilvorgänge.") : `Noch ${isCase ? "keine Akte" : "kein Vorgang"}. Lege den ersten Eintrag an.`}
/>
{isCase && folder ? (
<>
<h2 className="library-section">Vorgänge in dieser Akte</h2>
<Entries
kind="matter"
items={folderMatters}
view={view}
hrefFor={matterHref}
rooms={library.targets}
onShare={library.share}
onUnshare={library.unshare}
empty="Noch keine Vorgänge in dieser Akte."
/>
</>
) : null}
</>
) : null}
<CreateEntry
kind={kind}
parentId={folder}
open={creating}
onClose={() => setCreating(false)}
onCreated={async (created) => {
setCreating(false);
await library.reload();
if (created?.id && !folder) navigate(`${base}/${created.id}`);
}}
/>
</main>
);
}
function AddToRoom({ room, open, onClose, onDone }) {
const library = useLibrary();
const [picked, setPicked] = useState(() => new Map());
const [error, setError] = useState("");
const [pending, setPending] = useState(false);
const cases = addable(library.cases || [], room.id);
const matters = addable(library.matters || [], room.id);
useEffect(() => {
if (open) {
setPicked(new Map());
setError("");
}
}, [open]);
function toggle(kind, item) {
setPicked((current) => {
const next = new Map(current);
const key = `${kind}:${item.id}`;
if (next.has(key)) next.delete(key);
else next.set(key, { kind, id: item.id, title: item.title });
return next;
});
}
async function submit(event) {
event.preventDefault();
if (!picked.size) return;
setPending(true);
setError("");
try {
const items = [...picked.values()];
const result = await api(`/api/v1/rooms/${room.id}/shares`, {
method: "POST",
body: { items: items.map(({ kind, id }) => ({ kind, id })), access: "edit" },
});
library.notify(effectText(room.name, result.effect, items.length === 1 ? items[0].title : ""));
await library.reload();
await onDone?.();
onClose();
} catch (err) {
setError(err.message);
} finally {
setPending(false);
}
}
function group(title, kind, items) {
return (
<fieldset className="pick-group">
<legend>{title}</legend>
{items.length ? items.map((item) => (
<label key={item.id} className="check">
<input type="checkbox" checked={picked.has(`${kind}:${item.id}`)} onChange={() => toggle(kind, item)} />
{item.title}
</label>
)) : <p className="muted">Nichts mehr zum Hinzufügen.</p>}
</fieldset>
);
}
return (
<Modal open={open} title={`Zu „${room.name}“ hinzufügen`} onClose={onClose} wide>
<form onSubmit={submit} className="stack">
<p className="muted">
Die Einträge bleiben, wo sie sind. Sie liegen danach zusätzlich in diesem Datenraum. Die Mitglieder erhalten Rechte nach ihrer Rolle.
</p>
{group("Akten", "case", cases)}
{group("Vorgänge", "matter", matters)}
<ErrorNote error={error} />
<button type="submit" disabled={pending || !picked.size}>{picked.size ? `${picked.size} hinzufügen` : "Auswahl treffen"}</button>
</form>
</Modal>
);
}
export function RoomsPage() {
const library = useLibrary();
const { session } = useContext(SessionContext);
const rooms = library.rooms;
return (
<main className="page library-page">
<header className="page-head">
<div>
<h1>Datenräume</h1>
<p className="muted">
Ein Datenraum ist ein Team. Akten und Vorgänge liegen darin als Verknüpfung: Du kannst sie in mehrere Räume legen, ohne sie zu verschieben.
</p>
</div>
</header>
{rooms === null ? <p className="muted">Wird geladen …</p> : null}
{rooms && !rooms.length ? <p className="muted library-empty">Du bist noch in keinem Datenraum.{library.employee ? " Der Hauptnutzer lädt dich ein." : " Lege unten den ersten an."}</p> : null}
<div className="tile-grid">
{(rooms || []).map((room) => (
<FolderTile
key={room.id}
kind="room"
item={{ ...room, title: room.name }}
href={`/rooms/${room.id}`}
onDropEntry={(payload) => library.dropOnRoom(payload, room)}
/>
))}
</div>
<RoomTools onChanged={library.reload} />
{session.account.is_superadmin ? <AdminRoomsPanel /> : null}
</main>
);
}
export function RoomPage() {
const { id } = useParams();
const library = useLibrary();
const navigate = useNavigate();
const { session, refresh } = useContext(SessionContext);
const [params, setParams] = useSearchParams();
const tab = params.get("reiter") === "mitglieder" ? "members" : "content";
const [content, setContent] = useState(null);
const [view, setView] = useState(readView);
const [adding, setAdding] = useState(false);
const [creating, setCreating] = useState("");
const [error, setError] = useState("");
const room = (library.rooms || []).find((item) => item.id === id);
const sessionRoom = session.rooms.find((item) => item.id === id);
const writes = room && (room.role === "member" || room.role === "manager");
async function loadContent() {
try {
setContent(await api(`/api/v1/rooms/${id}/contents`));
setError("");
} catch (err) {
setError(err.message);
}
}
useEffect(() => {
setContent(null);
loadContent();
}, [id, library.cases, library.matters]);
async function afterArchive() {
await refresh();
await library.reload();
navigate("/rooms");
}
if (library.rooms === null) return <main className="page"><p className="muted">Wird geladen …</p></main>;
if (!room) {
return (
<main className="page">
<p className="muted"><Link to="/rooms">Datenräume</Link></p>
<p className="muted">Diesen Datenraum gibt es nicht, er ist archiviert, oder du bist kein Mitglied.</p>
</main>
);
}
const roots = content ? content.cases.filter((c) => !c.parent_case_id || !content.cases.some((p) => p.id === c.parent_case_id)) : [];
const matterRoots = content ? content.matters.filter((m) => !m.parent_matter_id || !content.matters.some((p) => p.id === m.parent_matter_id)) : [];
const withMarks = (items) => items.map((item) => ({ ...item, shared_with: (item.shared_with || []).filter((mark) => mark.id === id) }));
return (
<main className="page library-page">
<header className="page-head room-head">
<div>
<p className="muted"><Link to="/rooms">Datenräume</Link></p>
<h1>{room.name}</h1>
<p className="muted">
{room.private ? "Privat: nur du bist Mitglied." : `${room.member_count} Mitglieder`} · Deine Rolle: {roleLabel(room.role)}{room.is_owner ? " · Eigentümer" : ""}
{room.members?.length ? ` · ${room.members.join(", ")}` : ""}
</p>
</div>
<div className="page-actions">
{tab === "content" ? <ViewToggle view={view} onChange={setView} /> : null}
{writes ? <button type="button" onClick={() => setAdding(true)}>Hinzufügen</button> : null}
{writes ? <button type="button" className="quiet" onClick={() => setCreating("case")}>Neue Akte hier</button> : null}
</div>
</header>
<div className="tabs" role="tablist">
<button type="button" role="tab" aria-selected={tab === "content"} className={tab === "content" ? "" : "quiet"} onClick={() => setParams({})}>Inhalt</button>
<button type="button" role="tab" aria-selected={tab === "members"} className={tab === "members" ? "" : "quiet"} onClick={() => setParams({ reiter: "mitglieder" })}>
Mitglieder und Rechte
</button>
</div>
<ErrorNote error={error} />
{tab === "content" ? (
<>
{content === null && !error ? <p className="muted">Wird geladen …</p> : null}
{content ? (
<>
<h2 className="library-section">Akten</h2>
<Entries
kind="case"
items={withMarks(roots)}
view={view}
hrefFor={(item) => `/cases/${item.id}`}
enterFor={(item) => (item.child_cases || item.matter_count ? `/cases?ordner=${item.id}` : "")}
rooms={library.targets.filter((target) => target.id !== id)}
onShare={library.share}
onUnshare={library.unshare}
empty="Noch keine Akte in diesem Raum."
/>
<h2 className="library-section">Vorgänge</h2>
<Entries
kind="matter"
items={withMarks(matterRoots)}
view={view}
hrefFor={(item) => `/matters/${item.id}`}
rooms={library.targets.filter((target) => target.id !== id)}
onShare={library.share}
onUnshare={library.unshare}
empty="Noch kein Vorgang in diesem Raum."
/>
{writes && !roots.length && !matterRoots.length ? (
<p className="muted library-empty">Mit „Hinzufügen“ legst du eigene Akten und Vorgänge in diesen Raum. Sie bleiben, wo sie sind.</p>
) : null}
</>
) : null}
</>
) : room.role === "manager" && sessionRoom ? (
<RoomAdmin key={room.id} room={sessionRoom} onRenamed={async () => { await refresh(); await library.reload(); }} onArchived={afterArchive} />
) : (
<p className="muted">Mitglieder, Rollen und Einladungen von {room.name} verwalten die Verwalter des Raums. Deine Rolle: {roleLabel(room.role)}.</p>
)}
<AddToRoom room={room} open={adding} onClose={() => setAdding(false)} onDone={loadContent} />
<CreateEntry
kind="case"
roomId={id}
open={creating === "case"}
onClose={() => setCreating("")}
onCreated={async (created) => {
setCreating("");
await library.reload();
if (created?.id) navigate(`/cases/${created.id}`);
}}
/>
</main>
);
}
+37
View File
@@ -0,0 +1,37 @@
// Large symbols for the tiles. They use currentColor and the tile accent, so light and dark mode follow the theme.
export function TileIcon({ kind }) {
const common = { viewBox: "0 0 48 48", width: 48, height: 48, "aria-hidden": "true", focusable: "false" };
if (kind === "matter" || kind === "submatter") {
return (
<svg {...common}>
<rect x="14" y="6" width="26" height="32" rx="3" className="tile-icon__back" />
<rect x="9" y="10" width="26" height="32" rx="3" className="tile-icon__front" />
<path d="M14 19h16M14 25h16M14 31h10" className="tile-icon__lines" />
</svg>
);
}
if (kind === "room") {
return (
<svg {...common}>
<path d="M4 14a4 4 0 0 1 4-4h10l4 5h18a4 4 0 0 1 4 4v19a4 4 0 0 1-4 4H8a4 4 0 0 1-4-4z" className="tile-icon__front" />
<circle cx="19" cy="26" r="4" className="tile-icon__lines" />
<circle cx="31" cy="27" r="3.2" className="tile-icon__lines" />
<path d="M11 38c.6-4.2 3.8-6.5 8-6.5s7.4 2.3 8 6.5M27 37.5c.6-3 2.6-4.7 5-4.7s4.5 1.7 5 4.7" className="tile-icon__lines" />
</svg>
);
}
if (kind === "subcase") {
return (
<svg {...common}>
<path d="M6 15a3.5 3.5 0 0 1 3.5-3.5h8l3.5 4.5H38a3.5 3.5 0 0 1 3.5 3.5v16.5A3.5 3.5 0 0 1 38 39.5H9.5A3.5 3.5 0 0 1 6 36z" className="tile-icon__back" />
<path d="M6 20a3.5 3.5 0 0 1 3.5-3.5H38A3.5 3.5 0 0 1 41.5 20v16.5A3.5 3.5 0 0 1 38 40H9.5A3.5 3.5 0 0 1 6 36.5z" className="tile-icon__front" />
</svg>
);
}
return (
<svg {...common}>
<path d="M4 12a4 4 0 0 1 4-4h10l4 5h18a4 4 0 0 1 4 4v21a4 4 0 0 1-4 4H8a4 4 0 0 1-4-4z" className="tile-icon__back" />
<path d="M4 19a4 4 0 0 1 4-4h32a4 4 0 0 1 4 4v19a4 4 0 0 1-4 4H8a4 4 0 0 1-4-4z" className="tile-icon__front" />
</svg>
);
}
+222
View File
@@ -0,0 +1,222 @@
// Pure helpers for the library: tiles, tree and the effect of a share. No React, so Node can test them.
import { roleLabel } from "../admin/admin-core.js";
export const KIND_LABELS = { case: "Akte", subcase: "Unterakte", matter: "Vorgang", submatter: "Teilvorgang", room: "Datenraum" };
export function tileKind(item, kind) {
if (kind === "case") return item.parent_case_id ? "subcase" : "case";
if (kind === "matter") return item.parent_matter_id ? "submatter" : "matter";
return kind;
}
function plural(count, one, many) {
return `${count} ${count === 1 ? one : many}`;
}
// Lines under the title of a tile. Only counts the person may see.
export function tileLines(item, kind) {
const lines = [];
if (kind === "case") {
if (item.child_cases) lines.push(plural(item.child_cases, "Unterakte", "Unterakten"));
if (item.matter_count) lines.push(plural(item.matter_count, "Vorgang", "Vorgänge"));
if (!lines.length) lines.push("Leer");
} else if (kind === "matter") {
if (item.child_matters) lines.push(plural(item.child_matters, "Teilvorgang", "Teilvorgänge"));
const cases = (item.contexts || []).filter((entry) => entry.kind === "case").length;
if (cases) lines.push(`in ${plural(cases, "Akte", "Akten")}`);
if (!lines.length) lines.push("Eigenständig");
} else if (kind === "room") {
lines.push(plural(item.member_count, "Mitglied", "Mitglieder"));
const entries = (item.case_count || 0) + (item.matter_count || 0);
lines.push(entries ? `${plural(item.case_count || 0, "Akte", "Akten")}, ${plural(item.matter_count || 0, "Vorgang", "Vorgänge")}` : "Noch nichts darin");
}
return lines;
}
export function statusLabel(item) {
if (item.status === "closed") return "Geschlossen";
return "";
}
// Marks on a tile: the rooms an entry lies in. Only the owner sees them.
export function roomMarks(item) {
return (item.shared_with || []).map((share) => ({
id: share.id,
name: share.name,
readOnly: share.access === "read",
}));
}
// What a share does, in words, for the confirmation after sharing.
export function effectText(roomName, effect, title = "") {
const head = title ? `„${title}“ liegt jetzt in „${roomName}“.` : `Die Auswahl liegt jetzt in „${roomName}“.`;
if (!effect?.length) return `${head} Außer dir hat noch niemand Zugriff.`;
const parts = effect.map((person) => `${person.display_name} ${person.rights.edit ? "bearbeitet" : person.rights.read ? "liest" : "sieht nichts"}`);
return `${head} ${parts.join(", ")}.`;
}
// The folder tree: top-level entries with their children, sorted by title.
export function folderTree(items, parentKey) {
const children = new Map();
const roots = [];
const ids = new Set(items.map((item) => item.id));
for (const item of items) {
const parent = item[parentKey];
if (parent && ids.has(parent)) {
if (!children.has(parent)) children.set(parent, []);
children.get(parent).push(item);
} else {
roots.push(item);
}
}
const byTitle = (a, b) => a.title.localeCompare(b.title, "de");
roots.sort(byTitle);
for (const list of children.values()) list.sort(byTitle);
return { roots, children };
}
// The folder a view shows: the children of the selected entry, or the roots.
export function folderContents(items, parentKey, folderId) {
const { roots, children } = folderTree(items, parentKey);
if (!folderId) return roots;
return children.get(folderId) || [];
}
export function breadcrumb(items, parentKey, folderId) {
const byId = new Map(items.map((item) => [item.id, item]));
const trail = [];
let current = byId.get(folderId);
const seen = new Set();
while (current && !seen.has(current.id)) {
seen.add(current.id);
trail.unshift({ id: current.id, title: current.title });
current = current[parentKey] ? byId.get(current[parentKey]) : null;
}
return trail;
}
// Entries of the person that are not yet in the room, for the "Hinzufügen" selection.
export function addable(items, roomId) {
return items.filter((item) => item.is_owner && !(item.shared_with || []).some((share) => share.id === roomId));
}
export function roleHint(role) {
return roleLabel(role);
}
// ---- Navigation tree: keys, the path that opens for the focused entry, chapters and links ----
export const caseKey = (id) => `c:${id}`;
export const matterKey = (id, contextId = "") => (contextId ? `m:${id}@${contextId}` : `m:${id}`);
// Keys of all nodes that open so that the focused entry is visible: its sections, parents and itself.
export function focusKeys(focus, cases = [], matters = []) {
const keys = new Set();
if (!focus) return keys;
const caseById = new Map(cases.map((item) => [item.id, item]));
const matterById = new Map(matters.map((item) => [item.id, item]));
const addCaseChain = (caseId) => {
keys.add("sec:cases");
keys.add(caseKey(caseId));
const seen = new Set();
let current = caseById.get(caseId);
while (current && !seen.has(current.id)) {
seen.add(current.id);
keys.add(caseKey(current.id));
current = current.parent_case_id ? caseById.get(current.parent_case_id) : null;
}
};
if (focus.kind === "case") {
addCaseChain(focus.id);
} else if (focus.kind === "matter") {
const context = focus.contextId || "";
if (context) addCaseChain(context);
else keys.add("sec:matters");
keys.add(matterKey(focus.id, context));
const seen = new Set();
let current = matterById.get(focus.id);
while (current && current.parent_matter_id && !seen.has(current.id)) {
seen.add(current.id);
keys.add(matterKey(current.parent_matter_id, context));
current = matterById.get(current.parent_matter_id);
}
}
return keys;
}
// Chapters of one container as a tree. Each node knows its siblings for the move arrows.
export function chapterTree(chapters = [], parentId = "") {
const siblings = chapters.filter((chapter) => (chapter.parent_chapter_id || "") === parentId);
return siblings.map((chapter, index) => ({
chapter,
first: index === 0,
last: index === siblings.length - 1,
children: chapterTree(chapters, chapter.id),
}));
}
export function caseHref(id, extra = {}) {
const query = new URLSearchParams(extra).toString();
return `/cases/${id}${query ? `?${query}` : ""}`;
}
export function matterHref(id, contextId = "", extra = {}) {
const query = new URLSearchParams({ ...(contextId ? { context_kind: "case", context_id: contextId } : {}), ...extra }).toString();
return `/matters/${id}${query ? `?${query}` : ""}`;
}
// Which row is the current one for the focus. The container row is current only when nothing below it is selected.
export function rowState(focus, kind, id, contextId = "") {
const here = Boolean(focus) && focus.kind === kind && focus.id === id && (kind === "case" || (focus.contextId || "") === (contextId || ""));
return {
here,
chapter: here ? focus.chapterId || "" : "",
overview: here && kind === "case" ? Boolean(focus.overview) : false,
whole: here && !focus.chapterId && !focus.overview,
};
}
// A short signature of what the tree shows below an entry. A change reloads that outline.
export function outlineSignature(record) {
if (!record) return "";
const chapters = (record.chapters || []).map((chapter) => `${chapter.id}:${chapter.title}:${chapter.position}:${chapter.parent_chapter_id || ""}`).join("|");
const subcases = (record.subcases || []).map((item) => item.id).join(",");
const matters = [];
const walk = (nodes) => (nodes || []).forEach((node) => { matters.push(node.id); walk(node.children); });
walk(record.matters);
const submatters = (record.submatters || []).map((item) => item.id).join(",");
return [record.id, record.title, chapters, subcases, matters.join(","), submatters].join("#");
}
// ---- Width of the navigation tree: set by dragging, remembered per browser ----
export const TREE_WIDTH_KEY = "tsumugu-tree-width";
export const TREE_DEFAULT = 264;
export const TREE_MIN = 200;
export const TREE_MAX = 560;
export function clampTreeWidth(value) {
const number = Number(value);
if (!Number.isFinite(number)) return TREE_DEFAULT;
return Math.min(TREE_MAX, Math.max(TREE_MIN, Math.round(number)));
}
export function readTreeWidth(storage = typeof window === "undefined" ? null : window.localStorage) {
try {
const raw = storage?.getItem(TREE_WIDTH_KEY);
return raw ? clampTreeWidth(raw) : TREE_DEFAULT;
} catch {
return TREE_DEFAULT;
}
}
export function writeTreeWidth(value, storage = typeof window === "undefined" ? null : window.localStorage) {
const width = clampTreeWidth(value);
try {
storage?.setItem(TREE_WIDTH_KEY, String(width));
} catch {
/* The width then only lasts for this visit. */
}
return width;
}
+156
View File
@@ -0,0 +1,156 @@
import assert from "node:assert/strict";
import test from "node:test";
import { addable, breadcrumb, effectText, folderContents, folderTree, roomMarks, tileKind, tileLines } from "./library-core.js";
const cases = [
{ id: "a", title: "Vermietung", parent_case_id: null, is_owner: true, shared_with: [{ id: "r1", name: "Werkstatt", access: "edit" }], child_cases: 2, matter_count: 1 },
{ id: "b", title: "Nebenkosten", parent_case_id: "a", is_owner: true, shared_with: [], child_cases: 0, matter_count: 0 },
{ id: "c", title: "Auto", parent_case_id: null, is_owner: false, shared_with: [] },
{ id: "d", title: "Kaution", parent_case_id: "a", is_owner: true, shared_with: [] },
];
test("a tile kind follows the hierarchy", () => {
assert.equal(tileKind(cases[0], "case"), "case");
assert.equal(tileKind(cases[1], "case"), "subcase");
assert.equal(tileKind({ parent_matter_id: "x" }, "matter"), "submatter");
assert.equal(tileKind({}, "room"), "room");
});
test("tile lines show only counts and say when a folder is empty", () => {
assert.deepEqual(tileLines(cases[0], "case"), ["2 Unterakten", "1 Vorgang"]);
assert.deepEqual(tileLines(cases[1], "case"), ["Leer"]);
assert.deepEqual(tileLines({ child_matters: 1, contexts: [{ kind: "case" }, { kind: "case" }] }, "matter"), ["1 Teilvorgang", "in 2 Akten"]);
assert.deepEqual(tileLines({ contexts: [] }, "matter"), ["Eigenständig"]);
assert.deepEqual(tileLines({ member_count: 1, case_count: 0, matter_count: 0 }, "room"), ["1 Mitglied", "Noch nichts darin"]);
assert.deepEqual(tileLines({ member_count: 3, case_count: 2, matter_count: 1 }, "room"), ["3 Mitglieder", "2 Akten, 1 Vorgang"]);
});
test("room marks mark read-only shares", () => {
assert.deepEqual(roomMarks(cases[0]), [{ id: "r1", name: "Werkstatt", readOnly: false }]);
assert.deepEqual(roomMarks({}), []);
assert.equal(roomMarks({ shared_with: [{ id: "x", name: "Anwalt", access: "read" }] })[0].readOnly, true);
});
test("the effect of a share is told in words", () => {
const effect = [
{ display_name: "Ben", rights: { read: true, edit: true } },
{ display_name: "Cem", rights: { read: true, edit: false } },
];
assert.equal(effectText("Werkstatt", effect, "Vermietung"), "„Vermietung“ liegt jetzt in „Werkstatt“. Ben bearbeitet, Cem liest.");
assert.equal(effectText("Werkstatt", [], "Vermietung"), "„Vermietung“ liegt jetzt in „Werkstatt“. Außer dir hat noch niemand Zugriff.");
assert.match(effectText("Werkstatt", effect), /^Die Auswahl liegt jetzt/);
});
test("the folder tree nests children and a folder shows its children", () => {
const { roots, children } = folderTree(cases, "parent_case_id");
assert.deepEqual(roots.map((c) => c.id), ["c", "a"]);
assert.deepEqual(children.get("a").map((c) => c.id), ["d", "b"]);
assert.deepEqual(folderContents(cases, "parent_case_id", "a").map((c) => c.title), ["Kaution", "Nebenkosten"]);
assert.deepEqual(folderContents(cases, "parent_case_id", "").map((c) => c.title), ["Auto", "Vermietung"]);
assert.deepEqual(folderContents(cases, "parent_case_id", "zzz"), []);
});
test("an orphaned child becomes a root and a breadcrumb stops at the top", () => {
const items = [{ id: "x", title: "Kind", parent_case_id: "weg" }];
assert.deepEqual(folderTree(items, "parent_case_id").roots.map((c) => c.id), ["x"]);
assert.deepEqual(breadcrumb(cases, "parent_case_id", "b").map((e) => e.title), ["Vermietung", "Nebenkosten"]);
assert.deepEqual(breadcrumb(cases, "parent_case_id", "nope"), []);
});
test("only own entries that are not yet in the room can be added", () => {
assert.deepEqual(addable(cases, "r1").map((c) => c.id), ["b", "d"]);
assert.deepEqual(addable(cases, "r2").map((c) => c.id), ["a", "b", "d"]);
});
import { caseHref, caseKey, chapterTree, focusKeys, matterHref, matterKey, outlineSignature, rowState } from "./library-core.js";
const allCases = [
{ id: "a", parent_case_id: null },
{ id: "b", parent_case_id: "a" },
];
const allMatters = [
{ id: "m1", parent_matter_id: null },
{ id: "m2", parent_matter_id: "m1" },
];
test("the focus opens the path to a case, its parents and its section", () => {
assert.deepEqual([...focusKeys({ kind: "case", id: "b" }, allCases, allMatters)].sort(), ["c:a", "c:b", "sec:cases"]);
assert.equal(focusKeys(null, allCases, allMatters).size, 0);
});
test("a matter opens under its case context or under the matters section", () => {
const inCase = focusKeys({ kind: "matter", id: "m2", contextId: "b" }, allCases, allMatters);
assert.deepEqual([...inCase].sort(), ["c:a", "c:b", "m:m1@b", "m:m2@b", "sec:cases"]);
const alone = focusKeys({ kind: "matter", id: "m2", contextId: "" }, allCases, allMatters);
assert.deepEqual([...alone].sort(), ["m:m1", "m:m2", "sec:matters"]);
assert.equal(matterKey("x", "c"), "m:x@c");
assert.equal(matterKey("x"), "m:x");
assert.equal(caseKey("x"), "c:x");
});
test("chapters become a tree that knows its first and last sibling", () => {
const chapters = [
{ id: "1", parent_chapter_id: null },
{ id: "2", parent_chapter_id: "1" },
{ id: "3", parent_chapter_id: "1" },
{ id: "4", parent_chapter_id: null },
];
const tree = chapterTree(chapters);
assert.deepEqual(tree.map((n) => [n.chapter.id, n.first, n.last]), [["1", true, false], ["4", false, true]]);
assert.deepEqual(tree[0].children.map((n) => [n.chapter.id, n.first, n.last]), [["2", true, false], ["3", false, true]]);
});
test("links keep the case context of a matter", () => {
assert.equal(caseHref("a"), "/cases/a");
assert.equal(caseHref("a", { kapitel: "k" }), "/cases/a?kapitel=k");
assert.equal(matterHref("m", "a"), "/matters/m?context_kind=case&context_id=a");
assert.equal(matterHref("m", "a", { kapitel: "k" }), "/matters/m?context_kind=case&context_id=a&kapitel=k");
assert.equal(matterHref("m"), "/matters/m");
});
test("a row is current only for its own context", () => {
const focus = { kind: "matter", id: "m", contextId: "a", chapterId: "" };
assert.equal(rowState(focus, "matter", "m", "a").whole, true);
assert.equal(rowState(focus, "matter", "m", "b").here, false);
assert.equal(rowState(focus, "matter", "m", "").here, false);
assert.equal(rowState({ kind: "case", id: "a", overview: true }, "case", "a").overview, true);
assert.equal(rowState({ kind: "case", id: "a", chapterId: "k" }, "case", "a").whole, false);
assert.equal(rowState(null, "case", "a").here, false);
});
test("the outline signature changes with chapters, subcases and matters", () => {
const base = { id: "a", title: "T", chapters: [{ id: "1", title: "K", position: 1 }], subcases: [{ id: "s" }], matters: [{ id: "m", children: [{ id: "n", children: [] }] }] };
const same = outlineSignature(base);
assert.equal(outlineSignature({ ...base }), same);
assert.notEqual(outlineSignature({ ...base, chapters: [...base.chapters, { id: "2", title: "L", position: 2 }] }), same);
assert.notEqual(outlineSignature({ ...base, subcases: [] }), same);
assert.notEqual(outlineSignature({ ...base, matters: [] }), same);
assert.equal(outlineSignature(null), "");
});
import { TREE_DEFAULT, TREE_MAX, TREE_MIN, clampTreeWidth, readTreeWidth, writeTreeWidth } from "./library-core.js";
function memory(initial = {}) {
const data = { ...initial };
return { getItem: (key) => (key in data ? data[key] : null), setItem: (key, value) => { data[key] = value; }, data };
}
test("the tree width stays within its limits and falls back to the default", () => {
assert.equal(clampTreeWidth(10), TREE_MIN);
assert.equal(clampTreeWidth(9999), TREE_MAX);
assert.equal(clampTreeWidth(300.4), 300);
assert.equal(clampTreeWidth("abc"), TREE_DEFAULT);
assert.equal(clampTreeWidth(undefined), TREE_DEFAULT);
});
test("the tree width is remembered and a broken store does not matter", () => {
const store = memory();
assert.equal(readTreeWidth(store), TREE_DEFAULT);
assert.equal(writeTreeWidth(380, store), 380);
assert.equal(readTreeWidth(store), 380);
assert.equal(readTreeWidth(memory({ "tsumugu-tree-width": "99999" })), TREE_MAX);
const broken = { getItem() { throw new Error("blocked"); }, setItem() { throw new Error("blocked"); } };
assert.equal(readTreeWidth(broken), TREE_DEFAULT);
assert.equal(writeTreeWidth(300, broken), 300);
assert.equal(readTreeWidth(null), TREE_DEFAULT);
});
+167
View File
@@ -0,0 +1,167 @@
/* Library: folder tree and tiles. Colors come from the theme variables, so light and dark follow. */
.library { --tree-width: 264px; display: grid; grid-template-columns: var(--tree-width) minmax(0, 1fr); min-height: 100%; }
.library__tree { position: relative; border-right: 1px solid var(--border); background: var(--surface2); overflow: auto; padding: 12px 6px 24px 8px; }
.library__main { min-width: 0; }
.library__toggle { display: none; margin: 10px 16px 0; }
.library-page .page-head { align-items: flex-start; }
.library-tree { display: grid; gap: 2px; align-content: start; }
.library-tree__heading { margin: 14px 8px 4px; font-size: 11px; letter-spacing: 0.06em; text-transform: uppercase; color: var(--text2); }
.library-tree__heading:first-child { margin-top: 2px; }
.library-tree__root, .library-tree__link {
display: flex; align-items: center; gap: 8px; min-height: 34px; padding: 5px 8px; border-radius: 8px;
color: var(--text1); text-decoration: none; font-size: 14px; font-weight: 600; min-width: 0;
}
.library-tree__link { font-weight: 500; font-size: 13px; flex: 1; }
.library-tree__root:hover, .library-tree__link:hover { background: color-mix(in srgb, var(--accent) 10%, transparent); }
.library-tree__root.is-current, .library-tree__link.is-current { background: var(--accent-light); color: var(--accent-dark); }
.library-tree__link.is-over { outline: 2px dashed var(--accent); outline-offset: -2px; background: var(--accent-light); }
.library-tree__title { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.library-tree__count { margin-left: auto; color: var(--text2); font-size: 12px; font-weight: 600; }
.library-tree__list { list-style: none; margin: 0; padding: 0 0 0 10px; display: grid; gap: 1px; }
.library-tree__list .library-tree__list { border-left: 1px solid var(--border); margin-left: 10px; }
.library-tree__row { display: flex; align-items: center; min-width: 0; }
.library-tree__toggle { width: 24px; min-width: 24px; min-height: 30px; padding: 0; border: 0; background: transparent; color: var(--text2); font-size: 12px; }
.library-tree__toggle.is-empty { visibility: hidden; }
.library-tree__icon { flex: none; }
.library-tree__section { display: grid; gap: 1px; }
.page-actions { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; }
a.button {
display: inline-flex; align-items: center; justify-content: center; min-height: 44px; padding: 10px 18px; border-radius: 10px;
font-size: 14px; font-weight: 600; text-decoration: none; background: var(--accent); color: #fff;
}
a.button.quiet { background: var(--surface2); border: 1px solid var(--border2); color: var(--text2); }
.view-toggle { display: inline-flex; gap: 0; }
.view-toggle button { border-radius: 0; min-height: 40px; padding: 8px 14px; }
.view-toggle button:first-child { border-radius: 10px 0 0 10px; }
.view-toggle button:last-child { border-radius: 0 10px 10px 0; }
.crumbs { font-size: 13px; color: var(--text2); margin-bottom: 4px; }
.crumbs a { color: var(--accent-dark); }
.library-section { margin: 18px 0 4px; font-size: 13px; letter-spacing: 0.04em; text-transform: uppercase; color: var(--text2); }
.library-empty { padding: 18px 0; }
.toast { margin: 8px 0 0; padding: 10px 14px; border-radius: 10px; background: var(--accent-light); color: var(--accent-dark); font-weight: 600; font-size: 14px; }
.tabs { display: flex; gap: 8px; margin: 6px 0 10px; }
.tile-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(236px, 1fr)); gap: 14px; margin: 10px 0 22px; }
.folder-tile {
--tile-accent: var(--kind-case);
display: flex; flex-direction: column; min-width: 0; background: var(--surface); border: 1px solid var(--border);
border-radius: 14px; box-shadow: 0 1px 2px rgba(0, 0, 0, 0.04); transition: border-color 0.15s, box-shadow 0.15s;
}
.folder-tile:hover { border-color: var(--tile-accent); box-shadow: var(--shadow); }
.folder-tile.is-over { border-color: var(--tile-accent); background: color-mix(in srgb, var(--tile-accent) 12%, var(--surface)); box-shadow: 0 0 0 2px var(--tile-accent); }
.folder-tile--subcase { --tile-accent: color-mix(in srgb, var(--kind-case) 72%, var(--text2)); }
.folder-tile--matter, .folder-tile--submatter { --tile-accent: var(--kind-matter); }
.folder-tile--room { --tile-accent: var(--kind-room); }
.folder-tile__main { display: flex; gap: 12px; align-items: flex-start; padding: 14px 14px 10px; color: inherit; text-decoration: none; min-width: 0; flex: 1; }
.folder-tile__icon { flex: none; width: 48px; height: 48px; }
.folder-tile__text { display: grid; gap: 2px; min-width: 0; }
.folder-tile__kind { font-size: 11px; font-weight: 700; letter-spacing: 0.05em; text-transform: uppercase; color: var(--tile-accent); }
.folder-tile__title { font-size: 16px; line-height: 1.25; overflow-wrap: anywhere; }
.folder-tile__meta { font-size: 13px; color: var(--text2); }
.folder-tile__foot { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; padding: 0 12px 12px; }
.folder-tile__enter { margin-left: auto; min-height: 30px; padding: 3px 10px; border-radius: 999px; font-size: 12px; text-decoration: none; display: inline-flex; align-items: center; background: var(--surface2); border: 1px solid var(--border2); color: var(--text2); font-weight: 600; }
.tile-icon__back { fill: color-mix(in srgb, var(--tile-accent) 50%, var(--surface)); }
.tile-icon__front { fill: var(--tile-accent); }
.tile-icon__lines { fill: none; stroke: var(--surface); stroke-width: 2.4; stroke-linecap: round; }
.popover { position: relative; display: inline-block; }
.popover__button { min-height: 30px; padding: 3px 11px; border-radius: 999px; font-size: 12px; font-weight: 600; }
.chip-popover .popover__button { background: color-mix(in srgb, var(--kind-room) 16%, var(--surface)); border: 1px solid color-mix(in srgb, var(--kind-room) 45%, var(--border)); color: var(--text1); }
.popover__panel {
position: absolute; z-index: 40; top: calc(100% + 4px); min-width: 210px; max-width: 280px; padding: 6px; display: grid; gap: 2px;
background: var(--surface); border: 1px solid var(--border2); border-radius: 12px; box-shadow: var(--shadow);
}
.popover__panel--left { left: 0; }
.popover__panel button { justify-content: flex-start; min-height: 36px; text-align: left; font-weight: 500; background: transparent; color: var(--text1); border-radius: 8px; padding: 6px 10px; }
.popover__panel button:hover { background: var(--accent-light); }
.popover__note { padding: 6px 10px; font-size: 12px; color: var(--text2); }
.tile-list { list-style: none; margin: 8px 0 20px; padding: 0; display: grid; gap: 2px; }
.tile-list li { display: grid; grid-template-columns: minmax(0, 2fr) minmax(0, 2fr) auto; gap: 12px; align-items: center; padding: 8px 10px; border-bottom: 1px solid var(--border); }
.tile-list a { text-decoration: none; color: var(--text1); }
.tile-list__marks { display: flex; gap: 6px; flex-wrap: wrap; }
.mark { font-size: 12px; padding: 2px 9px; border-radius: 999px; background: color-mix(in srgb, var(--kind-room) 16%, var(--surface)); border: 1px solid color-mix(in srgb, var(--kind-room) 40%, var(--border)); }
.pick-group { border: 1px solid var(--border); border-radius: 12px; padding: 8px 12px 10px; display: grid; gap: 4px; max-height: 260px; overflow: auto; }
.pick-group legend { font-size: 12px; font-weight: 700; letter-spacing: 0.04em; text-transform: uppercase; color: var(--text2); padding: 0 6px; }
.check { display: flex; flex-direction: row; align-items: center; gap: 10px; font-weight: 500; }
.check input { width: 20px; min-height: 20px; height: 20px; flex: none; }
@media (max-width: 900px) {
.library { display: block; }
.library__toggle { display: inline-flex; }
.library__tree { display: none; }
.library__tree.is-open { display: block; border-right: 0; border-bottom: 1px solid var(--border); margin-top: 8px; }
.tile-grid { grid-template-columns: repeat(auto-fill, minmax(168px, 1fr)); gap: 10px; }
.folder-tile__main { flex-direction: column; gap: 6px; }
.tile-list li { grid-template-columns: 1fr; gap: 2px; }
}
.mini-icon { vertical-align: -3px; flex: none; }
.mini-icon--case { color: var(--kind-case); }
.mini-icon--matter { color: var(--kind-matter); }
.mini-icon--room { color: var(--kind-room); }
.library-tree__toggle { font-size: 14px; }
.mark, .chip-popover .popover__button { display: inline-flex; align-items: center; gap: 5px; }
/* Navigation tree below the entries */
.library-tree__link.is-ancestor { font-weight: 700; }
.library-tree__add .library-tree__link, .library-tree__add button { color: var(--accent-dark); font-weight: 600; }
.library-tree__hint .library-tree__link { color: var(--text2); font-style: italic; }
.library-tree__moves { display: inline-flex; gap: 0; flex: none; }
.library-tree__moves button { min-height: 26px; width: 24px; padding: 0; font-size: 13px; background: transparent; color: var(--text2); border-radius: 6px; }
.library-tree__moves button:hover:not(:disabled) { background: var(--accent-light); color: var(--accent-dark); }
.library-tree button.library-tree__link { background: transparent; border: 0; justify-content: flex-start; text-align: left; width: 100%; }
.library__main .workspace { min-height: 0; }
.library__main > .page, .library__main > .workspace { max-width: none; }
.library-tree__list { min-width: 0; }
.library-tree__section > .library-tree__row > .library-tree__root { flex: 1; }
.mini-icon--plus { color: var(--accent-dark); }
/* Compact rows and less indentation, so deep structures fit */
.library-tree__root, .library-tree__link { min-height: 28px; padding: 3px 6px; gap: 6px; }
.library-tree__list { padding: 0 0 0 4px; gap: 0; }
.library-tree__list .library-tree__list { margin-left: 8px; padding-left: 3px; }
.library-tree__toggle { width: 20px; min-width: 20px; min-height: 26px; }
.library-tree__heading { margin: 10px 6px 2px; }
.library-tree__title { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
/* Handle on the right edge of the tree */
.library__resizer { position: absolute; top: 0; right: -3px; width: 7px; height: 100%; cursor: col-resize; z-index: 5; touch-action: none; }
.library__resizer:hover, .library__resizer:focus-visible { background: color-mix(in srgb, var(--accent) 35%, transparent); outline: none; }
body.is-resizing { cursor: col-resize; user-select: none; }
body.is-resizing .library__resizer { background: color-mix(in srgb, var(--accent) 50%, transparent); }
@media (max-width: 900px) { .library__resizer { display: none; } }
.inline-actions { display: flex; align-items: center; justify-content: space-between; gap: 12px; flex-wrap: wrap; }
.document-pages { width: 100%; }
.document-pages canvas { display: block; width: 100%; margin: 0 0 8px; background: #fff; }
/* Pages with a reader (case, matter) fill the height exactly; the lists inside scroll, not the frame. */
.app-main:has(.workspace) > .library { height: 100%; min-height: 0; grid-template-rows: minmax(0, 1fr); }
.app-main:has(.workspace) .library__main { min-height: 0; min-width: 0; display: flex; flex-direction: column; overflow: hidden; }
.app-main:has(.workspace) .library__main > .workspace { flex: 1; min-height: 0; }
.app-main:has(.workspace) .library__tree { min-height: 0; }
@media (max-width: 900px) {
.app-main:has(.workspace) > .library { display: flex; flex-direction: column; }
.app-main:has(.workspace) .library__toggle { flex: none; margin: 4px 12px; }
.app-main:has(.workspace) .library__tree.is-open { flex: none; max-height: 45%; overflow: auto; }
.app-main:has(.workspace) .library__main { flex: 1; }
}
@media (max-width: 759px) { body.is-phone-reading .library__toggle { display: none; } }
.mail-frame { display: block; width: 100%; height: 60vh; min-height: 260px; border: 1px solid var(--border); border-radius: 8px; background: #fff; }
.mail-reading .segmented { display: inline-flex; gap: 6px; margin-bottom: 8px; }
/* Reader header on the phone: back link and tools on one line, a modest title below */
@media (max-width: 759px) {
.reader-pane__bar { padding: 8px 12px 4px; gap: 2px 8px; flex-wrap: wrap; }
.reader-pane__bar .reader-back { order: 1; }
.reader-pane__bar .reader-pane__tools { order: 2; margin-left: auto; }
.reader-pane__bar .reader-pane__heading { order: 3; flex: 1 1 100%; }
.reader-pane__heading h2 { font-size: 17px; line-height: 1.25; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; }
.reader-pane__heading .direction-column__icon { width: 18px; height: 18px; }
.reader-pane__heading .reader-facts { margin: 2px 0 0; font-size: 12px; }
}
.mail-images { display: grid; gap: 4px; margin: 4px 0; }
+30
View File
@@ -0,0 +1,30 @@
// Pictures in a mail come from the sender's server. The app loads them on request, through its own server.
// The choice lives in the browser: one value for pointer devices (computer) and one for touch devices (phone, tablet).
export const IMAGE_KEYS = { desktop: "tsumugu-mail-images-desktop", touch: "tsumugu-mail-images-touch" };
export function deviceClass(match = typeof window === "undefined" ? null : window.matchMedia) {
try {
return match && match.call(typeof window === "undefined" ? undefined : window, "(pointer: coarse)").matches ? "touch" : "desktop";
} catch {
return "desktop";
}
}
export function readImageChoice(device, storage = typeof window === "undefined" ? null : window.localStorage) {
try {
return storage?.getItem(IMAGE_KEYS[device]) === "auto" ? "auto" : "ask";
} catch {
return "ask";
}
}
export function writeImageChoice(device, choice, storage = typeof window === "undefined" ? null : window.localStorage) {
const value = choice === "auto" ? "auto" : "ask";
try {
storage?.setItem(IMAGE_KEYS[device], value);
} catch {
/* The choice then only lasts for this visit. */
}
return value;
}
+28
View File
@@ -0,0 +1,28 @@
import assert from "node:assert/strict";
import test from "node:test";
import { IMAGE_KEYS, deviceClass, readImageChoice, writeImageChoice } from "./mail-images.js";
function memory() {
const data = {};
return { getItem: (key) => (key in data ? data[key] : null), setItem: (key, value) => { data[key] = value; } };
}
test("pictures are asked for by default and the choice is kept per device kind", () => {
const store = memory();
assert.equal(readImageChoice("touch", store), "ask");
assert.equal(writeImageChoice("desktop", "auto", store), "auto");
assert.equal(readImageChoice("desktop", store), "auto");
assert.equal(readImageChoice("touch", store), "ask");
assert.equal(writeImageChoice("touch", "anything", store), "ask");
assert.ok(IMAGE_KEYS.desktop !== IMAGE_KEYS.touch);
});
test("a blocked store and a missing media query fall back to the safe choice", () => {
const broken = { getItem() { throw new Error("blocked"); }, setItem() { throw new Error("blocked"); } };
assert.equal(readImageChoice("desktop", broken), "ask");
assert.equal(writeImageChoice("desktop", "auto", broken), "auto");
assert.equal(readImageChoice("desktop", null), "ask");
assert.equal(deviceClass(null), "desktop");
assert.equal(deviceClass(function () { return { matches: true }; }), "touch");
assert.equal(deviceClass(function () { throw new Error("x"); }), "desktop");
});
+65 -4
View File
@@ -1,9 +1,70 @@
export function MailBody({ html, text, truncated, notices = [] }) { import { useEffect, useState } from "react";
// The cleaned HTML of a mail is shown in a frame without scripts and without any reach into the app:
// an empty `sandbox` gives it its own origin, and the policy inside allows no loads except inline images.
const FRAME_POLICY = "default-src 'none'; img-src data:; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'";
export function mailDocument(html) {
return `<!doctype html><html><head><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="${FRAME_POLICY}">`
+ '<meta name="referrer" content="no-referrer"><meta name="viewport" content="width=device-width, initial-scale=1"><base target="_blank">'
+ "<style>body{margin:12px;font:15px/1.45 system-ui,sans-serif;color:#1c1b18;background:#fff;overflow-wrap:anywhere}"
+ "img,table{max-width:100%}table{border-collapse:collapse}a{color:#0b5d4b}blockquote{margin:8px 0 8px 4px;padding-left:10px;border-left:3px solid #ccc;color:#555}</style>"
+ `</head><body>${html}</body></html>`;
}
// `remote` describes the pictures of other servers: { key, count, auto, load }. `load` asks the app's server for them.
export function MailBody({ html, text, truncated, notices = [], remote = null }) {
const [view, setView] = useState(html ? "html" : "text");
const [withImages, setWithImages] = useState(null);
const [busy, setBusy] = useState(false);
const [problem, setProblem] = useState("");
const mode = html ? view : "text";
const shownHtml = withImages ? withImages.html : html;
async function loadImages() {
setBusy(true);
setProblem("");
try {
setWithImages(await remote.load());
} catch (err) {
setProblem(err.message || "Die Bilder konnten nicht geladen werden.");
} finally {
setBusy(false);
}
}
useEffect(() => {
setWithImages(null);
setProblem("");
if (remote?.auto && remote.count > 0) loadImages();
}, [remote?.key]);
return ( return (
<div className="mail-reading"> <div className="mail-reading">
{html ? <div className="mail-letter__html" dangerouslySetInnerHTML={{ __html: html }} /> : null} {html ? (
<p className="muted">Vereinfachte Textfassung. Sie ist nicht die formatierte Ansicht.</p> <div className="segmented" role="group" aria-label="Darstellung der Nachricht">
{text ? <pre className="mail-letter__body">{text}</pre> : <p className="muted">Diese Nachricht hat keinen lesbaren Text.</p>} <button type="button" className={mode === "html" ? "" : "quiet"} aria-pressed={mode === "html"} onClick={() => setView("html")}>Formatiert</button>
<button type="button" className={mode === "text" ? "" : "quiet"} aria-pressed={mode === "text"} onClick={() => setView("text")}>Nur Text</button>
</div>
) : null}
{mode === "html" ? (
<>
{remote && remote.count > 0 && !withImages ? (
<p className="mail-images">
<button type="button" className="quiet" disabled={busy} onClick={loadImages}>{busy ? "Bilder werden geladen …" : `Bilder nachladen (${remote.count})`}</button>
<span className="muted">Unsere Server laden die Bilder für dich, der Absender sieht deine Adresse nicht. Er kann aber erkennen, dass die Nachricht geöffnet wurde.</span>
</p>
) : null}
{withImages ? <p className="muted">{withImages.loaded} Bild(er) geladen{withImages.failed ? `, ${withImages.failed} nicht verfügbar oder nicht sicher` : ""}.</p> : null}
{problem ? <p className="error">{problem}</p> : null}
<iframe className="mail-frame" title="Nachricht" sandbox="allow-popups allow-popups-to-escape-sandbox" referrerPolicy="no-referrer" srcDoc={mailDocument(shownHtml)} />
<p className="muted">Aus Sicherheitsgründen sind Skripte und eingebettete Formulare entfernt, Bilder von fremden Servern erst nach deiner Freigabe sichtbar. Links öffnen externe Seiten: nur bekannten Absendern vertrauen.</p>
</>
) : (
<>
{text ? <pre className="mail-letter__body">{text}</pre> : <p className="muted">Diese Nachricht hat keinen lesbaren Text.</p>}
</>
)}
{truncated ? <p className="muted">Der Text ist gekürzt, weil die Nachricht sehr groß ist. Das Original bleibt die vollständige E-Mail.</p> : null} {truncated ? <p className="muted">Der Text ist gekürzt, weil die Nachricht sehr groß ist. Das Original bleibt die vollständige E-Mail.</p> : null}
{notices.map((item) => <p key={item} className="notice">{item}</p>)} {notices.map((item) => <p key={item} className="notice">{item}</p>)}
</div> </div>
+1
View File
@@ -3,6 +3,7 @@ import { createRoot } from "react-dom/client";
import { BrowserRouter } from "react-router-dom"; import { BrowserRouter } from "react-router-dom";
import { App } from "./App.jsx"; import { App } from "./App.jsx";
import "./styles.css"; import "./styles.css";
import "./library/library.css";
if (import.meta.env.DEV && new URLSearchParams(window.location.search).has("probe")) { if (import.meta.env.DEV && new URLSearchParams(window.location.search).has("probe")) {
const probe = await import("./sources/sample-source.js"); const probe = await import("./sources/sample-source.js");
+47 -301
View File
@@ -8,195 +8,14 @@ import "./Sources.jsx";
import { SourcePicker, moduleFor, sourceModules } from "../sources/registry.jsx"; import { SourcePicker, moduleFor, sourceModules } from "../sources/registry.jsx";
import { ErrorNote, ShareBox } from "./widgets.jsx"; import { ErrorNote, ShareBox } from "./widgets.jsx";
import { RoomShare } from "../admin/RoomShare.jsx"; import { RoomShare } from "../admin/RoomShare.jsx";
import { ContentBoard, DateField, DirectionChoice, MarkdownEditor, ObjectMenu, OrderChoice, RecordTree, SurfaceView, TargetLine, Trail, WorkLists, WorkSwitch, saveChapterOrder, writeSelection } from "./content.jsx"; import { writableRooms } from "../admin/admin-core.js";
import { ContentBoard, DateField, DirectionChoice, MarkdownEditor, ObjectMenu, OrderChoice, SurfaceView, TargetLine, Trail, WorkLists, WorkSwitch, saveChapterOrder, writeSelection } from "./content.jsx";
import { ReadingPane } from "./ReadingPane.jsx"; import { ReadingPane } from "./ReadingPane.jsx";
import { StructureNavigator, Workspace, rememberScroll, restoreScroll, useWorkspaceLayout } from "./workspace.jsx"; import { Workspace, rememberScroll, restoreScroll, useWorkspaceLayout } from "./workspace.jsx";
import { useLibraryFocus } from "../library/LibraryLayout.jsx";
import { outlineSignature } from "../library/library-core.js";
import { NavIcon } from "./icons.jsx"; import { NavIcon } from "./icons.jsx";
import { useExternalPlacement } from "../sources/duplicates.jsx";
export function CaseList() {
const { session } = useContext(SessionContext);
const [items, setItems] = useState([]);
const [title, setTitle] = useState("");
const [roomId, setRoomId] = useState(session.rooms[0]?.id || "");
const [roomFilter, setRoomFilter] = useState("");
const [error, setError] = useState("");
const [creating, setCreating] = useState(false);
async function load() {
const data = await api("/api/v1/cases");
setItems(data.items);
}
useEffect(() => {
load().catch((err) => setError(err.message));
}, [session.scope.id]);
async function create(event) {
event.preventDefault();
setError("");
try {
await api("/api/v1/cases", { method: "POST", body: { title, home_scope_id: roomId } });
setTitle("");
markDirty(false);
setCreating(false);
await load();
} catch (err) {
setError(err.message);
}
}
return (
<main className="page">
<header className="page-head">
<div>
<h1>Akten</h1>
<p className="muted">Eine Akte sammelt die Vorgänge. Der Datenraum an der Akte bestimmt, wer sie sieht.</p>
</div>
<button type="button" onClick={() => setCreating(true)}>Akte anlegen</button>
</header>
<ErrorNote error={error} />
<div className="filters">
<button type="button" className={roomFilter ? "quiet" : ""} onClick={() => setRoomFilter("")}>Alle</button>
{session.rooms.map((room) => (
<button key={room.id} type="button" className={roomFilter === room.id ? "" : "quiet"} onClick={() => setRoomFilter(room.id)}>
{room.name}
</button>
))}
</div>
{items.filter((item) => !roomFilter || item.home_scope_id === roomFilter).length ? (
<RecordTree
items={items.filter((item) => !roomFilter || item.home_scope_id === roomFilter)}
parentKey="parent_case_id"
hrefFor={(item) => `/cases/${item.id}`}
/>
) : (
<p className="muted">Noch keine Akte. Lege die erste an.</p>
)}
<Modal open={creating} title="Akte anlegen" onClose={() => setCreating(false)}>
<form onSubmit={create} className="stack">
<label>
Titel
<input
value={title}
onChange={(event) => {
setTitle(event.target.value);
markDirty(true);
}}
placeholder="Zum Beispiel Mietstreit Musterstraße"
required
/>
</label>
<label>
Datenraum
<select value={roomId} onChange={(event) => setRoomId(event.target.value)}>
{session.rooms.map((room) => (
<option key={room.id} value={room.id}>{room.name}</option>
))}
</select>
</label>
<button type="submit">Akte anlegen</button>
</form>
</Modal>
</main>
);
}
function OutlineLink({ kind, title, to }) {
return (
<Link className="hierarchy__row" to={to}>
<span className="hierarchy__kind">{kind}</span>
<strong>{title}</strong>
</Link>
);
}
function matterChapters(record, matterId) {
return (record.contained || []).find((item) => item.matter_id === matterId)?.chapters || [];
}
function ChapterLinks({ chapters, scopeId, scope, chapterId, onChapter }) {
if (!chapters.length) return null;
return (
<ul>
{chapters.map((chapter) => (
<li key={chapter.id}>
<button
type="button"
className={scope === scopeId && chapterId === chapter.id ? "hierarchy__row is-current" : "hierarchy__row"}
onClick={() => onChapter(scopeId, chapter.id)}
>
<span className="hierarchy__kind">Kapitel</span>
<strong>{chapter.title}</strong>
</button>
</li>
))}
</ul>
);
}
function MatterBranch({ matter, caseId, scope, chapterId, record, onScope, onChapter }) {
const selected = scope === matter.id && !chapterId;
return (
<li>
<div className="hierarchy__line">
<button type="button" className={selected ? "hierarchy__row is-current" : "hierarchy__row"} onClick={() => onScope(matter.id)}>
<span className="hierarchy__kind">{matter.kind_label || "Vorgang"}</span>
<strong>{matter.title}</strong>
</button>
<Link className="hierarchy__open" to={`/matters/${matter.id}?context_kind=case&context_id=${caseId}`}>Öffnen</Link>
</div>
<ChapterLinks chapters={matterChapters(record, matter.id)} scopeId={matter.id} scope={scope} chapterId={chapterId} onChapter={onChapter} />
{matter.children?.length ? (
<ul>
{matter.children.map((child) => (
<MatterBranch key={child.id} matter={child} caseId={caseId} scope={scope} chapterId={chapterId} record={record} onScope={onScope} onChapter={onChapter} />
))}
</ul>
) : null}
</li>
);
}
function CaseOutline({ record, caseId, scope, chapterId, onScope, onChapter }) {
const hasParent = Boolean(record.parent_case_id && record.parent_title);
return (
<nav className="outline-nav" aria-label="Gliederung">
<h2>Gliederung</h2>
<button type="button" className={scope === "all" ? "hierarchy__row is-current" : "hierarchy__row"} onClick={() => onScope("all")}>
<span className="hierarchy__kind">Überblick</span>
<strong>Alle Inhalte</strong>
</button>
<button type="button" className={scope === "direct" && !chapterId ? "hierarchy__row is-current" : "hierarchy__row"} onClick={() => onScope("direct")}>
<span className="hierarchy__kind">Akte</span>
<strong>Direkt in dieser Akte</strong>
</button>
<ChapterLinks chapters={record.chapters || []} scopeId="direct" scope={scope} chapterId={chapterId} onChapter={onChapter} />
{hasParent ? (
<p className="hierarchy__parent">Übergeordnet: <Link to={`/cases/${record.parent_case_id}`}>Akte {record.parent_title}</Link></p>
) : null}
{record.subcases?.length ? (
<>
<h3>Unterakten</h3>
<ul className="hierarchy">
{record.subcases.map((item) => (
<li key={item.id}><OutlineLink kind="Unterakte" title={item.title} to={`/cases/${item.id}`} /></li>
))}
</ul>
</>
) : null}
{record.matters?.length ? (
<>
<h3>Vorgänge</h3>
<ul className="hierarchy">
{record.matters.map((matter) => (
<MatterBranch key={matter.id} matter={matter} caseId={caseId} scope={scope} chapterId={chapterId} record={record} onScope={onScope} onChapter={onChapter} />
))}
</ul>
</>
) : null}
</nav>
);
}
function matterOrigin(group) { function matterOrigin(group) {
const kind = group.kind_label === "Teilvorgang" ? "Teilvorgang" : "Vorgang"; const kind = group.kind_label === "Teilvorgang" ? "Teilvorgang" : "Vorgang";
@@ -233,59 +52,6 @@ function mergedCaseItems(record, direction, caseId) {
return [...dated, ...undated]; return [...dated, ...undated];
} }
function matterNode(matter, caseId) {
const query = `?context_kind=case&context_id=${caseId}`;
return {
id: matter.id,
title: matter.title,
kind: matter.kind_label || "Vorgang",
href: `/matters/${matter.id}${query}`,
current: false,
children: (matter.children || []).map((child) => matterNode(child, caseId)),
};
}
function caseNodes(record, parentRecord) {
const self = {
id: record.id,
title: record.title,
kind: record.kind_label || "Akte",
href: null,
current: true,
children: [
...(record.subcases || []).map((item) => ({
id: item.id,
title: item.title,
kind: "Unterakte",
href: `/cases/${item.id}`,
current: false,
children: [],
})),
...(record.matters || []).map((matter) => matterNode(matter, record.id)),
],
};
if (!parentRecord) return [self];
const siblings = (parentRecord.subcases || []).map((item) => (item.id === record.id ? self : {
id: item.id,
title: item.title,
kind: "Unterakte",
href: `/cases/${item.id}`,
current: false,
children: [],
}));
return [{
id: parentRecord.id,
title: parentRecord.title,
kind: "Akte",
href: `/cases/${parentRecord.id}`,
current: false,
children: [
...(siblings.length ? siblings : [self]),
...(parentRecord.matters || []).map((matter) => matterNode(matter, parentRecord.id)),
],
}];
}
export function CaseDetail() { export function CaseDetail() {
const { id } = useParams(); const { id } = useParams();
const navigate = useNavigate(); const navigate = useNavigate();
@@ -295,7 +61,6 @@ export function CaseDetail() {
const chapterId = overview ? "" : (params.get("kapitel") || ""); const chapterId = overview ? "" : (params.get("kapitel") || "");
const entryId = params.get("eintrag") || ""; const entryId = params.get("eintrag") || "";
const [record, setRecord] = useState(null); const [record, setRecord] = useState(null);
const [parentTree, setParentTree] = useState(null);
const [error, setError] = useState(""); const [error, setError] = useState("");
const [modal, setModal] = useState(""); const [modal, setModal] = useState("");
const [chapterParentId, setChapterParentId] = useState(""); const [chapterParentId, setChapterParentId] = useState("");
@@ -356,7 +121,6 @@ export function CaseDetail() {
setModal(""); setModal("");
setDateDir("asc"); setDateDir("asc");
setStructureOpen(false); setStructureOpen(false);
setParentTree(null);
api(`/api/v1/cases/${id}`).then((detail) => { api(`/api/v1/cases/${id}`).then((detail) => {
if (!alive) return; if (!alive) return;
pendingChapter.current = ""; pendingChapter.current = "";
@@ -367,19 +131,6 @@ export function CaseDetail() {
return () => { alive = false; }; return () => { alive = false; };
}, [id]); }, [id]);
useEffect(() => {
if (!record || record.id !== id || !record.parent_case_id) return undefined;
let alive = true;
api(`/api/v1/cases/${record.parent_case_id}`).then((parent) => {
if (alive) setParentTree(parent);
}).catch(() => {
if (alive) setParentTree(null);
});
return () => {
alive = false;
};
}, [record, id]);
useEffect(() => { useEffect(() => {
if (!record || record.id !== id) return; if (!record || record.id !== id) return;
const matterId = rawScope && !["all", "ueberblick", "direkt", "direct"].includes(rawScope) ? rawScope : ""; const matterId = rawScope && !["all", "ueberblick", "direkt", "direct"].includes(rawScope) ? rawScope : "";
@@ -472,6 +223,25 @@ export function CaseDetail() {
} }
} }
useLibraryFocus(
record && record.id === id
? {
kind: "case",
id,
chapterId: overview ? "" : chapterId,
overview,
canEdit: Boolean(record.rights?.edit),
canReorder: Boolean(record.rights?.edit) && (record.chapters || []).length > 1,
stamp: outlineSignature(record),
}
: null,
{ addChapter: (parentId) => openChapter(parentId), moveChapter },
);
useEffect(() => {
setView("contents");
}, [chapterId, overview]);
if (error && !record) return <main className="page"><ErrorNote error={error} /></main>; if (error && !record) return <main className="page"><ErrorNote error={error} /></main>;
if (!record) return <main className="page"><p className="muted">Akte wird geladen …</p></main>; if (!record) return <main className="page"><p className="muted">Akte wird geladen …</p></main>;
@@ -483,10 +253,6 @@ export function CaseDetail() {
count: (record.bindings || []).filter((item) => item.chapter_id === chapter.id).length, count: (record.bindings || []).filter((item) => item.chapter_id === chapter.id).length,
})); }));
const merged = mergedCaseItems(record, dateDir, id); const merged = mergedCaseItems(record, dateDir, id);
const contexts = [
...(parentTree ? [{ id: parentTree.id, label: parentTree.title }] : []),
{ id: record.id, label: record.title },
];
const entry = overview ? null : ((record.bindings || []).find((item) => item.id === entryId) || null); const entry = overview ? null : ((record.bindings || []).find((item) => item.id === entryId) || null);
const hasContained = Boolean(record.contained?.length); const hasContained = Boolean(record.contained?.length);
@@ -498,29 +264,6 @@ export function CaseDetail() {
setStructureOpen={setStructureOpen} setStructureOpen={setStructureOpen}
hasEntry={Boolean(entry) && !overview} hasEntry={Boolean(entry) && !overview}
listRef={listRef} listRef={listRef}
nav={(
<StructureNavigator
contexts={contexts}
contextValue={id}
onContext={parentTree ? ((next) => { if (next !== id) navigate(`/cases/${next}`); }) : null}
nodes={caseNodes(record, parentTree)}
allLabel="Direkt in dieser Akte"
chapters={chapters}
chapterId={overview ? "" : chapterId}
allCount={(record.bindings || []).length}
overview={hasContained ? { active: overview, count: merged.length, onSelect: showOverview } : null}
chapterHeading={`Kapitel in ${record.title}`}
onChapter={chooseChapter}
onAddChapter={canEdit ? () => openChapter(chapterId) : null}
onAddRootChapter={canEdit ? () => openChapter("") : null}
canAddChapter={canEdit}
onMoveChapter={moveChapter}
canReorder={canEdit && chapters.length > 1}
links={[]}
onNavigate={() => setStructureOpen(false)}
onClose={width < 1500 ? () => setStructureOpen(false) : null}
/>
)}
reader={entry ? ( reader={entry ? (
<ReadingPane <ReadingPane
binding={entry} binding={entry}
@@ -546,7 +289,6 @@ export function CaseDetail() {
</div> </div>
</div> </div>
<div className="page-actions"> <div className="page-actions">
{width < 1500 ? <button type="button" className="quiet" onClick={() => setStructureOpen(true)}>Struktur</button> : null}
{canEdit ? ( {canEdit ? (
<button type="button" className="desktop-add" onClick={() => openAdd(chapterId)}> <button type="button" className="desktop-add" onClick={() => openAdd(chapterId)}>
<NavIcon name="plus" /> Inhalt hinzufügen <NavIcon name="plus" /> Inhalt hinzufügen
@@ -648,7 +390,7 @@ export function CaseDetail() {
<Modal open={modal === "file"} title="Datei" onClose={() => setModal("")}> <Modal open={modal === "file"} title="Datei" onClose={() => setModal("")}>
<FileForm context={context} chapters={record.chapters} initialChapter={addChapterId} targetLabel={targetLabel} onChange={(finished = true) => { load(); if (finished) setModal(""); }} /> <FileForm context={context} chapters={record.chapters} initialChapter={addChapterId} targetLabel={targetLabel} onChange={(finished = true) => { load(); if (finished) setModal(""); }} />
</Modal> </Modal>
<Modal open={modal.startsWith("source:")} title={moduleFor(modal.slice(7))?.title || "Quelle"} wide={Boolean(moduleFor(modal.slice(7))?.wide)} split={Boolean(moduleFor(modal.slice(7))?.wide)} onClose={() => setModal("")}> <Modal open={modal.startsWith("source:")} title={moduleFor(modal.slice(7))?.title || "Quelle"} wide={Boolean(moduleFor(modal.slice(7))?.wide)} split={Boolean(moduleFor(modal.slice(7))?.wide)} large={Boolean(moduleFor(modal.slice(7))?.large)} onClose={() => setModal("")}>
<SourcePicker sourceKind={modal.slice(7)} context={context} chapterId={addChapterId} chapterTitle={addChapterId ? chapterPathLabel(record.chapters, addChapterId) : ""} targetLabel={targetLabel} onInserted={load} onDone={() => { setModal(""); load(); }} /> <SourcePicker sourceKind={modal.slice(7)} context={context} chapterId={addChapterId} chapterTitle={addChapterId ? chapterPathLabel(record.chapters, addChapterId) : ""} targetLabel={targetLabel} onInserted={load} onDone={() => { setModal(""); load(); }} />
</Modal> </Modal>
<Modal open={modal === "subcase"} title="Unterakte anlegen" onClose={() => setModal("")}> <Modal open={modal === "subcase"} title="Unterakte anlegen" onClose={() => setModal("")}>
@@ -1164,6 +906,15 @@ function ExternalForm({ context, placement, chapters = [], initialChapter = "",
const [sentOn, setSentOn] = useState(""); const [sentOn, setSentOn] = useState("");
const [receivedOn, setReceivedOn] = useState(""); const [receivedOn, setReceivedOn] = useState("");
const [error, setError] = useState(""); const [error, setError] = useState("");
const { place, panel } = useExternalPlacement({
context,
placement,
onPlaced: () => {
setTitle("");
setExternalId("");
onChange();
},
});
useEffect(() => { setChapterId(initialChapter || ""); }, [initialChapter]); useEffect(() => { setChapterId(initialChapter || ""); }, [initialChapter]);
@@ -1171,25 +922,19 @@ function ExternalForm({ context, placement, chapters = [], initialChapter = "",
event.preventDefault(); event.preventDefault();
setError(""); setError("");
try { try {
await api("/api/v1/external-refs", { await place({
method: "POST", title,
body: { source,
title, external_id: externalId,
source, context,
external_id: externalId, ...(placement ? { placement } : {}),
context, ...(chapterId ? { chapter_id: chapterId } : {}),
...(placement ? { placement } : {}), dates: {
...(chapterId ? { chapter_id: chapterId } : {}), document_on: documentOn || null,
dates: { sent_on: sentOn || null,
document_on: documentOn || null, received_on: receivedOn || null,
sent_on: sentOn || null,
received_on: receivedOn || null,
},
}, },
}); });
setTitle("");
setExternalId("");
onChange();
} catch (err) { } catch (err) {
setError(err.message); setError(err.message);
} }
@@ -1210,6 +955,7 @@ function ExternalForm({ context, placement, chapters = [], initialChapter = "",
{chapterSelect(chapters, chapterId, setChapterId)} {chapterSelect(chapters, chapterId, setChapterId)}
<button type="submit">Referenz erfassen</button> <button type="submit">Referenz erfassen</button>
<ErrorNote error={error} /> <ErrorNote error={error} />
{panel}
</form> </form>
); );
} }
+82
View File
@@ -0,0 +1,82 @@
import { useEffect, useRef, useState } from "react";
import workerSrc from "pdfjs-dist/legacy/build/pdf.worker.min.mjs?url";
// Safari on iPhone and iPad shows a PDF in an iframe as a white area, or only its first page.
export function isAppleTouch() {
if (typeof navigator === "undefined") return false;
return /iP(hone|ad|od)/.test(navigator.userAgent) || (navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1);
}
// Safari limits a canvas to about 16.7 million pixels. Stay below that.
const MAX_PIXELS = 12_000_000;
// Shows a document from a blob URL. Desktop browsers use their own viewer in a frame;
// on Apple touch devices a PDF is drawn page by page, which works there.
export function DocumentView({ url, title, className = "reader-frame", frameRef = null }) {
const holder = useRef(null);
const [mode, setMode] = useState(isAppleTouch() ? "loading" : "frame");
const [failed, setFailed] = useState(false);
useEffect(() => {
if (!url || !isAppleTouch()) {
setMode("frame");
return undefined;
}
let alive = true;
let doc = null;
setMode("loading");
setFailed(false);
(async () => {
try {
const blob = await (await fetch(url)).blob();
if (!alive) return;
if (!/pdf/i.test(blob.type)) {
setMode("frame");
return;
}
const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
pdfjs.GlobalWorkerOptions.workerSrc = workerSrc;
doc = await pdfjs.getDocument({ data: await blob.arrayBuffer() }).promise;
if (!alive) return;
setMode("pages");
await new Promise((resolve) => requestAnimationFrame(resolve));
const target = holder.current;
if (!target) return;
target.replaceChildren();
const width = target.clientWidth || 320;
const ratio = Math.min(window.devicePixelRatio || 1, 2);
for (let number = 1; number <= doc.numPages; number += 1) {
const page = await doc.getPage(number);
if (!alive) return;
const base = page.getViewport({ scale: 1 });
let scale = (width / base.width) * ratio;
scale = Math.min(scale, Math.sqrt(MAX_PIXELS / (base.width * base.height)));
const viewport = page.getViewport({ scale });
const canvas = document.createElement("canvas");
canvas.width = Math.floor(viewport.width);
canvas.height = Math.floor(viewport.height);
canvas.style.width = "100%";
canvas.style.height = "auto";
canvas.className = "reader-canvas";
target.appendChild(canvas);
await page.render({ canvasContext: canvas.getContext("2d"), viewport }).promise;
}
} catch {
if (alive) setFailed(true);
}
})();
return () => {
alive = false;
doc?.destroy?.();
};
}, [url]);
if (mode === "frame") return <iframe ref={frameRef} className={className} title={title} src={url} />;
return (
<div className="document-pages">
{mode === "loading" && !failed ? <p className="muted">Dokument wird dargestellt …</p> : null}
{failed ? <p className="error">Die Vorschau ist hier nicht möglich. <a href={url} target="_blank" rel="noreferrer">Dokument öffnen</a></p> : null}
<div ref={holder} />
</div>
);
}
+83 -217
View File
@@ -8,12 +8,15 @@ import { SourcePicker, moduleFor, sourceModules } from "../sources/registry.jsx"
import { ErrorNote, ShareBox } from "./widgets.jsx"; import { ErrorNote, ShareBox } from "./widgets.jsx";
import { chapterPathLabel, siblingChapterIds, trailWithChapter } from "./chapters.js"; import { chapterPathLabel, siblingChapterIds, trailWithChapter } from "./chapters.js";
import { ChapterForm, FileForm, NoteForm } from "./Cases.jsx"; import { ChapterForm, FileForm, NoteForm } from "./Cases.jsx";
import { ContentBoard, DateField, ObjectMenu, Placements, RecordTree, SurfaceView, TargetLine, Trail, WorkLists, WorkSwitch, matterOpenHref, saveChapterOrder, writeChapter } from "./content.jsx"; import { ContentBoard, DateField, ObjectMenu, Placements, SurfaceView, TargetLine, Trail, WorkLists, WorkSwitch, matterOpenHref, saveChapterOrder, writeChapter } from "./content.jsx";
import { ReadingPane } from "./ReadingPane.jsx"; import { ReadingPane } from "./ReadingPane.jsx";
import { StructureNavigator, Workspace, rememberScroll, restoreScroll, useWorkspaceLayout } from "./workspace.jsx"; import { Workspace, rememberScroll, restoreScroll, useWorkspaceLayout } from "./workspace.jsx";
import { useLibrary, useLibraryFocus } from "../library/LibraryLayout.jsx";
import { outlineSignature } from "../library/library-core.js";
import { NavIcon } from "./icons.jsx"; import { NavIcon } from "./icons.jsx";
import { ExportPackage } from "./ExportPackage.jsx"; import { ExportPackage } from "./ExportPackage.jsx";
import { RoomShare } from "../admin/RoomShare.jsx"; import { RoomShare } from "../admin/RoomShare.jsx";
import { writableRooms } from "../admin/admin-core.js";
function pageContext(params) { function pageContext(params) {
const kind = params.get("context_kind"); const kind = params.get("context_kind");
@@ -22,166 +25,10 @@ function pageContext(params) {
return { kind, id }; return { kind, id };
} }
export function MatterList() {
const { session } = useContext(SessionContext);
const navigate = useNavigate();
const [params] = useSearchParams();
const [items, setItems] = useState(null);
const [error, setError] = useState("");
const [creating, setCreating] = useState(params.get("neu") === "1");
const [title, setTitle] = useState("");
const [pending, setPending] = useState(false);
async function load() {
const data = await api("/api/v1/matters");
setItems(data.items);
}
useEffect(() => {
load().catch((err) => setError(err.message));
}, [session.scope.id]);
return (
<main className="page">
<header className="page-head">
<div>
<h1>Vorgänge</h1>
<p className="muted">Ein Vorgang kann eigenständig beginnen und später einer Akte zugeordnet werden.</p>
</div>
<button type="button" onClick={() => setCreating(true)}>Vorgang anlegen</button>
</header>
<ErrorNote error={error} />
{items === null ? <p className="muted">Vorgänge werden geladen …</p> : items.length ? (
<RecordTree
items={items}
parentKey="parent_matter_id"
hrefFor={(item) => matterOpenHref(item)}
/>
) : (
<p className="muted">Noch kein Vorgang.</p>
)}
<Modal open={creating} title="Vorgang anlegen" onClose={() => setCreating(false)}>
<form className="stack compact" onSubmit={async (event) => {
event.preventDefault();
if (pending) return;
setError("");
setPending(true);
try {
const matter = await api("/api/v1/matters", { method: "POST", body: { title, home_scope_id: session.scope.id } });
markDirty(false);
setCreating(false);
navigate(`/matters/${matter.id}`);
} catch (err) {
setError(err.message);
} finally {
setPending(false);
}
}}>
<label>Titel <input value={title} onChange={(event) => { setTitle(event.target.value); markDirty(true); }} required /></label>
<button type="submit" disabled={pending}>{pending ? "Wird angelegt …" : "Vorgang anlegen"}</button>
<ErrorNote error={error} />
</form>
</Modal>
</main>
);
}
function contextQuery(inherited) { function contextQuery(inherited) {
return inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : ""; return inherited ? `?context_kind=${inherited.kind}&context_id=${inherited.id}` : "";
} }
function mapMatterNodes(nodes, activeId, query) {
return (nodes || []).map((node) => ({
id: node.id,
title: node.title,
kind: node.kind_label || "Vorgang",
href: `/matters/${node.id}${query}`,
current: node.id === activeId,
children: mapMatterNodes(node.children, activeId, query),
}));
}
function caseNodes(caseRecord, parentRecord, activeId, contextId) {
const query = `?context_kind=case&context_id=${contextId}`;
const self = {
id: caseRecord.id,
title: caseRecord.title,
kind: caseRecord.kind_label || "Akte",
href: `/cases/${caseRecord.id}`,
current: false,
children: [
...(caseRecord.subcases || []).map((item) => ({
id: item.id,
title: item.title,
kind: "Unterakte",
href: `/cases/${item.id}`,
current: false,
children: [],
})),
...mapMatterNodes(caseRecord.matters, activeId, query),
],
};
if (!parentRecord) return [self];
const siblings = (parentRecord.subcases || []).map((item) => (item.id === caseRecord.id ? self : {
id: item.id,
title: item.title,
kind: "Unterakte",
href: `/cases/${item.id}`,
current: false,
children: [],
}));
return [{
id: parentRecord.id,
title: parentRecord.title,
kind: "Akte",
href: `/cases/${parentRecord.id}`,
current: false,
children: [
...(siblings.length ? siblings : [self]),
...mapMatterNodes(parentRecord.matters, activeId, `?context_kind=case&context_id=${parentRecord.id}`),
],
}];
}
function placementNodes(record) {
const matter = {
id: record.id,
title: record.title,
kind: record.kind_label || "Vorgang",
href: null,
current: true,
children: (record.submatters || []).map((item) => ({
id: item.id,
title: item.title,
kind: "Teilvorgang",
href: `/matters/${item.id}`,
current: false,
children: [],
})),
};
const rooted = record.parent_matter_id && record.parent_title ? [{
id: record.parent_matter_id,
title: record.parent_title,
kind: "Vorgang",
href: `/matters/${record.parent_matter_id}`,
current: false,
children: [matter],
}] : [matter];
const cases = record.placements || [];
if (cases.length < 2) return rooted;
return [
...rooted,
...cases.map((item) => ({
id: item.case_id,
title: String(item.label || "Akte").replaceAll("Unterakte ", "").replaceAll("Akte ", "").replaceAll(" → ", " / "),
kind: "Akte",
href: `/matters/${record.id}?context_kind=case&context_id=${item.case_id}`,
current: false,
children: [],
})),
];
}
function objectTrail(record, query) { function objectTrail(record, query) {
const items = [{ label: "Vorgänge", href: "/matters" }]; const items = [{ label: "Vorgänge", href: "/matters" }];
if (record.parent_matter_id && record.parent_title) { if (record.parent_matter_id && record.parent_title) {
@@ -194,6 +41,7 @@ function objectTrail(record, query) {
export function MatterDetail() { export function MatterDetail() {
const { id } = useParams(); const { id } = useParams();
const navigate = useNavigate(); const navigate = useNavigate();
const library = useLibrary();
const [params, setParams] = useSearchParams(); const [params, setParams] = useSearchParams();
const inherited = pageContext(params); const inherited = pageContext(params);
const chapterId = params.get("kapitel") || ""; const chapterId = params.get("kapitel") || "";
@@ -207,8 +55,6 @@ export function MatterDetail() {
const [view, setView] = useState("contents"); const [view, setView] = useState("contents");
const { width, structureOpen, setStructureOpen } = useWorkspaceLayout(); const { width, structureOpen, setStructureOpen } = useWorkspaceLayout();
const listRef = useRef(null); const listRef = useRef(null);
const [caseTree, setCaseTree] = useState(null);
const [parentTree, setParentTree] = useState(null);
const pendingChapter = useRef(""); const pendingChapter = useRef("");
const entryId = params.get("eintrag") || ""; const entryId = params.get("eintrag") || "";
@@ -303,33 +149,6 @@ export function MatterDetail() {
setParams(next, { replace: true }); setParams(next, { replace: true });
}, [record, id, inherited?.kind]); }, [record, id, inherited?.kind]);
useEffect(() => {
if (inherited?.kind !== "case") {
setCaseTree(null);
setParentTree(null);
return undefined;
}
let alive = true;
api(`/api/v1/cases/${inherited.id}`).then((detail) => {
if (!alive) return;
setCaseTree(detail);
if (!detail.parent_case_id) {
setParentTree(null);
return;
}
api(`/api/v1/cases/${detail.parent_case_id}`).then((parent) => {
if (alive) setParentTree(parent);
}).catch(() => {
if (alive) setParentTree(null);
});
}).catch(() => {
if (alive) setCaseTree(null);
});
return () => {
alive = false;
};
}, [inherited?.kind, inherited?.id]);
useEffect(() => { useEffect(() => {
if (!record || record.id !== id || !entryId) return; if (!record || record.id !== id || !entryId) return;
if ((record.bindings || []).some((item) => item.id === entryId)) return; if ((record.bindings || []).some((item) => item.id === entryId)) return;
@@ -405,6 +224,25 @@ export function MatterDetail() {
} }
} }
useLibraryFocus(
record && record.id === id
? {
kind: "matter",
id,
contextId: inherited?.kind === "case" ? inherited.id : "",
chapterId,
canEdit: Boolean(record.rights?.edit),
canReorder: Boolean(record.rights?.edit) && (record.chapters || []).length > 1,
stamp: outlineSignature(record),
}
: null,
{ addChapter: (parentId) => openChapter(parentId), moveChapter },
);
useEffect(() => {
setView("contents");
}, [chapterId]);
if (error && !record) return <main className="page"><ErrorNote error={error} /></main>; if (error && !record) return <main className="page"><ErrorNote error={error} /></main>;
if (!record) return <main className="page"><p className="muted">Vorgang wird geladen …</p></main>; if (!record) return <main className="page"><p className="muted">Vorgang wird geladen …</p></main>;
@@ -416,12 +254,6 @@ export function MatterDetail() {
...chapter, ...chapter,
count: (record.bindings || []).filter((item) => item.chapter_id === chapter.id).length, count: (record.bindings || []).filter((item) => item.chapter_id === chapter.id).length,
})); }));
const contexts = (record.placements || []).map((item) => ({
id: item.case_id,
label: String(item.label || "Akte").replaceAll("Unterakte ", "").replaceAll("Akte ", "").replaceAll(" → ", " / "),
}));
const contextValue = inherited?.kind === "case" ? inherited.id : (contexts.length === 1 ? contexts[0].id : "");
const nodes = caseTree && inherited ? caseNodes(caseTree, parentTree, id, inherited.id) : placementNodes(record);
const links = [ const links = [
...(record.cross_links || []).map((item) => ({ ...(record.cross_links || []).map((item) => ({
id: `cross-${item.id}`, id: `cross-${item.id}`,
@@ -447,28 +279,6 @@ export function MatterDetail() {
setStructureOpen={setStructureOpen} setStructureOpen={setStructureOpen}
hasEntry={Boolean(entry)} hasEntry={Boolean(entry)}
listRef={listRef} listRef={listRef}
nav={(
<StructureNavigator
contexts={contexts.length > 1 && !inherited ? [{ id: "", label: "Keine Akte gewählt" }, ...contexts] : contexts}
contextValue={contextValue}
onContext={contexts.length > 1 ? switchContext : null}
nodes={nodes}
chapters={chapters}
chapterId={chapterId}
allLabel=""
allCount={(record.bindings || []).length}
chapterHeading={`Kapitel in ${record.title}`}
onChapter={chooseChapter}
onAddChapter={canEdit ? () => openChapter(chapterId) : null}
onAddRootChapter={canEdit ? () => openChapter("") : null}
canAddChapter={canEdit}
onMoveChapter={moveChapter}
canReorder={canEdit && chapters.length > 1}
links={links}
onNavigate={() => setStructureOpen(false)}
onClose={width < 1500 ? () => setStructureOpen(false) : null}
/>
)}
reader={entry ? ( reader={entry ? (
<ReadingPane <ReadingPane
binding={entry} binding={entry}
@@ -490,13 +300,22 @@ export function MatterDetail() {
<div> <div>
<Trail items={trailWithChapter(record.trail?.length ? record.trail : objectTrail(record, query), record.chapters, chapterId, `/matters/${id}${query}`)} /> <Trail items={trailWithChapter(record.trail?.length ? record.trail : objectTrail(record, query), record.chapters, chapterId, `/matters/${id}${query}`)} />
<Placements items={record.placements} /> <Placements items={record.placements} />
{links.length ? (
<p className="placements">
{links.map((item, index) => (
<span key={item.id}>
{index ? <span aria-hidden="true"> · </span> : null}
<span className="muted">{item.kind}: </span><Link to={item.href}>{item.title}</Link>
</span>
))}
</p>
) : null}
<div className="title-row"> <div className="title-row">
<h1>{record.title}</h1> <h1>{record.title}</h1>
<span className={record.status === "open" ? "status-pill" : "status-pill is-closed"}>{record.status === "open" ? "Offen" : "Geschlossen"}</span> <span className={record.status === "open" ? "status-pill" : "status-pill is-closed"}>{record.status === "open" ? "Offen" : "Geschlossen"}</span>
</div> </div>
</div> </div>
<div className="page-actions"> <div className="page-actions">
{width < 1500 ? <button type="button" className="quiet" onClick={() => setStructureOpen(true)}>Struktur</button> : null}
{canEdit ? ( {canEdit ? (
<button type="button" className="desktop-add" onClick={() => openAdd(chapterId)}> <button type="button" className="desktop-add" onClick={() => openAdd(chapterId)}>
<NavIcon name="plus" /> Inhalt hinzufügen <NavIcon name="plus" /> Inhalt hinzufügen
@@ -507,6 +326,7 @@ export function MatterDetail() {
{canEdit ? <button type="button" className="quiet" onClick={renameMatter}>Umbenennen</button> : null} {canEdit ? <button type="button" className="quiet" onClick={renameMatter}>Umbenennen</button> : null}
{canEdit ? <button type="button" className="quiet" onClick={archiveMatter}>{record.status === "closed" ? "Wieder öffnen" : "Archivieren"}</button> : null} {canEdit ? <button type="button" className="quiet" onClick={archiveMatter}>{record.status === "closed" ? "Wieder öffnen" : "Archivieren"}</button> : null}
{canEdit ? <button type="button" className="quiet" onClick={() => setModal("move")}>Verschieben</button> : null} {canEdit ? <button type="button" className="quiet" onClick={() => setModal("move")}>Verschieben</button> : null}
{(record.case_links || []).length && (canEdit || record.rights.share || record.is_owner) ? <button type="button" className="quiet" onClick={() => setModal("unlink")}>Aus Akte lösen</button> : null}
{canEdit ? <button type="button" className="danger" onClick={deleteMatter}>Löschen</button> : null} {canEdit ? <button type="button" className="danger" onClick={deleteMatter}>Löschen</button> : null}
{canEdit ? <button type="button" className="quiet" onClick={() => setModal("submatter")}>Teilvorgang anlegen</button> : null} {canEdit ? <button type="button" className="quiet" onClick={() => setModal("submatter")}>Teilvorgang anlegen</button> : null}
{canEdit ? <button type="button" className="quiet" onClick={() => setModal("cross")}>Querverweis</button> : null} {canEdit ? <button type="button" className="quiet" onClick={() => setModal("cross")}>Querverweis</button> : null}
@@ -593,7 +413,7 @@ export function MatterDetail() {
<Modal open={modal === "file"} title="Datei" onClose={() => setModal("")}> <Modal open={modal === "file"} title="Datei" onClose={() => setModal("")}>
<FileForm context={rightsContext} placement={placement} chapters={record.chapters} initialChapter={addChapterId} targetLabel={targetLabel} onChange={(finished = true) => { load(); if (finished) setModal(""); }} /> <FileForm context={rightsContext} placement={placement} chapters={record.chapters} initialChapter={addChapterId} targetLabel={targetLabel} onChange={(finished = true) => { load(); if (finished) setModal(""); }} />
</Modal> </Modal>
<Modal open={modal.startsWith("source:")} title={moduleFor(modal.slice(7))?.title || "Quelle"} wide={Boolean(moduleFor(modal.slice(7))?.wide)} split={Boolean(moduleFor(modal.slice(7))?.wide)} onClose={() => setModal("")}> <Modal open={modal.startsWith("source:")} title={moduleFor(modal.slice(7))?.title || "Quelle"} wide={Boolean(moduleFor(modal.slice(7))?.wide)} split={Boolean(moduleFor(modal.slice(7))?.wide)} large={Boolean(moduleFor(modal.slice(7))?.large)} onClose={() => setModal("")}>
<SourcePicker sourceKind={modal.slice(7)} context={rightsContext} placement={placement} chapterId={addChapterId} chapterTitle={addChapterId ? chapterPathLabel(record.chapters, addChapterId) : ""} targetLabel={targetLabel} onInserted={load} onDone={() => { setModal(""); load(); }} /> <SourcePicker sourceKind={modal.slice(7)} context={rightsContext} placement={placement} chapterId={addChapterId} chapterTitle={addChapterId ? chapterPathLabel(record.chapters, addChapterId) : ""} targetLabel={targetLabel} onInserted={load} onDone={() => { setModal(""); load(); }} />
</Modal> </Modal>
<Modal open={modal === "submatter"} title="Teilvorgang anlegen" onClose={() => setModal("")}> <Modal open={modal === "submatter"} title="Teilvorgang anlegen" onClose={() => setModal("")}>
@@ -621,6 +441,19 @@ export function MatterDetail() {
{record.is_owner ? <RoomShare resource="matters" id={id} onChange={load} /> : null} {record.is_owner ? <RoomShare resource="matters" id={id} onChange={load} /> : null}
<ShareBox path={`/api/v1/matters/${id}/grants`} grants={record.grants || []} onChange={load} allowSources={Boolean(record.is_owner)} /> <ShareBox path={`/api/v1/matters/${id}/grants`} grants={record.grants || []} onChange={load} allowSources={Boolean(record.is_owner)} />
</Modal> </Modal>
<Modal open={modal === "unlink"} title="Aus Akte lösen" onClose={() => setModal("")}>
<UnlinkMatter
title={record.title}
links={[...(record.case_links || [])].sort((a, b) => Number(b.case_id === inherited?.id) - Number(a.case_id === inherited?.id))}
currentId={inherited?.kind === "case" ? inherited.id : ""}
onDone={(link) => {
setModal("");
library?.refreshAll();
if (inherited?.kind === "case" && inherited.id === link.case_id) navigate(`/matters/${id}`, { replace: true });
else load();
}}
/>
</Modal>
<Modal open={modal === "move"} title="Vorgang verschieben" onClose={() => setModal("")}> <Modal open={modal === "move"} title="Vorgang verschieben" onClose={() => setModal("")}>
<MoveMatter <MoveMatter
matterId={id} matterId={id}
@@ -634,6 +467,39 @@ export function MatterDetail() {
); );
} }
// Detaches the matter from one case. The matter itself and its content stay.
function UnlinkMatter({ title, links, currentId = "", onDone }) {
const [error, setError] = useState("");
const [pending, setPending] = useState("");
async function unlink(link) {
setPending(link.id);
setError("");
try {
await api(`/api/v1/matter-case-links/${link.id}`, { method: "DELETE" });
onDone(link);
} catch (err) {
setError(err.message);
setPending("");
}
}
return (
<div className="stack">
<p className="muted">„{title}“ bleibt mit allen Inhalten erhalten und wird nur aus der gewählten Akte gelöst. In anderen Akten und unter „Vorgänge“ bleibt er sichtbar.</p>
<ErrorNote error={error} />
{links.map((link) => (
<div key={link.id} className="inline-actions">
<span>Akte {link.title}{link.case_id === currentId ? " (hier geöffnet)" : ""}</span>
<button type="button" className="quiet" disabled={Boolean(pending)} onClick={() => unlink(link)}>
{pending === link.id ? "Wird gelöst …" : "Aus dieser Akte lösen"}
</button>
</div>
))}
</div>
);
}
function MoveMatter({ matterId, version, context, soleCaseId = "", onDone }) { function MoveMatter({ matterId, version, context, soleCaseId = "", onDone }) {
const [cases, setCases] = useState([]); const [cases, setCases] = useState([]);
const [caseId, setCaseId] = useState(""); const [caseId, setCaseId] = useState("");
+2 -2
View File
@@ -1,7 +1,7 @@
import { useEffect, useRef } from "react"; import { useEffect, useRef } from "react";
import { isDirty, markDirty } from "../api.js"; import { isDirty, markDirty } from "../api.js";
export function Modal({ open, title, onClose, wide = false, split = false, children }) { export function Modal({ open, title, onClose, wide = false, split = false, large = false, children }) {
const dialogRef = useRef(null); const dialogRef = useRef(null);
const restoreRef = useRef(null); const restoreRef = useRef(null);
@@ -33,7 +33,7 @@ export function Modal({ open, title, onClose, wide = false, split = false, child
if (!open) return null; if (!open) return null;
return ( return (
<div className="modal-overlay" onClick={(event) => { if (event.target === event.currentTarget) requestClose(); }}> <div className="modal-overlay" onClick={(event) => { if (event.target === event.currentTarget) requestClose(); }}>
<div ref={dialogRef} className={`modal${wide ? " modal--wide" : ""}${split ? " modal--split" : ""}`} role="dialog" aria-modal="true" aria-label={title} tabIndex={-1}> <div ref={dialogRef} className={`modal${wide ? " modal--wide" : ""}${split ? " modal--split" : ""}${large ? " modal--large" : ""}`} role="dialog" aria-modal="true" aria-label={title} tabIndex={-1}>
<header className="modal__bar"> <header className="modal__bar">
<h2>{title}</h2> <h2>{title}</h2>
<button type="button" className="quiet" onClick={requestClose}>Schließen</button> <button type="button" className="quiet" onClick={requestClose}>Schließen</button>
+17 -17
View File
@@ -1,13 +1,14 @@
import { DocumentView } from "./DocumentView.jsx";
import { useContext, useEffect, useRef, useState } from "react"; import { useContext, useEffect, useRef, useState } from "react";
import { SessionContext } from "../session.js"; import { SessionContext } from "../session.js";
import { documentToText, downloadMailPart, fetchExternal, fetchFile, fetchMailPart, isDirty, markDirty, textToDocument, api } from "../api.js"; import { documentToText, downloadMailPart, fetchExternal, fetchFile, fetchMailPart, isDirty, markDirty, saveDocument, textToDocument, api } from "../api.js";
import { SourceAssignment, representationOf, stageFor } from "../sources/registry.jsx"; import { SourceAssignment, representationOf, stageFor } from "../sources/registry.jsx";
import "../sources/builtin-views.jsx"; import "../sources/builtin-views.jsx";
import { ErrorNote } from "./widgets.jsx"; import { ErrorNote } from "./widgets.jsx";
import { UnitDetail } from "./correspondence.jsx"; import { UnitDetail } from "./correspondence.jsx";
import { dateCaption, DateField, DirectionChoice, DirectionColumn, directionValue, directionWord, formatDate, mailFacts, sourceLabel } from "./content.jsx"; import { dateCaption, DateField, DirectionChoice, DirectionColumn, directionValue, directionWord, formatDate, mailFacts, sourceLabel } from "./content.jsx";
import { NavIcon } from "./icons.jsx"; import { NavIcon } from "./icons.jsx";
import workerSrc from "pdfjs-dist/build/pdf.worker.min.mjs?url"; import workerSrc from "pdfjs-dist/legacy/build/pdf.worker.min.mjs?url";
const SCALES = [0.75, 1, 1.25, 1.5, 2]; const SCALES = [0.75, 1, 1.25, 1.5, 2];
@@ -173,7 +174,7 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
setMedia("pdf"); setMedia("pdf");
try { try {
const bytes = await blob.arrayBuffer(); const bytes = await blob.arrayBuffer();
const pdfjs = await import("pdfjs-dist"); const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
pdfjs.GlobalWorkerOptions.workerSrc = workerSrc; pdfjs.GlobalWorkerOptions.workerSrc = workerSrc;
const doc = await pdfjs.getDocument({ data: bytes }).promise; const doc = await pdfjs.getDocument({ data: bytes }).promise;
if (!alive) { if (!alive) {
@@ -243,7 +244,7 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
setMedia("pdf"); setMedia("pdf");
try { try {
const bytes = await blob.arrayBuffer(); const bytes = await blob.arrayBuffer();
const pdfjs = await import("pdfjs-dist"); const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
pdfjs.GlobalWorkerOptions.workerSrc = workerSrc; pdfjs.GlobalWorkerOptions.workerSrc = workerSrc;
const doc = await pdfjs.getDocument({ data: bytes }).promise; const doc = await pdfjs.getDocument({ data: bytes }).promise;
if (!alive) { if (!alive) {
@@ -308,7 +309,8 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
const canvas = canvasRef.current; const canvas = canvasRef.current;
const context2d = canvas?.getContext("2d"); const context2d = canvas?.getContext("2d");
if (!canvas || !context2d) return; if (!canvas || !context2d) return;
const viewport = pdfPage.getViewport({ scale }); const base = pdfPage.getViewport({ scale: 1 });
const viewport = pdfPage.getViewport({ scale: Math.min(scale, Math.sqrt(12_000_000 / (base.width * base.height))) });
canvas.width = viewport.width; canvas.width = viewport.width;
canvas.height = viewport.height; canvas.height = viewport.height;
const render = pdfPage.render({ canvasContext: context2d, viewport }); const render = pdfPage.render({ canvasContext: context2d, viewport });
@@ -354,12 +356,10 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
setError(""); setError("");
try { try {
const view = representationOf(element); const view = representationOf(element);
const blob = view === "source-file" || view === "text" const path = view === "source-file" || view === "text"
? await fetchExternal(element.id, context) ? `/api/v1/external-refs/${element.id}/content`
: await fetchFile(element.id, context); : `/api/v1/files/${element.id}/content`;
const url = URL.createObjectURL(blob); await saveDocument(path, context, element.file?.filename || element.title || "dokument");
window.open(url, "_blank", "noopener");
setTimeout(() => URL.revokeObjectURL(url), 60000);
} catch (err) { } catch (err) {
setError(err.message); setError(err.message);
} }
@@ -524,8 +524,8 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
</p> </p>
</div> </div>
<div className="reader-pane__tools"> <div className="reader-pane__tools">
{element.kind !== "note" && !isMail ? ( {element.kind !== "note" && !isMail && binding.rights.download ? (
<button type="button" className="icon-button" aria-label="Original öffnen" onClick={openOriginal}> <button type="button" className="icon-button" aria-label="Original herunterladen" title="Original herunterladen" onClick={openOriginal}>
<NavIcon name="link" /> <NavIcon name="link" />
</button> </button>
) : null} ) : null}
@@ -570,13 +570,13 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
{!isMail && !locked && !unassigned && phase === "missing" ? ( {!isMail && !locked && !unassigned && phase === "missing" ? (
<div className="reader-pane__state"> <div className="reader-pane__state">
<p>Für diesen Inhalt gibt es keine eingebaute Vorschau.</p> <p>Für diesen Inhalt gibt es keine eingebaute Vorschau.</p>
<button type="button" onClick={openOriginal}>Original öffnen</button> {binding.rights.download ? <button type="button" onClick={openOriginal}>Original herunterladen</button> : null}
</div> </div>
) : null} ) : null}
{!isMail && phase === "error" ? ( {!isMail && phase === "error" ? (
<div className="reader-pane__state"> <div className="reader-pane__state">
<p>Die Vorschau ist nicht verfügbar.</p> <p>Die Vorschau ist nicht verfügbar.</p>
<button type="button" onClick={openOriginal}>Original öffnen</button> {binding.rights.download ? <button type="button" onClick={openOriginal}>Original herunterladen</button> : null}
</div> </div>
) : null} ) : null}
{!isMail && media === "text" ? <pre className="mail-letter__body">{sourceText}</pre> : null} {!isMail && media === "text" ? <pre className="mail-letter__body">{sourceText}</pre> : null}
@@ -584,11 +584,11 @@ export function ReadingPane({ binding, context, backLabel, onClose, onReload, ca
<img className="reader-image" alt={element.title} src={blobUrl} style={{ width: `${Math.round(scale * 100)}%` }} /> <img className="reader-image" alt={element.title} src={blobUrl} style={{ width: `${Math.round(scale * 100)}%` }} />
) : null} ) : null}
{!isMail && media === "pdf" && pdf ? <canvas ref={canvasRef} className="reader-canvas" /> : null} {!isMail && media === "pdf" && pdf ? <canvas ref={canvasRef} className="reader-canvas" /> : null}
{!isMail && media === "pdf-frame" && blobUrl ? <iframe className="reader-frame" title={element.title} src={blobUrl} /> : null} {!isMail && media === "pdf-frame" && blobUrl ? <DocumentView title={element.title} url={blobUrl} /> : null}
{!isMail && media === "other" && blobUrl ? ( {!isMail && media === "other" && blobUrl ? (
<div className="reader-pane__state"> <div className="reader-pane__state">
<p>Die Datei ist geladen, aber hier nicht als Seite darstellbar.</p> <p>Die Datei ist geladen, aber hier nicht als Seite darstellbar.</p>
<a href={blobUrl} target="_blank" rel="noreferrer">Original öffnen</a> {binding.rights.download ? <a href={blobUrl} target="_blank" rel="noreferrer">Original öffnen</a> : null}
</div> </div>
) : null} ) : null}
</div> </div>
+40 -51
View File
@@ -5,10 +5,12 @@ import {
exposureSummary, exposureSummary,
formatWhen, formatWhen,
inviteLink, inviteLink,
isEmployee,
isPrivateRoom, isPrivateRoom,
lastManagerIds, lastManagerIds,
roleLabel, roleLabel,
} from "../admin/admin-core.js"; } from "../admin/admin-core.js";
import { DownloadPolicy } from "../admin/DownloadPolicy.jsx";
import { OneTimeSecret } from "../admin/widgets.jsx"; import { OneTimeSecret } from "../admin/widgets.jsx";
import { SessionContext } from "../session.js"; import { SessionContext } from "../session.js";
import { ErrorNote } from "./widgets.jsx"; import { ErrorNote } from "./widgets.jsx";
@@ -30,7 +32,7 @@ function VisibilitySelect({ value, onChange, disabled = false }) {
); );
} }
function RoomAdmin({ room, onRenamed, onArchived }) { export function RoomAdmin({ room, onRenamed, onArchived }) {
const [members, setMembers] = useState([]); const [members, setMembers] = useState([]);
const [invitations, setInvitations] = useState([]); const [invitations, setInvitations] = useState([]);
const [name, setName] = useState(room.name); const [name, setName] = useState(room.name);
@@ -149,7 +151,6 @@ function RoomAdmin({ room, onRenamed, onArchived }) {
return ( return (
<section className="card stack" aria-label={`Verwaltung von ${room.name}`}> <section className="card stack" aria-label={`Verwaltung von ${room.name}`}>
<h2>{room.name}</h2>
<p className="muted"> <p className="muted">
{members.length <= 1 ? "Privater Raum: nur du bist Mitglied." : `Mehrbenutzer-Raum mit ${members.length} Mitgliedern.`} {members.length <= 1 ? "Privater Raum: nur du bist Mitglied." : `Mehrbenutzer-Raum mit ${members.length} Mitgliedern.`}
{room.is_owner ? " Du bist Eigentümer." : ""} {room.is_owner ? " Du bist Eigentümer." : ""}
@@ -176,6 +177,8 @@ function RoomAdmin({ room, onRenamed, onArchived }) {
</label> </label>
) : null} ) : null}
<DownloadPolicy path={`/api/v1/rooms/${room.id}/download-policy`} editable={Boolean(room.is_owner)} />
<h3>Mitglieder</h3> <h3>Mitglieder</h3>
<ul className="index"> <ul className="index">
{members.map((member) => ( {members.map((member) => (
@@ -246,14 +249,23 @@ function RoomAdmin({ room, onRenamed, onArchived }) {
</form> </form>
) : null} ) : null}
<h3>Einladungen</h3> <h3>Mitarbeiter einladen</h3>
<p className="muted">Für Personen ohne Konto. Du erhältst einen Link, den du selbst weitergibst. Er gilt 7 Tage und einmal.</p> {room.is_owner ? (
{link ? <OneTimeSecret title="Einladungslink" value={link} onDone={() => setLink("")} /> : null} <>
<form onSubmit={invite} className="inline"> <p className="muted">
<input type="email" value={inviteMail} onChange={(event) => { setInviteMail(event.target.value); markDirty(true); }} placeholder="E-Mail der eingeladenen Person" aria-label="E-Mail der eingeladenen Person" required /> Die Person erhält ein Mitarbeiter-Konto und arbeitet nur in den Räumen, in die du sie einlädst, nach der gewählten Rolle.
<RoleSelect value={inviteRole} onChange={setInviteRole} label="Rolle der eingeladenen Person" /> Du erhältst einen Link, den du selbst weitergibst. Er gilt 7 Tage und einmal.
<button type="submit">Einladung erstellen</button> </p>
</form> {link ? <OneTimeSecret title="Einladungslink" value={link} onDone={() => setLink("")} /> : null}
<form onSubmit={invite} className="inline">
<input type="email" value={inviteMail} onChange={(event) => { setInviteMail(event.target.value); markDirty(true); }} placeholder="E-Mail der eingeladenen Person" aria-label="E-Mail der eingeladenen Person" required />
<RoleSelect value={inviteRole} onChange={setInviteRole} label="Rolle der eingeladenen Person" />
<button type="submit">Einladung erstellen</button>
</form>
</>
) : (
<p className="muted">Neue Mitarbeiter lädt der Eigentümer des Raums ein. Du kannst bestehende Konten aufnehmen.</p>
)}
{invitations.length ? ( {invitations.length ? (
<ul className="index"> <ul className="index">
{invitations.map((item) => ( {invitations.map((item) => (
@@ -286,13 +298,14 @@ function RoomAdmin({ room, onRenamed, onArchived }) {
); );
} }
export function Rooms() { // Create a room and restore archived ones. The rooms themselves are shown as tiles by the library.
export function RoomTools({ onChanged }) {
const { session, refresh } = useContext(SessionContext); const { session, refresh } = useContext(SessionContext);
const employee = isEmployee(session);
const [name, setName] = useState(""); const [name, setName] = useState("");
const [visibility, setVisibility] = useState("room"); const [visibility, setVisibility] = useState("room");
const [archived, setArchived] = useState([]); const [archived, setArchived] = useState([]);
const [error, setError] = useState(""); const [error, setError] = useState("");
const current = session.rooms.find((room) => room.id === session.scope.id);
async function loadArchived() { async function loadArchived() {
const data = await api("/api/v1/rooms?include_archived=true"); const data = await api("/api/v1/rooms?include_archived=true");
@@ -311,6 +324,7 @@ export function Rooms() {
setName(""); setName("");
markDirty(false); markDirty(false);
await refresh(); await refresh();
await onChanged?.();
} catch (err) { } catch (err) {
setError(err.message); setError(err.message);
} }
@@ -322,52 +336,27 @@ export function Rooms() {
await api(`/api/v1/rooms/${room.id}`, { method: "PATCH", body: { status: "active" } }); await api(`/api/v1/rooms/${room.id}`, { method: "PATCH", body: { status: "active" } });
await refresh(); await refresh();
await loadArchived(); await loadArchived();
await onChanged?.();
} catch (err) { } catch (err) {
setError(err.message); setError(err.message);
} }
} }
async function afterArchive() {
await refresh();
await loadArchived();
}
function roomLabel(room) {
if (room.kind === "personal") return "Persönlich";
const state = isPrivateRoom(room) ? "Privat" : "Mehrbenutzer";
return `${state} · ${roleLabel(room.role)}${room.is_owner ? " · Eigentümer" : ""}`;
}
return ( return (
<main className="page"> <>
<header className="page-head">
<div>
<h1>Datenräume</h1>
<p className="muted">
Ein Raum ist privat, bis du Personen aufnimmst. Ein Raum ist ein Team: Du teilst Akten und Vorgänge mit ihm, die Mitglieder erhalten Rechte nach ihrer Rolle.
</p>
</div>
</header>
<ul className="index">
{session.rooms.map((room) => (
<li key={room.id}>
<strong>{room.name}</strong>
<span>{roomLabel(room)}</span>
</li>
))}
</ul>
<form onSubmit={create} className="inline">
<input value={name} onChange={(event) => { setName(event.target.value); markDirty(true); }} placeholder="Name des neuen Datenraums" aria-label="Name des neuen Datenraums" required />
<VisibilitySelect value={visibility} onChange={setVisibility} />
<button type="submit">Datenraum anlegen</button>
</form>
<ErrorNote error={error} /> <ErrorNote error={error} />
{current?.kind === "organization" && current.role === "manager" ? ( {employee ? (
<RoomAdmin key={current.id} room={current} onRenamed={refresh} onArchived={afterArchive} /> <p className="muted">Du arbeitest als Mitarbeiter in den Räumen, in die du eingeladen wurdest. Eigene Datenräume legt der Hauptnutzer an.</p>
) : current?.kind === "organization" ? (
<p className="muted">Mitglieder und Rollen von {current.name} verwalten die Verwalter des Raums.</p>
) : ( ) : (
<p className="muted">Wechsle in einen gemeinsamen Datenraum, um seine Mitglieder zu verwalten.</p> <section className="card stack" aria-label="Datenraum anlegen">
<h2>Neuen Datenraum anlegen</h2>
<form onSubmit={create} className="inline">
<input value={name} onChange={(event) => { setName(event.target.value); markDirty(true); }} placeholder="Name des neuen Datenraums" aria-label="Name des neuen Datenraums" required />
<VisibilitySelect value={visibility} onChange={setVisibility} />
<button type="submit">Datenraum anlegen</button>
</form>
<p className="muted">Du wirst Eigentümer und Verwalter. Der Raum ist privat, bis du Personen aufnimmst.</p>
</section>
)} )}
{archived.length ? ( {archived.length ? (
<section className="card stack" aria-label="Archivierte Datenräume"> <section className="card stack" aria-label="Archivierte Datenräume">
@@ -383,6 +372,6 @@ export function Rooms() {
</ul> </ul>
</section> </section>
) : null} ) : null}
</main> </>
); );
} }
+11 -4
View File
@@ -16,13 +16,20 @@ export function Settings() {
<Link className="tile" to="/rooms"> <Link className="tile" to="/rooms">
<span className="tile__kind">Verwaltung</span> <span className="tile__kind">Verwaltung</span>
<strong>Datenräume</strong> <strong>Datenräume</strong>
<span>Räume anlegen und wechseln</span> <span>Teams, Mitglieder und Rollen</span>
</Link> </Link>
<Link className="tile" to="/sources"> <Link className="tile" to="/sources">
<span className="tile__kind">Verwaltung</span> <span className="tile__kind">Verwaltung</span>
<strong>Quellen</strong> <strong>Quellen</strong>
<span>Paperless und E-Mail</span> <span>Paperless und E-Mail</span>
</Link> </Link>
{session?.account?.account_kind !== "employee" ? (
<Link className="tile" to="/team">
<span className="tile__kind">Verwaltung</span>
<strong>Mein Team</strong>
<span>Mitarbeiter und ihre Räume</span>
</Link>
) : null}
<Link className="tile" to="/account"> <Link className="tile" to="/account">
<span className="tile__kind">Verwaltung</span> <span className="tile__kind">Verwaltung</span>
<strong>Mein Konto</strong> <strong>Mein Konto</strong>
@@ -35,10 +42,10 @@ export function Settings() {
<strong>Nutzer</strong> <strong>Nutzer</strong>
<span>Konten, Rollen, Zugang</span> <span>Konten, Rollen, Zugang</span>
</Link> </Link>
<Link className="tile" to="/admin/rooms"> <Link className="tile" to="/admin/team">
<span className="tile__kind">Betreiber</span> <span className="tile__kind">Betreiber</span>
<strong>Alle Datenräume</strong> <strong>Team-Übersicht</strong>
<span>Übersicht ohne Inhalte</span> <span>Hauptnutzer, Mitarbeiter, Räume</span>
</Link> </Link>
<Link className="tile" to="/admin/events"> <Link className="tile" to="/admin/events">
<span className="tile__kind">Betreiber</span> <span className="tile__kind">Betreiber</span>
+1 -5
View File
@@ -9,6 +9,7 @@ const WORK = [
{ to: "/", end: true, label: "Übersicht", short: "Start", icon: "home" }, { to: "/", end: true, label: "Übersicht", short: "Start", icon: "home" },
{ to: "/matters", label: "Vorgänge", short: "Vorgänge", icon: "layers" }, { to: "/matters", label: "Vorgänge", short: "Vorgänge", icon: "layers" },
{ to: "/cases", label: "Akten", short: "Akten", icon: "folder" }, { to: "/cases", label: "Akten", short: "Akten", icon: "folder" },
{ to: "/rooms", label: "Räume", short: "Räume", icon: "rooms" },
{ to: "/work", label: "Aufgaben", short: "Aufgaben", icon: "check" }, { to: "/work", label: "Aufgaben", short: "Aufgaben", icon: "check" },
]; ];
@@ -21,7 +22,6 @@ function initials(name) {
const MOBILE = [ const MOBILE = [
...WORK, ...WORK,
{ to: "/settings", label: "Verwaltung", short: "Verwaltung", icon: "gear" }, { to: "/settings", label: "Verwaltung", short: "Verwaltung", icon: "gear" },
{ to: "/search", label: "Suche", short: "Suche", icon: "search" },
]; ];
class PageBoundary extends Component { class PageBoundary extends Component {
@@ -212,10 +212,6 @@ export function Shell() {
<span>{item.short}</span> <span>{item.short}</span>
</NavLink> </NavLink>
))} ))}
<button type="button" className="nav-item" onClick={logout}>
<NavIcon name="logout" />
<span>Abmelden</span>
</button>
</nav> </nav>
</div> </div>
</div> </div>
+610 -118
View File
@@ -1,12 +1,14 @@
import { DocumentView } from "./DocumentView.jsx";
import { useEffect, useRef, useState } from "react"; import { useEffect, useRef, useState } from "react";
import { Link, useNavigate } from "react-router-dom"; import { Link, useNavigate } from "react-router-dom";
import { api, fetchBlob } from "../api.js"; import { api, fetchBlob } from "../api.js";
import { MailBody } from "../mail-view.jsx"; import { MailBody } from "../mail-view.jsx";
import { NewConnector, useSourceModules } from "../sources/connector-config.jsx"; import { NewConnector, useSourceModules } from "../sources/connector-config.jsx";
import { SourceFrame, registerSourceModule } from "../sources/registry.jsx"; import { SourceFrame, registerSourceModule } from "../sources/registry.jsx";
import { PresentNote, bindable, describeMatch, lookupPresent, presentKey, useExternalPlacement } from "../sources/duplicates.jsx";
const SEARCH_LIMITS = { const SEARCH_LIMITS = {
paperless: "Suchtext gilt für Titel und Dokumentinhalt. Zusätzlich gibt es Titel, Korrespondent, Dokumenttyp, Tags, Dokumentdatum und Sortierung.", paperless: "Die Suche läuft in Paperless selbst, über Titel und Inhalt, den Titel allein, den Inhalt allein oder den Volltextindex. Filter nach Korrespondent, Dokumenttyp, Speicherpfad, Tags, Dokumentdatum, Hinzugefügt-Datum und Archivnummer grenzen sie ein.",
imap: "Die Suche gilt für das ganze gewählte Fach, auch über die erste Seite hinaus. Betreff, Absender und Nachrichtentext werden auf dem Server geprüft.", imap: "Die Suche gilt für das ganze gewählte Fach, auch über die erste Seite hinaus. Betreff, Absender und Nachrichtentext werden auf dem Server geprüft.",
}; };
import { formatDate } from "./content.jsx"; import { formatDate } from "./content.jsx";
@@ -68,28 +70,250 @@ function paperlessLabel(item) {
return dated !== "Ohne Datum" ? `${dated} · ${item.title}` : item.title; return dated !== "Ohne Datum" ? `${dated} · ${item.title}` : item.title;
} }
function paperlessFacts(item) {
return [
formatDate(item.document_on) !== "Ohne Datum" ? formatDate(item.document_on) : "",
item.correspondent,
item.document_type,
item.pages ? `${item.pages} ${item.pages === 1 ? "Seite" : "Seiten"}` : "",
item.asn ? `ASN ${item.asn}` : "",
].filter(Boolean);
}
const PAPERLESS_MODES = [
["title_content", "Titel und Inhalt"],
["title", "Nur Titel"],
["content", "Nur Inhalt"],
["index", "Volltextindex"],
];
const PAPERLESS_MODE_HINTS = {
title_content: "Sucht den Text im Titel und im erkannten Inhalt, wie „Titel & Inhalt“ in Paperless.",
title: "Sucht den Text nur im Titel.",
content: "Sucht den Text nur im erkannten Inhalt der Dokumente.",
index: "Der Volltextindex von Paperless findet ganze Wörter, auch mit AND, OR und Anführungszeichen, und ordnet nach Relevanz. Ein neues Dokument erscheint erst, wenn Paperless es indexiert hat.",
};
const NO_FACETS = { correspondents: [], document_types: [], storage_paths: [], tags: [], custom_fields: [] };
const EMPTY_FILTERS = { const EMPTY_FILTERS = {
query: "", query: "",
mode: "title_content",
title: "", title: "",
correspondent: "", correspondent: "",
documentType: "", documentType: "",
storagePath: "",
tags: [], tags: [],
tagMode: "all",
documentFrom: "", documentFrom: "",
documentTo: "", documentTo: "",
addedFrom: "",
addedTo: "",
asn: "",
custom: [],
sort: "-created", sort: "-created",
}; };
function activeFilterCount(filters) {
return [
filters.title.trim(),
filters.correspondent,
filters.documentType,
filters.storagePath,
filters.tags.length ? "tags" : "",
filters.documentFrom,
filters.documentTo,
filters.addedFrom,
filters.addedTo,
filters.asn.trim(),
].filter(Boolean).length + customPayload(filters.custom).length;
}
const CUSTOM_KINDS = {
string: "text",
url: "text",
longtext: "text",
integer: "number",
float: "number",
monetary: "number",
date: "date",
boolean: "boolean",
select: "select",
};
const CUSTOM_OPERATORS = {
text: [["icontains", "enthält"], ["exact", "ist gleich"], ["istartswith", "beginnt mit"], ["iendswith", "endet mit"]],
number: [["exact", "gleich"], ["gte", "mindestens"], ["lte", "höchstens"], ["gt", "größer als"], ["lt", "kleiner als"], ["range", "zwischen"]],
date: [["exact", "am"], ["gte", "ab"], ["lte", "bis"], ["gt", "nach"], ["lt", "vor"], ["range", "zwischen"]],
boolean: [["exact", "ist"]],
select: [["exact", "ist"]],
};
const CUSTOM_PRESENCE = [["set", "hat einen Wert"], ["unset", "ist leer"]];
const CUSTOM_LIMIT = 5;
function customKind(field) {
return CUSTOM_KINDS[field?.type] || "text";
}
// A row that is not complete is reported, not left out of the search.
function customProblem(rows) {
for (const row of rows) {
const name = row.field ? "Eine Zusatzfeld-Bedingung" : "Eine Zusatzfeld-Bedingung ohne Feld";
if (!row.field) return `${name} ist unvollständig. Wähle ein Feld oder entferne die Zeile.`;
const presence = row.op === "set" || row.op === "unset";
if (presence || row.kind === "boolean") continue;
if (row.op === "range" ? !(row.value && row.value2) : !String(row.value).trim()) {
return `${name} ist unvollständig. Gib den Wert an oder entferne die Zeile.`;
}
}
return "";
}
function customPayload(rows) {
const payload = [];
for (const row of rows) {
if (!row.field) continue;
if (row.op === "set" || row.op === "unset") {
payload.push({ field: row.field, op: "exists", value: row.op === "set" });
} else if (row.op === "range") {
if (row.value && row.value2) payload.push({ field: row.field, op: "range", value: [row.value, row.value2] });
} else if (row.kind === "boolean") {
payload.push({ field: row.field, op: "exact", value: row.value !== "false" });
} else if (String(row.value).trim()) {
payload.push({ field: row.field, op: row.op, value: String(row.value).trim() });
}
}
return payload;
}
function CustomFieldFilters({ fields, rows, onChange }) {
if (!fields.length) return null;
const byId = new Map(fields.map((item) => [item.id, item]));
function update(key, patch) {
onChange(rows.map((row) => (row.key === key ? { ...row, ...patch } : row)));
}
function choose(key, id) {
const field = byId.get(id);
const kind = customKind(field);
const first = field ? CUSTOM_OPERATORS[kind][0][0] : "";
update(key, { field: id, kind, op: first, value: kind === "boolean" ? "true" : "", value2: "" });
}
function add() {
onChange([...rows, { key: `${Date.now()}-${rows.length}`, field: "", kind: "text", op: "", value: "", value2: "" }]);
}
return (
<fieldset className="paperless-custom">
<legend>Zusatzfelder, alle Bedingungen zugleich</legend>
{rows.map((row) => {
const field = byId.get(row.field);
const kind = customKind(field);
const value = (name, label) => {
if (kind === "boolean") {
return (
<select aria-label={label} value={row.value} onChange={(event) => update(row.key, { [name]: event.target.value })}>
<option value="true">Ja</option>
<option value="false">Nein</option>
</select>
);
}
if (kind === "select") {
return (
<select aria-label={label} value={row.value} onChange={(event) => update(row.key, { [name]: event.target.value })}>
<option value="">Wert wählen</option>
{(field.options || []).map((option) => <option key={option.id} value={option.id}>{option.name}</option>)}
</select>
);
}
return (
<input
aria-label={label}
type={kind === "date" ? "date" : "text"}
inputMode={kind === "number" ? "decimal" : undefined}
value={name === "value" ? row.value : row.value2}
onChange={(event) => update(row.key, { [name]: event.target.value })}
/>
);
};
const presence = row.op === "set" || row.op === "unset";
return (
<div key={row.key} className="paperless-custom__row">
<select aria-label="Zusatzfeld" value={row.field} onChange={(event) => choose(row.key, event.target.value)}>
<option value="">Feld wählen</option>
{fields.map((item) => <option key={item.id} value={item.id}>{item.name}</option>)}
</select>
{field ? (
<select aria-label="Bedingung" value={row.op} onChange={(event) => update(row.key, { op: event.target.value })}>
{CUSTOM_OPERATORS[kind].map(([op, label]) => <option key={op} value={op}>{label}</option>)}
{CUSTOM_PRESENCE.map(([op, label]) => <option key={op} value={op}>{label}</option>)}
</select>
) : null}
{field && !presence ? value("value", row.op === "range" ? "Von" : "Wert") : null}
{field && row.op === "range" ? value("value2", "Bis") : null}
<button type="button" className="quiet" onClick={() => onChange(rows.filter((item) => item.key !== row.key))}>Entfernen</button>
</div>
);
})}
{rows.length < CUSTOM_LIMIT ? <button type="button" className="quiet" onClick={add}>Zusatzfeld-Bedingung hinzufügen</button> : null}
</fieldset>
);
}
// The thumbnail comes through the server like every other Paperless call, so the key stays there.
function PaperlessThumb({ connectorId, id }) {
const [url, setUrl] = useState("");
const [failed, setFailed] = useState("");
useEffect(() => {
let alive = true;
let made = "";
setUrl("");
setFailed("");
fetchBlob(`/api/v1/sources/paperless/thumbnail?connector_id=${connectorId}&item=${id}`)
.then((blob) => {
if (!alive) return;
made = URL.createObjectURL(blob);
setUrl(made);
})
.catch((err) => {
if (alive) setFailed(err.message || "Das Vorschaubild ist nicht verfügbar.");
});
return () => {
alive = false;
if (made) URL.revokeObjectURL(made);
};
}, [connectorId, id]);
if (url) return <img src={url} alt="" className="paperless-thumb__image" />;
return <span className="paperless-thumb__empty" title={failed || undefined}>{failed ? "Kein Bild" : ""}</span>;
}
export function PaperlessPicker({ context, placement, chapterId = "", chapterTitle = "", targetLabel = "", onDone, onInserted }) { export function PaperlessPicker({ context, placement, chapterId = "", chapterTitle = "", targetLabel = "", onDone, onInserted }) {
const [filters, setFilters] = useState(EMPTY_FILTERS); const [filters, setFilters] = useState(EMPTY_FILTERS);
const [items, setItems] = useState([]); const [items, setItems] = useState([]);
const [connectors, setConnectors] = useState([]); const [connectors, setConnectors] = useState([]);
const [connectorId, setConnectorId] = useState(""); const [connectorId, setConnectorId] = useState("");
const [facets, setFacets] = useState({ correspondents: [], document_types: [], tags: [] }); const [facets, setFacets] = useState(NO_FACETS);
const [page, setPage] = useState(1);
const [nextPage, setNextPage] = useState(null); const [nextPage, setNextPage] = useState(null);
const [previousPage, setPreviousPage] = useState(null);
const [total, setTotal] = useState(null);
const [searched, setSearched] = useState(false);
const [picked, setPicked] = useState(() => new Map()); const [picked, setPicked] = useState(() => new Map());
// Documents that are already present around the target, by presentKey. `review` holds the choices while the user decides.
const [present, setPresent] = useState(() => new Map());
const [review, setReview] = useState(null);
const [previewKey, setPreviewKey] = useState("");
const [previewUrl, setPreviewUrl] = useState(""); const [previewUrl, setPreviewUrl] = useState("");
const [pending, setPending] = useState(false); const [pending, setPending] = useState(false);
const [error, setError] = useState(""); const [error, setError] = useState("");
// The filters sit beside the hits on a wide screen. On a phone they start folded away.
const [tagSearch, setTagSearch] = useState("");
const [moreOpen, setMoreOpen] = useState(() => typeof window === "undefined" || !window.matchMedia || window.matchMedia("(min-width: 900px)").matches);
const searchRef = useRef(0); const searchRef = useRef(0);
const previewRef = useRef(0); const previewRef = useRef(0);
const facetRef = useRef(0); const facetRef = useRef(0);
@@ -106,7 +330,7 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
useEffect(() => { useEffect(() => {
if (!connectorId) { if (!connectorId) {
setFacets({ correspondents: [], document_types: [], tags: [] }); setFacets(NO_FACETS);
return undefined; return undefined;
} }
const token = facetRef.current + 1; const token = facetRef.current + 1;
@@ -114,7 +338,7 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
let alive = true; let alive = true;
api(`/api/v1/sources/paperless/facets?connector_id=${connectorId}`) api(`/api/v1/sources/paperless/facets?connector_id=${connectorId}`)
.then((data) => { .then((data) => {
if (alive && token === facetRef.current) setFacets(data); if (alive && token === facetRef.current) setFacets({ ...NO_FACETS, ...data });
}) })
.catch((err) => { .catch((err) => {
if (alive && token === facetRef.current) setError(err.message); if (alive && token === facetRef.current) setError(err.message);
@@ -128,57 +352,112 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
if (previewUrl) URL.revokeObjectURL(previewUrl); if (previewUrl) URL.revokeObjectURL(previewUrl);
}, [previewUrl]); }, [previewUrl]);
function paramsFor(page) { function paramsFor(pageNumber) {
const params = new URLSearchParams(); const params = new URLSearchParams();
const text = filters.query.trim();
if (connectorId) params.set("connector_id", connectorId); if (connectorId) params.set("connector_id", connectorId);
if (filters.query.trim()) params.set("q", filters.query.trim()); if (text) params.set("q", text);
if (text && filters.mode !== "title_content") params.set("mode", filters.mode);
if (filters.title.trim()) params.set("title", filters.title.trim()); if (filters.title.trim()) params.set("title", filters.title.trim());
if (filters.correspondent) params.set("correspondent", filters.correspondent); if (filters.correspondent) params.set("correspondent", filters.correspondent);
if (filters.documentType) params.set("document_type", filters.documentType); if (filters.documentType) params.set("document_type", filters.documentType);
if (filters.tags.length) params.set("tag", filters.tags.join(",")); if (filters.storagePath) params.set("storage_path", filters.storagePath);
if (filters.tags.length) {
params.set("tag", filters.tags.join(","));
if (filters.tagMode !== "all") params.set("tag_mode", filters.tagMode);
}
if (filters.documentFrom) params.set("document_from", filters.documentFrom); if (filters.documentFrom) params.set("document_from", filters.documentFrom);
if (filters.documentTo) params.set("document_to", filters.documentTo); if (filters.documentTo) params.set("document_to", filters.documentTo);
if (filters.addedFrom) params.set("added_from", filters.addedFrom);
if (filters.addedTo) params.set("added_to", filters.addedTo);
if (filters.asn.trim()) params.set("asn", filters.asn.trim());
const custom = customPayload(filters.custom);
if (custom.length) params.set("custom", JSON.stringify(custom));
if (filters.sort === "-score") { if (filters.sort === "-score") {
if (filters.query.trim()) params.set("sort", "-score"); if (text && filters.mode === "index") params.set("sort", "-score");
} else if (filters.sort) { } else if (filters.sort) {
params.set("sort", filters.sort); params.set("sort", filters.sort);
} }
if (page) params.set("cursor", String(page)); if (pageNumber) params.set("cursor", String(pageNumber));
return params; return params;
} }
function closePreview() {
previewRef.current += 1;
if (previewUrl) URL.revokeObjectURL(previewUrl);
setPreviewUrl("");
setPreviewKey("");
}
function invalidate() { function invalidate() {
searchRef.current += 1; searchRef.current += 1;
previewRef.current += 1; previewRef.current += 1;
facetRef.current += 1; facetRef.current += 1;
} }
async function runSearch(event, page = "") { async function runSearch(event, wanted = "") {
event?.preventDefault(); event?.preventDefault();
setError(""); setError("");
if (connectors.length > 1 && !connectorId) { if (connectors.length > 1 && !connectorId) {
setError("Wähle zuerst den Paperless-Zugang."); setError("Wähle zuerst den Paperless-Zugang.");
return; return;
} }
const problem = customProblem(filters.custom);
if (problem) {
setError(problem);
return;
}
const token = searchRef.current + 1; const token = searchRef.current + 1;
searchRef.current = token; searchRef.current = token;
const asked = connectorId; const asked = connectorId;
try { try {
const data = await api(`/api/v1/sources/paperless/documents?${paramsFor(page)}`); const data = await api(`/api/v1/sources/paperless/documents?${paramsFor(wanted)}`);
if (token !== searchRef.current) return; if (token !== searchRef.current) return;
closePreview();
setItems(data.items || []); setItems(data.items || []);
setPage(Number(wanted) || 1);
setNextPage(data.next_page || data.continuation || null); setNextPage(data.next_page || data.continuation || null);
setPreviousPage(data.previous_page || null);
setTotal(typeof data.total === "number" ? data.total : null);
setSearched(true);
if (!asked && data.connector_id) setConnectorId(data.connector_id); if (!asked && data.connector_id) setConnectorId(data.connector_id);
refreshPresent(data.items || [], asked || data.connector_id || "");
} catch (err) { } catch (err) {
if (token !== searchRef.current) return; if (token !== searchRef.current) return;
setError(err.message); setError(err.message);
} }
} }
function presentEntry(item, bound = connectorId) {
return { source: "paperless", external_id: String(item.id), connector_id: item.connector_id || bound };
}
function matchesOf(item) {
const entry = presentEntry(item);
return present.get(presentKey(entry.source, entry.connector_id, entry.external_id)) || [];
}
async function refreshPresent(list, bound) {
const entries = list.map((item) => presentEntry(item, bound));
const found = await lookupPresent(context, placement, entries);
setPresent((current) => {
const next = new Map(current);
entries.forEach((entry) => next.delete(presentKey(entry.source, entry.connector_id, entry.external_id)));
found.forEach((value, key) => next.set(key, value));
return next;
});
}
function resetFilters() { function resetFilters() {
invalidate();
closePreview();
setFilters(EMPTY_FILTERS); setFilters(EMPTY_FILTERS);
setItems([]); setItems([]);
setNextPage(null); setNextPage(null);
setPreviousPage(null);
setTotal(null);
setSearched(false);
setPage(1);
} }
function toggle(item) { function toggle(item) {
@@ -194,73 +473,123 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
async function preview(item) { async function preview(item) {
setError(""); setError("");
if (previewUrl) URL.revokeObjectURL(previewUrl); const bound = item.connector_id || connectorId;
setPreviewUrl(""); const key = `${bound}:${item.id}`;
if (key === previewKey) {
closePreview();
return;
}
closePreview();
const token = previewRef.current + 1; const token = previewRef.current + 1;
previewRef.current = token; previewRef.current = token;
const bound = item.connector_id || connectorId; setPreviewKey(key);
try { try {
const blob = await fetchBlob(`/api/v1/sources/paperless/documents/${item.id}/preview?connector_id=${bound}`); const blob = await fetchBlob(`/api/v1/sources/paperless/documents/${item.id}/preview?connector_id=${bound}`);
if (token !== previewRef.current) return; if (token !== previewRef.current) return;
setPreviewUrl(URL.createObjectURL(blob)); setPreviewUrl(URL.createObjectURL(blob));
} catch (err) { } catch (err) {
if (token !== previewRef.current) return; if (token !== previewRef.current) return;
setPreviewKey("");
setError(err.message); setError(err.message);
} }
} }
async function linkMany() { async function linkMany(choices = null) {
const chosen = [...picked.values()]; const chosen = [...picked.values()];
if (!chosen.length) return; if (!chosen.length) return;
setError(""); setError("");
const keyOf = (item) => `${item.connector_id || connectorId}:${item.id}`;
if (!choices) {
const known = chosen.filter((item) => matchesOf(item).length);
if (known.length) {
setReview(new Map(known.map((item) => [keyOf(item), "skip"])));
return;
}
}
setReview(null);
setPending(true); setPending(true);
const inserted = []; const inserted = [];
const skipped = [];
const conflicts = [];
try { try {
for (const item of chosen) { for (const item of chosen) {
await api("/api/v1/external-refs", { const key = keyOf(item);
method: "POST", const choice = choices?.get(key);
body: { if (choice === "skip") {
title: item.title, skipped.push(key);
source: "paperless", continue;
external_id: String(item.id), }
context, const existing = choice === "bind" ? bindable(matchesOf(item)) : null;
...(placement ? { placement } : {}), try {
...(chapterId ? { chapter_id: chapterId } : {}), await api("/api/v1/external-refs", {
...(item.document_on || item.correspondent || item.open_url || connectorId method: "POST",
? { body: {
dates: { document_on: item.document_on || null, sent_on: null, received_on: null }, title: item.title,
detail: { source: "paperless",
...(item.connector_id || connectorId ? { connector_id: item.connector_id || connectorId } : {}), external_id: String(item.id),
...(item.correspondent ? { correspondent: item.correspondent } : {}), context,
...(item.open_url ? { open_url: item.open_url } : {}), ...(placement ? { placement } : {}),
}, ...(chapterId ? { chapter_id: chapterId } : {}),
} ...(choice === "insert" ? { duplicate: "insert" } : {}),
: {}), ...(existing ? { bind_element_id: existing.element_id } : {}),
}, ...(item.document_on || item.correspondent || item.open_url || connectorId
}); ? {
inserted.push(`${item.connector_id || connectorId}:${item.id}`); dates: { document_on: item.document_on || null, sent_on: null, received_on: null },
detail: {
...(item.connector_id || connectorId ? { connector_id: item.connector_id || connectorId } : {}),
...(item.correspondent ? { correspondent: item.correspondent } : {}),
...(item.open_url ? { open_url: item.open_url } : {}),
},
}
: {}),
},
});
inserted.push(key);
} catch (err) {
// Inserted by someone else in the meantime: ask again instead of failing.
if (err.code !== "already_present") throw err;
conflicts.push(item);
}
} }
} catch (err) { } catch (err) {
setError(err.message); setError(err.message);
} finally { } finally {
setPending(false); setPending(false);
} }
if (conflicts.length) {
await refreshPresent(conflicts, connectorId);
setReview(new Map(conflicts.map((item) => [keyOf(item), "skip"])));
}
if (inserted.length) { if (inserted.length) {
setItems((current) => current.filter((item) => !inserted.includes(`${connectorId}:${item.id}`))); setItems((current) => current.filter((item) => !inserted.includes(`${connectorId}:${item.id}`)));
setPicked((current) => {
const next = new Map(current);
inserted.forEach((id) => next.delete(id));
return next;
});
onInserted?.(); onInserted?.();
} }
if (inserted.length === chosen.length) onDone(); setPicked((current) => {
const next = new Map(current);
[...inserted, ...skipped].forEach((id) => next.delete(id));
return next;
});
if (inserted.length && inserted.length + skipped.length === chosen.length) onDone();
} }
function setFilter(name, value) { function setFilter(name, value) {
setFilters((current) => ({ ...current, [name]: value })); setFilters((current) => ({ ...current, [name]: value }));
} }
function setMode(mode) {
setFilters((current) => ({ ...current, mode, sort: current.sort === "-score" && mode !== "index" ? "-created" : current.sort }));
}
const visibleTags = facets.tags.filter((item) => item.name.toLocaleLowerCase().includes(tagSearch.trim().toLocaleLowerCase()));
function tagName(id) {
return facets.tags.find((item) => item.id === id)?.name || id;
}
function selectTags(ids) {
setFilters((current) => ({ ...current, tags: [...new Set([...current.tags, ...ids])] }));
}
function toggleTag(id) { function toggleTag(id) {
setFilters((current) => { setFilters((current) => {
const tags = current.tags.includes(id) ? current.tags.filter((item) => item !== id) : [...current.tags, id]; const tags = current.tags.includes(id) ? current.tags.filter((item) => item !== id) : [...current.tags, id];
@@ -269,21 +598,38 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
} }
const held = [...picked.values()].filter((item) => !items.some((entry) => `${connectorId}:${entry.id}` === `${item.connector_id}:${item.id}`)); const held = [...picked.values()].filter((item) => !items.some((entry) => `${connectorId}:${entry.id}` === `${item.connector_id}:${item.id}`));
const active = activeFilterCount(filters);
const relevance = filters.mode === "index" && filters.query.trim() !== "";
function choiceSelect(name, value, entries, empty) {
return (
<select value={value} onChange={(event) => setFilter(name, event.target.value)}>
<option value="">Alle</option>
<option value="none">{empty}</option>
{entries.map((item) => <option key={item.id} value={item.id}>{item.name}</option>)}
</select>
);
}
return ( return (
<SourceFrame targetLabel={targetLabel} chapterId={chapterId} chapterTitle={chapterTitle}> <SourceFrame targetLabel={targetLabel} chapterId={chapterId} chapterTitle={chapterTitle}>
<div className="paperless-layout">
<aside className="paperless-layout__filters" aria-label="Suche und Filter">
{connectors.length > 1 ? ( {connectors.length > 1 ? (
<label> <label>
Paperless-Zugang Paperless-Zugang
<select value={connectorId} onChange={(event) => { <select value={connectorId} onChange={(event) => {
invalidate(); invalidate();
if (previewUrl) URL.revokeObjectURL(previewUrl); closePreview();
setPreviewUrl("");
setConnectorId(event.target.value); setConnectorId(event.target.value);
setFilters(EMPTY_FILTERS); setFilters(EMPTY_FILTERS);
setItems([]); setItems([]);
setNextPage(null); setNextPage(null);
setFacets({ correspondents: [], document_types: [], tags: [] }); setPreviousPage(null);
setTotal(null);
setSearched(false);
setPage(1);
setFacets(NO_FACETS);
}}> }}>
<option value="">Zugang wählen</option> <option value="">Zugang wählen</option>
{connectors.map((item) => ( {connectors.map((item) => (
@@ -293,69 +639,169 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
</label> </label>
) : null} ) : null}
<form onSubmit={(event) => runSearch(event)} className="stack source-filters"> <form onSubmit={(event) => runSearch(event)} className="stack source-filters">
<label> <div className="paperless-search">
Suchtext in Titel und Inhalt <label>
<input value={filters.query} onChange={(event) => setFilter("query", event.target.value)} /> Suche in
</label> <select value={filters.mode} onChange={(event) => setMode(event.target.value)}>
<label> {PAPERLESS_MODES.map(([value, label]) => <option key={value} value={value}>{label}</option>)}
Titel </select>
<input value={filters.title} onChange={(event) => setFilter("title", event.target.value)} /> </label>
</label> <label className="paperless-search__text">
<label> Suchtext
Korrespondent <input value={filters.query} onChange={(event) => setFilter("query", event.target.value)} />
<select value={filters.correspondent} onChange={(event) => setFilter("correspondent", event.target.value)}> </label>
<option value="">Alle</option> <button type="submit">Suchen</button>
{facets.correspondents.map((item) => <option key={item.id} value={item.id}>{item.name}</option>)} </div>
</select> <p className="muted">{PAPERLESS_MODE_HINTS[filters.mode]}</p>
</label> <details className="paperless-more" open={moreOpen} onToggle={(event) => setMoreOpen(event.currentTarget.open)}>
<label> <summary>{active ? `Weitere Filter (${active} aktiv)` : "Weitere Filter"}</summary>
Dokumenttyp <div className="source-filters">
<select value={filters.documentType} onChange={(event) => setFilter("documentType", event.target.value)}> <label>
<option value="">Alle</option> Titel enthält
{facets.document_types.map((item) => <option key={item.id} value={item.id}>{item.name}</option>)} <input value={filters.title} onChange={(event) => setFilter("title", event.target.value)} />
</select>
</label>
<fieldset>
<legend>Tags, alle gewählten</legend>
{facets.tags.length ? facets.tags.map((item) => (
<label key={item.id} className="paperless-pick">
<input type="checkbox" checked={filters.tags.includes(item.id)} onChange={() => toggleTag(item.id)} />
<span>{item.name}</span>
</label> </label>
)) : <p className="muted">Keine Tags an diesem Zugang.</p>} <label>
</fieldset> Korrespondent
<label> {choiceSelect("correspondent", filters.correspondent, facets.correspondents, "Ohne Korrespondent")}
Dokumentdatum von </label>
<input type="date" value={filters.documentFrom} onChange={(event) => setFilter("documentFrom", event.target.value)} /> <label>
</label> Dokumenttyp
<label> {choiceSelect("documentType", filters.documentType, facets.document_types, "Ohne Dokumenttyp")}
Dokumentdatum bis </label>
<input type="date" value={filters.documentTo} onChange={(event) => setFilter("documentTo", event.target.value)} /> <label>
</label> Speicherpfad
{choiceSelect("storagePath", filters.storagePath, facets.storage_paths, "Ohne Speicherpfad")}
</label>
<fieldset>
<legend>Tags</legend>
<label>
Verknüpfung
<select value={filters.tagMode} onChange={(event) => setFilter("tagMode", event.target.value)}>
<option value="all">Alle gewählten Tags</option>
<option value="any">Mindestens eines der gewählten Tags</option>
<option value="none">Keines der gewählten Tags</option>
</select>
</label>
{filters.tags.length ? (
<ul className="paperless-chips" aria-label="Gewählte Tags">
{filters.tags.map((id) => (
<li key={id}>
<button type="button" className="paperless-chip" onClick={() => toggleTag(id)} aria-label={`Tag ${tagName(id)} entfernen`}>
{tagName(id)} <span aria-hidden="true">×</span>
</button>
</li>
))}
</ul>
) : null}
{facets.tags.length ? (
<>
<input type="search" value={tagSearch} onChange={(event) => setTagSearch(event.target.value)} placeholder="Tags suchen" aria-label="Tags suchen" />
<div className="paperless-tags__actions">
<button type="button" className="quiet" onClick={() => selectTags(visibleTags.map((item) => item.id))} disabled={!visibleTags.length}>
{tagSearch.trim() ? "Treffer wählen" : "Alle wählen"}
</button>
<button type="button" className="quiet" onClick={() => setFilter("tags", [])} disabled={!filters.tags.length}>
Alle abwählen
</button>
</div>
</>
) : null}
<div className="paperless-tags">
{visibleTags.map((item) => (
<label key={item.id} className="paperless-pick">
<input type="checkbox" checked={filters.tags.includes(item.id)} onChange={() => toggleTag(item.id)} />
<span>{item.name}</span>
</label>
))}
{!facets.tags.length ? <p className="muted">Keine Tags an diesem Zugang.</p> : null}
{facets.tags.length && !visibleTags.length ? <p className="muted">Kein Tag passt zur Suche.</p> : null}
</div>
</fieldset>
<label>
Dokumentdatum von
<input type="date" value={filters.documentFrom} onChange={(event) => setFilter("documentFrom", event.target.value)} />
</label>
<label>
Dokumentdatum bis
<input type="date" value={filters.documentTo} onChange={(event) => setFilter("documentTo", event.target.value)} />
</label>
<label>
Hinzugefügt von
<input type="date" value={filters.addedFrom} onChange={(event) => setFilter("addedFrom", event.target.value)} />
</label>
<label>
Hinzugefügt bis
<input type="date" value={filters.addedTo} onChange={(event) => setFilter("addedTo", event.target.value)} />
</label>
<label>
Archivnummer (ASN)
<input inputMode="numeric" value={filters.asn} onChange={(event) => setFilter("asn", event.target.value)} />
</label>
<CustomFieldFilters fields={facets.custom_fields || []} rows={filters.custom} onChange={(rows) => setFilter("custom", rows)} />
</div>
</details>
<label> <label>
Sortierung Sortierung
<select value={filters.sort} onChange={(event) => setFilter("sort", event.target.value)}> <select value={filters.sort} onChange={(event) => setFilter("sort", event.target.value)}>
<option value="-created">Dokumentdatum, neueste zuerst</option> <option value="-created">Dokumentdatum, neueste zuerst</option>
<option value="created">Dokumentdatum, älteste zuerst</option> <option value="created">Dokumentdatum, älteste zuerst</option>
<option value="-added">Hinzugefügt, neueste zuerst</option>
<option value="added">Hinzugefügt, älteste zuerst</option>
<option value="title">Titel aufsteigend</option> <option value="title">Titel aufsteigend</option>
<option value="-title">Titel absteigend</option> <option value="-title">Titel absteigend</option>
<option value="-score" disabled={!filters.query.trim()}>Relevanz zum Suchtext</option> <option value="-score" disabled={!relevance}>Relevanz (nur Volltextindex mit Suchtext)</option>
</select> </select>
</label> </label>
<div className="row"> <div className="row">
<button type="submit">Suchen</button>
<button type="button" className="quiet" onClick={resetFilters}>Filter zurücksetzen</button> <button type="button" className="quiet" onClick={resetFilters}>Filter zurücksetzen</button>
</div> </div>
</form> </form>
</aside>
<section className="paperless-layout__results" aria-label="Treffer">
<ErrorNote error={error} /> <ErrorNote error={error} />
<p className="muted">{SEARCH_LIMITS.paperless}</p> <p className="muted">{SEARCH_LIMITS.paperless}</p>
<p className="muted">Die Verbindung richtest du unter <Link to="/sources">Quellen</Link> ein. Ausgewählte Belege bleiben erhalten, wenn du weiterblätterst oder neu suchst.</p> <p className="muted">Die Verbindung richtest du unter <Link to="/sources">Quellen</Link> ein. Ausgewählte Belege bleiben erhalten, wenn du weiterblätterst oder neu suchst.</p>
{review ? (
<div className="card stack duplicate-panel" role="alert">
<strong>Diese Belege sind schon vorhanden. Was soll geschehen?</strong>
<ul className="duplicate-list">
{[...picked.values()].filter((item) => review.has(`${item.connector_id || connectorId}:${item.id}`)).map((item) => {
const key = `${item.connector_id || connectorId}:${item.id}`;
const matches = matchesOf(item);
return (
<li key={key}>
<span>{item.title}: {matches.length ? describeMatch(matches[0]) : "schon vorhanden"}</span>
<select
value={review.get(key)}
aria-label={`Entscheidung für ${item.title}`}
onChange={(event) => setReview((current) => new Map(current).set(key, event.target.value))}
>
<option value="skip">Nicht einfügen</option>
<option value="insert">Trotzdem erneut einfügen</option>
{bindable(matches) ? <option value="bind">Vorhandenes zusätzlich einbinden</option> : null}
</select>
</li>
);
})}
</ul>
<div className="row">
<button type="button" className="quiet" disabled={pending} onClick={() => setReview(null)}>Zurück zur Auswahl</button>
<button type="button" disabled={pending} onClick={() => linkMany(review)}>Entscheidung ausführen</button>
</div>
</div>
) : null}
{items.length || picked.size ? ( {items.length || picked.size ? (
<button type="button" disabled={pending || picked.size === 0} onClick={linkMany}> <button type="button" disabled={pending || picked.size === 0 || Boolean(review)} onClick={() => linkMany()}>
{picked.size ? `${picked.size} Belege einfügen` : "Belege auswählen"} {picked.size ? `${picked.size} Belege einfügen` : "Belege auswählen"}
</button> </button>
) : null} ) : null}
{previewUrl ? <iframe className="reader-frame" title="Paperless-Vorschau" src={previewUrl} /> : null} {searched ? (
<p className="muted" role="status">
{items.length
? `${total !== null ? `${total} Treffer` : "Treffer"}, Seite ${page}`
: "Dazu gibt es in Paperless keinen Treffer."}
</p>
) : null}
<div className="stack"> <div className="stack">
{held.map((item) => ( {held.map((item) => (
<div key={`held-${item.connector_id}:${item.id}`} className="paperless-pick"> <div key={`held-${item.connector_id}:${item.id}`} className="paperless-pick">
@@ -365,17 +811,65 @@ export function PaperlessPicker({ context, placement, chapterId = "", chapterTit
</label> </label>
</div> </div>
))} ))}
{items.map((item) => ( {items.map((item) => {
<div key={`${connectorId}:${item.id}`} className="paperless-pick"> const key = `${connectorId}:${item.id}`;
<label> const open = previewKey === key;
<input type="checkbox" checked={picked.has(`${connectorId}:${item.id}`)} disabled={pending} onChange={() => toggle(item)} /> const facts = paperlessFacts(item);
<span>{paperlessLabel(item)}</span> return (
</label> <article key={key} className={open ? "paperless-card is-open" : "paperless-card"}>
<button type="button" className="quiet" onClick={() => preview(item)}>Ansehen</button> <input
</div> type="checkbox"
))} checked={picked.has(key)}
disabled={pending}
onChange={() => toggle(item)}
aria-label={`${item.title} auswählen`}
/>
<button type="button" className="paperless-thumb" onClick={() => preview(item)} aria-label={`${item.title} ansehen`}>
<PaperlessThumb connectorId={connectorId} id={item.id} />
</button>
<div className="paperless-card__body">
<strong>{item.title}</strong>
<PresentNote matches={matchesOf(item)} />
{facts.length ? <span className="paperless-card__facts">{facts.join(" · ")}</span> : null}
{item.tags?.length ? (
<ul className="paperless-card__tags" aria-label="Tags">
{item.tags.map((tag) => <li key={tag}>{tag}</li>)}
</ul>
) : null}
{item.custom_fields?.length ? (
<dl className="paperless-card__fields" aria-label="Zusatzfelder">
{item.custom_fields.map((field) => (
<div key={field.name}>
<dt>{field.name}</dt>
<dd>{field.type === "date" && formatDate(field.value) !== "Ohne Datum" ? formatDate(field.value) : field.value}</dd>
</div>
))}
</dl>
) : null}
{item.snippet ? <p className="paperless-card__snippet">{item.snippet}</p> : null}
<div className="row">
<button type="button" className="quiet" onClick={() => preview(item)} aria-expanded={open}>
{open ? "Ansicht schließen" : "Ansehen"}
</button>
</div>
</div>
{open ? (
<div className="paperless-card__view">
{previewUrl ? <DocumentView title={`Paperless-Vorschau: ${item.title}`} url={previewUrl} /> : <p className="muted">Vorschau wird geladen …</p>}
</div>
) : null}
</article>
);
})}
</div>
{previousPage || nextPage ? (
<div className="row">
{previousPage ? <button type="button" className="quiet" onClick={(event) => runSearch(event, previousPage)}>Vorherige Treffer</button> : null}
{nextPage ? <button type="button" onClick={(event) => runSearch(event, nextPage)}>Weitere Treffer</button> : null}
</div>
) : null}
</section>
</div> </div>
{nextPage ? <button type="button" onClick={(event) => runSearch(event, nextPage)}>Weitere Treffer</button> : null}
</SourceFrame> </SourceFrame>
); );
} }
@@ -492,6 +986,7 @@ export function MailPicker({ context, placement, chapterId = "", chapterTitle =
const [preview, setPreview] = useState(null); const [preview, setPreview] = useState(null);
const [previewError, setPreviewError] = useState(""); const [previewError, setPreviewError] = useState("");
const [adopting, setAdopting] = useState(false); const [adopting, setAdopting] = useState(false);
const { place, panel } = useExternalPlacement({ context, placement, onPlaced: () => onDone() });
const [loading, setLoading] = useState(""); const [loading, setLoading] = useState("");
const [error, setError] = useState(""); const [error, setError] = useState("");
const requestRef = useRef(0); const requestRef = useRef(0);
@@ -674,26 +1169,22 @@ export function MailPicker({ context, placement, chapterId = "", chapterTitle =
if (cc) detail.message_cc = cc; if (cc) detail.message_cc = cc;
if (attachments.length) detail.attachments = attachments; if (attachments.length) detail.attachments = attachments;
try { try {
await api("/api/v1/external-refs", { await place({
method: "POST", title: item.title,
body: { source: "imap",
title: item.title, external_id: item.id,
source: "imap", context,
external_id: item.id, ...(placement ? { placement } : {}),
context, ...(chapterId ? { chapter_id: chapterId } : {}),
...(placement ? { placement } : {}), ...(item.document_on ? {
...(chapterId ? { chapter_id: chapterId } : {}), dates: {
...(item.document_on ? { document_on: item.document_on,
dates: { sent_on: direction === "out" ? item.document_on : null,
document_on: item.document_on, received_on: direction === "in" ? item.document_on : null,
sent_on: direction === "out" ? item.document_on : null, },
received_on: direction === "in" ? item.document_on : null, } : {}),
}, detail,
} : {}),
detail,
},
}); });
onDone();
} catch (err) { } catch (err) {
setError(err.message); setError(err.message);
} finally { } finally {
@@ -774,6 +1265,7 @@ export function MailPicker({ context, placement, chapterId = "", chapterTitle =
{selected && !preview && !previewError ? <p className="muted">Vorschau wird geladen …</p> : null} {selected && !preview && !previewError ? <p className="muted">Vorschau wird geladen …</p> : null}
{preview ? <MailBody html={preview.html} text={preview.text} truncated={preview.text_truncated} notices={preview.notices} /> : null} {preview ? <MailBody html={preview.html} text={preview.text} truncated={preview.text_truncated} notices={preview.notices} /> : null}
<ErrorNote error={error} /> <ErrorNote error={error} />
{panel}
<button type="button" onClick={() => link(selected)} disabled={!selected.uid || adopting}>{adopting ? "Wird übernommen …" : "Übernehmen"}</button> <button type="button" onClick={() => link(selected)} disabled={!selected.uid || adopting}>{adopting ? "Wird übernommen …" : "Übernehmen"}</button>
</> </>
)} )}
@@ -783,5 +1275,5 @@ export function MailPicker({ context, placement, chapterId = "", chapterTitle =
); );
} }
registerSourceModule({ kind: "paperless", title: "Paperless", addLabel: "Paperless", manual: true, searchHint: SEARCH_LIMITS.paperless, Picker: PaperlessPicker }); registerSourceModule({ kind: "paperless", title: "Paperless", addLabel: "Paperless", manual: true, large: true, searchHint: SEARCH_LIMITS.paperless, Picker: PaperlessPicker });
registerSourceModule({ kind: "imap", title: "E-Mail-Konto", addLabel: "E-Mail", wide: true, searchHint: SEARCH_LIMITS.imap, Picker: MailPicker }); registerSourceModule({ kind: "imap", title: "E-Mail-Konto", addLabel: "E-Mail", wide: true, searchHint: SEARCH_LIMITS.imap, Picker: MailPicker });
-33
View File
@@ -191,39 +191,6 @@ export function nestRecords(items, parentKey) {
return { roots, children }; return { roots, children };
} }
function TreeBranch({ item, children, hrefFor, nested }) {
const kids = children.get(item.id) || [];
return (
<li>
<Link className="hierarchy__row" to={hrefFor(item)}>
<span className="hierarchy__kind">{item.kind_label || "Eintrag"}</span>
<strong>{item.title}</strong>
{!nested && item.parent_title ? <span className="muted">in {item.parent_title}</span> : null}
<span className="muted">{item.status === "open" ? "Offen" : item.status === "closed" ? "Geschlossen" : ""}</span>
</Link>
{kids.length ? (
<ul>
{kids.map((child) => (
<TreeBranch key={child.id} item={child} children={children} hrefFor={hrefFor} nested />
))}
</ul>
) : null}
</li>
);
}
export function RecordTree({ items, parentKey, hrefFor }) {
const { roots, children } = nestRecords(items, parentKey);
if (!roots.length) return null;
return (
<ul className="hierarchy">
{roots.map((item) => (
<TreeBranch key={item.id} item={item} children={children} hrefFor={hrefFor} nested={false} />
))}
</ul>
);
}
function looseSection(loose, chapters) { function looseSection(loose, chapters) {
if (chapters.length && loose.length) { if (chapters.length && loose.length) {
return { id: "loose", title: "Ohne Kapitel", documentOn: "", parentId: "", items: loose, children: [] }; return { id: "loose", title: "Ohne Kapitel", documentOn: "", parentId: "", items: loose, children: [] };
+1
View File
@@ -16,6 +16,7 @@ const common = {
export function NavIcon({ name }) { export function NavIcon({ name }) {
if (name === "home") return <svg {...common}><path d="M4 10.5 12 4l8 6.5V20a1 1 0 0 1-1 1h-5v-6H10v6H5a1 1 0 0 1-1-1z" /></svg>; if (name === "home") return <svg {...common}><path d="M4 10.5 12 4l8 6.5V20a1 1 0 0 1-1 1h-5v-6H10v6H5a1 1 0 0 1-1-1z" /></svg>;
if (name === "folder") return <svg {...common}><path d="M3 7.5A2 2 0 0 1 5 5.5h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z" /></svg>; if (name === "folder") return <svg {...common}><path d="M3 7.5A2 2 0 0 1 5 5.5h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z" /></svg>;
if (name === "rooms") return <svg {...common}><circle cx="9" cy="9" r="3" /><path d="M3.5 19c.5-3.3 2.8-5 5.5-5s5 1.7 5.5 5" /><circle cx="17" cy="9.5" r="2.4" /><path d="M16 14.2c2.6-.3 4.4 1.1 4.8 4.3" /></svg>;
if (name === "layers") return <svg {...common}><path d="m12 3 9 5-9 5-9-5z" /><path d="m3 12 9 5 9-5" /></svg>; if (name === "layers") return <svg {...common}><path d="m12 3 9 5-9 5-9-5z" /><path d="m3 12 9 5 9-5" /></svg>;
if (name === "check") return <svg {...common}><rect x="4" y="4" width="16" height="16" rx="2" /><path d="m8 12 2.5 2.5L16 9" /></svg>; if (name === "check") return <svg {...common}><rect x="4" y="4" width="16" height="16" rx="2" /><path d="m8 12 2.5 2.5L16 9" /></svg>;
if (name === "gear") return <svg {...common}><circle cx="12" cy="12" r="3" /><path d="M12 3.5v2.2M12 18.3v2.2M3.5 12h2.2M18.3 12h2.2M6 6l1.6 1.6M16.4 16.4 18 18M18 6l-1.6 1.6M7.6 16.4 6 18" /></svg>; if (name === "gear") return <svg {...common}><circle cx="12" cy="12" r="3" /><path d="M12 3.5v2.2M12 18.3v2.2M3.5 12h2.2M18.3 12h2.2M6 6l1.6 1.6M16.4 16.4 18 18M18 6l-1.6 1.6M7.6 16.4 6 18" /></svg>;
+7 -4
View File
@@ -1,3 +1,4 @@
import { DocumentView } from "./DocumentView.jsx";
import { useEffect, useRef, useState } from "react"; import { useEffect, useRef, useState } from "react";
import { Link } from "react-router-dom"; import { Link } from "react-router-dom";
import { api, documentToText, downloadFile, fetchExternal, markDirty, textToDocument } from "../api.js"; import { api, documentToText, downloadFile, fetchExternal, markDirty, textToDocument } from "../api.js";
@@ -199,9 +200,11 @@ function Binding({ binding, context, canEdit, isOwner, onChange }) {
{element.kind === "note" ? <RegisteredNote element={element} context={context} binding={binding} onReload={onChange} /> : null} {element.kind === "note" ? <RegisteredNote element={element} context={context} binding={binding} onReload={onChange} /> : null}
{element.kind === "file" && element.file ? ( {element.kind === "file" && element.file ? (
element.file.status === "active" ? ( element.file.status === "active" ? (
<button type="button" onClick={() => downloadFile(element.id, context, element.file.filename)}> binding.rights.download ? (
{element.file.filename} herunterladen <button type="button" onClick={() => downloadFile(element.id, context, element.file.filename).catch((err) => setError(err.message))}>
</button> {element.file.filename} herunterladen
</button>
) : <p className="muted">{element.file.filename} · Das Herunterladen ist für dich nicht freigegeben.</p>
) : ( ) : (
<p className="error">Die Datei ist gerade nicht verfügbar.</p> <p className="error">Die Datei ist gerade nicht verfügbar.</p>
) )
@@ -227,7 +230,7 @@ function Binding({ binding, context, canEdit, isOwner, onChange }) {
onClose={() => setViewing(false)} onClose={() => setViewing(false)}
> >
<div className="viewer"> <div className="viewer">
{previewUrl ? <iframe ref={frameRef} title={element.title} src={previewUrl} /> : <p className="muted">Dokument wird geladen …</p>} {previewUrl ? <DocumentView frameRef={frameRef} className="" title={element.title} url={previewUrl} /> : <p className="muted">Dokument wird geladen …</p>}
<div className="row"> <div className="row">
<button type="button" onClick={() => frameRef.current?.contentWindow?.print()} disabled={!previewUrl}>Drucken</button> <button type="button" onClick={() => frameRef.current?.contentWindow?.print()} disabled={!previewUrl}>Drucken</button>
</div> </div>
+15 -8
View File
@@ -2,6 +2,8 @@ import { useEffect, useState } from "react";
import { Link } from "react-router-dom"; import { Link } from "react-router-dom";
import { chapterPathLabel } from "./chapters.js"; import { chapterPathLabel } from "./chapters.js";
import { NavIcon } from "./icons.jsx"; import { NavIcon } from "./icons.jsx";
import { MiniIcon } from "../library/MiniIcon.jsx";
import { readTreeWidth } from "../library/library-core.js";
export function useWorkspaceLayout() { export function useWorkspaceLayout() {
const [width, setWidth] = useState(() => (typeof window === "undefined" ? 1280 : window.innerWidth)); const [width, setWidth] = useState(() => (typeof window === "undefined" ? 1280 : window.innerWidth));
@@ -16,12 +18,16 @@ export function useWorkspaceLayout() {
return { width, structureOpen, setStructureOpen }; return { width, structureOpen, setStructureOpen };
} }
// The navigation tree of the library sits left of the page on wide screens. Its width is set by the person.
export function Workspace({ width, structureOpen, setStructureOpen, hasEntry, nav, reader, listRef, children }) { export function Workspace({ width, structureOpen, setStructureOpen, hasEntry, nav, reader, listRef, children }) {
const phone = width < 760; const phone = width < 760;
const navColumn = width >= 1500; // Room for the page itself: the tree narrows it on wide screens.
const split = width >= 1180 && hasEntry; const room = width > 900 ? width - readTreeWidth() : width;
const showNav = phone ? structureOpen && !hasEntry : navColumn || structureOpen; const navColumn = Boolean(nav) && width >= 1500;
const showList = phone ? !structureOpen && !hasEntry : !(hasEntry && width < 1180); const split = room >= 1180 && hasEntry;
const showNav = Boolean(nav) && (phone ? structureOpen && !hasEntry : navColumn || structureOpen);
const showList = phone ? !structureOpen && !hasEntry : !(hasEntry && room < 1180);
const showReader = hasEntry && (phone ? !structureOpen : true); const showReader = hasEntry && (phone ? !structureOpen : true);
const overlay = showNav && !phone && !navColumn; const overlay = showNav && !phone && !navColumn;
@@ -52,12 +58,13 @@ export function Workspace({ width, structureOpen, setStructureOpen, hasEntry, na
); );
} }
// The same colored symbols as in the library tree: folder for cases, document stack for matters.
function structureIcon(kind) { function structureIcon(kind) {
if (kind === "Akte" || kind === "Unterakte") return "folder"; if (kind === "Akte" || kind === "Unterakte" || kind === "Weitere Akte") return "case";
if (kind === "Kapitel" || kind === "Unterkapitel") return "chapter"; if (kind === "Kapitel" || kind === "Unterkapitel") return "chapter";
if (kind === "Inhalte") return "contents"; if (kind === "Inhalte") return "contents";
if (kind === "Querverweis" || kind === "Weitere Akte") return "link"; if (kind === "Querverweis") return "link";
return "layers"; return "matter";
} }
function branchHasCurrent(node) { function branchHasCurrent(node) {
@@ -67,7 +74,7 @@ function branchHasCurrent(node) {
function TreeRow({ node, onNavigate, ancestor = false, toggle = null }) { function TreeRow({ node, onNavigate, ancestor = false, toggle = null }) {
const className = node.current ? "nav-tree__link is-current" : ancestor ? "nav-tree__link is-ancestor" : "nav-tree__link"; const className = node.current ? "nav-tree__link is-current" : ancestor ? "nav-tree__link is-ancestor" : "nav-tree__link";
const icon = <NavIcon name={structureIcon(node.kind)} />; const icon = <span className="nav-tree__icon"><MiniIcon kind={structureIcon(node.kind)} /></span>;
const name = node.path ? `${node.kind}: ${node.path}` : `${node.kind}: ${node.title}`; const name = node.path ? `${node.kind}: ${node.path}` : `${node.kind}: ${node.title}`;
const label = ( const label = (
<span className="nav-tree__title"> <span className="nav-tree__title">
+48 -69
View File
@@ -1,10 +1,11 @@
import { useEffect, useRef, useState } from "react"; import { useEffect, useRef, useState } from "react";
import { api, documentToText, downloadMailPart, fetchExternal, fetchMailPart, markDirty, textToDocument } from "../api.js"; import { api, documentToText, downloadMailPart, fetchExternal, fetchMailPart, markDirty, textToDocument } from "../api.js";
import { MailAttachments, MailBody } from "../mail-view.jsx"; import { MailAttachments, MailBody } from "../mail-view.jsx";
import { deviceClass, readImageChoice } from "../mail-images.js";
import { MarkdownView } from "../markdown.jsx"; import { MarkdownView } from "../markdown.jsx";
import { NoteEditor } from "../notes.jsx"; import { NoteEditor } from "../notes.jsx";
import { DirectionColumn, directionWord } from "../pages/content.jsx"; import { DirectionColumn, directionWord } from "../pages/content.jsx";
import workerSrc from "pdfjs-dist/build/pdf.worker.min.mjs?url"; import { DocumentView } from "../pages/DocumentView.jsx";
import { editors, registerStage } from "./registry.jsx"; import { editors, registerStage } from "./registry.jsx";
function previewKind(type, filename) { function previewKind(type, filename) {
@@ -15,6 +16,11 @@ function previewKind(type, filename) {
return "other"; return "other";
} }
function isPdfBytes(buffer) {
const sample = new TextDecoder("iso-8859-1").decode(buffer.slice(0, 1024)).trim();
return sample.startsWith("%PDF");
}
export function NoteStage({ element, context, binding, onReload }) { export function NoteStage({ element, context, binding, onReload }) {
const editor = editors.note; const editor = editors.note;
const [text, setText] = useState(() => documentToText(element.document)); const [text, setText] = useState(() => documentToText(element.document));
@@ -123,17 +129,13 @@ export function TextStage({ element, context }) {
); );
} }
export function MailStage({ element, context, shownDirection }) { export function MailStage({ element, context, binding, shownDirection }) {
const [letter, setLetter] = useState(null); const [letter, setLetter] = useState(null);
const [error, setError] = useState(""); const [error, setError] = useState("");
const [shownFor, setShownFor] = useState(null); const [shownFor, setShownFor] = useState(null);
const [phase, setPhase] = useState("idle"); const [phase, setPhase] = useState("idle");
const [media, setMedia] = useState(""); const [media, setMedia] = useState("");
const [blobUrl, setBlobUrl] = useState(""); const [blobUrl, setBlobUrl] = useState("");
const [pdf, setPdf] = useState(null);
const [page, setPage] = useState(1);
const [pages, setPages] = useState(0);
const canvasRef = useRef(null);
const objectUrl = useRef(""); const objectUrl = useRef("");
const shownIndex = shownFor?.elementId === element?.id ? shownFor.index : null; const shownIndex = shownFor?.elementId === element?.id ? shownFor.index : null;
const shownFile = (letter?.attachments || []).find((item) => item.index === shownIndex) || null; const shownFile = (letter?.attachments || []).find((item) => item.index === shownIndex) || null;
@@ -160,49 +162,41 @@ export function MailStage({ element, context, shownDirection }) {
}, [element.id, element.external?.source, context?.kind, context?.id]); }, [element.id, element.external?.source, context?.kind, context?.id]);
useEffect(() => { useEffect(() => {
if (shownIndex === null) return undefined; if (shownIndex === null) {
setMedia("");
setPhase("idle");
if (objectUrl.current) {
URL.revokeObjectURL(objectUrl.current);
objectUrl.current = "";
}
setBlobUrl("");
return undefined;
}
const file = (letter?.attachments || []).find((item) => item.index === shownIndex); const file = (letter?.attachments || []).find((item) => item.index === shownIndex);
if (!file) return undefined; if (!file) return undefined;
let alive = true; let alive = true;
setPhase("loading"); setPhase("loading");
setMedia("");
fetchMailPart(element.id, context, `attachments/${file.index}`).then(async (blob) => { fetchMailPart(element.id, context, `attachments/${file.index}`).then(async (blob) => {
if (!alive) return; if (!alive) return;
if (objectUrl.current) URL.revokeObjectURL(objectUrl.current); const buffer = await blob.arrayBuffer();
const url = URL.createObjectURL(blob); if (!alive) return;
const declared = previewKind(blob.type || file.content_type, file.filename);
const kind = isPdfBytes(buffer) ? "pdf" : declared;
if (objectUrl.current) {
URL.revokeObjectURL(objectUrl.current);
objectUrl.current = "";
}
const type = kind === "pdf" ? "application/pdf" : (blob.type || file.content_type || "application/octet-stream");
const url = URL.createObjectURL(new Blob([buffer], { type }));
objectUrl.current = url; objectUrl.current = url;
setBlobUrl(url); setBlobUrl(url);
const kind = previewKind(blob.type || file.content_type, file.filename); setMedia(kind === "pdf" ? "pdf" : kind);
if (kind === "image") {
setMedia("image");
setPhase("ready");
return;
}
if (kind === "pdf") {
setMedia("pdf");
try {
const bytes = await blob.arrayBuffer();
const pdfjs = await import("pdfjs-dist");
pdfjs.GlobalWorkerOptions.workerSrc = workerSrc;
const doc = await pdfjs.getDocument({ data: bytes }).promise;
if (!alive) {
doc.destroy();
return;
}
setPdf(doc);
setPages(doc.numPages);
setPhase("ready");
} catch (err) {
if (!alive) return;
setMedia("pdf-frame");
setPhase("ready");
}
return;
}
setMedia("other");
setPhase("ready"); setPhase("ready");
}).catch((err) => { }).catch((err) => {
if (!alive) return; if (!alive) return;
setPhase("ready"); setPhase("ready");
setMedia("");
setError(err.message || "Die Anlage ist nicht verfügbar."); setError(err.message || "Die Anlage ist nicht verfügbar.");
}); });
return () => { return () => {
@@ -211,31 +205,13 @@ export function MailStage({ element, context, shownDirection }) {
}, [element.id, shownIndex, letter, context?.kind, context?.id]); }, [element.id, shownIndex, letter, context?.kind, context?.id]);
useEffect(() => () => { useEffect(() => () => {
pdf?.destroy?.();
if (objectUrl.current) URL.revokeObjectURL(objectUrl.current); if (objectUrl.current) URL.revokeObjectURL(objectUrl.current);
}, [pdf]); }, []);
useEffect(() => {
if (!pdf || !canvasRef.current) return undefined;
let alive = true;
pdf.getPage(page).then((pdfPage) => {
if (!alive || !canvasRef.current) return;
const canvas = canvasRef.current;
const context2d = canvas.getContext("2d");
const viewport = pdfPage.getViewport({ scale: 1 });
canvas.width = viewport.width;
canvas.height = viewport.height;
return pdfPage.render({ canvasContext: context2d, viewport }).promise;
}).catch(() => {});
return () => {
alive = false;
};
}, [pdf, page]);
async function openOriginal() { async function openOriginal() {
setError(""); setError("");
try { try {
await downloadMailPart(element.id, context, "original", "nachricht.eml"); await downloadMailPart(element.id, context, "original", `${letter?.title || "nachricht"}.eml`);
} catch (err) { } catch (err) {
setError(err.message); setError(err.message);
} }
@@ -259,18 +235,21 @@ export function MailStage({ element, context, shownDirection }) {
{shownFile ? <p className="mail-attachment__caption">Anlage: {shownFile.filename}</p> : null} {shownFile ? <p className="mail-attachment__caption">Anlage: {shownFile.filename}</p> : null}
{shownFile && phase === "loading" ? <p className="muted">Die Anlage wird geladen …</p> : null} {shownFile && phase === "loading" ? <p className="muted">Die Anlage wird geladen …</p> : null}
{media === "image" && blobUrl ? <img className="reader-image" alt={shownFile?.filename || element.title} src={blobUrl} /> : null} {media === "image" && blobUrl ? <img className="reader-image" alt={shownFile?.filename || element.title} src={blobUrl} /> : null}
{media === "pdf" && pdf ? <canvas ref={canvasRef} className="reader-canvas" /> : null} {media === "pdf" && blobUrl ? <DocumentView title={shownFile?.filename || element.title} url={blobUrl} /> : null}
{media === "pdf-frame" && blobUrl ? <iframe className="reader-frame" title={shownFile?.filename || element.title} src={blobUrl} /> : null} {media === "other" && blobUrl && binding?.rights?.download ? <a href={blobUrl} target="_blank" rel="noreferrer">Anlage öffnen</a> : null}
{media === "other" && blobUrl ? <a href={blobUrl} target="_blank" rel="noreferrer">Anlage öffnen</a> : null} <MailBody
{pages > 1 ? ( html={letter.html}
<div className="reader-pages"> text={letter.text}
<button type="button" disabled={page <= 1} onClick={() => setPage((current) => Math.max(1, current - 1))}>Vorherige Seite</button> truncated={letter.text_truncated}
<span>{page} / {pages}</span> notices={letter.notices}
<button type="button" disabled={page >= pages} onClick={() => setPage((current) => Math.min(pages, current + 1))}>Nächste Seite</button> remote={{
</div> key: element.id,
) : null} count: letter.remote_images || 0,
<MailBody html={letter.html} text={letter.text} truncated={letter.text_truncated} notices={letter.notices} /> auto: readImageChoice(deviceClass()) === "auto",
<button type="button" onClick={openOriginal}>Vollständige E-Mail</button> load: () => api(`/api/v1/external-refs/${element.id}/mail/html-with-images${context?.kind && context?.id ? `?context_kind=${context.kind}&context_id=${context.id}` : ""}`),
}}
/>
{binding?.rights?.download ? <button type="button" onClick={openOriginal}>Vollständige E-Mail herunterladen</button> : null}
</> </>
) : ( ) : (
<p className="muted">{error ? "Die vollständige Nachricht konnte nicht geladen werden." : "Die vollständige Nachricht wird geladen …"}</p> <p className="muted">{error ? "Die vollständige Nachricht konnte nicht geladen werden." : "Die vollständige Nachricht wird geladen …"}</p>
@@ -35,13 +35,20 @@ const OPERATIONS = [
const SEARCH_FILTERS = [ const SEARCH_FILTERS = [
["query", "Suchtext"], ["query", "Suchtext"],
["mode", "Suchart (Titel und Inhalt, Titel, Inhalt, Volltextindex)"],
["title", "Titel"], ["title", "Titel"],
["correspondent", "Korrespondent"], ["correspondent", "Korrespondent"],
["document_type", "Dokumenttyp"], ["document_type", "Dokumenttyp"],
["storage_path", "Speicherpfad"],
["tags", "Tags"], ["tags", "Tags"],
["tag_mode", "Tag-Verknüpfung (alle, mindestens eines, keines)"],
["document_range", "Dokumentdatum"], ["document_range", "Dokumentdatum"],
["added_range", "Hinzugefügt am"],
["asn", "Archivnummer"],
["custom_fields", "Zusatzfelder (benutzerdefinierte Felder)"],
["sort", "Sortierung"], ["sort", "Sortierung"],
["continuation", "Weitere Seiten"], ["continuation", "Weitere Seiten"],
["result_preview", "Vorschaubild und Textauszug je Treffer"],
]; ];
function Availability({ items, source }) { function Availability({ items, source }) {
+121
View File
@@ -0,0 +1,121 @@
import { useState } from "react";
import { api } from "../api.js";
// A document that is already present around the target. The server decides; this only asks and explains.
export function presentKey(source, connectorId, externalId) {
return `${source}:${connectorId || ""}:${externalId}`;
}
export function describeMatch(match) {
const title = match.container?.title;
const maybe = match.certain ? "" : "möglicherweise ";
if (match.where === "here") return `${maybe}schon hier${match.chapter ? ` (Kapitel „${match.chapter}“)` : ""}`;
if (match.where === "inside") return `${maybe}schon ${title ? `in „${title}“` : "in einem zugehörigen Teil"}`;
const kind = match.container?.kind === "case" ? "in der Akte" : "im Vorgang";
return `${maybe}schon ${kind}${title ? ` „${title}“` : ""}`;
}
export function bindable(matches) {
return (matches || []).find((item) => item.certain && item.can_bind && item.where !== "here") || null;
}
// entries: [{ source, external_id, connector_id }]. Answers a Map of presentKey -> matches, only for documents that are present.
// A failed lookup answers nothing: the warning is a help, the server still protects on insert.
export async function lookupPresent(context, placement, entries) {
const found = new Map();
if (!entries.length) return found;
try {
const data = await api("/api/v1/external-refs/existing", {
method: "POST",
body: {
context,
...(placement ? { placement } : {}),
items: entries.map((item) => ({ source: item.source, external_id: item.external_id, ...(item.connector_id ? { connector_id: item.connector_id } : {}) })),
},
});
for (const entry of data.items || []) {
if (entry.matches?.length) found.set(presentKey(entry.source, entry.connector_id, entry.external_id), entry.matches);
}
} catch {
return found;
}
return found;
}
export function PresentNote({ matches }) {
if (!matches?.length) return null;
return <p className="duplicate-note" role="status">Schon vorhanden: {matches.map(describeMatch).join(", ")}.</p>;
}
// Choices when a document is already present: do not insert, insert again, or bind the existing element as well.
export function DuplicatePanel({ matches, busy, onCancel, onInsert, onBind }) {
const existing = bindable(matches);
return (
<div className="card stack duplicate-panel" role="alert">
<strong>Dieses Dokument ist schon vorhanden.</strong>
<ul>
{matches.map((item) => <li key={item.element_id}>{item.title}: {describeMatch(item)}</li>)}
</ul>
<div className="row">
<button type="button" className="quiet" disabled={busy} onClick={onCancel}>Nicht einfügen</button>
<button type="button" className="quiet" disabled={busy} onClick={onInsert}>Trotzdem erneut einfügen</button>
{existing ? <button type="button" disabled={busy} onClick={() => onBind(existing.element_id)}>Vorhandenes zusätzlich einbinden</button> : null}
</div>
</div>
);
}
// One document at a time. `place(body)` posts it. If the server finds it already present, `panel` offers the choices
// and `onPlaced` runs once the document is in, whichever way.
export function useExternalPlacement({ context, placement, onPlaced }) {
const [conflict, setConflict] = useState(null);
const [busy, setBusy] = useState(false);
const [error, setError] = useState("");
async function send(body) {
await api("/api/v1/external-refs", { method: "POST", body });
setConflict(null);
await onPlaced?.();
}
async function place(body) {
setError("");
try {
await send(body);
} catch (err) {
if (err.code !== "already_present") throw err;
const entry = { source: body.source, external_id: body.external_id, connector_id: body.detail?.connector_id };
const found = await lookupPresent(context, placement, [entry]);
const matches = found.get(presentKey(entry.source, entry.connector_id, entry.external_id)) || [];
if (!matches.length) throw err;
setConflict({ body, matches });
}
}
async function resolve(extra) {
if (!conflict) return;
setBusy(true);
setError("");
try {
await send({ ...conflict.body, ...extra });
} catch (err) {
setError(err.message);
} finally {
setBusy(false);
}
}
const panel = conflict ? (
<>
<DuplicatePanel
matches={conflict.matches}
busy={busy}
onCancel={() => setConflict(null)}
onInsert={() => resolve({ duplicate: "insert" })}
onBind={(elementId) => resolve({ bind_element_id: elementId })}
/>
{error ? <p className="error" role="alert">{error}</p> : null}
</>
) : null;
return { place, panel };
}
+11 -13
View File
@@ -2,6 +2,7 @@ import { useEffect, useRef, useState } from "react";
import { api } from "../api.js"; import { api } from "../api.js";
import { TargetLine } from "../pages/content.jsx"; import { TargetLine } from "../pages/content.jsx";
import { ErrorNote } from "../pages/widgets.jsx"; import { ErrorNote } from "../pages/widgets.jsx";
import { useExternalPlacement } from "./duplicates.jsx";
import { defineSourceModules, moduleFor, registerSourceModule, sourceModules, unregisterSourceModule } from "./registry-core.js"; import { defineSourceModules, moduleFor, registerSourceModule, sourceModules, unregisterSourceModule } from "./registry-core.js";
export { defineSourceModules, moduleFor, registerSourceModule, sourceModules, unregisterSourceModule }; export { defineSourceModules, moduleFor, registerSourceModule, sourceModules, unregisterSourceModule };
@@ -71,6 +72,7 @@ export function StandardSourcePicker({ sourceKind, context, placement, chapterId
const [error, setError] = useState(""); const [error, setError] = useState("");
const [pending, setPending] = useState(false); const [pending, setPending] = useState(false);
const searchRef = useRef(0); const searchRef = useRef(0);
const { place, panel } = useExternalPlacement({ context, placement, onPlaced: () => { onInserted?.(); onDone?.(); } });
const hint = module?.searchHint || "Suche im heute unterstützten Umfang dieser Quelle."; const hint = module?.searchHint || "Suche im heute unterstützten Umfang dieser Quelle.";
useEffect(() => { useEffect(() => {
@@ -111,20 +113,15 @@ export function StandardSourcePicker({ sourceKind, context, placement, chapterId
setPending(true); setPending(true);
setError(""); setError("");
try { try {
await api("/api/v1/external-refs", { await place({
method: "POST", title: item.title,
body: { source: sourceKind,
title: item.title, external_id: String(item.id),
source: sourceKind, context,
external_id: String(item.id), ...(placement ? { placement } : {}),
context, ...(chapterId ? { chapter_id: chapterId } : {}),
...(placement ? { placement } : {}), ...(connectorId ? { detail: { connector_id: connectorId } } : {}),
...(chapterId ? { chapter_id: chapterId } : {}),
...(connectorId ? { detail: { connector_id: connectorId } } : {}),
},
}); });
onInserted?.();
onDone?.();
} catch (err) { } catch (err) {
setError(err.message); setError(err.message);
} finally { } finally {
@@ -149,6 +146,7 @@ export function StandardSourcePicker({ sourceKind, context, placement, chapterId
<button type="submit">Suchen</button> <button type="submit">Suchen</button>
</form> </form>
<ErrorNote error={error} /> <ErrorNote error={error} />
{panel}
<p className="muted">{hint}</p> <p className="muted">{hint}</p>
<div className="stack"> <div className="stack">
{items.map((item) => ( {items.map((item) => (
Loaded 100 of 101 files, more files were not shown because too many files have changed in this diff. Show more