Phase 8 abgeschlossen: Export als PDF, Wasserzeichen, Vier-Augen-Freigabe

Die Druckansicht ist die einzige Vorlage für den Export: kein zweites Layout
von Hand in einer PDF-Bibliothek. Der Playwright-Dienst ruft genau diese Seite
auf und bekommt dafür ein signiertes, kurzlebiges Zeichen statt eines
Sitzungscookies. Es gilt nur, solange der Auftrag läuft, ist an den Anfragenden
gebunden, und die Stufe wird beim Einlösen frisch aufgelöst und auf die im
Zeichen vermerkte gedeckelt.

Der Export darf nie sauberer aussehen als die Akte: gesperrte Felder erscheinen
als Balken mit Vermerk statt zu fehlen, geänderte Einträge tragen ihre Version,
zurückgezogene stehen als Grabstein. Wasserzeichen mit Name, Zeitstempel und
Stufe auf jeder Seite.

Die Stufe steckt im Zwischenspeicherschlüssel. Ohne sie bekäme ein Leser der
Stufe 1 das PDF, das für Stufe 4 gerendert wurde.

Ab Stufe 3 wartet der Auftrag auf Freigabe durch ein zweites Augenpaar - und
der Anfragende darf sich nicht selbst freigeben, auch nicht mit dem Recht
dazu. Offene Freigaben stehen auf der Übersicht.

Dazu Einzeldokumente als PDF (Aktenblatt bleibt Aktenblatt), ZIP-Sammelexport
mit eigenem achtzigzeiligem Schreiber statt einer Abhängigkeit, und der
JSON-Vollabzug ohne Stufenfilterung - die einzige Stelle, an der die
Klassifizierung nicht greift, deshalb hinter einem eigenen Admin-Endpunkt.

Zwei Funde unterwegs, beide in docs/13 festgehalten:

Die Druckansicht warf notFound(), und das Skelett aus dem Wurzel-loading.tsx
blieb im Browser stehen - der PDF-Dienst hätte leere Blätter gedruckt.
Gefunden nur, weil der e2e-Test auf den Inhalt prüft und nicht auf den
Statuscode. Sie rendert die Auskunft jetzt selbst.

Und die Entdopplung der Anhänge verwies auf Dateien, ohne nachzusehen, ob sie
noch daliegen. Nach einem geleerten /tmp zeigte jeder weitere Upload desselben
Inhalts stumm ins Leere.

178 Tests im Web-Paket, 17 in der Datenbank, 7 im Worker, 44 e2e.
Fallakte bei 119,8 von 120 kB - das Budget ist aufgebraucht.

web/app/api/admin/export/route.ts

