Phase 4 abgeschlossen: Personalakten, Dokumente, Beteiligte, Verknüpfungen

Die Dokumentebene aus docs/13 ist gebaut, additiv: Document, DocumentSection und DocumentSectionVersion neben Case, CaseSection und CaseEntry. Ein Dokument hängt an einer Fallakte, an einer Personalakte oder an nichts, höchstens an einem - gesichert durch eine CHECK-Bedingung. Es gibt kein DELETE; eine Zurücknahme lässt einen Grabstein stehen, der auch für den Admin zu ist. Eine neue Dokumentart ist damit ein Datensatz, kein Deployment. Im Seed stehen vier: vermerk, vorfallsbericht, sonderarbeitsvertrag (mehrseitiger Vertragstext mit Platzhaltern und Unterschriftenzeilen) und bussgeld. Zwei Umbenennungen, beide von Hand migriert, damit die vorhandenen Zeilen und Zählerstände stehen bleiben: - CaseTemplate -> DocumentTemplate, plus uses[] und layout - CaseCounter -> NumberSeries, ein Nummernkreis je Präfix für Aktenzeichen und Dokumentnummern Die Regeln für Abschnitte stehen jetzt einmal in lib/sections/render.ts und gelten für Fallakten und Dokumente gleichermaßen. Die Frage aus docs/13, ob CaseSection langfristig in die Dokumentebene wandert, ist damit verneint und begründet. Rückverweise auf der Personalakte laufen durch visibleCaseWhere, die Zahl daneben entsteht aus dem gefilterten Ergebnis. Auch die Rollengruppe verschwindet mit, sonst verriete "Betroffener" ohne Eintrag die Ermittlung. Die eigene Personalakte ist keine Ausnahme von der Freigabestufe. Vier neue Rechte: document.create, .edit, .finalize, .retract. Das letzte steht bei den zurückgehaltenen, es greift in Geschriebenes ein. 91 Tests im Web-Paket, 15 in der Datenbank, 28 e2e. Größte Route 118 kB gegen das Budget von 120 kB - die Luft wird knapp.
2026-09-02 14:15:16 +02:00
parent d2174f472b
commit 03cb5ec9a7
58 changed files with 5121 additions and 210 deletions
@@ -0,0 +1,113 @@
+import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
+import type { WriteCheck } from '@/lib/access/caseWrite'
+
+/**
+ * Schreibgrenzen für Personalakten und Dokumente.
+ *
+ * Dieselbe Bauform wie `caseWrite.ts`: reine Funktionen, die auch dann greifen,
+ * wenn die Oberfläche einen Knopf versehentlich stehen lässt. Jede Server
+ * Action ruft sie auf, nicht nur die, die den Knopf zeichnet.
+ */
+
+/** Status, in denen ein Dokument nicht mehr verändert wird. */
+export const READ_ONLY_DOCUMENT_STATUS = ['RETRACTED'] as const
+
+function requirePermission(p: EffectivePermissions, permission: Permission): WriteCheck {
+  if (p.isAdmin || p.permissions.has(permission)) return { ok: true }
+  return { ok: false, reason: 'no-permission', permission }
+}
+
+/**
+ * Darf dieser Nutzer eine Personalakte mit dieser Klassifizierung anlegen oder
+ * auf diese Stufe heben? Wie bei der Fallakte: nie über der eigenen Stufe.
+ */
+export function canWritePersonnel(
+  p: EffectivePermissions,
+  classification: number,
+): WriteCheck {
+  const permitted = requirePermission(p, 'personnel.edit')
+  if (!permitted.ok) return permitted
+  if (classification > p.clearanceLevel && !p.isAdmin) {
+    return { ok: false, reason: 'clearance-too-low', required: classification }
+  }
+  return { ok: true }
+}
+
+/**
+ * Darf dieser Nutzer ein Dokument mit dieser Klassifizierung anlegen?
+ *
+ * Der Besitzer ist vorher schon durch die Sichtbarkeitsprüfung gelaufen — was
+ * man nicht sieht, kann man nicht bestücken.
+ */
+export function canCreateDocument(
+  p: EffectivePermissions,
+  classification: number,
+): WriteCheck {
+  const permitted = requirePermission(p, 'document.create')
+  if (!permitted.ok) return permitted
+  if (classification > p.clearanceLevel) {
+    return { ok: false, reason: 'clearance-too-low', required: classification }
+  }
+  return { ok: true }
+}
+
+/**
+ * Darf dieser Nutzer dieses Dokument ändern?
+ *
+ * Ein zurückgezogenes Dokument ist endgültig schreibgeschützt, auch für
+ * Admins: es steht als Grabstein und darf nicht nachträglich zu etwas anderem
+ * werden. Ein ausgefertigtes Dokument zu ändern setzt dasselbe Recht voraus,
+ * das die Ausfertigung erlaubt hat.
+ */
+export function canEditDocument(
+  p: EffectivePermissions,
+  target: { status: string; classification: number },
+): WriteCheck {
+  if ((READ_ONLY_DOCUMENT_STATUS as readonly string[]).includes(target.status)) {
+    return { ok: false, reason: 'read-only', status: target.status }
+  }
+
+  const permitted = requirePermission(p, 'document.edit')
+  if (!permitted.ok) return permitted
+
+  if (target.classification > p.clearanceLevel && !p.isAdmin) {
+    return { ok: false, reason: 'clearance-too-low', required: target.classification }
+  }
+
+  if (target.status === 'FINAL') {
+    const final = requirePermission(p, 'document.finalize')
+    if (!final.ok) return { ok: false, reason: 'closed' }
+  }
+
+  return { ok: true }
+}
+
+/** Ausfertigen: aus einem Entwurf wird ein gültiges Dokument. */
+export function canFinalizeDocument(
+  p: EffectivePermissions,
+  target: { status: string; classification: number },
+): WriteCheck {
+  if (target.status !== 'DRAFT') return { ok: false, reason: 'read-only', status: target.status }
+  const permitted = requirePermission(p, 'document.finalize')
+  if (!permitted.ok) return permitted
+  if (target.classification > p.clearanceLevel && !p.isAdmin) {
+    return { ok: false, reason: 'clearance-too-low', required: target.classification }
+  }
+  return { ok: true }
+}
+
+/** Zurückziehen. Löschen gibt es nicht, der Grabstein bleibt stehen. */
+export function canRetractDocument(
+  p: EffectivePermissions,
+  target: { status: string; classification: number },
+): WriteCheck {
+  if (target.status === 'RETRACTED') {
+    return { ok: false, reason: 'read-only', status: target.status }
+  }
+  const permitted = requirePermission(p, 'document.retract')
+  if (!permitted.ok) return permitted
+  if (target.classification > p.clearanceLevel && !p.isAdmin) {
+    return { ok: false, reason: 'clearance-too-low', required: target.classification }
+  }
+  return { ok: true }
+}
@@ -0,0 +1,68 @@
+import type { Prisma } from '@afis/db'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+
+/**
+ * Where-Fragmente für Personalakten und Dokumente.
+ *
+ * Wie bei den Fallakten gilt: **die Prüfung wird nie in JavaScript
+ * nachgelagert.** Trefferzahlen, Rückverweise und Paginierung laufen über
+ * dieselbe Abfrage. Siehe docs/03-auth-und-rechte.md.
+ */
+
+/**
+ * Personalakten, die ein Nutzer lesen darf.
+ *
+ * Anders als bei der Fallakte gibt es hier keinen „Beteiligten": eine
+ * Personalakte hat keine Ermittlergruppe. Es zählt allein die Freigabestufe.
+ *
+ * Auch die eigene Akte ist keine Ausnahme. Das ist bewusst so: eine Beurteilung
+ * auf Stufe 4 über einen Mitarbeiter der Stufe 1 wäre sonst genau für den
+ * einen Menschen lesbar, vor dem sie geschützt werden soll.
+ */
+export function visiblePersonnelWhere(p: EffectivePermissions): Prisma.PersonnelFileWhereInput {
+  if (p.isAdmin) return {}
+  return { classification: { lte: p.clearanceLevel } }
+}
+
+/**
+ * Dokumente, die ein Nutzer lesen darf.
+ *
+ * Zwei Bedingungen, beide müssen zutreffen:
+ *
+ *  1. **Der Besitzer muss lesbar sein.** Ein Vertrag an einer Personalakte der
+ *     Stufe 4 bleibt verborgen, auch wenn der Vertrag selbst Stufe 1 trägt —
+ *     sonst verriete die Dokumentenliste die Existenz der Person.
+ *  2. **Das Dokument selbst muss lesbar sein.** Innerhalb einer sichtbaren
+ *     Akte kann ein einzelnes Dokument höher klassifiziert sein.
+ *
+ * Wer an der besitzenden Fallakte beteiligt ist, liest ihre Dokumente
+ * unabhängig von seiner Stufe — das ist derselbe ausnahmsweise Zugang wie beim
+ * Verlauf, siehe docs/03-auth-und-rechte.md. Für Dokumente an einer
+ * Personalakte und für Dokumente ohne Besitzer gibt es diesen Weg nicht.
+ */
+export function visibleDocumentWhere(p: EffectivePermissions): Prisma.DocumentWhereInput {
+  const besitzerLesbar: Prisma.DocumentWhereInput = {
+    OR: [
+      { case: { is: visibleCaseWhere(p) } },
+      { personnelFile: { is: visiblePersonnelWhere(p) } },
+      // Ohne Besitzer, etwa ein Bußgeldbescheid: dann entscheidet allein die
+      // Klassifizierung des Dokuments.
+      { AND: [{ caseId: null }, { personnelFileId: null }] },
+    ],
+  }
+
+  if (p.isAdmin) return besitzerLesbar
+
+  return {
+    AND: [
+      besitzerLesbar,
+      {
+        OR: [
+          { classification: { lte: p.clearanceLevel } },
+          { case: { is: { participants: { some: { userId: p.userId } } } } },
+        ],
+      },
+    ],
+  }
+}