feat(cms): Aufraeumen von Uploads, Texte-Bearbeitung und PDF-Slot

Bilder wurden nie geloescht - weder beim Loeschen eines Datensatzes noch
beim Austauschen. Dazu waren die Textbereiche zwar im Backend vorhanden,
aber ohne Oberflaeche, und die Getraenkekarte hing hartkodiert im Markup.

Aufraeumen:
- asset.service.ts loescht ausschliesslich Dateien, die das CMS selbst
  angelegt hat (Muster <zeitstempel>-<zufall>.<ext>) und nur innerhalb der
  Upload-Ordner. Handgepflegte Assets wie event_karaoke.jpg oder Welcome.png
  bleiben unangetastet, auch wenn sie nirgends referenziert sind.
- image-refs.service.ts sammelt alle benutzten Bild-URLs, inklusive der
  Pfade aus den Textbereichen. Geloescht wird nur, was wirklich niemand
  mehr benutzt - ein von zwei Events geteiltes Bild bleibt liegen.
- Events und Gallery raeumen beim Loeschen und beim Bildwechsel mit auf.
- Der Publish entfernt zusaetzlich Verwaiste. Die Referenzliste deckt
  bewusst alle Zeilen ab, auch unveroeffentlichte, sonst verlieren die ihr
  Bild. Die Loeschungen werden mitcommittet, das Repo schrumpft also.

Texte:
- Neuer Adminbereich fuer Hero, Willkommen und Drinks ueber die schon
  vorhandenen /api/content-Endpunkte, samt Highlights-Liste und Bildern.
- Der Generator maskiert Texte jetzt. Ohne das haette ein "<" oder "&" in
  einem Feld gereicht, um den Astro-Build und damit den Deploy zu killen.

PDF:
- POST /api/pdf/drinks nimmt die Getraenkekarte entgegen, hinterlegt die
  URL in der drinks-Section und raeumt den Vorgaenger weg. Der Generator
  verlinkt sie, statt den Pfad fest im Markup zu haben.

Ausserdem:
- Vorschaubilder im Admin auf eine feste Box gezwungen. Uploads sind bis
  1600px breit und haben das Layout je nach Seitenverhaeltnis zerrissen.
- git.service.ts sichert public/pdf beim Neu-Clone mit weg, nicht nur
  public/images.
- Der Publish scheitert nicht mehr, wenn nur das Audit-Log nicht
  geschrieben werden kann - der Push ist da laengst durch.
- Upload-Logik lag dreifach kopiert vor, jetzt in upload.service.ts. Der
  Helfer prueft auch auf abgeschnittene Dateien; bisher landete bei zu
  grossen Uploads ein kaputtes Bild auf der Platte.

Co-Authored-By: Claude Opus 5 (1M context) <[email protected]>

backend/src/routes/pdf.ts