@@ -0,0 +1,94 @@
+import { NextResponse } from 'next/server'
+import { db } from '@/lib/db'
+import { getCurrentUser } from '@/lib/auth/current'
+import { AccessError } from '@/lib/errors'
+import { exportDatabase } from '@/lib/export/database'
+import { createZip } from '@/lib/export/zip'
+import { absolutePath } from '@/lib/files/paths'
+import { readFile } from 'node:fs/promises'
+import { writeAudit } from '@/lib/audit'
+
+export const runtime = 'nodejs'
+export const dynamic = 'force-dynamic'
+
+/**
+ * Die beiden Wege für Administratoren aus docs/08-suche-und-export.md:
+ *
+ *     GET /api/admin/export?kind=database   vollständiger JSON-Abzug
+ *     GET /api/admin/export?kind=bundle     ZIP mit den fertigen Exporten
+ *
+ * Beide nur mit Recht `admin`, beide protokolliert. Der JSON-Abzug ist die
+ * einzige Stelle im System, an der die Klassifizierung nicht greift — deshalb
+ * liegt er hinter einem eigenen Endpunkt und nicht hinter einem Knopf an einer
+ * Akte.
+ */
+export async function GET(request: Request): Promise<Response> {
+  const user = await getCurrentUser()
+  // Kein 403: wer das Recht nicht hat, für den gibt es den Endpunkt nicht.
+  if (!user?.permissions.isAdmin) return new NextResponse(null, { status: 404 })
+
+  const kind = new URL(request.url).searchParams.get('kind')
+
+  try {
+    if (kind === 'database') {
+      const abzug = await exportDatabase(user.permissions)
+      return datei(abzug, 'application/json', `afis-abzug-${heute()}.json`)
+    }
+
+    if (kind === 'bundle') {
+      const fertige = await db.exportJob.findMany({
+        where: { status: 'READY', storageKey: { not: null } },
+        orderBy: { finishedAt: 'desc' },
+        take: 100,
+        select: { id: true, storageKey: true, kind: true },
+      })
+
+      const eintraege: { name: string; content: Uint8Array }[] = []
+      for (const auftrag of fertige) {
+        try {
+          eintraege.push({
+            name: `${auftrag.kind.toLowerCase()}-${auftrag.id}.pdf`,
+            content: new Uint8Array(await readFile(absolutePath(auftrag.storageKey!))),
+          })
+        } catch {
+          // Eine fehlende Datei hält den Sammelexport nicht auf.
+        }
+      }
+
+      await db.$transaction(async (tx) => {
+        await writeAudit(tx, {
+          actorId: user.id,
+          action: 'export.pdf',
+          targetType: 'ExportJob',
+          targetId: 'bundle',
+          clearanceAtTime: user.permissions.clearanceLevel,
+          meta: { files: eintraege.length },
+        })
+      })
+
+      return datei(createZip(eintraege), 'application/zip', `afis-sammelexport-${heute()}.zip`)
+    }
+
+    return new NextResponse(null, { status: 404 })
+  } catch (error) {
+    if (error instanceof AccessError) return new NextResponse(null, { status: 404 })
+    console.error('[export] Adminexport fehlgeschlagen', error)
+    return NextResponse.json({ error: 'unbekannt' }, { status: 500 })
+  }
+}
+
+function heute(): string {
+  return new Date().toISOString().slice(0, 10)
+}
+
+function datei(inhalt: Uint8Array, typ: string, name: string): Response {
+  return new NextResponse(inhalt as unknown as BodyInit, {
+    headers: {
+      'Content-Type': typ,
+      'Content-Length': String(inhalt.byteLength),
+      'X-Content-Type-Options': 'nosniff',
+      'Cache-Control': 'private, no-store',
+      'Content-Disposition': `attachment; filename="${name}"`,
+    },
+  })
+}

web/app/api/exports/[id]/route.ts

@@ -0,0 +1,63 @@
+import { createReadStream } from 'node:fs'
+import { stat } from 'node:fs/promises'
+import { Readable } from 'node:stream'
+import { NextResponse } from 'next/server'
+import { db } from '@/lib/db'
+import { getCurrentUser } from '@/lib/auth/current'
+import { recordRead } from '@/lib/audit'
+import { absolutePath } from '@/lib/files/paths'
+
+export const runtime = 'nodejs'
+export const dynamic = 'force-dynamic'
+
+/**
+ * Herunterladen eines fertigen Exports.
+ *
+ * Nur der Auftraggeber selbst. Ein Export ist auf **seine** Stufe gekürzt und
+ * trägt **seinen** Namen im Wasserzeichen — ihn an jemand anderen auszuliefern
+ * hiesse, ein Dokument mit fremdem Namen zu verteilen.
+ */
+export async function GET(
+  _request: Request,
+  context: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const user = await getCurrentUser()
+  if (!user) return new NextResponse(null, { status: 404 })
+
+  const { id } = await context.params
+  const auftrag = await db.exportJob.findFirst({
+    where: { id, requestedById: user.id, status: 'READY' },
+    select: { id: true, kind: true, targetId: true, storageKey: true },
+  })
+  if (!auftrag?.storageKey) return new NextResponse(null, { status: 404 })
+
+  let groesse: number
+  try {
+    groesse = (await stat(absolutePath(auftrag.storageKey))).size
+  } catch {
+    return new NextResponse(null, { status: 404 })
+  }
+
+  // Jeder Abruf wird protokolliert, nicht nur die Erzeugung: ein PDF kann
+  // mehrfach heruntergeladen und weitergegeben werden.
+  recordRead({
+    actorId: user.id,
+    action: 'export.download',
+    targetType: 'ExportJob',
+    targetId: auftrag.id,
+    clearanceAtTime: user.permissions.clearanceLevel,
+    meta: { kind: auftrag.kind, targetId: auftrag.targetId ?? undefined },
+  })
+
+  const stream = Readable.toWeb(createReadStream(absolutePath(auftrag.storageKey))) as ReadableStream
+  return new NextResponse(stream, {
+    headers: {
+      'Content-Type': 'application/pdf',
+      'Content-Length': String(groesse),
+      'X-Content-Type-Options': 'nosniff',
+      'Cache-Control': 'private, no-store',
+      'Content-Security-Policy': "default-src 'none'; sandbox",
+      'Content-Disposition': `attachment; filename="afis-export-${auftrag.id}.pdf"`,
+    },
+  })
+}