dogfather-universe/server/workspace-wissen.js

/* =====================================================================
   workspace-wissen.js — Wissens-Bibliothek (Anleitungen als PDF).

   Die Gliederung ist der eigentliche Wert dieses Bereichs, deshalb steht
   sie hier im Code und nicht in der Datenbank: zwanzig Kategorien, von
   Filipe vorgegeben, in sechs Welten gebuendelt. Zwanzig gleich
   aussehende Kacheln untereinander findet niemand -- gebuendelt sucht
   man erst die Welt und dann die Kategorie, und das geht mit einem Blick.

   JEDE PDF HAT GENAU EINE HAUPTKATEGORIE. So gibt es sie nur einmal, es
   entstehen keine Doppelungen und keine Frage "wo lag die noch mal".
   Alles Weitere laeuft ueber Tags -- damit ist dieselbe Anleitung
   trotzdem ueber mehrere Suchbegriffe auffindbar.

   Sicherheit beim Ausliefern: Hochgeladen wird nur, was wirklich eine
   PDF ist (geprueft an den ersten Bytes, nicht an der Dateiendung -- die
   kann jeder umbenennen). Nur deshalb darf die Datei ueberhaupt im
   Browser angezeigt statt bloss heruntergeladen werden.
   ===================================================================== */

import express from "express";
import { randomBytes } from "node:crypto";
import { join } from "node:path";
import { mkdirSync, createReadStream, writeFileSync, unlinkSync, statSync } from "node:fs";
import {
  db, protokolliere, echteIp, sitzungLesen, DATEN_ORDNER, istLeitung, heuteLokal,
} from "./workspace.js";

export const wissenRouter = express.Router();

const ORDNER = join(DATEN_ORDNER, "wissen");
const MAX_BYTES = 40 * 1024 * 1024;      // 40 MB je Anleitung
const TITEL_MAX = 140;
const TEXT_MAX = 400;
const TAGS_MAX = 8;

/* Wie lange eine Anleitung unter "Neu & wichtig" steht. Danach ist sie
   nur noch in ihrer Kategorie zu finden -- so wie es sein soll: Der
   Block oben ist eine Neuigkeitenanzeige, kein zweites Regal. */
const NEU_STUNDEN = 48;

const jetzt = () => new Date().toISOString();
/* ORTSZEIT -- als Vorgabe fuer das Veroeffentlichungsdatum. Mit UTC
   schlug die Seite nachts den Vortag vor. */
const heute = () => heuteLokal();

/* ---------- Die Gliederung ------------------------------------------------
   Die Beschreibungen sind woertlich Filipes Vorgabe -- sie sagen, was in
   die Kategorie gehoert, und beantworten damit die einzige Frage, die
   man beim Einsortieren wirklich hat.                                    */

export const WELTEN = [
  { schluessel: "tiktok",   name: "TikTok" },
  { schluessel: "aufbau",   name: "Streaming einrichten" },
  { schluessel: "bildton",  name: "Bild & Ton" },
  { schluessel: "technik",  name: "Übertragung & Aussehen" },
  { schluessel: "inhalt",   name: "Inhalt & Menschen" },
  { schluessel: "hilfe",    name: "Hilfe & Schnellstart" },
];

