dogfather-universe/server/workspace-schulung.js

/* =====================================================================
   workspace-schulung.js — Unterweisungen mit beidseitiger Bestätigung.

   Der Wunsch vom 01.09.2026: "jeder Scout, Manager oder DogFather muss
   mit seinen Creatorn die PDFs durchgehen, und beide drücken dann auf
   verifiziert, so dass wir den Beweis haben – und das ist danach auch
   nicht mehr zu ändern."

   Das ist kein Häkchen, das ist ein NACHWEIS. Wer so etwas baut, muss
   drei Fragen beantworten, sonst ist er wertlos:

   1. WER hat bestätigt?
      Beide Seiten getrennt, mit Name, Zeitpunkt und IP. Eine einzelne
      Bestätigung reicht nicht: "Ich habe es ihm gezeigt" und "Er hat es
      mir gezeigt" sind zwei verschiedene Aussagen, und erst zusammen
      ergeben sie einen Beweis. Bestätigt nur einer, steht die
      Unterweisung als OFFEN da -- halbe Nachweise gibt es nicht.

   2. WORAUF genau?
      Nicht auf "die Regeln", sondern auf eine bestimmte Datei. Deshalb
      wird beim Bestätigen der SHA-256 der PDF-Datei mitgespeichert.
      Tauscht später jemand die Datei aus, passt der Fingerabdruck nicht
      mehr -- und die Seite sagt das auch. Ohne diesen Wert wäre die
      Bestätigung ein Zettel ohne Bezug.

   3. IST ES UNVERÄNDERT?
      Eine abgeschlossene Bestätigung lässt sich nicht mehr ändern und
      nicht löschen -- und zwar nicht, weil der Code es nicht anbietet,
      sondern weil die DATENBANK es ablehnt. Zwei Trigger sorgen dafür.
      Ein Schutz, der nur im Code steht, ist beim nächsten neuen Weg zur
      Datenbank wieder weg.

   Erfahrung aus RunOne (01.09.2026): Dort war die Festschreibung tagelang
   live und NIE gelaufen -- null festgeschriebene Buchungen. Der zentrale
   Weg war unerprobt, ausgerechnet der einzige, den man nicht rückgängig
   machen kann. Deshalb prüft pruef-schulung.mjs hier ausdrücklich den
   Vollzug: bestätigen, dann Änderung versuchen, und die Ablehnung
   nachweisen.
   ===================================================================== */

import express from "express";
import {
  createHash } from "node:crypto";
import { join } from "node:path";
import { readFileSync, existsSync } from "node:fs";
import {
  db, sitzungLesen, istLeitung, istDogFather, siehtAlles, darfCreator, betreuteIds,
  protokolliere, echteIp, DATEN_ORDNER,
  sichtbareCreatorIds,
} from "./workspace.js";

export const schulungRouter = express.Router();

const jetzt = () => new Date().toISOString();
const TITEL_MAX = 160;

/* ---------- Tabellen ------------------------------------------------------

   Werden beim ersten Zugriff angelegt. Die Trigger stehen bewusst hier
   und nicht in einer Umstellung: Sie gehören zur Tabelle wie ihre
   Spalten. */

