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>
This commit is contained in:
Harlekin
2026-09-02 14:15:16 +02:00
co-authored by Claude Opus 5
parent f5769ca58a
commit d65cc95eb2
62 changed files with 5312 additions and 225 deletions
+188
View File
@@ -0,0 +1,188 @@
import type { Metadata } from 'next'
import { Suspense } from 'react'
import Link from 'next/link'
import { notFound } from 'next/navigation'
import { db } from '@/lib/db'
import { requirePermission } from '@/lib/auth/current'
import { recordRead, READ_AUDIT_FROM_LEVEL } from '@/lib/audit'
import { loadBacklinks, loadVisiblePersonnelFile } from '@/lib/personnel/service'
import { listDocuments, listTemplatesFor } from '@/lib/documents/service'
import { canWritePersonnel } from '@/lib/access/documentWrite'
import { de } from '@/lib/i18n/de'
import { StampMark, classificationEdgeStyle } from '@/components/StampMark'
import { SkeletonLine } from '@/components/Skeleton'
import { DocumentList } from '@/components/documents/DocumentList'
import { NewDocument } from '@/components/documents/NewDocument'
import { PersonnelHead } from './PersonnelHead'
import type { EffectivePermissions } from '@/lib/auth/permissions'
export const dynamic = 'force-dynamic'
export async function generateMetadata({
params,
}: {
params: Promise<{ id: string }>
}): Promise<Metadata> {
const user = await requirePermission('personnel.read')
const { id } = await params
const akte = await loadVisiblePersonnelFile(user.permissions, id)
return { title: akte?.displayName ?? de.personnel.one }
}
/**
* Rückverweise: die Fälle, in denen diese Person vorkommt.
*
* Streamt in einer eigenen Suspense-Grenze nach, weil die Abfrage über die
* Sichtbarkeitsprüfung der Fallakten läuft und damit die teuerste auf dieser
* Seite ist. Die Kopfdaten stehen währenddessen schon.
*/
async function Backlinks({
file,
permissions,
}: {
file: { id: string; userId: string | null }
permissions: EffectivePermissions
}) {
const { total, byRole } = await loadBacklinks(permissions, file)
if (total === 0) {
return <p className="text-text-dim">{de.personnel.backlinksEmpty}</p>
}
return (
<div className="space-y-6">
{byRole.map(({ role, eintraege }) => (
<div key={role}>
<h3 className="font-condensed text-xs text-text-dim">
{de.participant.roles[role] ?? role}
</h3>
<ul className="mt-2 border-t border-line">
{eintraege.map(({ case: akte }) => (
<li key={`${role}:${akte.id}`} className="border-b border-line">
<Link
href={`/faelle/${akte.caseNumber}`}
prefetch
className="flex flex-wrap items-baseline gap-x-4 gap-y-1 py-2 pl-3 text-text no-underline"
style={classificationEdgeStyle(akte.classification)}
>
<span className="font-mono text-xs text-text-dim">{akte.caseNumber}</span>
<span className="grow">{akte.title}</span>
<span className="font-condensed text-2xs text-text-dim">
{de.case.statusNames[akte.status]}
</span>
</Link>
</li>
))}
</ul>
</div>
))}
</div>
)
}
async function Documents({
file,
permissions,
canEdit,
}: {
file: { id: string; classification: number }
permissions: EffectivePermissions
canEdit: boolean
}) {
const [documents, templates, levels] = await Promise.all([
listDocuments(permissions, { personnelFileId: file.id }),
canEdit ? listTemplatesFor('PERSON_DOCUMENT') : Promise.resolve([]),
db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
])
return (
<div className="space-y-4">
<DocumentList
documents={documents}
levelName={new Map(levels.map((l) => [l.level, l.name]))}
/>
{canEdit ? (
<NewDocument
templates={templates}
levels={levels.filter((l) => l.level <= permissions.clearanceLevel)}
defaultLevel={Math.min(file.classification, permissions.clearanceLevel)}
personnelFileId={file.id}
/>
) : null}
</div>
)
}
export default async function PersonnelPage({ params }: { params: Promise<{ id: string }> }) {
const user = await requirePermission('personnel.read')
const { id } = await params
const akte = await loadVisiblePersonnelFile(user.permissions, id)
// Kein Zugriff heisst 404, nicht 403: die Existenz ist selbst eine Information.
if (!akte) notFound()
// Harte Regel 3: jeder Lesezugriff ab Stufe 3 wird protokolliert.
if (akte.classification >= READ_AUDIT_FROM_LEVEL) {
recordRead({
actorId: user.id,
action: 'personnel.read',
targetType: 'PersonnelFile',
targetId: akte.id,
clearanceAtTime: user.permissions.clearanceLevel,
meta: { displayName: akte.displayName, classification: akte.classification },
})
}
const levels = await db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } })
const level = levels.find((l) => l.level === akte.classification)
const canEdit = canWritePersonnel(user.permissions, akte.classification).ok
return (
<main className="mx-auto max-w-5xl px-6 py-10">
<header className="pl-3" style={classificationEdgeStyle(akte.classification)}>
<div className="flex flex-wrap items-baseline gap-x-4 gap-y-2">
<span className="font-condensed text-xs text-text-dim">{de.personnel.one}</span>
<StampMark level={akte.classification} name={level?.name ?? de.common.unknown} />
</div>
<h1 className="mt-2 font-condensed">{akte.displayName}</h1>
</header>
<section className="mt-8">
<h2 className="font-condensed">{de.personnel.headData}</h2>
<div className="mt-4">
<PersonnelHead
file={akte}
canEdit={canEdit}
levels={levels.filter((l) => l.level <= user.permissions.clearanceLevel)}
/>
</div>
</section>
<section className="mt-10">
<h2 className="font-condensed">{de.document.heading}</h2>
<div className="mt-4">
<Suspense fallback={<SkeletonLine width="60%" />}>
<Documents file={akte} permissions={user.permissions} canEdit={canEdit} />
</Suspense>
</div>
</section>
<section className="mt-10">
<h2 className="font-condensed">{de.personnel.backlinks}</h2>
<div className="mt-4">
<Suspense
fallback={
<div className="space-y-3">
<SkeletonLine width="8rem" />
<SkeletonLine width="70%" />
<SkeletonLine width="55%" />
</div>
}
>
<Backlinks file={akte} permissions={user.permissions} />
</Suspense>
</div>
</section>
</main>
)
}