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>
2026-09-02 14:15:16 +02:00
parent f5769ca58a
commit d65cc95eb2
62 changed files with 5312 additions and 225 deletions
@@ -0,0 +1,452 @@
+import { db } from '@/lib/db'
+import { writeAudit } from '@/lib/audit'
+import { visibleDocumentWhere, visiblePersonnelWhere } from '@/lib/access/personnelFilter'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import {
+  canCreateDocument,
+  canEditDocument,
+  canFinalizeDocument,
+  canRetractDocument,
+  canWritePersonnel,
+} from '@/lib/access/documentWrite'
+import { canEditCase } from '@/lib/access/caseWrite'
+import { AccessError, must } from '@/lib/errors'
+import { nextNumber } from '@/lib/numbering'
+import { parseTemplateFields } from '@/lib/templates/schema'
+import { asJson, planSectionSave, renderSections, type RenderedSection } from '@/lib/sections/render'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+import type { Prisma } from '@afis/db'
+
+/**
+ * Dokumente. Eine Ausfertigung aus einer Vorlage — Vorfallsbericht,
+ * Sonderarbeitsvertrag, Bußgeldbescheid — an einer Fallakte, an einer
+ * Personalakte oder für sich stehend.
+ *
+ * Eine neue Dokumentart braucht hier keine Zeile: sie ist eine Vorlage mit
+ * passendem `uses`. Siehe docs/13-entscheidungen.md.
+ */
+
+export type TemplateUse = 'CASE' | 'CASE_DOCUMENT' | 'PERSON_DOCUMENT' | 'STANDALONE'
+
+/** Wo soll das Dokument hängen? Genau eine der drei Formen. */
+export type Owner =
+  | { kind: 'case'; caseNumber: string }
+  | { kind: 'personnel'; personnelFileId: string }
+  | { kind: 'standalone' }
+
+const KOPFDATEN = {
+  id: true,
+  documentNumber: true,
+  title: true,
+  templateId: true,
+  templateKey: true,
+  templateVersion: true,
+  layout: true,
+  status: true,
+  classification: true,
+  caseId: true,
+  personnelFileId: true,
+  createdById: true,
+  createdAt: true,
+  updatedAt: true,
+  finalizedAt: true,
+  finalizedById: true,
+  retractedAt: true,
+  retractedById: true,
+  retractionReason: true,
+} satisfies Prisma.DocumentSelect
+
+/** Die aktiven Vorlagen, die an dieser Stelle verwendet werden dürfen. */
+export async function listTemplatesFor(use: TemplateUse) {
+  const rows = await db.documentTemplate.findMany({
+    where: { isActive: true, uses: { has: use } },
+    orderBy: [{ key: 'asc' }, { version: 'desc' }],
+    select: { id: true, key: true, version: true, name: true, description: true, layout: true },
+  })
+  // Nur die jeweils höchste Version je Schlüssel. Ältere Versionen bleiben
+  // bestehen, weil Dokumente sich ihre merken, aber neu angelegt wird stets
+  // mit der aktuellen.
+  const gesehen = new Set<string>()
+  return rows.filter((row) => (gesehen.has(row.key) ? false : (gesehen.add(row.key), true)))
+}
+
+export async function loadVisibleDocument(p: EffectivePermissions, documentNumber: string) {
+  return db.document.findFirst({
+    where: { AND: [visibleDocumentWhere(p), { documentNumber }] },
+    select: KOPFDATEN,
+  })
+}
+
+/**
+ * Die Dokumente eines Besitzers. Der Filter steckt in der Abfrage: ein
+ * Dokument über der Stufe des Lesers taucht weder auf noch in der Zählung.
+ */
+export async function listDocuments(
+  p: EffectivePermissions,
+  owner: { caseId: string } | { personnelFileId: string },
+) {
+  const wo: Prisma.DocumentWhereInput =
+    'caseId' in owner ? { caseId: owner.caseId } : { personnelFileId: owner.personnelFileId }
+
+  return db.document.findMany({
+    where: { AND: [visibleDocumentWhere(p), wo] },
+    orderBy: { createdAt: 'desc' },
+    take: 100,
+    select: KOPFDATEN,
+  })
+}
+
+/**
+ * Legt ein Dokument an.
+ *
+ * Reihenfolge der Prüfungen, jede einzeln nötig:
+ *  1. Die Vorlage muss an dieser Stelle erlaubt sein (`uses`).
+ *  2. Der Besitzer muss sichtbar **und** beschreibbar sein.
+ *  3. Der Nutzer braucht `document.create` und die Stufe.
+ */
+export async function createDocument(
+  p: EffectivePermissions,
+  input: { templateKey: string; title?: string; classification: number; owner: Owner },
+): Promise<{ documentNumber: string; id: string }> {
+  const use: TemplateUse =
+    input.owner.kind === 'case'
+      ? 'CASE_DOCUMENT'
+      : input.owner.kind === 'personnel'
+        ? 'PERSON_DOCUMENT'
+        : 'STANDALONE'
+
+  const template = await db.documentTemplate.findFirst({
+    where: { key: input.templateKey, isActive: true, uses: { has: use } },
+    orderBy: { version: 'desc' },
+    select: {
+      id: true,
+      key: true,
+      version: true,
+      name: true,
+      layout: true,
+      numberPrefix: true,
+      numberPadding: true,
+    },
+  })
+  if (!template) throw new AccessError('template-missing')
+
+  must(canCreateDocument(p, input.classification))
+
+  let caseId: string | null = null
+  let personnelFileId: string | null = null
+  let caseNumber: string | null = null
+
+  if (input.owner.kind === 'case') {
+    const akte = await db.case.findFirst({
+      where: { AND: [visibleCaseWhere(p), { caseNumber: input.owner.caseNumber }] },
+      select: { id: true, caseNumber: true, status: true, classification: true },
+    })
+    if (!akte) throw new AccessError('not-found')
+    must(canEditCase(p, akte, 'entry.create'))
+    caseId = akte.id
+    caseNumber = akte.caseNumber
+  } else if (input.owner.kind === 'personnel') {
+    const akte = await db.personnelFile.findFirst({
+      where: { AND: [visiblePersonnelWhere(p), { id: input.owner.personnelFileId }] },
+      select: { id: true, classification: true },
+    })
+    if (!akte) throw new AccessError('not-found')
+    must(canWritePersonnel(p, akte.classification))
+    personnelFileId = akte.id
+  }
+
+  const titel = input.title?.trim() || template.name
+
+  return db.$transaction(async (tx) => {
+    const documentNumber = await nextNumber(tx, {
+      prefix: template.numberPrefix,
+      padding: template.numberPadding,
+    })
+
+    const created = await tx.document.create({
+      data: {
+        documentNumber,
+        title: titel,
+        templateId: template.id,
+        templateKey: template.key,
+        templateVersion: template.version,
+        // Kopie, kein Verweis: ein späterer Umbau der Vorlage darf das
+        // Aussehen eines ausgefertigten Dokuments nicht verändern.
+        layout: template.layout,
+        classification: input.classification,
+        caseId,
+        personnelFileId,
+        createdById: p.userId,
+      },
+      select: { id: true, documentNumber: true },
+    })
+
+    // Ein Dokument in einer Fallakte gehört in ihren Verlauf, sonst entsteht
+    // es unsichtbar neben der Chronologie.
+    if (caseId) {
+      await tx.caseEntry.create({
+        data: {
+          id: crypto.randomUUID(),
+          caseId,
+          type: 'SYSTEM',
+          body: `Dokument ${created.documentNumber} angelegt: ${titel}`,
+          authorId: p.userId,
+          minClearance: 0,
+        },
+      })
+    }
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'document.create',
+      targetType: 'Document',
+      targetId: created.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        documentNumber: created.documentNumber,
+        templateKey: template.key,
+        classification: input.classification,
+        caseNumber: caseNumber ?? undefined,
+        personnelFileId: personnelFileId ?? undefined,
+      },
+    })
+
+    return created
+  })
+}
+
+/** Die Abschnitte eines Dokuments, mit der Stufe des Lesers angewendet. */
+export async function loadDocumentSections(
+  p: EffectivePermissions,
+  document: { id: string; templateId: string },
+): Promise<RenderedSection[]> {
+  const [template, rows] = await Promise.all([
+    db.documentTemplate.findUnique({
+      where: { id: document.templateId },
+      select: { fields: true },
+    }),
+    db.documentSection.findMany({ where: { documentId: document.id } }),
+  ])
+
+  return renderSections(parseTemplateFields(template?.fields), rows, p)
+}
+
+export async function saveDocumentSection(
+  p: EffectivePermissions,
+  input: {
+    documentNumber: string
+    fieldKey: string
+    value: unknown
+    baseVersion: number
+    minClearance?: number
+  },
+): Promise<{ version: number }> {
+  const target = await loadVisibleDocument(p, input.documentNumber)
+  if (!target) throw new AccessError('not-found')
+
+  const check = canEditDocument(p, target)
+  if (!check.ok) throw new AccessError(check.reason)
+
+  const template = await db.documentTemplate.findUnique({
+    where: { id: target.templateId },
+    select: { fields: true },
+  })
+  const field = parseTemplateFields(template?.fields).find((f) => f.key === input.fieldKey)
+  if (!field) throw new AccessError('field-unknown')
+
+  const existing = await db.documentSection.findUnique({
+    where: { documentId_fieldKey: { documentId: target.id, fieldKey: input.fieldKey } },
+  })
+
+  const { nextClearance, nextVersion } = planSectionSave({
+    p,
+    field,
+    existing,
+    baseVersion: input.baseVersion,
+    minClearance: input.minClearance,
+  })
+
+  await db.$transaction(async (tx) => {
+    if (existing) {
+      await tx.documentSectionVersion.create({
+        data: {
+          sectionId: existing.id,
+          version: existing.currentVersion,
+          value: asJson(existing.value),
+          authorId: existing.updatedById,
+        },
+      })
+      await tx.documentSection.update({
+        where: { id: existing.id },
+        data: {
+          value: asJson(input.value),
+          currentVersion: nextVersion,
+          updatedById: p.userId,
+          minClearance: nextClearance,
+        },
+      })
+    } else {
+      await tx.documentSection.create({
+        data: {
+          documentId: target.id,
+          fieldKey: input.fieldKey,
+          value: asJson(input.value),
+          currentVersion: 1,
+          updatedById: p.userId,
+          minClearance: nextClearance,
+        },
+      })
+    }
+
+    // Sonst bliebe `updatedAt` des Dokuments auf dem Anlagezeitpunkt stehen.
+    await tx.document.update({ where: { id: target.id }, data: { updatedAt: new Date() } })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'document.update',
+      targetType: 'DocumentSection',
+      targetId: `${target.id}:${input.fieldKey}`,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        documentNumber: target.documentNumber,
+        fieldKey: input.fieldKey,
+        version: nextVersion,
+        minClearance: nextClearance,
+      },
+    })
+  })
+
+  return { version: nextVersion }
+}
+
+/**
+ * Ausfertigen. Aus dem Entwurf wird ein gültiges Dokument; wer es danach noch
+ * ändern will, braucht dasselbe Recht erneut.
+ */
+export async function finalizeDocument(
+  p: EffectivePermissions,
+  documentNumber: string,
+): Promise<void> {
+  const target = await loadVisibleDocument(p, documentNumber)
+  if (!target) throw new AccessError('not-found')
+  must(canFinalizeDocument(p, target))
+
+  await db.$transaction(async (tx) => {
+    await tx.document.update({
+      where: { id: target.id },
+      data: { status: 'FINAL', finalizedAt: new Date(), finalizedById: p.userId },
+    })
+
+    if (target.caseId) {
+      await tx.caseEntry.create({
+        data: {
+          id: crypto.randomUUID(),
+          caseId: target.caseId,
+          type: 'SYSTEM',
+          body: `Dokument ${target.documentNumber} ausgefertigt`,
+          authorId: p.userId,
+          minClearance: 0,
+        },
+      })
+    }
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'document.finalize',
+      targetType: 'Document',
+      targetId: target.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { documentNumber: target.documentNumber },
+    })
+  })
+}
+
+/**
+ * Zurückziehen. Es gibt kein Löschen: das Dokument bleibt als Grabstein
+ * stehen, mit Datum, Person und Begründung. Siehe CLAUDE.md, harte Regel 2.
+ */
+export async function retractDocument(
+  p: EffectivePermissions,
+  documentNumber: string,
+  reason: string,
+): Promise<void> {
+  const target = await loadVisibleDocument(p, documentNumber)
+  if (!target) throw new AccessError('not-found')
+  must(canRetractDocument(p, target))
+
+  const begruendung = reason.trim()
+  if (begruendung.length < 10) throw new AccessError('reason-required')
+
+  await db.$transaction(async (tx) => {
+    await tx.document.update({
+      where: { id: target.id },
+      data: {
+        status: 'RETRACTED',
+        retractedAt: new Date(),
+        retractedById: p.userId,
+        retractionReason: begruendung,
+      },
+    })
+
+    if (target.caseId) {
+      await tx.caseEntry.create({
+        data: {
+          id: crypto.randomUUID(),
+          caseId: target.caseId,
+          type: 'SYSTEM',
+          body: `Dokument ${target.documentNumber} zurückgezogen. Begründung: ${begruendung}`,
+          authorId: p.userId,
+          minClearance: 0,
+        },
+      })
+    }
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'document.retract',
+      targetType: 'Document',
+      targetId: target.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { documentNumber: target.documentNumber, reason: begruendung },
+    })
+  })
+}
+
+/** Klassifizierung eines Dokuments ändern, mit denselben Regeln wie beim Fall. */
+export async function reclassifyDocument(
+  p: EffectivePermissions,
+  documentNumber: string,
+  to: number,
+  reason?: string,
+): Promise<void> {
+  const target = await loadVisibleDocument(p, documentNumber)
+  if (!target) throw new AccessError('not-found')
+  if (target.classification === to) return
+  if (to < 0 || to > 5) throw new AccessError('clearance-too-low')
+  if (to > p.clearanceLevel && !p.isAdmin) {
+    throw new AccessError('clearance-too-low')
+  }
+  must(canEditDocument(p, target))
+
+  const lowering = to < target.classification
+  const begruendung = reason?.trim() ?? ''
+  if (lowering && begruendung.length < 10) throw new AccessError('reason-required')
+
+  await db.$transaction(async (tx) => {
+    await tx.document.update({ where: { id: target.id }, data: { classification: to } })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'document.reclassify',
+      targetType: 'Document',
+      targetId: target.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        documentNumber: target.documentNumber,
+        from: target.classification,
+        to,
+        lowering,
+        reason: begruendung || undefined,
+      },
+    })
+  })
+}