dogfather-universe/server/workspace-content.js

/* =====================================================================
   workspace-content.js — was die Content-Planung ueber einen gewoehnlichen
   Bereich hinaus braucht.

   Die Eintraege selbst bleiben in workspace-bereiche.js. Es gibt bewusst
   NUR EINEN Schreiber fuer die Tabelle `eintraege` -- zwei Module, die
   dieselben Zeilen anfassen, sind der sichere Weg zu zwei Wahrheiten.

   Hier liegt nur, was es woanders nicht gibt:

   1. Saeulen -- die drei bis fuenf Themen, aus denen ein Kanal besteht.
   2. Die Kennzahlen der Strecke, allen voran der VORRAT.
   3. Das Ueberfuehren einer Idee in eine Aufgabe, einen Termin oder ein
      LIVE-Thema. Das steht woertlich im Konzept ("Ideen lassen sich
      direkt in Aufgabe/Termin/LIVE-Thema ueberfuehren") und war das
      letzte unumgesetzte Stueck des Content-Moduls.

   Warum ausgerechnet der Vorrat die wichtigste Zahl ist: Die Recherche
   vom 31.08.2026 ist an dieser Stelle einhellig -- der Algorithmus
   belohnt Regelmaessigkeit staerker als Menge; ein Video pro Tag zur
   gleichen Zeit schlaegt sieben Videos an einem Tag. Wer regelmaessig
   senden will, braucht Vorrat. Und Vorrat ist die eine Zahl, die man
   NICHT sieht, wenn man auf eine Liste von Ideen schaut.
   ===================================================================== */

import express from "express";
import {
  db, protokolliere, echteIp, sitzungLesen, betreutWo, darfCreator, betreuteIds,
  istLeitung, istDogFather, siehtAlles, tagLokal,
} from "./workspace.js";

export const contentRouter = express.Router();

const NAME_MAX = 40;
/* Drei bis fuenf Saeulen -- aus der Recherche. Weniger traegt keinen
   Kanal, mehr kann niemand bespielen, und mehr als fuenf Farben lassen
   sich in einem Balken ohnehin nicht mehr auseinanderhalten (die
   Farbpruefung deckt genau fuenf ab). */
const SAEULEN_MAX = 5;

const jetzt = () => new Date().toISOString();
const heute = () => jetzt().slice(0, 10);

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  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();
}

contentRouter.use("/workspace/api/content", angemeldet);

/* Dieselbe Regel wie in den Bereichen: Der Creator liest, die Betreuung
   schreibt. Steht als eine Schranke vor allen schreibenden Wegen. */
for (const weg of ["post", "patch", "delete", "put"]) {
  contentRouter[weg]("/workspace/api/content/*", (req, res, next) => {
    if (req.person?.rolle === "creator") {
      return res.status(403).json({
        fehler: "Hier trägt deine Betreuung ein. Du siehst alles, was zu dir gehört.",
      });
    }
    next();
  });
}

/* Welche Creator darf diese Person sehen? Gibt eine Liste von Nummern
   zurueck -- oder null fuer "alle" (Leitung). */
function sichtbareCreator(person) {
  /* NUR DogFather sieht alles (01.09.2026). Vorher stand hier
     istLeitung() -- damit sah auch jeder Manager jeden Creator. Ein
     Manager faellt jetzt in dieselbe Regel wie ein Scout: nur die
     Creator, die ihm zugeteilt sind. Ausdruecklicher Wunsch:
     "NUR DIE ROLLE DOGFATHER SOLL WIRKLICH ALLEINE ALLES SEHEN."

     Geaendert wird ausschliesslich, wer was SIEHT. Was ein Manager
     darf (freigeben, aendern, Personen verwalten), haengt weiterhin an
     istLeitung und bleibt unveraendert -- sonst haette dieser eine
     Wunsch stillschweigend seine halben Rechte mitgenommen. */
  if (siehtAlles(person)) return null;
  if (person.rolle === "creator") return [person.id];
  return betreuteIds(person);
}

function darfCreatorSehen(person, creatorId) {
  const erlaubt = sichtbareCreator(person);
  return erlaubt === null || erlaubt.includes(Number(creatorId));
}

/* ---------- Saeulen ---------------------------------------------------- */