@@ -0,0 +1,132 @@
+import { FastifyPluginAsync } from 'fastify';
+import fs from 'fs';
+import path from 'path';
+import { eq } from 'drizzle-orm';
+import { db } from '../config/database.js';
+import { contentSections } from '../db/schema.js';
+import { AssetService } from '../services/asset.service.js';
+import { env } from '../config/env.js';
+
+const assets = new AssetService();
+
+/**
+ * Feste PDF-Plaetze. Die URL landet jeweils in einer Content-Section, damit
+ * der Generator sie beim Publish in die Astro-Komponente schreiben kann.
+ */
+const PDF_SLOTS: Record<string, { section: string; field: string }> = {
+  drinks: { section: 'drinks', field: 'pdfUrl' },
+};
+
+/** contentJson kommt je nach Treiber als Objekt oder als String zurueck. */
+function asObject(value: any): Record<string, any> {
+  if (!value) return {};
+  if (typeof value === 'string') {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === 'object' ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return typeof value === 'object' ? value : {};
+}
+
+const pdfRoute: FastifyPluginAsync = async (fastify) => {
+
+  // PDF fuer einen festen Platz hochladen und verlinken
+  fastify.post('/pdf/:slot', {
+    preHandler: [fastify.authenticate],
+  }, async (request, reply) => {
+    const { slot } = request.params as { slot: string };
+    const target = PDF_SLOTS[slot];
+
+    if (!target) {
+      return reply.code(404).send({ error: `Unknown PDF slot "${slot}"` });
+    }
+
+    try {
+      const file = await (request as any).file();
+      if (!file) {
+        return reply.code(400).send({ error: 'No file uploaded' });
+      }
+
+      const mime = file.mimetype as string | undefined;
+      const originalName = (file.filename as string | undefined) || '';
+      if (mime !== 'application/pdf' && !originalName.toLowerCase().endsWith('.pdf')) {
+        return reply.code(400).send({ error: 'Only PDF uploads are allowed' });
+      }
+
+      const chunks: Buffer[] = [];
+      for await (const chunk of file.file) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      }
+      const buffer = Buffer.concat(chunks);
+
+      if ((file.file as any)?.truncated) {
+        const limit = Math.round(env.MAX_FILE_SIZE / 1024 / 1024);
+        return reply.code(413).send({ error: `PDF too large. Maximum is ${limit} MB` });
+      }
+
+      // Inhalt gegenpruefen, damit nicht irgendetwas mit .pdf-Endung landet
+      if (buffer.subarray(0, 5).toString('latin1') !== '%PDF-') {
+        return reply.code(400).send({ error: 'File is not a valid PDF' });
+      }
+
+      const uploadDir = path.join(env.GIT_WORKSPACE_DIR, 'public', 'pdf');
+      fs.mkdirSync(uploadDir, { recursive: true });
+
+      const stamp = Date.now().toString(36);
+      const rand = Math.random().toString(36).slice(2, 8);
+      const filename = `${stamp}-${rand}.pdf`;
+      fs.writeFileSync(path.join(uploadDir, filename), buffer);
+
+      const pdfUrl = `/pdf/${filename}`;
+
+      // URL in der Content-Section hinterlegen
+      const [existing] = await db
+        .select()
+        .from(contentSections)
+        .where(eq(contentSections.sectionName, target.section))
+        .limit(1);
+
+      const previousContent = asObject((existing as any)?.contentJson);
+      const previousUrl = previousContent[target.field];
+      const content = { ...previousContent, [target.field]: pdfUrl };
+
+      if (existing) {
+        await db
+          .update(contentSections)
+          .set({ contentJson: content, updatedAt: new Date() })
+          .where(eq(contentSections.sectionName, target.section));
+      } else {
+        await db
+          .insert(contentSections)
+          .values({ sectionName: target.section, contentJson: content });
+      }
+
+      // Vorgaenger wegraeumen - greift nur bei frueher hochgeladenen PDFs,
+      // die mitgelieferte Getraenkekarte aus dem Repo bleibt liegen
+      if (previousUrl && previousUrl !== pdfUrl) {
+        try {
+          if (assets.deletePdf(previousUrl)) {
+            fastify.log.info(`Removed replaced PDF ${previousUrl}`);
+          }
+        } catch (err) {
+          fastify.log.warn({ err }, 'Could not remove replaced PDF');
+        }
+      }
+
+      return reply.code(201).send({ pdfUrl, section: target.section });
+
+    } catch (err: any) {
+      if (err?.code === 'FST_REQ_FILE_TOO_LARGE') {
+        const limit = Math.round(env.MAX_FILE_SIZE / 1024 / 1024);
+        return reply.code(413).send({ error: `PDF too large. Maximum is ${limit} MB` });
+      }
+      fastify.log.error({ err }, 'PDF upload failed');
+      return reply.code(500).send({ error: 'Failed to upload PDF' });
+    }
+  });
+};
+
+export default pdfRoute;