dogfather-universe/server/workspace-ampel.js

/* =====================================================================
   workspace-ampel.js — Bewertung und Rückmeldungen an einem Eintrag.

   Der Wunsch vom 01.09.2026 zur LIVE-Analyse: "der Creator sieht, ob es
   gut ist oder schlecht. Und wenn nicht gut, dann muss es verbessert
   werden – und nur der Ansprechpartner kann das ändern. Die Creator
   können nur Nachrichten hinterlassen zum Kommunizieren."

   Das sind zwei getrennte Dinge, und sie getrennt zu halten ist der
   ganze Punkt:

     DIE AMPEL   ist eine Beurteilung. Sie gehört dem Betreuer, und nur
                 er setzt sie. Könnte der Creator sie selbst auf grün
                 stellen, wäre sie wertlos.

     DIE NACHRICHT ist ein Gespräch. Sie gehört beiden. Ein Creator, der
                 auf eine Bewertung nicht antworten kann, bekommt ein
                 Urteil statt einer Betreuung.

   Drei Stufen, nicht fünf. Eine Zahl von 1 bis 5 klingt genauer und ist
   es nicht: Niemand kann den Unterschied zwischen 3 und 4 erklären, und
   am Ende steht überall 3. Die Frage lautet "reicht das schon?", und
   darauf gibt es drei ehrliche Antworten:

     gut        so lassen
     verbessern noch nicht gut genug -- mit dem Satz, was fehlt
     offen      noch nicht angesehen

   "verbessern" verlangt eine Begründung. Eine Bewertung ohne Grund ist
   für den Creator nicht umsetzbar, sondern nur entmutigend -- und der
   Server lehnt sie deshalb ab.
   ===================================================================== */

import express from "express";
import {
  db, sitzungLesen, istLeitung, darfCreator, protokolliere, echteIp,
} from "./workspace.js";

export const ampelRouter = express.Router();

const jetzt = () => new Date().toISOString();
const STUFEN = new Set(["gut", "verbessern", "offen"]);
const NACHRICHT_MAX = 2000;

let bereit = false;
function tabellen() {
  if (bereit) return;
  db().exec(`
    /* Die Ampel haengt am Eintrag, steht aber in einer eigenen Tabelle:
       Sie hat einen eigenen Verfasser und einen eigenen Zeitpunkt, und
       beides gehoert nicht in die Zeile des Eintrags. */
    CREATE TABLE IF NOT EXISTS eintrag_ampel (
      eintrag_id   INTEGER PRIMARY KEY REFERENCES eintraege(id) ON DELETE CASCADE,
      stufe        TEXT NOT NULL CHECK (stufe IN ('gut','verbessern','offen')),
      begruendung  TEXT,
      von          INTEGER REFERENCES personen(id) ON DELETE SET NULL,
      am           TEXT NOT NULL
    );

    /* Rueckmeldungen. Jeder Beteiligte darf schreiben -- auch der
       Creator, fuer den das oft der einzige Weg ist, etwas zu sagen. */
    CREATE TABLE IF NOT EXISTS eintrag_nachricht (
      id          INTEGER PRIMARY KEY AUTOINCREMENT,
      eintrag_id  INTEGER NOT NULL REFERENCES eintraege(id) ON DELETE CASCADE,
      text        TEXT NOT NULL,
      von         INTEGER REFERENCES personen(id) ON DELETE SET NULL,
      am          TEXT NOT NULL
    );
    CREATE INDEX IF NOT EXISTS idx_nachricht_eintrag
      ON eintrag_nachricht (eintrag_id);
  `);
  bereit = true;
}

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] Ampeltabellen:", f?.message);
    return res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
  next();
}
ampelRouter.use("/workspace/api/eintrag", 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();
}

/** Darf die Person diesen Eintrag ueberhaupt sehen? Dieselbe Regel wie
 *  im Bereichsmodul -- sie hier zu wiederholen waere der sichere Weg,
 *  dass die beiden irgendwann auseinanderlaufen, deshalb wird sie aus
 *  denselben Bausteinen gebildet. */
