dogfather-universe/server/workspace-aufgaben.js

/* =====================================================================
   workspace-aufgaben.js — Aufgaben und Dashboard-Zahlen für /workspace.

   Kernpunkt dieses Moduls ist die Datentrennung aus dem Konzept:
   "Creator sehen ihren Bereich. Scouts sehen nur ihre Pipeline."
   Sie wird AUSSCHLIESSLICH serverseitig durchgesetzt -- in jeder Abfrage,
   nicht im Browser. Ein manipulierter Aufruf bekommt dadurch keine
   fremden Daten, egal was er behauptet.
   ===================================================================== */

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

export const aufgabenRouter = express.Router();

const STATUS = ["offen", "arbeit", "review", "erledigt"];
const PRIORITAETEN = ["hoch", "mittel", "niedrig"];
const TITEL_MAX = 160;
const TEXT_MAX = 4000;

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

/* ---------- Schranke ---------------------------------------------------- */

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  next();
}

/* Schutz gegen Anfragen von fremden Seiten. SameSite=lax verhindert das
   meiste schon, aber nur solange sich der Browser daran hält. Bei allem,
   was Daten verändert, wird zusätzlich geprüft, dass die Anfrage von
   dieser Domain kommt. Fehlt der Kopf ganz (z. B. bei curl), ist es kein
   Browser-Angriff über eine fremde Seite -- dann zählt allein das Cookie. */
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();
}

aufgabenRouter.use("/workspace/api", angemeldet);

/* ---------- Sichtbarkeit ------------------------------------------------ */

/* Liefert WHERE-Bedingung und Werte, passend zur Rolle. An genau einer
   Stelle definiert, damit keine Abfrage sie versehentlich vergisst. */
export function sichtbar(person) {
  switch (person.rolle) {
    case "admin":
      return { wo: "1=1", werte: [] };
    case "creator":
      return { wo: "(a.creator_id = ? OR a.verantwortlich_id = ?)", werte: [person.id, person.id] };
    case "scout": {
      /* Eigene Aufgaben -- und die der Creator, die dieser Scout
         betreut. Wer jemanden betreut, muss dessen Brett sehen. */
      const b = betreutWo(person, "a.creator_id");
      return b
        ? { wo: `(a.verantwortlich_id = ? OR ${b.wo})`, werte: [person.id, ...b.werte] }
        : { wo: "a.verantwortlich_id = ?", werte: [person.id] };
    }
    default:
      return { wo: "0=1", werte: [] };   // unbekannte Rolle sieht nichts
  }
}

function darfAendern(person, aufgabe) {
  if (istLeitung(person)) return true;
  return aufgabe.creator_id === person.id || aufgabe.verantwortlich_id === person.id;
}

const SPALTEN = `
  a.id, a.titel, a.beschreibung, a.status, a.prioritaet, a.frist,
  a.creator_id, a.verantwortlich_id, a.erstellt, a.geaendert, a.erledigt_am,
  pc.name AS creator_name, pv.name AS verantwortlich_name`;

const VERBUND = `
  FROM aufgaben a
  LEFT JOIN personen pc ON pc.id = a.creator_id
  LEFT JOIN personen pv ON pv.id = a.verantwortlich_id`;

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

