Personalakten und Abteilungen als vollstaendiges Dossier speichern

Bisher liess sich eine einzelne Fallakte und ein einzelnes Dokument als PDF
sichern. Wer den Stand zu einer Person brauchte, rief beides einzeln ab,
legte es von Hand zusammen und wusste danach nicht, ob er alles hatte.

Ein Dossier ist die Personalakte, dahinter alle ihre Dokumente, dahinter
alle Fallakten, in denen die Person vorkommt - jeweils in derselben
Druckdarstellung wie einzeln. Fuer eine Abteilung dasselbe, je Mitglied
getrennt: eine Abteilung hat keine eigenen Fallakten, sie hat Mitglieder,
die in Fallakten vorkommen. Alles in einen Topf geschuettet staende dieselbe
Akte mehrfach da, ohne dass man saehe, ueber wen sie dort steht.

Der Abrufer waehlt die hoechste Stufe, die aufgenommen wird. Das ist keine
Zugriffspruefung, sondern eine Entscheidung ueber den Umfang - und beides
darf nie durcheinandergeraten:

  - Was ueber der Freigabestufe des Abrufers liegt, existiert fuer ihn
    nicht. Es steht nicht im Abzug, wird nicht gezaehlt und nicht erwaehnt.
  - Was er selbst ausgeschlossen hat, steht als Vermerk im PDF, nach Stufe
    aufgeschluesselt. Eine gekuerzte Mappe darf nicht wie eine
    vollstaendige aussehen, und der Deckel steht zusaetzlich auf jeder
    Seite im Wasserzeichen.

Beide Grenzen laufen in der Datenbankabfrage, nicht danach in JavaScript.

Alles wird als eine Druckseite gerendert statt als mehrere
zusammengeheftete PDFs. So laufen Seitenzahlen, Kopfzeile und Wasserzeichen
durch, und es gibt keinen zweiten Weg, der irgendwann anders aussieht als
der erste. Dafuer sind die vorhandenen Druckansichten zu Bausteinen
geworden - CaseSheet und DocumentSheet stehen jetzt in components/print und
werden von den alten Seiten wie vom Dossier benutzt.

Der Zwischenspeicherschluessel traegt den Deckel, sonst bekaeme ein Abruf
bis Stufe 1 die Datei eines Abrufs bis Stufe 4. Und der Stand ist der
spaeteste ueber alle enthaltenen Akten, nicht der der Kopfdaten allein -
sonst gaebe der Zwischenspeicher einen Abzug heraus, in dem ein
inzwischen geaendertes Dokument im alten Wortlaut steht.

Jeder Abruf steht mit seinem Deckel im Protokoll. Ohne den sagt der
Eintrag, dass jemand etwas ausser Haus gegeben hat, aber nicht wie viel.

web/lib/export/service.ts

@@ -5,6 +5,13 @@ import { writeAudit } from '@/lib/audit/write'
 import { AccessError } from '@/lib/errors'
 import { loadVisibleCase } from '@/lib/cases/service'
 import { loadVisibleDocument } from '@/lib/documents/service'
+import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
+import {
+  departmentDossierStand,
+  effectiveCap,
+  loadVisibleDepartmentForPrint,
+  personnelDossierStand,
+} from '@/lib/export/dossier'
 import { ensureDirFor, storageKeyFor } from '@/lib/files/paths'
 import { exportCacheKey } from '@/lib/export/cacheKey'
 import { createRenderToken } from '@/lib/export/token'
@@ -36,6 +43,10 @@ import type { EffectivePermissions } from '@/lib/auth/permissions'
 export type ExportTarget =
   | { kind: 'CASE'; caseNumber: string }
   | { kind: 'DOCUMENT'; documentNumber: string }