function sichtbarerEintrag(person, id) {
  const e = db().prepare("SELECT id, creator_id, bereich FROM eintraege WHERE id = ?").get(id);
  if (!e) return null;
  if (istLeitung(person)) return e;
  if (person.rolle === "creator") return e.creator_id === person.id ? e : null;
  return e.creator_id && darfCreator(person, e.creator_id) ? e : null;
}

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

ampelRouter.get("/workspace/api/eintrag/:id(\\d+)/rueckmeldung", (req, res) => {
  try {
    const e = sichtbarerEintrag(req.person, Number(req.params.id));
    if (!e) return res.status(404).json({ fehler: "nicht_gefunden" });

    const ampel = db().prepare(`
      SELECT a.*, p.name AS von_name
      FROM eintrag_ampel a LEFT JOIN personen p ON p.id = a.von
      WHERE a.eintrag_id = ?`).get(e.id) || null;

    const nachrichten = db().prepare(`
      SELECT n.*, p.name AS von_name, p.rolle AS von_rolle
      FROM eintrag_nachricht n LEFT JOIN personen p ON p.id = n.von
      WHERE n.eintrag_id = ? ORDER BY n.id`).all(e.id);

    res.json({
      ampel, nachrichten,
      /* Die Oberflaeche soll nicht selbst raten muessen, wer was darf --
         sonst zeigt sie einem Creator einen Knopf, der beim Klicken 403
         sagt. Das ist schlechter als kein Knopf. */
      darf_bewerten: req.person.rolle !== "creator",
      ich: req.person.id,
    });
  } catch (fehler) {
    console.error("[workspace] Rückmeldung lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Bewerten (NUR die Betreuung) ---------------------------------- */

ampelRouter.put("/workspace/api/eintrag/:id(\\d+)/ampel", gleicheHerkunft,
  express.json({ limit: "8kb" }), (req, res) => {
    try {
      /* Ein Creator bewertet sich nicht selbst. Waere das moeglich,
         waere die Ampel wertlos -- jeder stuende auf gruen. */
      if (req.person.rolle === "creator") {
        return res.status(403).json({
          fehler: "Die Bewertung setzt deine Betreuung. Du kannst hier antworten.",
        });
      }
      const e = sichtbarerEintrag(req.person, Number(req.params.id));
      if (!e) return res.status(404).json({ fehler: "nicht_gefunden" });

      const stufe = String(req.body.stufe || "");
      if (!STUFEN.has(stufe)) return res.status(400).json({ fehler: "Unbekannte Stufe." });

      const begruendung = String(req.body.begruendung ?? "").trim().slice(0, NACHRICHT_MAX);
      /* "verbessern" ohne Grund ist fuer den Creator nicht umsetzbar --
         nur entmutigend. Deshalb Pflicht. */
      if (stufe === "verbessern" && begruendung.length < 5) {
        return res.status(400).json({
          fehler: "Bitte kurz schreiben, was verbessert werden soll – sonst kann er nichts damit anfangen.",
        });
      }

      db().prepare(`INSERT INTO eintrag_ampel (eintrag_id, stufe, begruendung, von, am)
          VALUES (?,?,?,?,?)
          ON CONFLICT(eintrag_id) DO UPDATE SET
            stufe = excluded.stufe, begruendung = excluded.begruendung,
            von = excluded.von, am = excluded.am`)
        .run(e.id, stufe, begruendung || null, req.person.id, jetzt());

      protokolliere("ampel_gesetzt", req.person, echteIp(req), `Eintrag ${e.id}: ${stufe}`);

      const neu = db().prepare(`
        SELECT a.*, p.name AS von_name FROM eintrag_ampel a
        LEFT JOIN personen p ON p.id = a.von WHERE a.eintrag_id = ?`).get(e.id);
      res.json({ ampel: neu });
    } catch (fehler) {
      console.error("[workspace] Ampel setzen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* ---------- Nachricht schreiben (JEDER Beteiligte) ------------------------ */

ampelRouter.post("/workspace/api/eintrag/:id(\\d+)/nachricht", gleicheHerkunft,
  express.json({ limit: "8kb" }), (req, res) => {
    try {
      const e = sichtbarerEintrag(req.person, Number(req.params.id));
      if (!e) return res.status(404).json({ fehler: "nicht_gefunden" });

      const text = String(req.body.text ?? "").trim();
      if (text.length < 2) return res.status(400).json({ fehler: "Die Nachricht ist leer." });
      if (text.length > NACHRICHT_MAX) {
        return res.status(400).json({ fehler: "Die Nachricht ist zu lang." });
      }

      db().prepare("INSERT INTO eintrag_nachricht (eintrag_id, text, von, am) VALUES (?,?,?,?)")
        .run(e.id, text, req.person.id, jetzt());
      protokolliere("nachricht", req.person, echteIp(req), `Eintrag ${e.id}`);

      const alle = db().prepare(`
        SELECT n.*, p.name AS von_name, p.rolle AS von_rolle
        FROM eintrag_nachricht n LEFT JOIN personen p ON p.id = n.von
        WHERE n.eintrag_id = ? ORDER BY n.id`).all(e.id);
      res.json({ nachrichten: alle });
    } catch (fehler) {
      console.error("[workspace] Nachricht:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* ---------- Eigene Nachricht zurücknehmen --------------------------------

   Nur die eigene, und nur die eigene. Fremde Nachrichten zu löschen
   hiesse, ein Gespräch nachträglich umzuschreiben -- selbst für die
   Leitung nicht. Wer etwas richtigstellen will, schreibt eine neue. */

ampelRouter.delete("/workspace/api/eintrag/:id(\\d+)/nachricht/:nid(\\d+)", gleicheHerkunft,
  (req, res) => {
    try {
      const e = sichtbarerEintrag(req.person, Number(req.params.id));
      if (!e) return res.status(404).json({ fehler: "nicht_gefunden" });

      const n = db().prepare("SELECT * FROM eintrag_nachricht WHERE id = ? AND eintrag_id = ?")
        .get(Number(req.params.nid), e.id);
      if (!n) return res.status(404).json({ fehler: "nicht_gefunden" });
      if (n.von !== req.person.id) {
        return res.status(403).json({
          fehler: "Fremde Nachrichten bleiben stehen. Schreib eine neue, wenn etwas richtigzustellen ist.",
        });
      }
      db().prepare("DELETE FROM eintrag_nachricht WHERE id = ?").run(n.id);
      res.json({ ok: true });
    } catch (fehler) {
      console.error("[workspace] Nachricht löschen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* ---------- Sammelabfrage für eine Liste ---------------------------------

   Damit die Seite nicht für zwanzig Einträge zwanzig Abfragen schickt.
   Geliefert wird nur, was die Person ohnehin sehen darf -- die Prüfung
   läuft je Eintrag, nicht einmal pauschal. */

ampelRouter.get("/workspace/api/eintrag/ampeln", (req, res) => {
  try {
    const ids = String(req.query.ids || "").split(",")
      .map((x) => Number(x)).filter((x) => Number.isInteger(x) && x > 0).slice(0, 200);
    if (!ids.length) return res.json({ ampeln: {}, anzahlNachrichten: {} });

    const erlaubt = ids.filter((id) => sichtbarerEintrag(req.person, id));
    if (!erlaubt.length) return res.json({ ampeln: {}, anzahlNachrichten: {} });

    const platz = erlaubt.map(() => "?").join(",");
    const ampeln = {};
    for (const a of db().prepare(`
      SELECT a.*, p.name AS von_name FROM eintrag_ampel a
      LEFT JOIN personen p ON p.id = a.von
      WHERE a.eintrag_id IN (${platz})`).all(...erlaubt)) {
      ampeln[a.eintrag_id] = a;
    }
    const anzahlNachrichten = {};
    for (const z of db().prepare(`
      SELECT eintrag_id, COUNT(*) AS n FROM eintrag_nachricht
      WHERE eintrag_id IN (${platz}) GROUP BY eintrag_id`).all(...erlaubt)) {
      anzahlNachrichten[z.eintrag_id] = z.n;
    }
    res.json({ ampeln, anzahlNachrichten, darf_bewerten: req.person.rolle !== "creator" });
  } catch (fehler) {
    console.error("[workspace] Ampeln lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});