Personalakte als Aktenblatt, Status als Etiketten, Verknüpfen von beiden Seiten

Das Formular der Personalabteilung ist übernommen, nicht durch eine
Bildschirmansicht ersetzt: schwarzer Rahmen, Kopf mit Kennung und
Klassifizierungsbalken, Raster aus fünf Spalten, Unterschriftenzeilen,
Fußzeile. Es steht bewusst außerhalb des Design-Systems — es wird gedruckt und
muss auf Papier aussehen wie das Blatt daneben.

Datengetrieben bleibt es trotzdem. Kein Feld steht im Programm: sheetTitle und
sheetSubtitle an der Vorlage, span für die Zellbreite, rows für das Lichtbild,
dateKey für das Datum unter einer Unterschrift, slot für den
Klassifizierungsbalken. Eine weitere Dokumentart mit layout = DOSSIER braucht
keine Zeile Code.

Der Balken zeigt die Foundation-Stufe aus der neuen Tabelle
FoundationClearance. Sie ist Inhalt, kein Zugriff — was jemand sehen darf,
entscheidet weiterhin allein die interne Stufe. Ohne Auswahl bleibt der Balken
neutral, statt eine Einstufung zu behaupten.

Die Dienstnummer ist entfallen, es gibt sie nicht. Der Status ist zu mehreren
Etiketten geworden: "Gekündigt" und "Verhaftet" schließen einander nicht aus.
Unbekannte Schlüssel werden verworfen und die Reihenfolge kommt aus der
Konfiguration, nicht aus der Eingabe.

PersonnelAssignment hängt AfiS-Mitglieder an eine Person — Aktenführung,
Ermittler, Ansprechpartner — und ist zugleich der ausnahmsweise Zugang, wie
CaseParticipant bei der Fallakte. Betroffen zu sein gibt weiterhin keinen
Zugang: das ist eine Eigenschaft der Person, die Zuordnung eine Entscheidung
der Abteilung.

Fall und Person lassen sich von beiden Seiten verknüpfen und schon beim
Anlegen einer Fallakte. Alle drei Wege laufen in addParticipant zusammen.

Noch offen: das Lichtbild. Feldtyp und Platz stehen, hochladen kommt mit der
Prüfkette in Phase 5 — ein Bild als Data-URL im Abschnittswert verstiesse
gegen harte Regel 4.

102 Tests im Web-Paket, davon sechs auf dem gerenderten Blatt selbst.

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

web/lib/access/personnelFilter.ts