contentRouter.get("/workspace/api/content/saeulen", (req, res) => {
  try {
    const erlaubt = sichtbareCreator(req.sicht || req.person);
    let wo = "1=1", werte = [];
    if (erlaubt !== null) {
      if (!erlaubt.length) return res.json({ saeulen: [] });
      wo = `creator_id IN (${erlaubt.map(() => "?").join(",")})`;
      werte = erlaubt;
    }
    const saeulen = db().prepare(`
      SELECT s.id, s.creator_id, s.name, s.ziel, s.slot,
             (SELECT name FROM personen p WHERE p.id = s.creator_id) AS creator_name,
             (SELECT COUNT(*) FROM eintraege e
               WHERE e.saeule_id = s.id AND e.bereich = 'content') AS videos
      FROM content_saeulen s WHERE ${wo}
      ORDER BY s.creator_id, s.slot, s.id`).all(...werte);
    res.json({ saeulen, hoechstens: SAEULEN_MAX });
  } catch (fehler) {
    console.error("[content] Säulen lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

contentRouter.post("/workspace/api/content/saeulen", gleicheHerkunft, (req, res) => {
  try {
    const name = String(req.body?.name ?? "").trim();
    if (name.length < 2) return res.status(400).json({ fehler: "Name fehlt." });
    if (name.length > NAME_MAX) return res.status(400).json({ fehler: "Name ist zu lang." });

    let creatorId = Number(req.body?.creator_id);
    if (req.person.rolle === "scout" && !darfCreator(req.person, creatorId)) {
      return res.status(403).json({ fehler: "Dieser Creator ist dir nicht zugeteilt." });
    }
    if (!Number.isInteger(creatorId)
        || !db().prepare("SELECT 1 FROM personen WHERE id = ? AND rolle = 'creator'").get(creatorId)) {
      return res.status(400).json({ fehler: "Bitte einen Creator auswählen." });
    }

    const vorhanden = db().prepare(
      "SELECT slot FROM content_saeulen WHERE creator_id = ? ORDER BY slot").all(creatorId);
    if (vorhanden.length >= SAEULEN_MAX) {
      return res.status(400).json({
        fehler: `Mehr als ${SAEULEN_MAX} Säulen kann niemand bespielen. Lieber eine schärfen als eine sechste anfangen.`,
      });
    }
    /* Doppelte Namen verhindern -- zwei Saeulen "Tutorials" waeren in
       jeder Auswertung nebeneinander und niemand koennte sie trennen. */
    if (db().prepare(
      "SELECT 1 FROM content_saeulen WHERE creator_id = ? AND lower(name) = lower(?)").get(creatorId, name)) {
      return res.status(400).json({ fehler: "Diese Säule gibt es schon." });
    }

    /* Den kleinsten freien Farbplatz nehmen, nicht einfach den naechsten:
       Nach dem Loeschen der zweiten von drei Saeulen bekaeme die naechste
       sonst Platz 4, und Platz 2 bliebe fuer immer leer. Die Farbe folgt
       damit der Saeule, nicht ihrem Alter. */
    const belegt = new Set(vorhanden.map((s) => s.slot));
    let slot = 1;
    while (belegt.has(slot) && slot < SAEULEN_MAX) slot++;

    const ziel = req.body?.ziel === null || req.body?.ziel === undefined || req.body?.ziel === ""
      ? null : Math.max(0, Math.min(100, Number(req.body.ziel) || 0));

    const { lastInsertRowid } = db().prepare(
      "INSERT INTO content_saeulen (creator_id, name, ziel, slot, erstellt) VALUES (?,?,?,?,?)")
      .run(creatorId, name, ziel, slot, jetzt());

    protokolliere("saeule_angelegt", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: name.slice(0, 60),
    });
    res.status(201).json({ id: Number(lastInsertRowid), slot });
  } catch (fehler) {
    console.error("[content] Säule anlegen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

contentRouter.patch("/workspace/api/content/saeulen/:id", gleicheHerkunft, (req, res) => {
  try {
    const id = Number(req.params.id);
    const s = db().prepare("SELECT * FROM content_saeulen WHERE id = ?").get(id);
    if (!s || !darfCreatorSehen(req.person, s.creator_id)) {
      return res.status(404).json({ fehler: "nicht_gefunden" });
    }
    const aus = {};
    if (req.body?.name !== undefined) {
      const n = String(req.body.name).trim();
      if (n.length < 2 || n.length > NAME_MAX) return res.status(400).json({ fehler: "Name ist ungültig." });
      aus.name = n;
    }
    if (req.body?.ziel !== undefined) {
      aus.ziel = req.body.ziel === null || req.body.ziel === ""
        ? null : Math.max(0, Math.min(100, Number(req.body.ziel) || 0));
    }
    const felder = Object.keys(aus);
    if (!felder.length) return res.status(400).json({ fehler: "nichts_zu_aendern" });
    db().prepare(`UPDATE content_saeulen SET ${felder.map((f) => `${f} = ?`).join(", ")} WHERE id = ?`)
      .run(...felder.map((f) => aus[f]), id);
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[content] Säule ändern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

contentRouter.delete("/workspace/api/content/saeulen/:id", gleicheHerkunft, (req, res) => {
  try {
    const id = Number(req.params.id);
    const s = db().prepare("SELECT * FROM content_saeulen WHERE id = ?").get(id);
    if (!s || !darfCreatorSehen(req.person, s.creator_id)) {
      return res.status(404).json({ fehler: "nicht_gefunden" });
    }
    /* Die Videos bleiben, sie verlieren nur ihre Saeule. Eine Saeule zu
       loeschen darf niemals Arbeit loeschen -- das waere eine
       Aufraeumaktion mit Nebenwirkung, die niemand erwartet. */
    const betroffen = db().prepare(
      "SELECT COUNT(*) AS n FROM eintraege WHERE saeule_id = ?").get(id)?.n ?? 0;
    db().prepare("UPDATE eintraege SET saeule_id = NULL WHERE saeule_id = ?").run(id);
    db().prepare("DELETE FROM content_saeulen WHERE id = ?").run(id);

    protokolliere("saeule_geloescht", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `${s.name} (${betroffen} Videos behalten)`.slice(0, 100),
    });
    res.json({ ok: true, gelöst: betroffen });
  } catch (fehler) {
    console.error("[content] Säule löschen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Kennzahlen der Strecke -------------------------------------

   Bewusst wenige. Aus der Recherche zu Kennzahlen-Anzeigen: Eine Zahl
   ohne Vergleich ist eine Eitelkeitszahl. Was hier steht, beantwortet je
   eine Frage, auf die eine Handlung folgt.
   ----------------------------------------------------------------------- */

contentRouter.get("/workspace/api/content/kennzahlen", (req, res) => {
  try {
    const erlaubt = sichtbareCreator(req.sicht || req.person);
    let wo = "e.bereich = 'content'", werte = [];
    if (erlaubt !== null) {
      if (!erlaubt.length) return res.json({ leer: true });
      wo += ` AND e.creator_id IN (${erlaubt.map(() => "?").join(",")})`;
      werte = erlaubt;
    }
    /* Auf einen Creator eingrenzen, wenn danach gefragt wird -- die
       Balance einer Saeule ergibt nur je Creator einen Sinn. */
    const nur = Number(req.query.creator);
    if (Number.isInteger(nur) && nur > 0) {
      if (!darfCreatorSehen(req.person, nur)) return res.status(404).json({ fehler: "nicht_gefunden" });
      wo += " AND e.creator_id = ?";
      werte = [...werte, nur];
    }

    const d = db();
    const stufen = Object.fromEntries(
      d.prepare(`SELECT e.art, COUNT(*) AS n FROM eintraege e WHERE ${wo} GROUP BY e.art`)
        .all(...werte).map((r) => [r.art, r.n]));

    /* VORRAT: alles, was gedreht oder fertig ist und noch nicht draussen.
       Das ist der Puffer, aus dem sich Regelmaessigkeit speist. Ideen und
       Skripte zaehlen NICHT mit -- eine Idee ist kein Video. Genau diese
       Unterscheidung macht die Zahl ehrlich; wer Ideen mitzaehlt, fuehlt
       sich reich und steht am Donnerstag ohne Material da. */
    const vorrat = (stufen.gedreht || 0) + (stufen.fertig || 0);

    const vor30 = tagLokal(-30);
    const veroeffentlicht30 = d.prepare(
      `SELECT COUNT(*) AS n FROM eintraege e WHERE ${wo} AND e.art = 'veroeffentlicht' AND e.datum >= ?`)
      .get(...werte, vor30)?.n ?? 0;

    /* Aus dem Tempo der letzten 30 Tage wird der Vorrat in TAGE
       umgerechnet. "4 Videos uebrig" sagt wenig; "reicht noch 5 Tage"
       sagt, ob man dieses Wochenende drehen muss. Ohne Verlauf keine
       Umrechnung -- dann wird die Zahl weggelassen statt geraten. */
    const proTag = veroeffentlicht30 / 30;
    const reichweiteTage = proTag > 0 ? Math.floor(vorrat / proTag) : null;

    /* Was ueberfaellig ist: geplant, aber der Zeitpunkt ist vorbei und es
       steht immer noch nicht auf "veroeffentlicht". */
    const ueberfaellig = d.prepare(
      `SELECT COUNT(*) AS n FROM eintraege e
       WHERE ${wo} AND e.art <> 'veroeffentlicht'
         AND e.geplant IS NOT NULL AND e.geplant < ?`).get(...werte, jetzt().slice(0, 16))?.n ?? 0;

    /* Ideen ohne Hook. Die Recherche ist eindeutig: Die ersten ein bis
       drei Sekunden entscheiden ueber die Verbreitung. Eine Idee ohne
       Aufhaenger ist eine halbe Idee -- und man sieht es ihr nicht an. */
    const ohneHook = d.prepare(
      `SELECT COUNT(*) AS n FROM eintraege e
       WHERE ${wo} AND e.art IN ('skript','gedreht','fertig')
         AND (e.hook IS NULL OR trim(e.hook) = '')`).get(...werte)?.n ?? 0;

    /* Balance ueber die letzten 90 Tage -- kuerzer schwankt zu stark,
       laenger reagiert nicht mehr auf eine Kursaenderung. Gezaehlt wird
       nur VEROEFFENTLICHTES: Was auf dem Kanal steht, ist die Wahrheit
       ueber seine Ausrichtung, nicht was in der Ideenliste liegt. */
    /* Die Säulen brauchen dieselbe Einschränkung wie alles andere
       (03.09.2026). Ohne sie zählte diese Abfrage die Säulen ALLER
       Creator zusammen -- mit Namen. Eine Managerin bekam damit über
       die Balance-Auswertung Themenschwerpunkte fremder Kanäle zu
       sehen, ohne dass irgendwo ein Name gestanden hätte, den sie
       öffnen könnte. Genau die Art Leck, die man beim Lesen übersieht:
       Die Abfrage darüber (`wo`) war korrekt eingeschränkt, diese hier
       hatte ihre eigene Bedingung. */
    const vor90 = tagLokal(-90);
    let saeulenWo = "";
    let saeulenWerte = [];
    if (Number.isInteger(nur) && nur > 0) {
      saeulenWo = "WHERE s.creator_id = ?";
      saeulenWerte = [nur];
    } else if (erlaubt !== null) {
      if (!erlaubt.length) saeulenWo = "WHERE 0=1";
      else {
        saeulenWo = `WHERE s.creator_id IN (${erlaubt.map(() => "?").join(",")})`;
        saeulenWerte = erlaubt;
      }
    }
    const balance = d.prepare(`
      SELECT s.id, s.name, s.slot, s.ziel, COUNT(e.id) AS n
      FROM content_saeulen s
      LEFT JOIN eintraege e ON e.saeule_id = s.id AND e.bereich = 'content'
        AND e.art = 'veroeffentlicht' AND e.datum >= ?
      ${saeulenWo}
      GROUP BY s.id ORDER BY s.slot`)
      .all(vor90, ...saeulenWerte);

    const ohneSaeule = d.prepare(
      `SELECT COUNT(*) AS n FROM eintraege e
       WHERE ${wo} AND e.art = 'veroeffentlicht' AND e.datum >= ? AND e.saeule_id IS NULL`)
      .get(...werte, vor90)?.n ?? 0;

    res.json({
      stufen, vorrat, veroeffentlicht30, reichweiteTage, ueberfaellig, ohneHook,
      balance, ohneSaeule, balanceTage: 90,
      stand: jetzt(),
    });
  } catch (fehler) {
    console.error("[content] Kennzahlen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Ueberfuehren ------------------------------------------------

   Woertlich aus dem Konzept: "Ideen lassen sich direkt in
   Aufgabe/Termin/LIVE-Thema ueberfuehren."

   Der Sinn dahinter: Eine Idee, die man abtippen muss, um sie zu einer
   Aufgabe zu machen, wird nicht abgetippt. Sie bleibt in der Liste
   liegen und stirbt dort.

   Die Idee bleibt bewusst BESTEHEN. Sie wandert nicht weg, sie bekommt
   ein Gegenstueck. Sonst waere die Strecke nach dem Ueberfuehren
   loechrig, und man wuesste spaeter nicht mehr, woher die Aufgabe kam.
   ----------------------------------------------------------------------- */

const ZIELE = new Set(["aufgabe", "termin", "live"]);

contentRouter.post("/workspace/api/content/:id/uebernehmen", gleicheHerkunft, (req, res) => {
  try {
    const id = Number(req.params.id);
    const ziel = String(req.body?.ziel || "");
    if (!Number.isInteger(id) || !ZIELE.has(ziel)) {
      return res.status(400).json({ fehler: "ungueltig" });
    }

    const e = db().prepare(
      "SELECT * FROM eintraege WHERE id = ? AND bereich = 'content'").get(id);
    if (!e || !darfCreatorSehen(req.person, e.creator_id)) {
      return res.status(404).json({ fehler: "nicht_gefunden" });
    }

    /* Der Hook ist der Kern -- er wandert in die Beschreibung mit, sonst
       steht die neue Aufgabe ohne das Wichtigste da. */
    const beschreibung = [
      e.hook ? `Hook: ${e.hook}` : null,
      e.text || null,
      e.format ? `Format: ${e.format}` : null,
      `Aus der Content-Planung (#${e.id}).`,
    ].filter(Boolean).join("\n\n");

    let neu = null;
    if (ziel === "aufgabe") {
      const frist = e.geplant ? e.geplant.slice(0, 10) : null;
      const r = db().prepare(`
        INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, creator_id, frist, erstellt, erstellt_von)
        VALUES (?,?,'offen','mittel',?,?,?,?)`).run(
        e.titel.slice(0, 160), beschreibung, e.creator_id, frist, jetzt(), req.person.id);
      neu = { art: "Aufgabe", id: Number(r.lastInsertRowid), wohin: "aufgaben.html" };

    } else if (ziel === "termin") {
      /* Ohne geplanten Zeitpunkt gibt es nichts einzutragen -- lieber
         eine klare Absage als ein Termin auf gut Glueck. */
      if (!e.geplant) {
        return res.status(400).json({
          fehler: "Für einen Termin braucht es einen geplanten Zeitpunkt am Video.",
        });
      }
      const beginn = e.geplant.length === 10 ? e.geplant + "T10:00" : e.geplant;
      const r = db().prepare(`
        INSERT INTO termine (titel, beschreibung, art, beginn, dauer_min, creator_id, erledigt, erstellt, erstellt_von, haus)
        VALUES (?,?,'termin',?,60,?,0,?,?,?)`).run(
        ("Dreh: " + e.titel).slice(0, 160), beschreibung, beginn, e.creator_id, jetzt(), req.person.id,
        req.person.haus || null);
      neu = { art: "Termin", id: Number(r.lastInsertRowid), wohin: "kalender.html" };

    } else {
      const r = db().prepare(`
        INSERT INTO eintraege (bereich, art, titel, text, datum, status, creator_id, erstellt, erstellt_von)
        VALUES ('live','vorbereitung',?,?,?,'offen',?,?,?)`).run(
        e.titel.slice(0, 160), beschreibung, e.geplant ? e.geplant.slice(0, 10) : heute(),
        e.creator_id, jetzt(), req.person.id);
      neu = { art: "LIVE-Thema", id: Number(r.lastInsertRowid), wohin: "bereich.html?b=live" };
    }

    /* Am Video vermerken, dass es uebernommen wurde -- sonst legt beim
       naechsten Durchsehen jemand dieselbe Aufgabe ein zweites Mal an. */
    const vermerk = `Übernommen als ${neu.art} (#${neu.id}) am ${heute().split("-").reverse().join(".")}.`;
    db().prepare("UPDATE eintraege SET text = ?, geaendert = ? WHERE id = ?")
      .run([e.text, vermerk].filter(Boolean).join("\n\n"), jetzt(), id);

    protokolliere("content_uebernommen", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} → ${neu.art} #${neu.id}`.slice(0, 120),
    });
    res.status(201).json(neu);
  } catch (fehler) {
    console.error("[content] Übernehmen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});