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/components/export/ExportPanel.tsx

@@ -13,13 +13,27 @@ import { requestExportAction, type ExportState } from '@/app/(app)/export/action
  * der Knopf zum Herunterladen bereit - automatisch losladen wäre unhöflich,
  * wenn jemand die Seite inzwischen wieder verlassen hat und zurückkommt.
  */
+export type ExportPanelTarget =
+  | { kind: 'CASE'; caseNumber: string }
+  | { kind: 'DOCUMENT'; documentNumber: string }
+  | { kind: 'PERSONNEL'; personnelFileId: string }
+  | { kind: 'DEPARTMENT'; departmentKey: string }
+
 export function ExportPanel({
   target,
   topic,
+  levels,
+  defaultLevel,
 }: {
-  target: { kind: 'CASE'; caseNumber: string } | { kind: 'DOCUMENT'; documentNumber: string }
+  target: ExportPanelTarget
   /** Eigenes Nutzerthema: der Export geht nur den Auftraggeber an. */
   topic: string
+  /**
+   * Wählbare Höchststufen. Nur beim Dossier gesetzt - eine einzelne Akte hat
+   * genau eine Stufe, da gäbe es nichts zu wählen.
+   */
+  levels?: { level: number; name: string }[]
+  defaultLevel?: number
 }) {
   const [state, action, pending] = useActionState<ExportState | null, FormData>(
     requestExportAction,
@@ -51,10 +65,35 @@ export function ExportPanel({
         <input type="hidden" name="kind" value={target.kind} />
         {target.kind === 'CASE' ? (
           <input type="hidden" name="caseNumber" value={target.caseNumber} />
-        ) : (
+        ) : target.kind === 'DOCUMENT' ? (
           <input type="hidden" name="documentNumber" value={target.documentNumber} />
+        ) : target.kind === 'PERSONNEL' ? (
+          <input type="hidden" name="personnelFileId" value={target.personnelFileId} />
+        ) : (
+          <input type="hidden" name="departmentKey" value={target.departmentKey} />
         )}
 
+        {levels ? (
+          <div className="mb-4">
+            <label htmlFor="maxLevel" className="field-label">
+              {exportText.maxLevel}
+            </label>
+            <select
+              id="maxLevel"
+              name="maxLevel"
+              defaultValue={defaultLevel ?? levels[levels.length - 1]?.level ?? 0}
+              className="field"
+            >
+              {levels.map((stufe) => (
+                <option key={stufe.level} value={stufe.level}>
+                  {stufe.level} · {stufe.name}
+                </option>
+              ))}
+            </select>
+            <p className="field-hint">{exportText.maxLevelHint}</p>
+          </div>
+        ) : null}
+
         <button
           type="submit"
           disabled={pending || Boolean(state?.jobId)}

web/components/print/CaseSheet.tsx

@@ -0,0 +1,277 @@
+import { db } from '@/lib/db'
+import { visibleEntryWhere } from '@/lib/access/caseFilter'
+import { visibleAttachmentWhere } from '@/lib/access/attachmentFilter'
+import { loadSections } from '@/lib/cases/sectionService'
+import { isInputField, fillPlaceholders } from '@/lib/templates/fields'
+import { de } from '@/lib/i18n/de'
+import type { RenderedSection } from '@/lib/sections/render'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Der Druckbogen einer Fallakte, ohne die Seite drumherum.
+ *
+ * Ausgelagert, weil er an drei Stellen gebraucht wird: in der Druckansicht der
+ * Akte selbst, im Dossier einer Person und im Bogen einer Abteilung. Stünde
+ * das Layout dort jeweils noch einmal, liefe es auseinander - und ein Export,
+ * der je nach Weg anders aussieht, ist keiner.
+ *
+ * **Ein Export darf nie sauberer aussehen als die Akte ist.** Deshalb:
+ * gesperrte Felder erscheinen als Balken mit Vermerk statt zu fehlen,
+ * geänderte Einträge sind als geändert gekennzeichnet, zurückgezogene stehen
+ * als Grabstein mit Begründung. Siehe docs/08-suche-und-export.md.
+ */
+export type CaseForPrint = {
+  id: string
+  caseNumber: string
+  title: string
+  status: string
+  templateId: string
+  templateKey: string
+  classification: number
+  createdById: string
+  dueAt: Date | null
+}
+
+export async function CaseSheet({
+  permissions,
+  displayName,
+  akte,
+  /** Im Dossier steht der Deckel schon vorn; dann nur der Inhalt. */
+  withCover = true,
+  authors,
+}: {
+  permissions: EffectivePermissions
+  displayName: string
+  akte: CaseForPrint
+  withCover?: boolean
+  /** Einmal geladen und durchgereicht, statt je Akte erneut. */
+  authors?: Map<string, string>
+}) {
+  const [sections, entries, anhaenge, levels, autoren] = await Promise.all([
+    loadSections(permissions, akte.id, akte.templateId),
+    db.caseEntry.findMany({
+      where: { AND: [visibleEntryWhere(permissions), { caseId: akte.id }] },
+      orderBy: [{ createdAt: 'asc' }, { id: 'asc' }],
+      select: {
+        id: true,
+        type: true,
+        body: true,
+        authorId: true,
+        createdAt: true,
+        version: true,
+        editedAt: true,
+        editVisible: true,
+        retractedAt: true,
+        retractionReason: true,
+      },
+    }),
+    db.attachment.findMany({
+      where: { AND: [visibleAttachmentWhere(permissions), { caseId: akte.id }] },
+      orderBy: { createdAt: 'asc' },
+      select: { id: true, originalName: true, sha256: true, sizeBytes: true, scanStatus: true },
+    }),
+    db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
+    authors ? [] : db.user.findMany({ select: { id: true, displayName: true } }),
+  ])
+
+  const levelName = new Map(levels.map((l) => [l.level, l.name]))
+  const nameVon = authors ?? new Map(autoren.map((a) => [a.id, a.displayName]))
+  const stand = new Date()
+
+  return (
+    <>
+      {withCover ? (
+      <section className="print-cover">
+        <span className="print-stamp">
+          {akte.classification} · {levelName.get(akte.classification) ?? de.common.unknown}
+        </span>
+        <h1 style={{ marginTop: '4mm' }}>{akte.title}</h1>
+        <p style={{ fontFamily: 'var(--font-mono, monospace)', margin: 0 }}>{akte.caseNumber}</p>
+
+        <table className="print-meta">
+          <tbody>
+            <Zeile label={de.case.status} value={de.case.statusNames[akte.status] ?? akte.status} />
+            <Zeile label={de.case.type} value={akte.templateKey} />
+            <Zeile
+              label={de.case.createdBy}
+              value={nameVon.get(akte.createdById) ?? akte.createdById}
+            />
+            <Zeile
+              label={de.case.dueAt}
+              value={akte.dueAt ? akte.dueAt.toLocaleDateString('de-DE') : '-'}
+            />
+            <Zeile label={de.export.retrievedBy} value={displayName} />
+            <Zeile
+              label={de.export.asOf}
+              value={`${stand.toLocaleString('de-DE')} · ${de.clearance.label} ${permissions.clearanceLevel}`}
+            />
+          </tbody>
+        </table>
+
+        <p className="print-note" style={{ marginTop: '4mm' }}>
+          {de.export.coverNote}
+        </p>
+      </section>
+      ) : (
+        <header className="print-runin">
+          <span className="print-stamp">
+            {akte.classification} · {levelName.get(akte.classification) ?? de.common.unknown}
+          </span>
+          <h2 style={{ margin: '2mm 0 0' }}>{akte.title}</h2>
+          <p className="print-note" style={{ margin: 0 }}>
+            {akte.caseNumber} · {de.case.statusNames[akte.status] ?? akte.status}
+          </p>
+        </header>
+      )}
+
+      <h2>{de.section.heading}</h2>
+      <PrintSections sections={sections} levelName={levelName} />
+
+      <h2>{de.case.timeline}</h2>
+      {entries.length === 0 ? (
+        <p className="print-note">{de.entry.empty}</p>
+      ) : (
+        entries.map((eintrag) => (
+          <div key={eintrag.id} className="print-entry">
+            <p className="print-label">
+              {de.entry.types[eintrag.type] ?? eintrag.type} ·{' '}
+              {nameVon.get(eintrag.authorId) ?? eintrag.authorId} ·{' '}
+              {eintrag.createdAt.toLocaleString('de-DE')}
+              {eintrag.editVisible && eintrag.editedAt
+                ? ` · ${de.export.editedAt(eintrag.version, eintrag.editedAt.toLocaleDateString('de-DE'))}`
+                : ''}
+            </p>
+            {eintrag.retractedAt ? (
+              <p style={{ margin: '1mm 0', fontStyle: 'italic' }}>
+                {de.entry.retracted(
+                  eintrag.retractedAt.toLocaleDateString('de-DE'),
+                  nameVon.get(eintrag.authorId) ?? eintrag.authorId,
+                  eintrag.retractionReason ?? '',
+                )}
+              </p>
+            ) : (
+              <p style={{ margin: '1mm 0', whiteSpace: 'pre-wrap' }}>{eintrag.body}</p>
+            )}
+          </div>
+        ))
+      )}
+
+      <h2>{de.attachment.heading}</h2>
+      {anhaenge.length === 0 ? (
+        <p className="print-note">{de.attachment.empty}</p>
+      ) : (
+        <table className="print-meta">
+          <thead>
+            <tr>
+              <th>{de.export.fileName}</th>
+              <th>{de.export.fileSize}</th>
+              <th>{de.export.fileHash}</th>
+            </tr>
+          </thead>
+          <tbody>
+            {anhaenge.map((anhang) => (
+              <tr key={anhang.id}>
+                <td>{anhang.originalName}</td>
+                <td>{anhang.sizeBytes}</td>
+                {/* Der Hash macht nachprüfbar, dass die Datei zum Ausdruck
+                    gehört - deshalb steht er im Verzeichnis. */}
+                <td style={{ fontFamily: 'monospace', fontSize: '7pt', wordBreak: 'break-all' }}>
+                  {anhang.sha256}
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      )}
+    </>
+  )
+}
+
+function Zeile({ label, value }: { label: string; value: string }) {
+  return (
+    <tr>
+      <th>{label}</th>
+      <td>{value}</td>
+    </tr>
+  )
+}
+
+/**
+ * Die Abschnitte im Druck. Ein gesperrtes Feld wird als Balken ausgegeben, mit
+ * dem Vermerk, ab welcher Stufe es lesbar wäre - sonst merkt der Empfänger
+ * nicht, dass er eine gekürzte Fassung in der Hand hält.
+ */
+function PrintSections({
+  sections,
+  levelName,
+}: {
+  sections: RenderedSection[]
+  levelName: Map<number, string>
+}) {
+  const werte = Object.fromEntries(
+    sections.filter((s) => s.visible).map((s) => [s.fieldKey, s.value]),
+  )
+
+  return (
+    <div>
+      {sections.map((section) => {
+        const field = section.field
+
+        if (!isInputField(field)) {
+          if (field.type === 'pagebreak') {
+            return <div key={field.key} style={{ breakAfter: 'page' }} />
+          }
+          const text = fillPlaceholders(field.text ?? '', werte)
+          return field.type === 'heading' ? (
+            <h3 key={field.key}>{text || field.label}</h3>
+          ) : (
+            <p key={field.key} style={{ whiteSpace: 'pre-wrap' }}>
+              {text}
+            </p>
+          )
+        }
+
+        return (
+          <div key={field.key} style={{ marginBottom: '3mm', breakInside: 'avoid' }}>
+            <p className="print-label">{field.label}</p>
+            {!section.visible ? (
+              <p style={{ margin: '1mm 0' }}>
+                <span className="print-redacted">&nbsp;</span>{' '}
+                <span className="print-note">
+                  {de.export.redactedAt(
+                    section.value.requiredLevel,
+                    levelName.get(section.value.requiredLevel) ?? '',
+                  )}
+                </span>
+              </p>
+            ) : section.segments ? (
+              <p style={{ margin: '1mm 0', whiteSpace: 'pre-wrap' }}>
+                {section.segments.map((segment, index) =>
+                  segment.kind === 'text' ? (
+                    <span key={index}>{segment.text}</span>
+                  ) : (
+                    // Balken statt Auslassung, mit der Stufe daneben: der
+                    // Empfaenger soll sehen, dass hier etwas fehlt.
+                    <span key={index}>
+                      <span
+                        className="print-redacted"
+                        style={{ width: `${segment.blockLength}ch` }}
+                      >
+                        &nbsp;
+                      </span>
+                      <span className="print-note"> [{segment.requiredLevel}]</span>
+                    </span>
+                  ),
+                )}
+              </p>
+            ) : (
+              <p style={{ margin: '1mm 0', whiteSpace: 'pre-wrap' }}>
+                {String(section.value ?? '-')}
+              </p>
+            )}
+          </div>
+        )
+      })}
+    </div>
+  )
+}

web/components/print/DocumentSheet.tsx

@@ -0,0 +1,189 @@
+import { db } from '@/lib/db'
+import { loadDocumentSections } from '@/lib/documents/service'
+import { resolvePhotoUrls } from '@/lib/files/service'
+import { Sheet } from '@/components/documents/Sheet'
+import { de } from '@/lib/i18n/de'
+import { isInputField, fillPlaceholders } from '@/lib/templates/fields'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Der Druckbogen eines Dokuments, ohne die Seite drumherum.
+ *
+ * Kein Verlauf, keine Kopfdatentabelle einer Akte - das Dokument selbst, so
+ * wie seine Vorlage es vorsieht. Ein Aktenblatt kommt als Aktenblatt heraus,
+ * ein Vertrag als Vertrag. Siehe docs/08-suche-und-export.md.
+ *
+ * Ausgelagert aus derselben Not wie CaseSheet: das Dossier einer Person hängt
+ * alle Dokumente hintereinander, und zwar in genau dieser Darstellung.
+ */
+export type DocumentForPrint = {
+  id: string
+  documentNumber: string
+  title: string
+  templateId: string
+  templateKey: string
+  layout: string
+  status: string
+  classification: number
+  createdAt: Date
+  retractedAt: Date | null
+}
+
+export async function DocumentSheet({
+  permissions,
+  displayName,
+  doc,
+  /** Im Dossier steht der Deckel schon vorn; dann nur der Inhalt. */
+  withCover = true,
+}: {
+  permissions: EffectivePermissions
+  displayName: string
+  doc: DocumentForPrint
+  withCover?: boolean
+}) {
+  const [sections, template, foundationLevels, levels] = await Promise.all([
+    loadDocumentSections(permissions, doc),
+    db.documentTemplate.findUnique({
+      where: { id: doc.templateId },
+      select: { sheetTitle: true, sheetSubtitle: true, name: true },
+    }),
+    db.foundationClearance.findMany({ orderBy: { sortOrder: 'asc' } }),
+    db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
+  ])
+
+  const photoUrls = await resolvePhotoUrls(
+    permissions,
+    sections.map((section) => ({
+      fieldKey: section.fieldKey,
+      visible: section.visible,
+      value: section.visible ? section.value : null,
+      type: section.field.type,
+    })),
+  )
+
+  const levelName = new Map(levels.map((l) => [l.level, l.name]))
+  const werte = Object.fromEntries(
+    sections.filter((s) => s.visible).map((s) => [s.fieldKey, s.value]),
+  )
+
+  // Das Aktenblatt bringt sein eigenes Aussehen mit und braucht keinen
+  // Berichtsrahmen darum.
+  if (doc.layout === 'DOSSIER') {
+    return (
+      <Sheet
+        sections={sections}
+        title={template?.sheetTitle ?? de.app.name}
+        subtitle={template?.sheetSubtitle ?? template?.name ?? doc.title}
+        documentNumber={doc.documentNumber}
+        issuedAt={doc.createdAt}
+        foundationLevels={foundationLevels}
+        footerNote={de.document.footerNote}
+        photoUrls={photoUrls}
+      />
+    )
+  }
+
+  return (
+    <>
+      {withCover ? (
+      <section className="print-cover">
+        <span className="print-stamp">
+          {doc.classification} · {levelName.get(doc.classification) ?? de.common.unknown}
+        </span>
+        <h1 style={{ marginTop: '4mm' }}>{doc.title}</h1>
+        <p style={{ fontFamily: 'var(--font-mono, monospace)', margin: 0 }}>
+          {doc.documentNumber}
+        </p>
+
+        <table className="print-meta">
+          <tbody>
+            <tr>
+              <th>{de.case.status}</th>
+              <td>{de.document.statusNames[doc.status] ?? doc.status}</td>
+            </tr>
+            <tr>
+              <th>{de.document.kind}</th>
+              <td>{doc.templateKey}</td>
+            </tr>
+            <tr>
+              <th>{de.export.retrievedBy}</th>
+              <td>{displayName}</td>
+            </tr>
+            <tr>
+              <th>{de.export.asOf}</th>
+              <td>
+                {new Date().toLocaleString('de-DE')} · {de.clearance.label}{' '}
+                {permissions.clearanceLevel}
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </section>
+      ) : (
+        <header className="print-runin">
+          <span className="print-stamp">
+            {doc.classification} · {levelName.get(doc.classification) ?? de.common.unknown}
+          </span>
+          <h3 style={{ margin: '2mm 0 0' }}>{doc.title}</h3>
+          <p className="print-note" style={{ margin: 0 }}>
+            {doc.documentNumber} · {de.document.statusNames[doc.status] ?? doc.status}
+          </p>
+        </header>
+      )}
+
+      {doc.retractedAt ? (
+        <p className="print-stamp" style={{ marginBottom: '4mm' }}>
+          {de.document.statusNames.RETRACTED}
+        </p>
+      ) : null}
+
+      {sections.map((section) => {
+        const field = section.field
+
+        if (!isInputField(field)) {
+          if (field.type === 'pagebreak') {
+            return <div key={field.key} style={{ breakAfter: 'page' }} />
+          }
+          const text = fillPlaceholders(field.text ?? '', werte)
+          return field.type === 'heading' ? (
+            <h3 key={field.key}>{text || field.label}</h3>
+          ) : (
+            <p key={field.key} style={{ whiteSpace: 'pre-wrap' }}>
+              {text}
+            </p>
+          )
+        }
+
+        if (field.type === 'signature') {
+          return (
+            <div key={field.key} style={{ marginTop: '10mm', breakInside: 'avoid' }}>
+              <div style={{ borderTop: '1pt solid #000', width: '70mm' }} />
+              <p className="print-note">{fillPlaceholders(field.label, werte)}</p>
+            </div>
+          )
+        }
+
+        return (
+          <div key={field.key} style={{ marginBottom: '3mm', breakInside: 'avoid' }}>
+            <p className="print-label">{field.label}</p>
+            {!section.visible ? (
+              <p style={{ margin: '1mm 0' }}>
+                <span className="print-redacted">&nbsp;</span>{' '}
+                <span className="print-note">
+                  {de.export.redactedAt(
+                    section.value.requiredLevel,
+                    levelName.get(section.value.requiredLevel) ?? '',
+                  )}
+                </span>
+              </p>
+            ) : (
+              <p style={{ margin: '1mm 0', whiteSpace: 'pre-wrap' }}>
+                {String(section.value ?? '-')}
+              </p>
+            )}
+          </div>
+        )
+      })}
+    </>
+  )
+}

web/components/print/DossierBody.tsx

@@ -0,0 +1,133 @@
+import { db } from '@/lib/db'
+import { de } from '@/lib/i18n/de'
+import { collectPersonnelDossier, type Dossier } from '@/lib/export/dossier'
+import { CaseSheet } from '@/components/print/CaseSheet'
+import { DocumentSheet } from '@/components/print/DocumentSheet'
+import { PersonnelSheet, type PersonnelForPrint } from '@/components/print/PersonnelSheet'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Ein Dossier: die Personalakte, dahinter ihre Dokumente, dahinter die
+ * Fallakten, in denen die Person vorkommt.
+ *
+ * Die Reihenfolge ist die Vorgabe und keine Geschmacksfrage - wer eine Akte
+ * aufschlägt, will zuerst wissen, um wen es geht.
+ *
+ * Der Vermerk über das Weggelassene steht **vorn**, gleich hinter der Akte,
+ * nicht am Ende: wer die letzten Seiten nicht liest, muss trotzdem erfahren,
+ * dass die Mappe gekürzt ist.
+ */
+export async function DossierBody({
+  permissions,
+  displayName,
+  akte,
+  cap,
+  /** Im Abteilungsbogen steht der Deckel schon vorn. */
+  withCover = true,
+}: {
+  permissions: EffectivePermissions
+  displayName: string
+  akte: PersonnelForPrint
+  cap: number
+  withCover?: boolean
+}) {
+  const [inhalt, autoren] = await Promise.all([
+    collectPersonnelDossier(permissions, { id: akte.id, userId: akte.userId }, cap),
+    db.user.findMany({ select: { id: true, displayName: true } }),
+  ])
+  const nameVon = new Map(autoren.map((a) => [a.id, a.displayName]))
+
+  return (
+    <>
+      <PersonnelSheet
+        permissions={permissions}
+        displayName={displayName}
+        akte={akte}
+        withCover={withCover}
+      />
+
+      <OmittedNote inhalt={inhalt} eigeneStufe={permissions.clearanceLevel} />
+
+      <h2 style={{ breakBefore: 'page' }}>{de.export.documentsHeading}</h2>
+      {inhalt.documents.length === 0 ? (
+        <p className="print-note">{de.export.noDocuments}</p>
+      ) : (
+        inhalt.documents.map((doc, index) => (
+          <section
+            key={doc.id}
+            style={index === 0 ? undefined : { breakBefore: 'page' }}
+          >
+            <DocumentSheet
+              permissions={permissions}
+              displayName={displayName}
+              doc={doc}
+              withCover={false}
+            />
+          </section>
+        ))
+      )}
+
+      <h2 style={{ breakBefore: 'page' }}>{de.export.casesHeading}</h2>
+      {inhalt.cases.length === 0 ? (
+        <p className="print-note">{de.export.noCases}</p>
+      ) : (
+        inhalt.cases.map((akte, index) => (
+          <section
+            key={akte.id}
+            style={index === 0 ? undefined : { breakBefore: 'page' }}
+          >
+            <CaseSheet
+              permissions={permissions}
+              displayName={displayName}
+              akte={akte}
+              withCover={false}
+              authors={nameVon}
+            />
+          </section>
+        ))
+      )}
+    </>
+  )
+}
+
+/**
+ * Was der Abrufer hätte sehen dürfen und selbst ausgeschlossen hat.
+ *
+ * Steht bewusst da, auch wenn nichts weggelassen wurde - dann als leere
+ * Aussage: "nichts weggelassen" ist eine Information. Nur was **über** der
+ * Stufe des Abrufers liegt, taucht hier nie auf; das existiert für ihn nicht.
+ */
+export function OmittedNote({
+  inhalt,
+  eigeneStufe,
+}: {
+  inhalt: Pick<Dossier, 'omitted' | 'omittedTotal' | 'truncated'>
+  eigeneStufe: number
+}) {
+  if (inhalt.omittedTotal === 0 && !inhalt.truncated) return null
+
+  return (
+    <section className="print-omitted" style={{ breakInside: 'avoid' }}>
+      <p className="print-label">{de.export.omittedHeading}</p>
+      {inhalt.omittedTotal > 0 ? (
+        <>
+          <p className="print-note" style={{ margin: '1mm 0' }}>
+            {de.export.omittedNote(eigeneStufe)}
+          </p>
+          <ul style={{ margin: '1mm 0 0', paddingLeft: '5mm' }}>
+            {inhalt.omitted.map((zeile) => (
+              <li key={zeile.level}>
+                {de.export.omittedRow(zeile.level, zeile.documents, zeile.cases)}
+              </li>
+            ))}
+          </ul>
+        </>
+      ) : null}
+      {inhalt.truncated ? (
+        <p className="print-note" style={{ margin: '1mm 0 0' }}>
+          {de.export.truncated}
+        </p>
+      ) : null}
+    </section>
+  )
+}

web/components/print/PersonnelSheet.tsx

@@ -0,0 +1,124 @@
+import { db } from '@/lib/db'
+import { de } from '@/lib/i18n/de'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Der Druckbogen einer Personalakte: die Kopfdaten selbst.
+ *
+ * Die Personalakte trägt keine Vorlage mit Abschnitten wie eine Fallakte - was
+ * über die Person aktenkundig ist, steht in ihren Dokumenten. Deshalb ist
+ * dieser Bogen kurz; das Gewicht des Dossiers liegt in dem, was dahinter
+ * kommt. Siehe lib/export/dossier.ts.
+ */
+export type PersonnelForPrint = {
+  id: string
+  userId: string | null
+  displayName: string
+  rank: string | null
+  classification: number
+  statusTags: string[]
+  note: string | null
+  department: { key: string; name: string } | null
+  createdAt: Date
+}
+
+export async function PersonnelSheet({
+  permissions,
+  displayName,
+  akte,
+  withCover = true,
+}: {
+  permissions: EffectivePermissions
+  displayName: string
+  akte: PersonnelForPrint
+  withCover?: boolean
+}) {
+  const [levels, etiketten] = await Promise.all([
+    db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
+    akte.statusTags.length === 0
+      ? []
+      : db.personnelStatusTag.findMany({
+          where: { key: { in: akte.statusTags } },
+          orderBy: { sortOrder: 'asc' },
+          select: { key: true, name: true },
+        }),
+  ])
+
+  const levelName = new Map(levels.map((l) => [l.level, l.name]))
+  const stufe = `${akte.classification} · ${levelName.get(akte.classification) ?? de.common.unknown}`
+
+  return (
+    <>
+      {withCover ? (
+        <section className="print-cover">
+          <span className="print-stamp">{stufe}</span>
+          <h1 style={{ marginTop: '4mm' }}>
+            {akte.rank ? `[${akte.rank}] ` : ''}
+            {akte.displayName}
+          </h1>
+          <p style={{ fontFamily: 'var(--font-mono, monospace)', margin: 0 }}>
+            {de.personnel.one}
+          </p>
+
+          <table className="print-meta">
+            <tbody>
+              <Zeile label={de.personnel.rank} value={akte.rank ?? '-'} />
+              <Zeile
+                label={de.personnel.department}
+                value={akte.department?.name ?? de.personnel.noDepartment}
+              />
+              <Zeile
+                label={de.personnel.linkedAccount}
+                value={akte.userId ?? de.personnel.noAccount}
+              />
+              <Zeile label={de.export.retrievedBy} value={displayName} />
+              <Zeile
+                label={de.export.asOf}
+                value={`${new Date().toLocaleString('de-DE')} · ${de.clearance.label} ${permissions.clearanceLevel}`}
+              />
+            </tbody>
+          </table>
+
+          <p className="print-note" style={{ marginTop: '4mm' }}>
+            {de.export.coverNote}
+          </p>
+        </section>
+      ) : (
+        <header className="print-runin">
+          <span className="print-stamp">{stufe}</span>
+          <h2 style={{ margin: '2mm 0 0' }}>
+            {akte.rank ? `[${akte.rank}] ` : ''}
+            {akte.displayName}
+          </h2>
+          <p className="print-note" style={{ margin: 0 }}>
+            {akte.department?.name ?? de.personnel.noDepartment}
+          </p>
+        </header>
+      )}
+
+      <table className="print-meta">
+        <tbody>
+          <Zeile
+            label={de.personnel.status}
+            value={
+              etiketten.length === 0
+                ? de.personnel.statusNone
+                : etiketten.map((tag) => tag.name).join(', ')
+            }
+          />
+          <Zeile label={de.personnel.note} value={akte.note ?? '-'} />
+          <Zeile label={de.case.createdAt} value={akte.createdAt.toLocaleDateString('de-DE')} />
+        </tbody>
+      </table>
+    </>
+  )
+}
+
+function Zeile({ label, value }: { label: string; value: string }) {
+  return (
+    <tr>
+      <th>{label}</th>
+      <td style={{ whiteSpace: 'pre-wrap' }}>{value}</td>
+    </tr>
+  )
+}