let bereit = false;
function tabellen() {
  if (bereit) return;
  db().exec(`
    /* Eine Unterweisung: ein Dokument, das durchgegangen werden muss. */
    CREATE TABLE IF NOT EXISTS schulungen (
      id            INTEGER PRIMARY KEY AUTOINCREMENT,
      titel         TEXT NOT NULL,
      beschreibung  TEXT,
      wissen_id     INTEGER REFERENCES wissen(id) ON DELETE SET NULL,
      pflicht       INTEGER NOT NULL DEFAULT 1,
      aktiv         INTEGER NOT NULL DEFAULT 1,
      erstellt      TEXT NOT NULL,
      erstellt_von  INTEGER REFERENCES personen(id) ON DELETE SET NULL
    );

    /* Eine Bestätigung je Creator und Unterweisung.

       Zwei Seiten, zwei Zeitpunkte. Erst wenn beide stehen, gilt sie --
       abgeschlossen = 1 setzt der Server, nicht der Absender. */
    CREATE TABLE IF NOT EXISTS schulung_bestaetigt (
      id              INTEGER PRIMARY KEY AUTOINCREMENT,
      schulung_id     INTEGER NOT NULL REFERENCES schulungen(id) ON DELETE CASCADE,
      creator_id      INTEGER NOT NULL REFERENCES personen(id) ON DELETE CASCADE,
      betreuer_id     INTEGER REFERENCES personen(id) ON DELETE SET NULL,

      creator_am      TEXT,
      creator_ip      TEXT,
      betreuer_am     TEXT,
      betreuer_ip     TEXT,

      /* Fingerabdruck der Datei zum Zeitpunkt der Bestätigung. */
      datei_hash      TEXT,
      /* Wie die Datei damals hiess -- fuer den Fall, dass sie spaeter
         umbenannt oder ersetzt wird. */
      datei_name      TEXT,

      abgeschlossen   INTEGER NOT NULL DEFAULT 0,
      abgeschlossen_am TEXT,
      UNIQUE (schulung_id, creator_id)
    );
    CREATE INDEX IF NOT EXISTS idx_schulung_creator
      ON schulung_bestaetigt (creator_id);

    /* DIE SPERRE.

       Eine abgeschlossene Bestätigung ist ein Nachweis. Sie zu ändern
       hiesse, den Nachweis zu fälschen -- also lehnt die Datenbank es
       ab, ganz gleich, wer es versucht und über welchen Weg.

       RAISE(ABORT) bricht die Anweisung ab und gibt den Text zurück.
       Das gilt auch für ein sqlite3 auf der Kommandozeile. */
    CREATE TRIGGER IF NOT EXISTS schulung_nicht_aendern
    BEFORE UPDATE ON schulung_bestaetigt
    FOR EACH ROW WHEN OLD.abgeschlossen = 1
    BEGIN
      SELECT RAISE(ABORT, 'Abgeschlossene Bestaetigung kann nicht geaendert werden');
    END;

    CREATE TRIGGER IF NOT EXISTS schulung_nicht_loeschen
    BEFORE DELETE ON schulung_bestaetigt
    FOR EACH ROW WHEN OLD.abgeschlossen = 1
    BEGIN
      SELECT RAISE(ABORT, 'Abgeschlossene Bestaetigung kann nicht geloescht werden');
    END;
  `);
  bereit = true;
}

/* ---------- Fingerabdruck der Datei -------------------------------------- */

function dateiHash(wissenId) {
  if (!wissenId) return { hash: null, name: null };
  try {
    const w = db().prepare("SELECT name_datei, name_original FROM wissen WHERE id = ?").get(wissenId);
    if (!w) return { hash: null, name: null };
    const pfad = join(DATEN_ORDNER, "wissen", w.name_datei);
    if (!existsSync(pfad)) return { hash: null, name: w.name_original };
    return {
      hash: createHash("sha256").update(readFileSync(pfad)).digest("hex"),
      name: w.name_original,
    };
  } catch {
    return { hash: null, name: null };
  }
}

/* ---------- Schranken ----------------------------------------------------- */

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  try { tabellen(); } catch (f) {
    console.error("[workspace] Schulungstabellen:", f?.message);
    return res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
  next();
}
schulungRouter.use("/workspace/api/schulung", angemeldet);

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();
}

/* ---------- Lesen ---------------------------------------------------------

   Ein Creator sieht SEINEN Stand. Ein Betreuer sieht den Stand der
   Creator, die er betreut. Die Leitung sieht alles. */