export const KATEGORIEN = [
  { nr: 1, schluessel: "tiktok-grundlagen", welt: "tiktok", symbol: "tiktok",
    name: "TikTok – Grundlagen & Funktionen",
    beschreibung: "Allgemeine TikTok-Erklärungen, Einstellungen, LIVE-Funktionen, Gäste, Co-Hosts, Abos, Geschenke, Coins und neue Features." },
  { nr: 2, schluessel: "tiktok-regeln", welt: "tiktok", symbol: "schild",
    name: "TikTok – Regeln & Sicherheit",
    beschreibung: "Community-Richtlinien, erlaubte und verbotene Inhalte, Altersprüfung, Sperren, Verwarnungen, Datenschutz, Jugendschutz und sicheres Verhalten." },
  { nr: 17, schluessel: "events-einnahmen", welt: "tiktok", symbol: "pokal",
    name: "Events, Kampagnen & Einnahmen",
    beschreibung: "TikTok-Events, Ranglisten, Kampagnen, LIVE-Geschenke, Abonnements, Monetarisierung und Teilnahmebedingungen." },
  { nr: 20, schluessel: "neuigkeiten", welt: "tiktok", symbol: "glocke",
    name: "Neuigkeiten & Updates",
    beschreibung: "Neue TikTok-Funktionen, Änderungen an Regeln, Software-Updates und aktuelle Entwicklungen im Streaming-Bereich." },

  { nr: 3, schluessel: "streaming-pc", welt: "aufbau", symbol: "monitor",
    name: "Streaming mit PC",
    beschreibung: "Komplettes Streaming-Setup am Computer, TikTok LIVE Studio, PC-Einstellungen, Leistung, Verkabelung und Einrichtung." },
  { nr: 4, schluessel: "obs", welt: "aufbau", symbol: "ebenen",
    name: "OBS & Streaming-Software",
    beschreibung: "OBS Studio, Szenen, Quellen, Übergänge, Plugins, virtuelle Kamera, TikTok-Anbindung und weitere Streaming-Programme." },
  { nr: 5, schluessel: "streaming-handy", welt: "aufbau", symbol: "handy",
    name: "Streaming mit Handy & Outdoor-Lives",
    beschreibung: "Mobile Livestreams, IRL-Streaming, Internetverbindung unterwegs, Powerbanks, Smartphone-Halterungen, mobile Mikrofone und Outdoor-Ausrüstung." },

  { nr: 6, schluessel: "kamera", welt: "bildton", symbol: "kamera",
    name: "Kamera & Bildqualität",
    beschreibung: "Webcams, Kameras, Kameraeinstellungen, Auflösung, FPS, Belichtung, Fokus, Unschärfe, Bildausschnitt, Filter und optimale Bildqualität." },
  { nr: 7, schluessel: "licht", welt: "bildton", symbol: "licht",
    name: "Licht & Hintergrund",
    beschreibung: "Beleuchtung, Ringlichter, Softboxen, LED-Lichter, Greenscreen, Hintergrundgestaltung und richtige Positionierung." },
  { nr: 8, schluessel: "audio", welt: "bildton", symbol: "mikrofon",
    name: "Mikrofone & Audio",
    beschreibung: "Mikrofone, Audioeinstellungen, Lautstärke, Rauschunterdrückung, Equalizer, Sprachqualität, Musik und Soundprobleme." },
  { nr: 9, schluessel: "mischpulte", welt: "bildton", symbol: "regler",
    name: "Mischpulte, Soundboards & Effekte",
    beschreibung: "Maono, RØDECaster, Stream Deck, Soundpads, Sprach- und Soundeffekte sowie das Belegen von Tasten mit Sounds." },
  { nr: 10, schluessel: "hardware", welt: "bildton", symbol: "stecker",
    name: "Streaming-Hardware & Zubehör",
    beschreibung: "Computer, Monitore, Capture Cards, Kabel, Adapter, Stative, Kopfhörer, Stream Decks und weiteres Zubehör." },

  { nr: 11, schluessel: "internet", welt: "technik", symbol: "wlan",
    name: "Internet & Stream-Qualität",
    beschreibung: "WLAN, LAN, Upload-Geschwindigkeit, Bitrate, Verbindungsabbrüche, Lags, eingefrorene Bilder und Optimierung der Übertragung." },
  { nr: 12, schluessel: "design", welt: "technik", symbol: "rahmen",
    name: "Stream-Design & Darstellung",
    beschreibung: "Overlays, Rahmen, Szenen, Animationen, Einblendungen, Alerts, Logos, Chat-Anzeigen und ein professionelles Stream-Layout." },
  { nr: 13, schluessel: "tools", welt: "technik", symbol: "zahnrad",
    name: "Tools, Bots & Automatisierungen",
    beschreibung: "Tikfinity, Discord-Bots, Benachrichtigungen, automatische Aktionen, Chat-Befehle und weitere hilfreiche Programme." },

  { nr: 14, schluessel: "content", welt: "inhalt", symbol: "kalender",
    name: "Content & Stream-Planung",
    beschreibung: "Stream-Ideen, Vorbereitung, Ablaufpläne, Challenges, Spiele, Themenstreams, Zuschauerbindung und Content-Planung." },
  { nr: 15, schluessel: "community", welt: "inhalt", symbol: "menschen",
    name: "Community & Moderation",
    beschreibung: "Aufgaben der Modis, Chatregeln, Deeskalation, Community-Aufbau, Umgang mit Zuschauern, Trollen und Konflikten." },
  { nr: 16, schluessel: "reichweite", welt: "inhalt", symbol: "wachstum",
    name: "Reichweite & Wachstum",
    beschreibung: "TikTok-Wachstum, Videos, Clips, Highlights, Hashtags, Stream-Zeiten, Zuschauergewinnung und Verbesserung der Reichweite." },

  { nr: 18, schluessel: "fehler", welt: "hilfe", symbol: "werkzeug",
    name: "Fehlerbehebung & Problemlösungen",
    beschreibung: "Lösungen für technische Fehler, fehlenden Ton, schlechtes Bild, Abstürze, Verbindungsprobleme, OBS-Fehler und TikTok-LIVE-Probleme." },
  { nr: 19, schluessel: "checklisten", welt: "hilfe", symbol: "haken",
    name: "Checklisten & Schnellstart-Anleitungen",
    beschreibung: "Kurze Schritt-für-Schritt-Anleitungen, Einsteiger-Checklisten, Stream-Vorbereitung und schnelle Einrichtungshilfen." },
];