@@ -13,16 +13,28 @@ import { visibleCaseWhere } from '@/lib/access/caseFilter'
 /**
  * Personalakten, die ein Nutzer lesen darf.
  *
- * Anders als bei der Fallakte gibt es hier keinen „Beteiligten": eine
- * Personalakte hat keine Ermittlergruppe. Es zählt allein die Freigabestufe.
+ * Zwei Wege, wie bei der Fallakte:
+ *  1. die Freigabestufe reicht, oder
+ *  2. der Nutzer ist der Akte **zugeordnet** (`PersonnelAssignment`)
  *
- * Auch die eigene Akte ist keine Ausnahme. Das ist bewusst so: eine Beurteilung
- * auf Stufe 4 über einen Mitarbeiter der Stufe 1 wäre sonst genau für den
- * einen Menschen lesbar, vor dem sie geschützt werden soll.
+ * Der zweite Weg ist der ausnahmsweise Zugang: die Leitung zieht einen
+ * Ermittler zu einer bestimmten Person hinzu, ohne ihm allgemein eine höhere
+ * Stufe zu geben. Er entsteht nur durch eine bewusste Eintragung und wird
+ * protokolliert.
+ *
+ * **Betroffen zu sein ist kein Weg.** Wer die Person selbst ist, liest ihre
+ * Akte nicht allein deshalb: eine Beurteilung auf Stufe 4 über einen
+ * Mitarbeiter der Stufe 1 wäre sonst genau für den einen Menschen lesbar, vor
+ * dem sie geschützt werden soll. Siehe docs/13-entscheidungen.md.
  */
 export function visiblePersonnelWhere(p: EffectivePermissions): Prisma.PersonnelFileWhereInput {
   if (p.isAdmin) return {}
-  return { classification: { lte: p.clearanceLevel } }
+  return {
+    OR: [
+      { classification: { lte: p.clearanceLevel } },
+      { assignments: { some: { userId: p.userId } } },
+    ],
+  }
 }
 
 /**

web/lib/audit.ts

@@ -32,6 +32,8 @@ export type AuditAction =
   | 'personnel.create'
   | 'personnel.update'
   | 'personnel.reclassify'
+  | 'personnel.assign'
+  | 'personnel.unassign'
   | 'document.read'
   | 'document.create'
   | 'document.update'

web/lib/i18n/de.ts

@@ -141,6 +141,8 @@ export const de = {
     empty: 'Noch keine Fallakte. Erste Fallakte anlegen.',
     create: 'Fallakte anlegen',
     createTitle: 'Neue Fallakte',
+    subject: 'Betroffene Person',
+    subjectNone: 'Keine',
     open: 'Öffnen',
     updatedAt: 'Zuletzt geändert',
     more: 'Weitere laden',
@@ -227,10 +229,13 @@ export const de = {
     many: 'Personalakten',
     listHeading: 'Personalakten',
     name: 'Name',
-    serviceNumber: 'Dienstnummer',
     rank: 'Dienstgrad',
     department: 'Abteilung',
     status: 'Status',
+    statusHint: 'Mehrere möglich. „Gekündigt" und „Verhaftet" schließen einander nicht aus.',
+    statusNone: 'Kein Status gesetzt',
+    filterStatus: 'Status',
+    filterAll: 'Alle',
     note: 'Anmerkung',
     noteHelp: 'Steht im Kopf der Akte, etwa "kein Discord-Konto, Aktenlage aus 2025".',
     linkedAccount: 'Discord-Konto',
@@ -240,8 +245,8 @@ export const de = {
     create: 'Personalakte anlegen',
     createTitle: 'Neue Personalakte',
     createHint:
-      'Auch für Personen ohne Discord-Konto: Zeugen, ehemalige Mitarbeiter, Aktenlage von außen.',
-    search: 'Name, Dienstnummer oder Dienstgrad',
+      'Meist für Externe ohne Discord-Konto: Sicherheitsdienst, Zeugen, Vertragspartner. Zusammen mit der Akte entsteht das Aktenblatt als erster Eintrag.',
+    search: 'Name, Dienstgrad oder Abteilung',
     countLabel: (n: number) => (n === 1 ? '1 Personalakte' : `${n} Personalakten`),
     edit: 'Kopfdaten ändern',
     reclassify: 'Klassifizierung ändern',
@@ -249,6 +254,22 @@ export const de = {
     backlinks: 'Fälle mit dieser Person',
     backlinksEmpty: 'Diese Person kommt in keinem Fall vor, den du sehen darfst.',
     backlinksCount: (n: number) => (n === 1 ? '1 Fall' : `${n} Fälle`),
+    linkCase: 'Fall verknüpfen',
+    linkCaseHint: 'Aktenzeichen eintragen und die Rolle wählen, in der die Person darin vorkommt.',
+  },
+
+  assignment: {
+    heading: 'Zuständige der Abteilung',
+    empty: 'Niemand zugeordnet.',
+    add: 'Mitglied zuordnen',
+    remove: 'Entfernen',
+    hint:
+      'Wer hier steht, liest die Personalakte unabhängig von seiner Freigabestufe.',
+    roles: {
+      HANDLER: 'Aktenführung',
+      INVESTIGATOR: 'Ermittler',
+      CONTACT: 'Ansprechpartner',
+    } as Record<string, string>,
   },
 
   participant: {
@@ -310,6 +331,15 @@ export const de = {
     retracted: (date: string, person: string, reason: string) =>
       `Dokument zurückgezogen am ${date} durch ${person} · Begründung: ${reason}`,
     finalized: (date: string, person: string) => `Ausgefertigt am ${date} durch ${person}`,
+    sheet: 'Aktenblatt',
+    edit: 'Bearbeiten',
+    print: 'Drucken',
+    issuedAt: 'Ausgestellt',
+    signedOn: 'Datum',
+    unclassified: 'Ohne Klassifikation',
+    photoEmpty: 'Lichtbild 3×4 cm',
+    photoLater: 'Lichtbilder kommen mit der Dateiprüfung.',
+    footerNote: 'Dieses Dokument ist klassifiziert. Nur für autorisiertes Personal.',
     ownerCase: 'Zur Fallakte',
     ownerPersonnel: 'Zur Personalakte',
     ownerNone: 'Ohne Besitzer',
@@ -322,6 +352,7 @@ export const de = {
       FORM: 'Formular',
       PROSE: 'Vertragstext',
       NOTE: 'Vermerk',
+      DOSSIER: 'Aktenblatt',
     } as Record<string, string>,
   },
 

web/lib/personnel/service.ts

@@ -4,6 +4,7 @@ import { visibleCaseWhere } from '@/lib/access/caseFilter'
 import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
 import { canWritePersonnel } from '@/lib/access/documentWrite'
 import { AccessError, must } from '@/lib/errors'
+import type { AssignmentRoleName } from '@/lib/personnel/terms'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 import type { Prisma } from '@afis/db'
 
@@ -19,10 +20,9 @@ const KOPFDATEN = {
   id: true,
   userId: true,
   displayName: true,
-  serviceNumber: true,
   rank: true,
   department: true,
-  status: true,
+  statusTags: true,
   note: true,
   classification: true,
   createdById: true,
@@ -44,19 +44,20 @@ export async function loadVisiblePersonnelFile(p: EffectivePermissions, id: stri
  */
 export async function listPersonnelFiles(
   p: EffectivePermissions,
-  options: { query?: string; take?: number } = {},
+  options: { query?: string; statusTag?: string; take?: number } = {},
 ) {
   const begriff = options.query?.trim()
   const where: Prisma.PersonnelFileWhereInput = {
     AND: [
       visiblePersonnelWhere(p),
+      ...(options.statusTag ? [{ statusTags: { has: options.statusTag } }] : []),
       ...(begriff
         ? [
             {
               OR: [
                 { displayName: { contains: begriff, mode: 'insensitive' as const } },
-                { serviceNumber: { contains: begriff, mode: 'insensitive' as const } },
                 { rank: { contains: begriff, mode: 'insensitive' as const } },
+                { department: { contains: begriff, mode: 'insensitive' as const } },
               ],
             },
           ]
@@ -82,10 +83,9 @@ export async function createPersonnelFile(
   input: {
     displayName: string
     userId?: string | null
-    serviceNumber?: string | null
     rank?: string | null
     department?: string | null
-    status?: string | null
+    statusTags?: string[]
     note?: string | null
     classification: number
   },
@@ -100,10 +100,9 @@ export async function createPersonnelFile(
       data: {
         displayName: name,
         userId: input.userId || null,
-        serviceNumber: input.serviceNumber?.trim() || null,
         rank: input.rank?.trim() || null,
         department: input.department?.trim() || null,
-        status: input.status?.trim() || null,
+        statusTags: await gueltigeStatusEtiketten(input.statusTags),
         note: input.note?.trim() || null,
         classification: input.classification,
         createdById: p.userId,
@@ -130,10 +129,9 @@ export async function updatePersonnelFile(
   id: string,
   input: {
     displayName?: string
-    serviceNumber?: string | null
     rank?: string | null
     department?: string | null
-    status?: string | null
+    statusTags?: string[]
     note?: string | null
   },
 ): Promise<void> {
@@ -149,14 +147,13 @@ export async function updatePersonnelFile(
       where: { id },
       data: {
         ...(name !== undefined ? { displayName: name } : {}),
-        ...(input.serviceNumber !== undefined
-          ? { serviceNumber: input.serviceNumber?.trim() || null }
-          : {}),
         ...(input.rank !== undefined ? { rank: input.rank?.trim() || null } : {}),
         ...(input.department !== undefined
           ? { department: input.department?.trim() || null }
           : {}),
-        ...(input.status !== undefined ? { status: input.status?.trim() || null } : {}),
+        ...(input.statusTags !== undefined
+          ? { statusTags: await gueltigeStatusEtiketten(input.statusTags) }
+          : {}),
         ...(input.note !== undefined ? { note: input.note?.trim() || null } : {}),
       },
     })
@@ -265,3 +262,132 @@ export async function loadBacklinks(
     byRole: [...nachRolle.entries()].map(([role, eintraege]) => ({ role, eintraege })),
   }
 }
+
+/**
+ * Filtert auf die Etiketten, die es wirklich gibt.
+ *
+ * Sonst könnte ein manipuliertes Formular einen erfundenen Status setzen, und
+ * die Liste im Adminbereich wäre nur noch eine Empfehlung. Die Reihenfolge
+ * kommt aus der Konfiguration, nicht aus der Eingabe: so steht auf jeder Akte
+ * dieselbe Abfolge.
+ */
+async function gueltigeStatusEtiketten(gewuenscht: string[] | undefined): Promise<string[]> {
+  if (!gewuenscht?.length) return []
+  const bekannt = await db.personnelStatusTag.findMany({
+    where: { key: { in: gewuenscht }, isActive: true },
+    orderBy: { sortOrder: 'asc' },
+    select: { key: true },
+  })
+  return bekannt.map((tag) => tag.key)
+}
+
+/** Die Etiketten zur Auswahl, für Formulare und Filter. */
+export async function listStatusTags() {
+  return db.personnelStatusTag.findMany({
+    where: { isActive: true },
+    orderBy: { sortOrder: 'asc' },
+    select: { key: true, name: true, colorToken: true },
+  })
+}
+
+/**
+ * Die AfiS-Mitglieder, die an dieser Personalakte hängen.
+ *
+ * Wer hier steht, liest die Akte unabhängig von seiner Freigabestufe — das ist
+ * derselbe ausnahmsweise Zugang wie `CaseParticipant` bei der Fallakte.
+ */
+export async function listAssignments(p: EffectivePermissions, personnelFileId: string) {
+  return db.personnelAssignment.findMany({
+    where: {
+      AND: [{ personnelFileId }, { personnelFile: { is: visiblePersonnelWhere(p) } }],
+    },
+    orderBy: { createdAt: 'asc' },
+    select: {
+      id: true,
+      role: true,
+      createdAt: true,
+      user: { select: { id: true, displayName: true } },
+    },
+  })
+}
+
+export async function addAssignment(
+  p: EffectivePermissions,
+  input: { personnelFileId: string; userId: string; role: AssignmentRoleName },
+): Promise<{ id: string }> {
+  const target = await loadVisiblePersonnelFile(p, input.personnelFileId)
+  if (!target) throw new AccessError('not-found')
+  must(canWritePersonnel(p, target.classification))
+
+  const mitglied = await db.user.findUnique({
+    where: { id: input.userId },
+    select: { id: true },
+  })
+  if (!mitglied) throw new AccessError('not-found')
+
+  const vorhanden = await db.personnelAssignment.findFirst({
+    where: { personnelFileId: target.id, userId: input.userId, role: input.role },
+    select: { id: true },
+  })
+  if (vorhanden) return vorhanden
+
+  return db.$transaction(async (tx) => {
+    const created = await tx.personnelAssignment.create({
+      data: {
+        personnelFileId: target.id,
+        userId: input.userId,
+        role: input.role,
+        addedById: p.userId,
+      },
+      select: { id: true },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'personnel.assign',
+      targetType: 'PersonnelAssignment',
+      targetId: created.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        personnelFileId: target.id,
+        displayName: target.displayName,
+        userId: input.userId,
+        role: input.role,
+      },
+    })
+
+    return created
+  })
+}
+
+export async function removeAssignment(
+  p: EffectivePermissions,
+  input: { personnelFileId: string; assignmentId: string },
+): Promise<void> {
+  const target = await loadVisiblePersonnelFile(p, input.personnelFileId)
+  if (!target) throw new AccessError('not-found')
+  must(canWritePersonnel(p, target.classification))
+
+  const zuordnung = await db.personnelAssignment.findFirst({
+    where: { id: input.assignmentId, personnelFileId: target.id },
+    select: { id: true, userId: true, role: true },
+  })
+  if (!zuordnung) throw new AccessError('not-found')
+
+  await db.$transaction(async (tx) => {
+    await tx.personnelAssignment.delete({ where: { id: zuordnung.id } })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'personnel.unassign',
+      targetType: 'PersonnelAssignment',
+      targetId: zuordnung.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        personnelFileId: target.id,
+        userId: zuordnung.userId,
+        role: zuordnung.role,
+      },
+    })
+  })
+}

web/lib/personnel/terms.ts

@@ -0,0 +1,15 @@
+/**
+ * Feste Wertelisten der Personalakte.
+ *
+ * **Ohne Abhängigkeiten**, weil der Client sie lädt — derselbe Schnitt wie
+ * `lib/cases/terms.ts`. Die Status-Etiketten stehen bewusst **nicht** hier:
+ * sie sind im Adminbereich pflegbar und kommen aus der Datenbank.
+ */
+
+export const ASSIGNMENT_ROLES = ['HANDLER', 'INVESTIGATOR', 'CONTACT'] as const
+
+export type AssignmentRoleName = (typeof ASSIGNMENT_ROLES)[number]
+
+export function isAssignmentRole(value: string): value is AssignmentRoleName {
+  return (ASSIGNMENT_ROLES as readonly string[]).includes(value)
+}

web/lib/templates/fields.ts

@@ -23,10 +23,14 @@ export const INPUT_TYPES = [
   'number',
   'checklist',
   'table',
+  /** Lichtbild. Der Wert ist die Kennung eines geprüften Anhangs, nie ein Bild. */
+  'photo',
+  /** Getippter Name, dargestellt als Zug über einer Linie. */
+  'signature',
 ] as const
 
 /** Bausteine, die aus der Vorlage kommen und nicht ausgefüllt werden. */
-export const STATIC_TYPES = ['heading', 'paragraph', 'signature', 'pagebreak'] as const
+export const STATIC_TYPES = ['heading', 'paragraph', 'pagebreak'] as const
 
 export type InputType = (typeof INPUT_TYPES)[number]
 export type StaticType = (typeof STATIC_TYPES)[number]
@@ -41,6 +45,25 @@ export type InputField = {
   requiredToClose?: boolean
   options?: string[]
   columns?: string[]
+  /**
+   * Breite im Raster des Aktenblatts, 1 bis 5 Spalten. Nur `layout = DOSSIER`
+   * wertet das aus; die übrigen Darstellungen setzen ohnehin untereinander.
+   */
+  span?: number
+  /** Nur bei `photo`: über wie viele Zeilen die Zelle reicht. */
+  rows?: number
+  /**
+   * Statt einer eigenen Zelle im Raster: dieses Feld füllt einen festen Platz
+   * des Aktenblatts. Bekannt ist `classbar` — der Klassifizierungsbalken.
+   */
+  slot?: string
+  /** Hebt den Wert hervor, etwa die Freigabestufen im Aktenblatt. */
+  emphasis?: boolean
+  /**
+   * Nur bei `signature`: Schlüssel des Datumsfeldes, das unter der Zeile
+   * steht. Das genannte Feld bekommt dadurch keine eigene Zelle mehr.
+   */
+  dateKey?: string
 }
 
 export type StaticBlock = {
@@ -50,6 +73,7 @@ export type StaticBlock = {
   help?: string
   minClearance?: number
   text?: string
+  span?: number
 }
 
 export type TemplateField = InputField | StaticBlock
@@ -80,6 +104,78 @@ export function requiredToCloseKeys(fields: TemplateField[]): string[] {
     .map((field) => field.key)
 }
 
+/**
+ * Die Datumsfelder, die eine Unterschrift bereits mitzeichnet. Sie bekommen
+ * im Aktenblatt keine eigene Zelle, bleiben aber ganz normal bearbeitbar.
+ */
+export const DOSSIER_COLUMNS = 5
+
+/**
+ * Zerlegt die Bausteine in die Zeilen des Aktenblatts.
+ *
+ * Solange die Lichtbildzelle mitläuft, ist eine Zeile eine Spalte schmaler —
+ * genau so, wie das Formular es tut. Danach nimmt sie die volle Breite.
+ * Felder, die in einen festen Platz gehören oder von einer Unterschrift
+ * mitgezeichnet werden, tauchen im Raster nicht auf.
+ */
+export function dossierRows(fields: TemplateField[]): {
+  photo: InputField | null
+  photoRows: number
+  rows: TemplateField[][]
+} {
+  const mitgezeichnet = signatureDateKeys(fields)
+  const photo =
+    fields.find((f): f is InputField => isInputField(f) && f.type === 'photo') ?? null
+  const photoRows = photo ? Math.max(1, photo.rows ?? 4) : 0
+
+  const rest = fields.filter(
+    (field) =>
+      field !== photo &&
+      !mitgezeichnet.has(field.key) &&
+      !(isInputField(field) && field.slot),
+  )
+
+  const rows: TemplateField[][] = []
+  let aktuell: TemplateField[] = []
+  let breite = 0
+
+  for (const field of rest) {
+    const grenze = rows.length < photoRows ? DOSSIER_COLUMNS - 1 : DOSSIER_COLUMNS
+    const span = Math.min(field.span ?? grenze, grenze)
+    if (breite + span > grenze && aktuell.length > 0) {
+      rows.push(aktuell)
+      aktuell = []
+      breite = 0
+    }
+    aktuell.push(field)
+    breite += span
+    if (breite >= grenze) {
+      rows.push(aktuell)
+      aktuell = []
+      breite = 0
+    }
+  }
+  if (aktuell.length > 0) rows.push(aktuell)
+
+  return { photo, photoRows, rows }
+}
+
+/** Die Breite einer Zelle in Rasterspalten, begrenzt auf die Zeilenbreite. */
+export function dossierSpan(field: TemplateField, inPhotoRows: boolean): number {
+  const grenze = inPhotoRows ? DOSSIER_COLUMNS - 1 : DOSSIER_COLUMNS
+  return Math.min(field.span ?? grenze, grenze)
+}
+
+export function signatureDateKeys(fields: TemplateField[]): Set<string> {
+  const keys = new Set<string>()
+  for (const field of fields) {
+    if (isInputField(field) && field.type === 'signature' && field.dateKey) {
+      keys.add(field.dateKey)
+    }
+  }
+  return keys
+}
+
 /**
  * Grobe Formprüfung für die Vorschau im Editor. Sagt, ob sich die Eingabe
  * überhaupt darstellen lässt — nicht, ob sie gespeichert werden darf. Das

web/lib/templates/schema.ts

@@ -29,12 +29,18 @@ const inputField = z.object({
   requiredToClose: z.boolean().optional(),
   options: z.array(z.string().min(1)).optional(),
   columns: z.array(z.string().min(1)).optional(),
+  span: z.number().int().min(1).max(5).optional(),
+  rows: z.number().int().min(1).max(12).optional(),
+  slot: z.enum(['classbar']).optional(),
+  emphasis: z.boolean().optional(),
+  dateKey: key.optional(),
 })
 
 const staticBlock = z.object({
   ...gemeinsam,
   type: z.enum(STATIC_TYPES),
   text: z.string().max(20_000).optional(),
+  span: z.number().int().min(1).max(5).optional(),
 })
 
 export const templateFieldSchema = z.union([inputField, staticBlock])
@@ -64,6 +70,14 @@ export const templateFieldsSchema = z
           message: 'Auswahlfelder brauchen mindestens eine Option',
         })
       }
+
+      if ('dateKey' in field && field.dateKey && field.type !== 'signature') {
+        ctx.addIssue({
+          code: 'custom',
+          path: [index, 'dateKey'],
+          message: 'Ein Datumsverweis gehört nur an eine Unterschrift',
+        })
+      }
     }
   })