schulungRouter.get("/workspace/api/schulung", (req, res) => {
  try {
    const schulungen = db().prepare(`
      SELECT s.*, w.name_original AS datei, w.id AS wissen,
             p.name AS von
      FROM schulungen s
      LEFT JOIN wissen w ON w.id = s.wissen_id
      LEFT JOIN personen p ON p.id = s.erstellt_von
      WHERE s.aktiv = 1
      ORDER BY s.pflicht DESC, s.id`).all();

    /* Fuer welche Creator wird der Stand gebraucht? */
    let creatorIds;
    /* DURCH DIE AUGEN DER ANGESEHENEN PERSON (11.09.2026).

       Filipe: "oben bei meine sicht soll ich auch die sicht von allen
       jeden moment sehen koennen und das genau genau so wie sie es
       sehen alles."

       Nur LESEN wird umgestellt, nie ein Recht: `req.person` bleibt
       ueberall dort stehen, wo geschrieben oder geprueft wird. Und
       weil DogFather ohnehin alles sehen darf, kann diese Umstellung
       nichts oeffnen -- sie kann nur WENIGER zeigen, naemlich genau
       das, was die andere Person sieht.
 */
    const zeigt = req.sicht || req.person;
    if (zeigt.rolle === "creator") creatorIds = [zeigt.id];
    else if (istLeitung(zeigt)) {
      creatorIds = db().prepare(
        "SELECT id FROM personen WHERE rolle = 'creator' AND aktiv = 1").all().map((z) => z.id);
      /* Zuteilung statt Rolle (03.09.2026) -- eine Managerin sah sonst
         den Schulungsstand aller Creator, auch fremder. */
      const erlaubtC = sichtbareCreatorIds(zeigt);
      if (erlaubtC !== null) creatorIds = creatorIds.filter((x) => erlaubtC.includes(x));
    } else creatorIds = betreuteIds(zeigt);

    const stand = creatorIds.length
      ? db().prepare(`
          SELECT b.*, pc.name AS creator_name, pb.name AS betreuer_name
          FROM schulung_bestaetigt b
          LEFT JOIN personen pc ON pc.id = b.creator_id
          LEFT JOIN personen pb ON pb.id = b.betreuer_id
          WHERE b.creator_id IN (${creatorIds.map(() => "?").join(",")})`).all(...creatorIds)
      : [];

    /* Stimmt die Datei noch mit dem ueberein, was bestaetigt wurde?
       Diese Frage stellt sonst niemand -- und sie ist der Unterschied
       zwischen einem Nachweis und einem Zettel. */
    for (const b of stand) {
      if (!b.abgeschlossen || !b.datei_hash) { b.datei_stimmt = null; continue; }
      const s = schulungen.find((x) => x.id === b.schulung_id);
      const aktuell = dateiHash(s?.wissen_id);
      b.datei_stimmt = aktuell.hash ? aktuell.hash === b.datei_hash : null;
    }

    const creatoren = creatorIds.length
      ? db().prepare(`SELECT id, name FROM personen
          WHERE id IN (${creatorIds.map(() => "?").join(",")}) ORDER BY name`).all(...creatorIds)
      : [];

    res.json({
      schulungen, stand, creatoren,
      /* Auch die Knoepfe gehoeren zur Sicht: Wer sich den
         Arbeitsplatz eines anderen ansieht, soll ihn sehen, wie er
         wirklich aussieht -- mit denselben Knoepfen. Geschrieben wird
         trotzdem immer als der Angemeldete; das entscheidet der Server
         beim Speichern, nicht diese Zeile. */
      ich: { id: zeigt.id, rolle: zeigt.rolle },
      darf_anlegen: istLeitung(zeigt),
    });
  } catch (fehler) {
    console.error("[workspace] Schulungen lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Anlegen (nur Leitung) ----------------------------------------- */

schulungRouter.post("/workspace/api/schulung", gleicheHerkunft,
  express.json({ limit: "16kb" }), (req, res) => {
    if (!istLeitung(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
    try {
      const titel = String(req.body.titel ?? "").trim();
      if (titel.length < 3 || titel.length > TITEL_MAX) {
        return res.status(400).json({ fehler: "Titel fehlt oder ist zu lang." });
      }
      const wissenId = Number(req.body.wissen_id) || null;
      /* Ohne Dokument keine Unterweisung: Man kann nichts bestaetigen,
         was man nicht gelesen hat. */
      if (!wissenId) return res.status(400).json({ fehler: "Bitte ein Dokument auswählen." });
      const da = db().prepare("SELECT id FROM wissen WHERE id = ?").get(wissenId);
      if (!da) return res.status(400).json({ fehler: "Dieses Dokument gibt es nicht." });

      db().prepare(`INSERT INTO schulungen
          (titel, beschreibung, wissen_id, pflicht, erstellt, erstellt_von)
          VALUES (?,?,?,?,?,?)`)
        .run(titel, String(req.body.beschreibung ?? "").trim().slice(0, 2000) || null,
             wissenId, req.body.pflicht === false ? 0 : 1, jetzt(), req.person.id);

      protokolliere("schulung_angelegt", req.person, echteIp(req), titel);
      res.json({ ok: true });
    } catch (fehler) {
      console.error("[workspace] Schulung anlegen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* ---------- Bestätigen -----------------------------------------------------

   Beide Seiten getrennt. Der Server entscheidet anhand der ROLLE des
   Absenders, welche Seite gesetzt wird -- nicht der Absender selbst.
   Sonst könnte ein Creator die Bestätigung seines Betreuers eintragen,
   und der ganze Nachweis wäre wertlos. */

schulungRouter.post("/workspace/api/schulung/:id(\\d+)/bestaetigen", gleicheHerkunft,
  express.json({ limit: "8kb" }), (req, res) => {
    try {
      const schulungId = Number(req.params.id);
      const s = db().prepare("SELECT * FROM schulungen WHERE id = ? AND aktiv = 1").get(schulungId);
      if (!s) return res.status(404).json({ fehler: "nicht_gefunden" });

      /* Um welchen Creator geht es? */
      const creatorId = req.person.rolle === "creator"
        ? req.person.id
        : Number(req.body.creator_id) || 0;
      if (!creatorId) return res.status(400).json({ fehler: "Kein Creator angegeben." });
      if (req.person.rolle !== "creator" && !darfCreator(req.person, creatorId)) {
        return res.status(404).json({ fehler: "nicht_gefunden" });
      }
      /* Ein Creator bestätigt nur für sich. */
      if (req.person.rolle === "creator" && creatorId !== req.person.id) {
        return res.status(403).json({ fehler: "nicht_erlaubt" });
      }

      const vorhanden = db().prepare(
        "SELECT * FROM schulung_bestaetigt WHERE schulung_id = ? AND creator_id = ?")
        .get(schulungId, creatorId);

      if (vorhanden?.abgeschlossen) {
        return res.status(409).json({
          fehler: "Diese Unterweisung ist bereits abgeschlossen und kann nicht geändert werden.",
        });
      }

      const alsCreator = req.person.rolle === "creator";
      const ip = echteIp(req);
      const nun = jetzt();

      if (!vorhanden) {
        const abdruck = dateiHash(s.wissen_id);
        db().prepare(`INSERT INTO schulung_bestaetigt
            (schulung_id, creator_id, betreuer_id, creator_am, creator_ip,
             betreuer_am, betreuer_ip, datei_hash, datei_name, abgeschlossen)
            VALUES (?,?,?,?,?,?,?,?,?,0)`)
          .run(schulungId, creatorId,
               alsCreator ? null : req.person.id,
               alsCreator ? nun : null, alsCreator ? ip : null,
               alsCreator ? null : nun, alsCreator ? null : ip,
               abdruck.hash, abdruck.name);
      } else {
        /* Die jeweils andere Seite ergänzen. Eine bereits gesetzte Seite
           wird NICHT überschrieben -- sonst könnte man ein Datum
           nachträglich verschieben. */
        if (alsCreator) {
          if (vorhanden.creator_am) {
            return res.status(409).json({ fehler: "Du hast bereits bestätigt." });
          }
          db().prepare(
            "UPDATE schulung_bestaetigt SET creator_am = ?, creator_ip = ? WHERE id = ?")
            .run(nun, ip, vorhanden.id);
        } else {
          if (vorhanden.betreuer_am) {
            return res.status(409).json({ fehler: "Die Betreuung hat bereits bestätigt." });
          }
          db().prepare(
            "UPDATE schulung_bestaetigt SET betreuer_am = ?, betreuer_ip = ?, betreuer_id = ? WHERE id = ?")
            .run(nun, ip, req.person.id, vorhanden.id);
        }
      }

      /* Abschliessen, sobald BEIDE stehen. Das entscheidet der Server
         anhand der Daten -- niemand kann "abgeschlossen" mitschicken. */
      const stand = db().prepare(
        "SELECT * FROM schulung_bestaetigt WHERE schulung_id = ? AND creator_id = ?")
        .get(schulungId, creatorId);

      if (stand.creator_am && stand.betreuer_am && !stand.abgeschlossen) {
        db().prepare(
          "UPDATE schulung_bestaetigt SET abgeschlossen = 1, abgeschlossen_am = ? WHERE id = ?")
          .run(nun, stand.id);
        protokolliere("schulung_abgeschlossen", req.person, ip,
          `${s.titel} · Creator ${creatorId}`);
      } else {
        protokolliere("schulung_bestaetigt", req.person, ip,
          `${s.titel} · ${alsCreator ? "Creator" : "Betreuung"}`);
      }

      const neu = db().prepare(
        "SELECT * FROM schulung_bestaetigt WHERE schulung_id = ? AND creator_id = ?")
        .get(schulungId, creatorId);
      res.json({ stand: neu });
    } catch (fehler) {
      console.error("[workspace] Schulung bestätigen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* ---------- Zurückziehen (nur solange NICHT abgeschlossen) ---------------- */

schulungRouter.delete("/workspace/api/schulung/:id(\\d+)/bestaetigen", gleicheHerkunft,
  (req, res) => {
    try {
      const schulungId = Number(req.params.id);
      const creatorId = req.person.rolle === "creator"
        ? req.person.id : Number(req.query.creator_id) || 0;
      if (!creatorId) return res.status(400).json({ fehler: "Kein Creator angegeben." });
      if (req.person.rolle !== "creator" && !darfCreator(req.person, creatorId)) {
        return res.status(404).json({ fehler: "nicht_gefunden" });
      }

      const stand = db().prepare(
        "SELECT * FROM schulung_bestaetigt WHERE schulung_id = ? AND creator_id = ?")
        .get(schulungId, creatorId);
      if (!stand) return res.status(404).json({ fehler: "nicht_gefunden" });

      /* Der Trigger würde das ohnehin ablehnen. Die Prüfung hier ist
         trotzdem richtig: Sie gibt eine verständliche Antwort statt
         eines Datenbankfehlers. */
      if (stand.abgeschlossen) {
        return res.status(409).json({
          fehler: "Abgeschlossen. Das ist der Nachweis und bleibt bestehen.",
        });
      }
      db().prepare("DELETE FROM schulung_bestaetigt WHERE id = ?").run(stand.id);
      protokolliere("schulung_zurueckgezogen", req.person, echteIp(req), `Schulung ${schulungId}`);
      res.json({ ok: true });
    } catch (fehler) {
      console.error("[workspace] Schulung zurückziehen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* ---------- Unterweisung abschalten (nur DogFather) -----------------------

   Nicht löschen: Die Bestätigungen daran hängen und sind Nachweise.
   `aktiv = 0` nimmt sie aus der Liste, ohne die Vergangenheit
   anzutasten. */

schulungRouter.delete("/workspace/api/schulung/:id(\\d+)", gleicheHerkunft, (req, res) => {
  if (!siehtAlles(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
  try {
    db().prepare("UPDATE schulungen SET aktiv = 0 WHERE id = ?").run(Number(req.params.id));
    protokolliere("schulung_abgeschaltet", req.person, echteIp(req), `Schulung ${req.params.id}`);
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Schulung abschalten:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});