const KAT_SCHLUESSEL = new Set(KATEGORIEN.map((k) => k.schluessel));

export const STUFEN = { einsteiger: "Einsteiger", fortgeschritten: "Fortgeschritten", profi: "Profi" };
export const GERAETE = { egal: "Egal", pc: "PC", handy: "Handy", beide: "PC & Handy" };

/* Vorschlaege, keine Vorschrift -- eigene Tags bleiben moeglich. */
export const TAG_VORSCHLAEGE = [
  "tiktok", "obs", "pc", "handy", "audio", "kamera", "licht", "internet",
  "overlay", "moderation", "einnahmen", "sicherheit", "checkliste",
];

/* ---------- Zugang ------------------------------------------------------
   Lesen darf jeder Angemeldete -- die Bibliothek ist fuer das ganze Team.
   Pflegen darf nur DogFather: Es ist kuratiertes Wissen, kein Ablageort.  */

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  /* ==== DIE WISSENSABLAGE WOHNT IM AGENTURHAUS (24.09.2026) ========

     Filipe, zur Frage, wohin die neun Dokumente gehoeren: "diese
     komplette kachel soll nur im workspace sein."

     DIE KACHEL IST DRUEBEN SCHON WEG (siehe MODI_BEREICHE in
     workspace.js). Das allein ist aber nur eine Bitte: `wissen.html`
     und `/workspace/api/wissen` kann jeder aufrufen, der die Adresse
     einmal gesehen hat -- und wer die Seite offen hatte, als die
     Kachel noch da war, hat sie im Verlauf stehen.

     GENAU DIESE LUECKE HAT DAS HAUS SCHON ZWEIMAL GEHABT: Am 10.09.
     die Zugangswand, am 21.09. `crew-haus.css` -- beide Male lieferte
     express.static eine Datei aus, die "eigentlich" woanders hingehoert,
     weil jemand ihren Namen nannte. Eine Absicht im Kommentar ist keine
     Schranke.

     404 UND KEINE 403: "Gibt es hier nicht" ist die Wahrheit -- die
     Ablage gehoert zum anderen Haus. Ein "verboten" wuerde sagen, dass
     es sie gibt und man nur nicht darf. */
  if (person.haus === "crew") {
    return res.status(404).json({ fehler: "nicht_gefunden" });
  }
  next();
}
function nurDogFather(req, res, next) {
  if (!istLeitung(req.person)) {
    return res.status(403).json({ fehler: "Die Bibliothek pflegt DogFather." });
  }
  next();
}
function gleicheHerkunft(req, res, next) {
  const herkunft = req.get("origin");
  if (!herkunft) return next();
  let erlaubt;
  try { erlaubt = new URL(herkunft).host === req.get("host"); } catch { erlaubt = false; }
  if (!erlaubt) return res.status(403).json({ fehler: "fremde_herkunft" });
  next();
}

wissenRouter.use("/workspace/api/wissen", angemeldet);

/* ---------- Aufbau: Kategorien mit Anzahl -------------------------------- */

