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.

web/tests/verknuepfungen.test.ts

@@ -0,0 +1,158 @@
+// @vitest-environment node
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { createPrismaClient, loadEnvFromRepoRoot, type PrismaClient } from '@afis/db'
+import { listLinks } from '@/lib/cases/links'
+import { listParticipants } from '@/lib/cases/participants'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
+
+/**
+ * Verknüpfungen zeigen in beide Richtungen. Eine Akte, die der Leser nicht
+ * sehen darf, darf auch von der Gegenseite aus nicht auftauchen — sonst
+ * verrät die verknüpfte Akte ihre Existenz.
+ */
+loadEnvFromRepoRoot()
+const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
+const suite = url ? describe : describe.skip
+
+let db: PrismaClient
+const marke = `link-${Date.now()}`
+
+function perms(userId: string, clearanceLevel: number): EffectivePermissions {
+  return {
+    userId,
+    clearanceLevel,
+    permissions: new Set<Permission>(),
+    isAdmin: false,
+    hasMembership: true,
+  }
+}
+
+suite('Verknüpfungen zwischen Akten', () => {
+  const nutzer = { stufe1: `${marke}-stufe1`, stufe4: `${marke}-stufe4` }
+  let offenId = ''
+  let geheimId = ''
+  let zweitOffenId = ''
+
+  beforeAll(async () => {
+    db = createPrismaClient(url)
+
+    const template = await db.documentTemplate.create({
+      data: { key: `${marke}-vorlage`, version: 1, name: 'Prüfvorlage', fields: [] },
+    })
+    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}-a`.slice(0, 40),
+        title: 'Offen',
+        classification: 1,
+        status: 'OPEN',
+      },
+    })
+    const geheim = await db.case.create({
+      data: {
+        ...gemeinsam,
+        caseNumber: `${marke}-b`.slice(0, 40),
+        title: 'Geheim',
+        classification: 4,
+        status: 'OPEN',
+      },
+    })
+    const zweitOffen = await db.case.create({
+      data: {
+        ...gemeinsam,
+        caseNumber: `${marke}-c`.slice(0, 40),
+        title: 'Auch offen',
+        classification: 1,
+        status: 'OPEN',
+      },
+    })
+    offenId = offen.id
+    geheimId = geheim.id
+    zweitOffenId = zweitOffen.id
+
+    await db.caseLink.createMany({
+      data: [
+        // Hinaus: offen -> geheim
+        { fromId: offen.id, toId: geheim.id, kind: 'RELATED', createdById: nutzer.stufe4 },
+        // Herein: geheim -> offen, dieselbe Falle aus der anderen Richtung
+        { fromId: geheim.id, toId: offen.id, kind: 'SUCCESSOR', createdById: nutzer.stufe4 },
+        // Unverfänglich
+        { fromId: offen.id, toId: zweitOffen.id, kind: 'RELATED', createdById: nutzer.stufe4 },
+      ],
+    })
+  })
+
+  afterAll(async () => {
+    await db.$disconnect()
+  })
+
+  it('verbirgt eine zu hoch eingestufte Akte in beiden Richtungen', async () => {
+    const links = await listLinks(perms(nutzer.stufe1, 1), offenId)
+    const ziele = links.map((link) => link.other.id)
+
+    expect(ziele).toContain(zweitOffenId)
+    expect(ziele).not.toContain(geheimId)
+    // Auch die eingehende Verknüpfung darf nicht als leerer Platzhalter stehen.
+    expect(links).toHaveLength(1)
+  })
+
+  it('zeigt der Stufe 4 beide Richtungen mit ihrer jeweiligen Bedeutung', async () => {
+    const links = await listLinks(perms(nutzer.stufe4, 4), offenId)
+    const richtungen = links
+      .filter((link) => link.other.id === geheimId)
+      .map((link) => `${link.direction}:${link.kind}`)
+      .sort()
+
+    expect(richtungen).toEqual(['in:SUCCESSOR', 'out:RELATED'])
+  })
+
+  it('nennt den Namen eines Beteiligten, verweist aber nur auf sichtbare Personalakten', async () => {
+    const verborgen = await db.personnelFile.create({
+      data: { displayName: `${marke} Verborgene Person`, classification: 4 },
+    })
+    await db.caseParticipant.create({
+      data: { caseId: offenId, personnelFileId: verborgen.id, role: 'SUBJECT' },
+    })
+
+    const beteiligte = await listParticipants(perms(nutzer.stufe1, 1), offenId)
+    const eintrag = beteiligte.find((b) => b.displayName?.includes('Verborgene Person'))
+
+    // Wer die Ermittlung lesen darf, muss wissen, gegen wen sie läuft.
+    expect(eintrag).toBeDefined()
+    // Was darüber hinaus über die Person aktenkundig ist, bleibt zu.
+    expect(eintrag?.personnelFileId).toBeNull()
+
+    const fuerStufe4 = await listParticipants(perms(nutzer.stufe4, 4), offenId)
+    expect(
+      fuerStufe4.find((b) => b.displayName?.includes('Verborgene Person'))?.personnelFileId,
+    ).toBe(verborgen.id)
+  })
+
+  it('gibt einem Beteiligten Zugriff auf die Akte über seiner Stufe', async () => {
+    await db.caseParticipant.create({
+      data: { caseId: geheimId, userId: nutzer.stufe1, role: 'WITNESS' },
+    })
+
+    const p = perms(nutzer.stufe1, 1)
+    const treffer = await db.case.findMany({
+      where: { AND: [visibleCaseWhere(p), { id: geheimId }] },
+      select: { id: true },
+    })
+    expect(treffer).toHaveLength(1)
+
+    // Und damit auch auf die Verknüpfung, die vorher verborgen war.
+    const links = await listLinks(p, offenId)
+    expect(links.map((link) => link.other.id)).toContain(geheimId)
+  })
+})