aufgabenRouter.get("/workspace/api/aufgaben", (req, res) => {
  try {
    const { wo, werte } = sichtbar(req.person);
    const reihen = db().prepare(`
      SELECT ${SPALTEN},
             (SELECT COUNT(*) FROM aufgaben_notizen n WHERE n.aufgabe_id = a.id) AS notizen
      ${VERBUND}
      WHERE ${wo}
      ORDER BY
        CASE a.prioritaet WHEN 'hoch' THEN 0 WHEN 'mittel' THEN 1 ELSE 2 END,
        CASE WHEN a.frist IS NULL THEN 1 ELSE 0 END, a.frist,
        a.id DESC`).all(...werte);
    res.json({ aufgaben: reihen });
  } catch (fehler) {
    console.error("[workspace] Aufgaben lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

aufgabenRouter.get("/workspace/api/uebersicht", (req, res) => {
  try {
    const { wo, werte } = sichtbar(req.person);
    const zaehle = (zusatz, extra = []) => db()
      .prepare(`SELECT COUNT(*) AS n ${VERBUND} WHERE ${wo}${zusatz}`)
      .get(...werte, ...extra).n;

    const heute = jetzt().slice(0, 10);
    res.json({
      offen:     zaehle(" AND a.status = 'offen'"),
      arbeit:    zaehle(" AND a.status = 'arbeit'"),
      review:    zaehle(" AND a.status = 'review'"),
      erledigt:  zaehle(" AND a.status = 'erledigt'"),
      /* Überfällig = Frist vorbei und noch nicht erledigt. Genau die Zahl,
         die das Konzept auf dem Dashboard sehen will. */
      ueberfaellig: zaehle(" AND a.status <> 'erledigt' AND a.frist IS NOT NULL AND a.frist < ?", [heute]),
      heute:        zaehle(" AND a.status <> 'erledigt' AND a.frist = ?", [heute]),
    });
  } catch (fehler) {
    console.error("[workspace] Übersicht:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* Für die Zuweisung: wen darf ich überhaupt eintragen? Scouts bekommen
   die Liste bewusst nicht -- sie sollen keine fremden Namen sehen. */
aufgabenRouter.get("/workspace/api/personen", (req, res) => {
  try {
    if (istLeitung(req.person)) {
      return res.json({
        personen: db().prepare(
          "SELECT id, name, rolle FROM personen WHERE aktiv = 1 ORDER BY " + ROLLEN_SORTIERUNG + ", name").all(),
      });
    }
    res.json({ personen: [{ id: req.person.id, name: req.person.name, rolle: req.person.rolle }] });
  } catch {
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Anlegen und Ändern ------------------------------------------ */

function pruefeFelder(körper, { neu }) {
  const fehler = [];
  const aus = {};

  if (neu || körper.titel !== undefined) {
    const titel = String(körper.titel ?? "").trim();
    if (titel.length < 2) fehler.push("Titel fehlt.");
    else if (titel.length > TITEL_MAX) fehler.push(`Titel ist länger als ${TITEL_MAX} Zeichen.`);
    else aus.titel = titel;
  }
  if (körper.beschreibung !== undefined) {
    const t = String(körper.beschreibung ?? "").trim();
    if (t.length > TEXT_MAX) fehler.push("Beschreibung ist zu lang.");
    else aus.beschreibung = t || null;
  }
  if (körper.status !== undefined) {
    if (!STATUS.includes(körper.status)) fehler.push("Unbekannter Status.");
    else aus.status = körper.status;
  }
  if (körper.prioritaet !== undefined) {
    if (!PRIORITAETEN.includes(körper.prioritaet)) fehler.push("Unbekannte Priorität.");
    else aus.prioritaet = körper.prioritaet;
  }
  if (körper.frist !== undefined) {
    const f = String(körper.frist ?? "").trim();
    if (!f) aus.frist = null;
    else if (!/^\d{4}-\d{2}-\d{2}$/.test(f) || Number.isNaN(Date.parse(f))) fehler.push("Frist ist kein gültiges Datum.");
    else aus.frist = f;
  }
  for (const feld of ["creator_id", "verantwortlich_id"]) {
    if (körper[feld] === undefined) continue;
    const wert = körper[feld];
    if (wert === null || wert === "") { aus[feld] = null; continue; }
    const zahl = Number(wert);
    if (!Number.isInteger(zahl) || zahl < 1) fehler.push("Ungültige Zuordnung.");
    else aus[feld] = zahl;
  }
  return { aus, fehler };
}

/* ---------- Rueckmeldungen ("Aufgaben & Feedback") ------------------------
   Wer die Aufgabe sieht, darf mitreden. Geprueft wird das ueber dieselbe
   Sichtbarkeitsregel wie fuer die Aufgabe selbst -- eine zweite Regel
   waere eine zweite Stelle, an der es irgendwann auseinanderlaeuft.

   404 statt 403, wenn die Aufgabe nicht sichtbar ist: Wer sie nicht
   sehen darf, soll auch nicht erfahren, dass es sie gibt.             */

const NOTIZ_MAX = 2000;

function aufgabeSichtbar(person, id) {
  const { wo, werte } = sichtbar(person);
  return db().prepare(`SELECT a.id FROM aufgaben a WHERE ${wo} AND a.id = ?`).get(...werte, id);
}

aufgabenRouter.get("/workspace/api/aufgaben/:id/notizen", (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
    if (!aufgabeSichtbar(req.person, id)) return res.status(404).json({ fehler: "nicht_gefunden" });

    res.json({
      notizen: db().prepare(`
        SELECT n.id, n.text, n.erstellt, n.person_id, p.name AS von, p.rolle AS rolle
        FROM aufgaben_notizen n LEFT JOIN personen p ON p.id = n.person_id
        WHERE n.aufgabe_id = ? ORDER BY n.id`).all(id),
      ich: req.person.id,
      darf_alles_loeschen: istLeitung(req.person),
    });
  } catch (fehler) {
    console.error("[workspace] Notizen lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

aufgabenRouter.post("/workspace/api/aufgaben/:id/notizen", gleicheHerkunft, (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
    if (!aufgabeSichtbar(req.person, id)) return res.status(404).json({ fehler: "nicht_gefunden" });

    const text = String(req.body?.text ?? "").trim().slice(0, NOTIZ_MAX);
    if (text.length < 2) return res.status(400).json({ fehler: "Schreib erst etwas." });

    const { lastInsertRowid } = db().prepare(
      "INSERT INTO aufgaben_notizen (aufgabe_id, person_id, text, erstellt) VALUES (?,?,?,?)")
      .run(id, req.person.id, text, jetzt());

    protokolliere("aufgabe_notiz", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `Aufgabe #${id}`.slice(0, 120),
    });
    res.status(201).json({ id: Number(lastInsertRowid) });
  } catch (fehler) {
    console.error("[workspace] Notiz schreiben:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

aufgabenRouter.delete("/workspace/api/notizen/:id", gleicheHerkunft, (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
    const notiz = db().prepare(
      "SELECT id, aufgabe_id, person_id FROM aufgaben_notizen WHERE id = ?").get(id);
    if (!notiz) return res.status(404).json({ fehler: "nicht_gefunden" });
    if (!aufgabeSichtbar(req.person, notiz.aufgabe_id)) {
      return res.status(404).json({ fehler: "nicht_gefunden" });
    }
    /* Die eigene Rueckmeldung darf jeder zuruecknehmen, fremde nur die
       Leitung. Eine Rueckmeldung ist keine Abstimmung -- wer sich
       vertippt hat, soll das nicht bei jemandem beantragen muessen. */
    if (notiz.person_id !== req.person.id && !istLeitung(req.person)) {
      return res.status(403).json({ fehler: "Fremde Rückmeldungen löscht nur die Leitung." });
    }
    db().prepare("DELETE FROM aufgaben_notizen WHERE id = ?").run(id);
    protokolliere("aufgabe_notiz_geloescht", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} zu Aufgabe #${notiz.aufgabe_id}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Notiz löschen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

aufgabenRouter.post("/workspace/api/aufgaben", gleicheHerkunft, (req, res) => {
  try {
    const { aus, fehler } = pruefeFelder(req.body || {}, { neu: true });
    if (fehler.length) return res.status(400).json({ fehler: fehler.join(" ") });

    /* Wer nicht Management ist, darf ausschließlich für sich selbst
       anlegen -- egal, was im Aufruf steht. */
    if (!istLeitung(req.person)) {
      aus.creator_id = req.person.rolle === "creator" ? req.person.id : null;
      aus.verantwortlich_id = req.person.id;
    }

    for (const feld of ["creator_id", "verantwortlich_id"]) {
      if (aus[feld] && !db().prepare("SELECT 1 FROM personen WHERE id = ? AND aktiv = 1").get(aus[feld])) {
        return res.status(400).json({ fehler: "Zugeordnete Person gibt es nicht." });
      }
    }

    const { lastInsertRowid } = db().prepare(`
      INSERT INTO aufgaben
        (titel, beschreibung, status, prioritaet, creator_id, verantwortlich_id,
         frist, erstellt, erstellt_von)
      VALUES (?,?,?,?,?,?,?,?,?)`).run(
      aus.titel, aus.beschreibung ?? null, aus.status ?? "offen",
      aus.prioritaet ?? "mittel", aus.creator_id ?? null, aus.verantwortlich_id ?? null,
      aus.frist ?? null, jetzt(), req.person.id);

    protokolliere("aufgabe_angelegt", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${lastInsertRowid} ${aus.titel}`.slice(0, 120),
    });
    res.status(201).json({ id: Number(lastInsertRowid) });
  } catch (fehler) {
    console.error("[workspace] Aufgabe anlegen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

aufgabenRouter.patch("/workspace/api/aufgaben/:id", gleicheHerkunft, (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });

    /* Erst mit der Sichtbarkeitsregel holen: Was jemand nicht sehen darf,
       existiert für ihn auch nicht -- deshalb 404 und nicht 403. Sonst
       liesse sich durch Ausprobieren herausfinden, welche Nummern es gibt. */
    const { wo, werte } = sichtbar(req.person);
    const aufgabe = db().prepare(
      `SELECT a.* ${VERBUND} WHERE ${wo} AND a.id = ?`).get(...werte, id);
    if (!aufgabe) return res.status(404).json({ fehler: "nicht_gefunden" });
    if (!darfAendern(req.person, aufgabe)) return res.status(403).json({ fehler: "nicht_erlaubt" });

    const { aus, fehler } = pruefeFelder(req.body || {}, { neu: false });
    if (fehler.length) return res.status(400).json({ fehler: fehler.join(" ") });

    /* Zuordnungen darf nur das Management verschieben. */
    if (!istLeitung(req.person)) { delete aus.creator_id; delete aus.verantwortlich_id; }

    const felder = Object.keys(aus);
    if (!felder.length) return res.status(400).json({ fehler: "nichts_zu_aendern" });

    const setz = felder.map((f) => `${f} = ?`);
    const daten = felder.map((f) => aus[f]);
    setz.push("geaendert = ?"); daten.push(jetzt());

    if (aus.status === "erledigt" && aufgabe.status !== "erledigt") {
      setz.push("erledigt_am = ?"); daten.push(jetzt());
    } else if (aus.status && aus.status !== "erledigt") {
      setz.push("erledigt_am = NULL");
    }

    db().prepare(`UPDATE aufgaben SET ${setz.join(", ")} WHERE id = ?`).run(...daten, id);

    protokolliere("aufgabe_geaendert", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${felder.join(",")}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Aufgabe ändern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Löschen ------------------------------------------------------
   Nur Management. Das Konzept will ausdrücklich, dass Erledigtes sichtbar
   bleibt ("Erledigte Aufgaben verschwinden nicht") -- Löschen ist deshalb
   der Ausnahmefall für Fehleinträge, nicht der normale Abschluss. Der
   Titel wandert ins Protokoll, damit nachvollziehbar bleibt, was weg ist. */

aufgabenRouter.delete("/workspace/api/aufgaben/:id", gleicheHerkunft, (req, res) => {
  try {
    if (!istLeitung(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });

    const aufgabe = db().prepare("SELECT id, titel FROM aufgaben WHERE id = ?").get(id);
    if (!aufgabe) return res.status(404).json({ fehler: "nicht_gefunden" });

    db().prepare("DELETE FROM aufgaben WHERE id = ?").run(id);
    protokolliere("aufgabe_geloescht", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${aufgabe.titel}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Aufgabe löschen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});