wissenRouter.get("/workspace/api/wissen/aufbau", (req, res) => {
  try {
    const zaehler = new Map(db().prepare(
      "SELECT kategorie, COUNT(*) AS n FROM wissen GROUP BY kategorie")
      .all().map((z) => [z.kategorie, z.n]));

    /* Tags, die tatsaechlich benutzt werden -- eine Filterliste mit
       Begriffen ohne Treffer waere eine Einladung ins Leere. */
    const benutzt = new Set();
    for (const z of db().prepare("SELECT tags FROM wissen WHERE tags IS NOT NULL").all()) {
      for (const t of String(z.tags).split(",")) if (t.trim()) benutzt.add(t.trim());
    }

    res.json({
      welten: WELTEN,
      kategorien: KATEGORIEN.map((k) => ({ ...k, anzahl: zaehler.get(k.schluessel) || 0 })),
      stufen: STUFEN,
      geraete: GERAETE,
      tags: [...benutzt].sort(),
      tag_vorschlaege: TAG_VORSCHLAEGE,
      darf_pflegen: istLeitung(req.person),
      gesamt: [...zaehler.values()].reduce((s, n) => s + n, 0),
    });
  } catch (fehler) {
    console.error("[workspace] Wissen Aufbau:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Liste, Suche und Filter -------------------------------------- */

function muster(text) {
  return "%" + text.replace(/[\\%_]/g, (z) => "\\" + z) + "%";
}

wissenRouter.get("/workspace/api/wissen", (req, res) => {
  try {
    const bedingungen = [];
    const werte = [];

    const k = String(req.query.k ?? "").trim();
    if (k && KAT_SCHLUESSEL.has(k)) { bedingungen.push("w.kategorie = ?"); werte.push(k); }

    const stufe = String(req.query.stufe ?? "").trim();
    if (stufe && Object.hasOwn(STUFEN, stufe)) { bedingungen.push("w.stufe = ?"); werte.push(stufe); }

    /* "PC" soll auch die Anleitungen zeigen, die fuer beide Geraete
       gelten -- sonst filtert man sich versehentlich das Halbe weg. */
    const geraet = String(req.query.geraet ?? "").trim();
    if (geraet === "pc" || geraet === "handy") {
      bedingungen.push("(w.geraet = ? OR w.geraet = 'beide')");
      werte.push(geraet);
    }

    const tag = String(req.query.tag ?? "").trim().toLowerCase();
    if (tag) {
      /* Kommas drumherum, sonst wuerde der Filter "pc" auch bei
         "pc-spiele" anschlagen. COALESCE, weil Tags leer sein duerfen --
         NULL || ',' waere NULL und die Zeile fiele stumm raus. */
      bedingungen.push("(',' || COALESCE(w.tags, '') || ',') LIKE ? ESCAPE '\\'");
      werte.push(muster("," + tag + ","));
    }

    const q = String(req.query.q ?? "").trim().slice(0, 80);
    if (q.length >= 2) {
      const m = muster(q);
      bedingungen.push("(w.titel LIKE ? ESCAPE '\\' OR w.beschreibung LIKE ? ESCAPE '\\' OR w.tags LIKE ? ESCAPE '\\' OR w.name_original LIKE ? ESCAPE '\\')");
      werte.push(m, m, m, m);
    }

    const wo = bedingungen.length ? "WHERE " + bedingungen.join(" AND ") : "";
    const liste = db().prepare(`
      SELECT w.id, w.titel, w.beschreibung, w.kategorie, w.stufe, w.geraet, w.tags,
             w.name_original, w.groesse, w.wichtig, w.veroeffentlicht, w.aktualisiert,
             w.hochgeladen, p.name AS von
      FROM wissen w LEFT JOIN personen p ON p.id = w.erstellt_von
      ${wo}
      ORDER BY w.wichtig DESC,
               COALESCE(w.aktualisiert, w.veroeffentlicht) DESC,
               w.titel`).all(...werte);

    for (const e of liste) e.tags = e.tags ? String(e.tags).split(",").filter(Boolean) : [];

    /* Neu und wichtig -- der Einstieg fuer alle, die nicht suchen,
       sondern schauen wollen, was sich getan hat.

       ZWEI VERSCHIEDENE DINGE, bewusst getrennt:

       NEU laeuft nach 48 Stunden von selbst ab. Gemessen ab dem
       Hochladen, nicht ab dem Veroeffentlichungsdatum -- das ist nur ein
       Datum und darf frei gesetzt werden. Bei alten Eintraegen ohne
       Zeitstempel wird auf Mitternacht des Datums zurueckgefallen.

       WICHTIG lief bis zum 01.09.2026 NICHT ab -- es blieb stehen, bis
       es jemand von Hand abschaltete. Das hat sich als falsch erwiesen:
       Niemand raeumt so etwas auf, und nach ein paar Wochen stuende
       oben eine Liste von Dingen, die laengst niemanden mehr angehen.
       Auf ausdruecklichen Wunsch laeuft es jetzt ebenfalls nach 48
       Stunden ab -- gemessen ab demselben Zeitpunkt wie bei NEU.

       Der Schalter bleibt sinnvoll: Er hebt einen Eintrag fuer zwei
       Tage nach oben, auch wenn dieser aelter ist. Er ist damit ein
       Scheinwerfer, kein Regal. Wer laenger oben stehen will, setzt
       ihn neu -- und trifft damit bewusst eine Entscheidung, statt
       dass etwas von allein liegen bleibt. */
    const grenze = Date.now() - NEU_STUNDEN * 3600_000;
    const istNeu = (e) => {
      const wann = e.hochgeladen
        ? Date.parse(e.hochgeladen)
        : Date.parse((e.veroeffentlicht || "") + "T00:00:00");
      return Number.isFinite(wann) && wann >= grenze;
    };
    /* Wichtig zaehlt nur, solange es FRISCH ist -- dieselben 48
       Stunden wie bei neu. */
    const istWichtig = (e) => !!e.wichtig && istNeu(e);
    const neu = !k && !q && !stufe && !geraet && !tag
      ? liste.filter((e) => istWichtig(e) || istNeu(e))
      : [];
    /* Damit die Oberflaeche sagen kann, WARUM etwas oben steht -- und
       damit sie Wichtiges zuerst zeigen kann. */
    for (const e of neu) { e.ist_neu = istNeu(e); e.ist_wichtig = istWichtig(e); }
    /* Wichtiges zuerst, dann das Neueste. Die Oberflaeche zeigt davon
       zunaechst nur je einen Eintrag (siehe wissen.js) -- deshalb wird
       hier NICHT mehr auf sechs gekuerzt: Was sie zeigt, entscheidet
       sie selbst, und der Aufklappknopf braucht den Rest. */
    neu.sort((a, b) => (Number(b.ist_wichtig) - Number(a.ist_wichtig))
      || String(b.hochgeladen || b.veroeffentlicht || '').localeCompare(
         String(a.hochgeladen || a.veroeffentlicht || '')));

    res.json({ eintraege: liste, neu, gesamt: liste.length });
  } catch (fehler) {
    console.error("[workspace] Wissen lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Angaben pruefen ---------------------------------------------- */

function pruefe(kopf, { neu }) {
  const fehler = [];
  const aus = {};
  const hole = (name) => {
    const roh = kopf[name];
    if (roh === undefined) return undefined;
    try { return decodeURIComponent(String(roh)); } catch { return String(roh); }
  };

  const titel = hole("titel");
  if (neu || titel !== undefined) {
    const t = String(titel ?? "").trim();
    if (t.length < 3) fehler.push("Der Titel fehlt.");
    else if (t.length > TITEL_MAX) fehler.push("Der Titel ist zu lang.");
    else aus.titel = t;
  }

  const besch = hole("beschreibung");
  if (besch !== undefined) aus.beschreibung = String(besch).trim().slice(0, TEXT_MAX) || null;

  const kat = hole("kategorie");
  if (neu || kat !== undefined) {
    if (!KAT_SCHLUESSEL.has(String(kat))) fehler.push("Diese Kategorie gibt es nicht.");
    else aus.kategorie = String(kat);
  }

  const stufe = hole("stufe");
  if (stufe !== undefined) {
    if (!Object.hasOwn(STUFEN, String(stufe))) fehler.push("Unbekannte Stufe.");
    else aus.stufe = String(stufe);
  }

  const geraet = hole("geraet");
  if (geraet !== undefined) {
    if (!Object.hasOwn(GERAETE, String(geraet))) fehler.push("Unbekanntes Gerät.");
    else aus.geraet = String(geraet);
  }

  const tags = hole("tags");
  if (tags !== undefined) {
    /* Klein geschrieben und ohne Komma gespeichert -- sonst waeren
       "OBS" und "obs" zwei verschiedene Filter, und ein Komma im Tag
       wuerde die Liste zerlegen. */
    const liste = [...new Set(String(tags).split(",")
      .map((t) => t.trim().toLowerCase().replace(/[^a-z0-9äöüß+\- ]/g, "").trim())
      .filter(Boolean))].slice(0, TAGS_MAX);
    aus.tags = liste.length ? liste.join(",") : null;
  }

  const wichtig = hole("wichtig");
  if (wichtig !== undefined) aus.wichtig = (wichtig === "1" || wichtig === "true") ? 1 : 0;

  const datum = hole("veroeffentlicht");
  if (datum !== undefined && String(datum).trim()) {
    const d = String(datum).trim();
    if (!/^\d{4}-\d{2}-\d{2}$/.test(d) || Number.isNaN(Date.parse(d))) {
      fehler.push("Das Veröffentlichungsdatum ist ungültig.");
    } else aus.veroeffentlicht = d;
  }

  return { aus, fehler };
}

/* ---------- Hochladen ----------------------------------------------------
   Angaben stehen in Kopfzeilen, weil der Rumpf die Datei selbst ist --
   dieselbe Loesung wie bei den Dateien, kein multipart-Paket noetig.     */

wissenRouter.post(
  "/workspace/api/wissen",
  gleicheHerkunft,
  nurDogFather,
  express.raw({ type: "*/*", limit: MAX_BYTES }),
  (req, res) => {
    let pfad = null;
    try {
      if (!req.body?.length) return res.status(400).json({ fehler: "Keine Datei angekommen." });

      /* Ist das wirklich eine PDF? Geprueft an den ersten Bytes, nicht an
         der Endung -- die kann jeder umbenennen. Nur weil das hier sicher
         ist, darf die Datei spaeter im Browser angezeigt werden. */
      const kopf = req.body.subarray(0, 5).toString("latin1");
      if (kopf !== "%PDF-") {
        return res.status(400).json({ fehler: "Das ist keine PDF-Datei." });
      }

      const felder = {};
      for (const n of ["titel", "beschreibung", "kategorie", "stufe", "geraet", "tags", "wichtig", "veroeffentlicht"]) {
        const w = req.get("x-" + n);
        if (w !== undefined) felder[n] = w;
      }
      const { aus, fehler } = pruefe(felder, { neu: true });
      if (fehler.length) return res.status(400).json({ fehler: fehler.join(" ") });

      let name = "anleitung.pdf";
      try { name = decodeURIComponent(req.get("x-dateiname") || "").trim() || name; } catch { /* Vorgabe */ }
      name = name.replace(/[\x00-\x1f\x7f/\\<>:"|?*]/g, "").slice(0, 160) || "anleitung.pdf";

      mkdirSync(ORDNER, { recursive: true });
      const dateiname = `${Date.now().toString(36)}-${randomBytes(8).toString("hex")}.pdf`;
      pfad = join(ORDNER, dateiname);
      writeFileSync(pfad, req.body, { flag: "wx" });

      const { lastInsertRowid } = db().prepare(`
        INSERT INTO wissen
          (titel, beschreibung, kategorie, stufe, geraet, tags,
           name_original, name_datei, groesse, wichtig, veroeffentlicht, hochgeladen,
           erstellt_von, haus)
        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(
        aus.titel, aus.beschreibung ?? null, aus.kategorie,
        aus.stufe ?? "einsteiger", aus.geraet ?? "egal", aus.tags ?? null,
        name, dateiname, req.body.length, aus.wichtig ?? 0,
        aus.veroeffentlicht ?? heute(), jetzt(), req.person.id,
        /* Die Wissensablage gibt es auf der Team-Adresse gar nicht
           (siehe `angemeldet` weiter oben) -- hier kann also nur
           "agentur" herauskommen. Trotzdem aus `person.haus` und nicht
           fest: Eine feste Zeichenkette waere eine zweite Wahrheit
           neben der Schranke, und die beiden liefen beim naechsten
           Umbau auseinander. */
        req.person.haus || null);

      protokolliere("wissen_hochgeladen", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${lastInsertRowid} ${aus.titel} (${Math.round(req.body.length / 1024)} KB)`.slice(0, 120),
      });
      res.status(201).json({ id: Number(lastInsertRowid) });
    } catch (fehler) {
      /* Liegt die Datei schon auf der Platte, der Eintrag aber nicht in
         der Datenbank, waere sie fuer immer verwaist. */
      if (pfad) { try { unlinkSync(pfad); } catch { /* war nie da */ } }
      console.error("[workspace] Wissen hochladen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* ---------- Angaben aendern ---------------------------------------------- */

wissenRouter.patch("/workspace/api/wissen/:id", gleicheHerkunft, nurDogFather, express.json(), (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
    const vorhanden = db().prepare("SELECT id FROM wissen WHERE id = ?").get(id);
    if (!vorhanden) return res.status(404).json({ fehler: "nicht_gefunden" });

    /* Der Aenderungsweg nimmt die Werte im Rumpf, nicht in Kopfzeilen --
       hier haengt keine Datei dran. */
    const felder = {};
    for (const n of ["titel", "beschreibung", "kategorie", "stufe", "geraet", "tags", "wichtig", "veroeffentlicht"]) {
      if (req.body?.[n] !== undefined) felder[n] = encodeURIComponent(String(req.body[n]));
    }
    const { aus, fehler } = pruefe(felder, { neu: false });
    if (fehler.length) return res.status(400).json({ fehler: fehler.join(" ") });
    const namen = Object.keys(aus);
    if (!namen.length) return res.status(400).json({ fehler: "nichts_zu_aendern" });

    const setz = namen.map((n) => `${n} = ?`);
    const daten = namen.map((n) => aus[n]);
    setz.push("aktualisiert = ?"); daten.push(heute());

    db().prepare(`UPDATE wissen SET ${setz.join(", ")} WHERE id = ?`).run(...daten, id);
    protokolliere("wissen_geaendert", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${namen.join(",")}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Wissen ändern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

wissenRouter.delete("/workspace/api/wissen/:id", gleicheHerkunft, nurDogFather, (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
    const e = db().prepare("SELECT titel, name_datei FROM wissen WHERE id = ?").get(id);
    if (!e) return res.status(404).json({ fehler: "nicht_gefunden" });

    db().prepare("DELETE FROM wissen WHERE id = ?").run(id);
    try { unlinkSync(join(ORDNER, e.name_datei)); } catch { /* schon weg */ }

    protokolliere("wissen_geloescht", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${e.titel}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Wissen löschen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Ausliefern ---------------------------------------------------- */

wissenRouter.get("/workspace/api/wissen/:id/datei", (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
    const e = db().prepare("SELECT titel, name_original, name_datei FROM wissen WHERE id = ?").get(id);
    if (!e) return res.status(404).json({ fehler: "nicht_gefunden" });

    const pfad = join(ORDNER, e.name_datei);
    try { statSync(pfad); } catch { return res.status(410).json({ fehler: "Datei fehlt auf der Platte." }); }

    /* Anzeigen ist nur erlaubt, weil beim Hochladen geprueft wurde, dass
       es wirklich eine PDF ist. Die strenge Regel darunter verbietet der
       Datei trotzdem jeden Nachladeversuch und jedes Skript. */
    const ansehen = req.query.modus === "ansehen";
    res.setHeader("Content-Type", ansehen ? "application/pdf" : "application/octet-stream");
    res.setHeader("X-Content-Type-Options", "nosniff");
    res.setHeader("Content-Security-Policy", "default-src 'none'; object-src 'self'; sandbox");
    res.setHeader("Content-Disposition",
      `${ansehen ? "inline" : "attachment"}; filename*=UTF-8''${encodeURIComponent(e.name_original)}`);

    protokolliere(ansehen ? "wissen_angesehen" : "wissen_geladen", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${e.titel}`.slice(0, 120),
    });
    createReadStream(pfad).pipe(res);
  } catch (fehler) {
    console.error("[workspace] Wissen ausliefern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* Grosse Datei: express.raw bricht ab, BEVOR der eigene Code laeuft --
   ohne diesen Fanghaken kaeme ein nackter 500er. */
wissenRouter.use((fehler, req, res, next) => {
  if (fehler?.type === "entity.too.large" || fehler?.status === 413) {
    return res.status(413).json({
      fehler: `Die PDF ist zu groß – erlaubt sind ${Math.round(MAX_BYTES / 1024 / 1024)} MB.`,
    });
  }
  return next(fehler);
});