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.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

web/tests/dokumente.test.ts

@@ -0,0 +1,225 @@
+// @vitest-environment node
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { createPrismaClient, loadEnvFromRepoRoot, type PrismaClient } from '@afis/db'
+import { visibleDocumentWhere } from '@/lib/access/personnelFilter'
+import {
+  canCreateDocument,
+  canEditDocument,
+  canRetractDocument,
+} from '@/lib/access/documentWrite'
+import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
+
+/**
+ * Dokumente erben die Sichtbarkeit ihres Besitzers **und** haben eine eigene.
+ * Beides muss zutreffen, sonst leckt entweder die Existenz der Akte oder der
+ * Inhalt des Dokuments.
+ */
+loadEnvFromRepoRoot()
+const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
+const suite = url ? describe : describe.skip
+
+let db: PrismaClient
+const marke = `dok-${Date.now()}`
+
+function perms(
+  userId: string,
+  clearanceLevel: number,
+  options: { isAdmin?: boolean; permissions?: Permission[] } = {},
+): EffectivePermissions {
+  return {
+    userId,
+    clearanceLevel,
+    permissions: new Set<Permission>(options.permissions ?? []),
+    isAdmin: options.isAdmin ?? false,
+    hasMembership: true,
+  }
+}
+
+suite('Sichtbarkeit von Dokumenten', () => {
+  const nutzer = {
+    stufe1: `${marke}-stufe1`,
+    stufe4: `${marke}-stufe4`,
+    beteiligt: `${marke}-beteiligt`,
+  }
+  const dok = {
+    imOffenenFall: '',
+    hochImOffenenFall: '',
+    imGeheimenFall: '',
+    anVerborgenerPerson: '',
+    freistehend: '',
+  }
+
+  beforeAll(async () => {
+    db = createPrismaClient(url)
+
+    const template = await db.documentTemplate.create({
+      data: {
+        key: `${marke}-vorlage`,
+        version: 1,
+        name: 'Prüfvorlage',
+        fields: [],
+        uses: ['CASE_DOCUMENT', 'PERSON_DOCUMENT', 'STANDALONE'],
+      },
+    })
+
+    for (const id of Object.values(nutzer)) {
+      await db.user.create({ data: { id, username: id, displayName: id } })
+    }
+
+    const gemeinsam = {
+      templateId: template.id,
+      templateKey: template.key,
+      createdById: nutzer.stufe4,
+    }
+
+    const offen = await db.case.create({
+      data: {
+        ...gemeinsam,
+        caseNumber: `${marke}-offen`.slice(0, 40),
+        title: 'Offen',
+        classification: 1,
+        status: 'OPEN',
+      },
+    })
+    const geheim = await db.case.create({
+      data: {
+        ...gemeinsam,
+        caseNumber: `${marke}-geheim`.slice(0, 40),
+        title: 'Geheim',
+        classification: 4,
+        status: 'OPEN',
+      },
+    })
+    await db.caseParticipant.create({
+      data: { caseId: geheim.id, userId: nutzer.beteiligt, role: 'INVESTIGATOR' },
+    })
+
+    const person = await db.personnelFile.create({
+      data: { displayName: `${marke} Verborgen`, classification: 4 },
+    })
+
+    const anlegen = async (
+      nummer: string,
+      classification: number,
+      besitzer: { caseId?: string; personnelFileId?: string },
+    ) =>
+      (
+        await db.document.create({
+          data: {
+            documentNumber: `${marke}-${nummer}`,
+            title: nummer,
+            templateId: template.id,
+            templateKey: template.key,
+            templateVersion: 1,
+            classification,
+            createdById: nutzer.stufe4,
+            ...besitzer,
+          },
+          select: { id: true },
+        })
+      ).id
+
+    dok.imOffenenFall = await anlegen('offen-niedrig', 1, { caseId: offen.id })
+    dok.hochImOffenenFall = await anlegen('offen-hoch', 4, { caseId: offen.id })
+    dok.imGeheimenFall = await anlegen('geheim', 1, { caseId: geheim.id })
+    dok.anVerborgenerPerson = await anlegen('person', 1, { personnelFileId: person.id })
+    dok.freistehend = await anlegen('frei', 1, {})
+  })
+
+  afterAll(async () => {
+    await db.$disconnect()
+  })
+
+  async function sichtbar(p: EffectivePermissions): Promise<string[]> {
+    const rows = await db.document.findMany({
+      where: { AND: [visibleDocumentWhere(p), { id: { in: Object.values(dok) } }] },
+      select: { id: true },
+    })
+    return rows.map((r) => r.id).sort()
+  }
+
+  it('zeigt einer Stufe 1 nur, was Besitzer und Dokument zugleich erlauben', async () => {
+    const p = perms(nutzer.stufe1, 1)
+    const treffer = await sichtbar(p)
+
+    expect(treffer).toContain(dok.imOffenenFall)
+    expect(treffer).toContain(dok.freistehend)
+
+    // Das Dokument ist zu hoch eingestuft, obwohl die Akte offen liegt.
+    expect(treffer).not.toContain(dok.hochImOffenenFall)
+    // Das Dokument wäre lesbar, aber die Akte darüber nicht — die
+    // Dokumentenliste verriete sonst ihre Existenz.
+    expect(treffer).not.toContain(dok.imGeheimenFall)
+    expect(treffer).not.toContain(dok.anVerborgenerPerson)
+
+    const anzahl = await db.document.count({
+      where: { AND: [visibleDocumentWhere(p), { id: { in: Object.values(dok) } }] },
+    })
+    expect(anzahl).toBe(treffer.length)
+  })
+
+  it('lässt einen Beteiligten die Dokumente seiner Akte lesen', async () => {
+    // Ausnahmsweiser Zugang gilt auch für die Dokumente der Akte, sonst wäre
+    // das Hinzuziehen wirkungslos. Siehe docs/03-auth-und-rechte.md.
+    const treffer = await sichtbar(perms(nutzer.beteiligt, 1))
+    expect(treffer).toContain(dok.imGeheimenFall)
+    // Er bleibt aber ein Stufe-1-Nutzer: an fremden Personalakten ändert das nichts.
+    expect(treffer).not.toContain(dok.anVerborgenerPerson)
+  })
+
+  it('zeigt der Stufe 4 alles', async () => {
+    expect(await sichtbar(perms(nutzer.stufe4, 4))).toHaveLength(Object.values(dok).length)
+  })
+})
+
+describe('Schreibgrenzen für Dokumente', () => {
+  const alle: Permission[] = [
+    'document.create',
+    'document.edit',
+    'document.finalize',
+    'document.retract',
+  ]
+
+  it('lässt niemanden ein Dokument über der eigenen Stufe anlegen', () => {
+    const p = perms('a', 2, { permissions: alle })
+    expect(canCreateDocument(p, 2).ok).toBe(true)
+    expect(canCreateDocument(p, 3)).toEqual({
+      ok: false,
+      reason: 'clearance-too-low',
+      required: 3,
+    })
+  })
+
+  it('verlangt für das Ändern eines ausgefertigten Dokuments das Ausfertigungsrecht', () => {
+    const nurEdit = perms('b', 5, { permissions: ['document.edit'] })
+    expect(canEditDocument(nurEdit, { status: 'DRAFT', classification: 1 }).ok).toBe(true)
+    expect(canEditDocument(nurEdit, { status: 'FINAL', classification: 1 })).toEqual({
+      ok: false,
+      reason: 'closed',
+    })
+
+    const mitFinalize = perms('c', 5, { permissions: ['document.edit', 'document.finalize'] })
+    expect(canEditDocument(mitFinalize, { status: 'FINAL', classification: 1 }).ok).toBe(true)
+  })
+
+  it('hält ein zurückgezogenes Dokument auch für den Admin geschlossen', () => {
+    // Der Grabstein bleibt stehen, wie er ist. Sonst liesse sich ein
+    // zurückgezogenes Dokument nachträglich zu etwas anderem machen.
+    const admin = perms('d', 5, { isAdmin: true })
+    expect(canEditDocument(admin, { status: 'RETRACTED', classification: 1 })).toEqual({
+      ok: false,
+      reason: 'read-only',
+      status: 'RETRACTED',
+    })
+    expect(canRetractDocument(admin, { status: 'RETRACTED', classification: 1 }).ok).toBe(false)
+  })
+
+  it('verlangt für das Zurückziehen ein eigenes Recht', () => {
+    const ohne = perms('e', 5, { permissions: ['document.edit'] })
+    expect(canRetractDocument(ohne, { status: 'FINAL', classification: 1 })).toEqual({
+      ok: false,
+      reason: 'no-permission',
+      permission: 'document.retract',
+    })
+  })
+})