+  /** Personalakte samt Dokumenten und den Fallakten, in denen sie vorkommt. */
+  | { kind: 'PERSONNEL'; personnelFileId: string; maxLevel: number }
+  /** Abteilung, je Mitglied ein vollständiges Dossier. */
+  | { kind: 'DEPARTMENT'; departmentKey: string; maxLevel: number }
 
 /**
  * Legt einen Auftrag an - oder gibt einen fertigen zurück, wenn genau dieser
@@ -59,6 +70,7 @@ export async function requestExport(
     updatedAt: ziel.updatedAt,
     clearanceLevel: p.clearanceLevel,
     templateVersion: ziel.templateVersion,
+    maxLevel: ziel.maxLevel,
   })
 
   // Derselbe Stand, dieselbe Stufe: das PDF liegt schon da.
@@ -67,7 +79,12 @@ export async function requestExport(
     select: { id: true },
   })
   if (fertig) {
-    await protokolliere(p, 'export.pdf', ziel.id, { cached: true, kind: target.kind })
+    await protokolliere(p, 'export.pdf', ziel.id, {
+      cached: true,
+      kind: target.kind,
+      label: ziel.label,
+      maxLevel: ziel.maxLevel,
+    })
     return { jobId: fertig.id, status: 'READY' }
   }
 
@@ -85,6 +102,7 @@ export async function requestExport(
       kind: target.kind,
       label: ziel.label,
       classification: ziel.classification,
+      maxLevel: ziel.maxLevel,
     })
     return { jobId: laufend.id, status: laufend.status }
   }
@@ -96,6 +114,7 @@ export async function requestExport(
         targetId: ziel.id,
         requestedById: p.userId,
         clearanceAtTime: p.clearanceLevel,
+        maxLevel: ziel.maxLevel,
         cacheKey,
         status: 'QUEUED',
       },
@@ -105,13 +124,17 @@ export async function requestExport(
     await writeAudit(tx, {
       actorId: p.userId,
       action: 'export.pdf',
-      targetType: target.kind === 'CASE' ? 'Case' : 'Document',
+      targetType: zielArt(target.kind),
       targetId: ziel.id,
       clearanceAtTime: p.clearanceLevel,
       meta: {
         jobId: angelegt.id,
+        kind: target.kind,
         label: ziel.label,
         classification: ziel.classification,
+        // Der Deckel gehört ins Protokoll: er sagt, wie viel das Haus
+        // verlassen hat.
+        maxLevel: ziel.maxLevel,
       },
     })
 
@@ -135,19 +158,66 @@ async function aufloesen(p: EffectivePermissions, target: ExportTarget) {
       classification: akte.classification,
       updatedAt: akte.updatedAt,
       templateVersion: vorlage?.version ?? 0,
+      maxLevel: null,
       printPath: `/faelle/${akte.caseNumber}/druck`,
     }
   }
 
-  const doc = await loadVisibleDocument(p, target.documentNumber)
-  if (!doc) throw new AccessError('not-found')
+  if (target.kind === 'DOCUMENT') {
+    const doc = await loadVisibleDocument(p, target.documentNumber)
+    if (!doc) throw new AccessError('not-found')
+    return {
+      id: doc.id,
+      label: doc.documentNumber,
+      classification: doc.classification,
+      updatedAt: doc.updatedAt,
+      templateVersion: doc.templateVersion,
+      maxLevel: null,
+      printPath: `/dokumente/${doc.documentNumber}/druck`,
+    }
+  }
+
+  // Ab hier die Dossiers. Der Deckel wird sofort auf die Stufe des Abrufers
+  // gebracht - alles Weitere rechnet mit dem gedeckelten Wert, damit es keinen
+  // zweiten Ort gibt, an dem das schiefgehen könnte.
+  const cap = effectiveCap(p, target.maxLevel)
+
+  if (target.kind === 'PERSONNEL') {
+    const akte = await db.personnelFile.findFirst({
+      where: { AND: [visiblePersonnelWhere(p), { id: target.personnelFileId }] },
+      select: {
+        id: true,
+        userId: true,
+        displayName: true,
+        classification: true,
+        updatedAt: true,
+      },
+    })
+    if (!akte) throw new AccessError('not-found')
+
+    return {
+      id: akte.id,
+      label: akte.displayName,
+      classification: akte.classification,
+      // Der Stand über das ganze Dossier, nicht nur über die Kopfdaten.
+      updatedAt: await personnelDossierStand(p, akte, cap),
+      templateVersion: 0,
+      maxLevel: cap,
+      printPath: `/personalakten/${akte.id}/druck`,
+    }
+  }
+
+  const abteilung = await loadVisibleDepartmentForPrint(p, target.departmentKey)
+  if (!abteilung) throw new AccessError('not-found')
+
   return {
-    id: doc.id,
-    label: doc.documentNumber,
-    classification: doc.classification,
-    updatedAt: doc.updatedAt,
-    templateVersion: doc.templateVersion,
-    printPath: `/dokumente/${doc.documentNumber}/druck`,
+    id: abteilung.id,
+    label: abteilung.name,
+    classification: abteilung.minClearance,
+    updatedAt: await departmentDossierStand(p, abteilung, cap),
+    templateVersion: 0,
+    maxLevel: cap,
+    printPath: `/abteilungen/${abteilung.key}/druck`,
   }
 }
 
@@ -185,8 +255,10 @@ export async function runExport(jobId: string): Promise<void> {
       jobId,
       userId: auftrag.requestedById,
       clearanceLevel: auftrag.clearanceAtTime,
+      ...(auftrag.maxLevel === null ? {} : { maxLevel: auftrag.maxLevel }),
     })
-    const url = `${env.APP_URL.replace(/\/$/, '')}${pfad}?token=${encodeURIComponent(token)}`
+    const deckel = auftrag.maxLevel === null ? '' : `&stufe=${auftrag.maxLevel}`
+    const url = `${env.APP_URL.replace(/\/$/, '')}${pfad}?token=${encodeURIComponent(token)}${deckel}`
 
     const antwort = await fetch(`${env.PDF_SERVICE_URL.replace(/\/$/, '')}/render`, {
       method: 'POST',
@@ -198,6 +270,7 @@ export async function runExport(jobId: string): Promise<void> {
         headerHtml: wasserzeichen(
           nutzer?.displayName ?? auftrag.requestedById,
           auftrag.clearanceAtTime,
+          auftrag.maxLevel,
         ),
         footerHtml:
           '<div style="width:100%;font-size:7pt;font-family:monospace;padding:0 16mm;' +
@@ -238,19 +311,24 @@ export async function runExport(jobId: string): Promise<void> {
   await publish(userTopic(auftrag.requestedById), 'export.ready', jobId)
 }
 
-function wasserzeichen(name: string, stufe: number): string {
+function wasserzeichen(name: string, stufe: number, deckel: number | null): string {
   const sicher = name.replace(/[<>&]/g, '')
+  // Der Deckel gehört auf jede Seite, nicht nur auf den Deckel: wer Blatt 40
+  // in der Hand hält, soll sehen, dass der Abzug gekürzt ist.
+  const bis = deckel === null || deckel >= stufe ? '' : ` · Abzug bis ${deckel}`
   return (
     '<div style="width:100%;font-size:7pt;font-family:monospace;padding:0 16mm;' +
     'display:flex;justify-content:space-between;color:#666">' +
-    `<span>${sicher} · Stufe ${stufe}</span>` +
+    `<span>${sicher} · Stufe ${stufe}${bis}</span>` +
     '<span class="date"></span>' +
     '</div>'
   )
 }
 
+/** Aus dem gespeicherten Auftrag zurück zur Druckansicht. */
 async function druckPfad(kind: string, targetId: string | null): Promise<string | null> {
   if (!targetId) return null
+
   if (kind === 'CASE') {
     const akte = await db.case.findUnique({
       where: { id: targetId },
@@ -258,6 +336,23 @@ async function druckPfad(kind: string, targetId: string | null): Promise<string
     })
     return akte ? `/faelle/${akte.caseNumber}/druck` : null
   }
+
+  if (kind === 'PERSONNEL') {
+    const akte = await db.personnelFile.findUnique({
+      where: { id: targetId },
+      select: { id: true },
+    })
+    return akte ? `/personalakten/${akte.id}/druck` : null
+  }
+
+  if (kind === 'DEPARTMENT') {
+    const abteilung = await db.department.findUnique({
+      where: { id: targetId },
+      select: { key: true },
+    })
+    return abteilung ? `/abteilungen/${abteilung.key}/druck` : null
+  }
+
   const doc = await db.document.findUnique({
     where: { id: targetId },
     select: { documentNumber: true },
@@ -265,6 +360,14 @@ async function druckPfad(kind: string, targetId: string | null): Promise<string
   return doc ? `/dokumente/${doc.documentNumber}/druck` : null
 }
 
+/** Für das Protokoll: worauf sich der Eintrag bezieht. */
+function zielArt(kind: ExportTarget['kind']): string {
+  if (kind === 'CASE') return 'Case'
+  if (kind === 'DOCUMENT') return 'Document'
+  if (kind === 'PERSONNEL') return 'PersonnelFile'
+  return 'Department'
+}
+
 async function protokolliere(
   p: EffectivePermissions,
   action: 'export.pdf',