dogfather-universe/server/workspace-calls.js

/* =====================================================================
   workspace-calls.js — Calls & Meeting-Protokolle (Konzept, Seite 13).

   Calls sind KEINE eigene Terminart neben dem Kalender, sondern
   dieselben Termine mit art = 'call'. Ein zweiter Terminspeicher waere
   die sichere Art, irgendwann zwei widerspruechliche Uhrzeiten zu haben.
   Diese Datei fuegt nur das hinzu, was ein Gespraech vom blossen Termin
   unterscheidet: das Protokoll danach.

   Der tragende Satz aus dem Deck:
   "Jeder Call endet mit klaren To-dos, die direkt ins Board uebernommen
   werden."

   Woertlich genommen heisst das: To-dos werden nicht als Text im
   Protokoll abgelegt, sondern sofort zu echten Aufgaben. Sonst steht die
   Verabredung in einem Dokument, das niemand mehr oeffnet.
   ===================================================================== */

import express from "express";
import {
  db, protokolliere, echteIp, sitzungLesen, einstellung, einstellungSetzen, istLeitung, istDogFather, siehtAlles,
} from "./workspace.js";
import { sichtbar } from "./workspace-kalender.js";

export const callRouter = express.Router();

/* Wie lange nach dem geplanten Ende ein Call noch als "läuft gerade"
   gilt. Gespräche ziehen sich; wer eine Viertelstunde später beitritt,
   soll den Knopf noch finden. */
const NACHLAUF_MIN = 60;

const TITEL_MAX = 160;
const TEXT_MAX = 6000;
const TODOS_MAX = 12;

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

/* Lokale Zeit im selben Format wie ein datetime-local-Feld -- damit ist
   "vergangen" derselbe Vergleich wie im Kalender. */
function jetztLokal() {
  const d = new Date();
  const p = (n) => String(n).padStart(2, "0");
  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}T${p(d.getHours())}:${p(d.getMinutes())}`;
}

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

callRouter.use("/workspace/api/calls", angemeldet);

/* Die Sichtbarkeitsregel kommt aus dem Kalender und wird hier NICHT
   wiederholt. Sie stand kurzzeitig zweimal da -- und prompt wurde beim
   Erweitern nur eine der beiden Kopien geaendert: Scouts sahen die
   Termine ihrer Creator, dieselben Termine als Call aber nicht. Eine
   Regel, zwei Orte, ein Fehler. */

const SPALTEN = `
  t.id, t.titel, t.beschreibung, t.art, t.beginn, t.dauer_min, t.ort,
  t.creator_id, t.teilnehmer_id, t.erledigt, t.serie_id,
  pc.name AS creator_name, pt.name AS teilnehmer_name,
  pr.id AS protokoll_id, pr.punkte, pr.entscheidungen,
  pr.erstellt AS protokoll_erstellt, pr.naechster_termin_id,
  pe.name AS protokoll_von`;

const VERBUND = `
  FROM termine t
  LEFT JOIN personen pc ON pc.id = t.creator_id
  LEFT JOIN personen pt ON pt.id = t.teilnehmer_id
  LEFT JOIN protokolle pr ON pr.termin_id = t.id
  LEFT JOIN personen pe ON pe.id = pr.erstellt_von`;

/* Aufgaben, die aus einem Gespraech entstanden sind. */
function aufgabenZu(protokollIds) {
  if (!protokollIds.length) return new Map();
  const platz = protokollIds.map(() => "?").join(",");
  const zeilen = db().prepare(`
    SELECT pa.protokoll_id, a.id, a.titel, a.status, a.frist, p.name AS verantwortlich_name
    FROM protokoll_aufgaben pa
    JOIN aufgaben a ON a.id = pa.aufgabe_id
    LEFT JOIN personen p ON p.id = a.verantwortlich_id
    WHERE pa.protokoll_id IN (${platz})
    ORDER BY a.id`).all(...protokollIds);
  const karte = new Map();
  for (const z of zeilen) {
    if (!karte.has(z.protokoll_id)) karte.set(z.protokoll_id, []);
    karte.get(z.protokoll_id).push({
      id: z.id, titel: z.titel, status: z.status,
      frist: z.frist, verantwortlich_name: z.verantwortlich_name,
    });
  }
  return karte;
}

/* ---------- Liste ------------------------------------------------------- */

callRouter.get("/workspace/api/calls", (req, res) => {
  try {
    /* Calls & Protokolle haengen an derselben Regel wie die Termine --
       und sind damit ebenso privat. Wer hier die fremde Sicht laesst,
       hat die Ausnahme nur halb gebaut. */
    const { wo, werte } = sichtbar(req.person);
    const alle = db().prepare(`
      SELECT ${SPALTEN} ${VERBUND}
      WHERE ${wo} AND t.art IN ('call','review')
      ORDER BY t.beginn DESC`).all(...werte);

    const karte = aufgabenZu(alle.filter((c) => c.protokoll_id).map((c) => c.protokoll_id));
    for (const c of alle) c.aufgaben = karte.get(c.protokoll_id) || [];

    const grenze = jetztLokal();
    res.json({
      jetzt: grenze,
      /* Wo der Call stattfindet, wenn am Termin selbst kein Link steht.
         Vorher gab es den Knopf "Call öffnen" nur, wenn jemand von Hand
         einen Link eingetragen hatte -- stand dort "Hier" oder "Discord",
         war da nichts zum Anklicken, und die Frage "wo führe ich den
         Call?" blieb unbeantwortet. Jetzt hat das Team einen festen
         Sprachkanal, und jeder Call zeigt darauf.

         Der Link liegt in den Einstellungen und nicht fest im Code: Ein
         Kanal kann umziehen, und dann darf das kein Programmierauftrag
         sein. */
      call_link: einstellung("call_link", "") || "",
      /* Die Reihenfolge der Gruppen ist die Dringlichkeit: Was fehlt,
         steht oben -- nicht was als Naechstes kommt. */
      /* WIEDERHOLUNGEN BEKOMMEN EINE EIGENE GRUPPE (07.09.2026).

         Filipe: "ich will da auch noch eine kategorie fuer automatische
         wiederholungen. die sollen dann auch nur fuer den monat selbst
         angezeigt werden und nicht monate im voraus."

         DAS PROBLEM WAR ECHT UND GROSS: Der Nachfueller haelt einen
         Horizont von 180 Tagen gefuellt (siehe workspace-serien.js).
         Ein woechentlicher Community-Talk ergibt darin sechsundzwanzig
         Zeilen -- und alle standen unter "Steht an". Auf Filipes Bild
         waren es siebenundzwanzig Karten, fast alle derselbe Termin.
         Die Liste war damit unbrauchbar fuer das, wofuer sie da ist:
         zu sehen, was WIRKLICH ansteht.

         Jetzt zwei getrennte Fragen:
           STEHT AN          was einmalig bevorsteht
           LAEUFT AUTOMATISCH  was von allein wiederkommt, und davon
                             nur der LAUFENDE MONAT

         Der Monatsschnitt ist die eigentliche Antwort auf "nicht Monate
         im Voraus": Eine Wiederholung im November sagt einem heute
         nichts, was man nicht schon weiss. Gerechnet wird auf dem
         reinen Datumstext (`beginn` beginnt mit JJJJ-MM) -- kein
         `new Date`, keine Zeitzone, kein Nachtfehler. */
      offen: alle.filter((c) => c.beginn <= grenze && !c.protokoll_id).reverse(),
      anstehend: alle.filter((c) => c.beginn > grenze && !c.serie_id).reverse(),
      serien: alle.filter((c) => c.beginn > grenze && c.serie_id
        && String(c.beginn).slice(0, 7) === grenze.slice(0, 7)).reverse(),
      erledigt: alle.filter((c) => c.beginn <= grenze && c.protokoll_id),
    });
  } catch (fehler) {
    console.error("[workspace] Calls lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Protokoll schreiben ----------------------------------------- */

/* ---------- Wo die Calls stattfinden -------------------------------------

   Ein Link, den das Management einmal setzt (der Discord-Sprachkanal des
   Teams). Er beantwortet die Frage "wo führe ich den Call?" ein für alle
   Mal, statt sie bei jedem Termin neu zu stellen.

   Ein Termin darf trotzdem seinen eigenen Ort haben -- ein Gespräch mit
   einer Agentur findet nun einmal woanders statt. Der eigene Ort
   gewinnt; dieser hier ist die Antwort, wenn keiner eingetragen wurde. */
callRouter.put("/workspace/api/call-link", gleicheHerkunft, (req, res) => {
  try {
    if (!istLeitung(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
    const roh = String(req.body?.link ?? "").trim();
    if (roh) {
      let u;
      try { u = new URL(roh); } catch { u = null; }
      /* Nur http(s). Ohne diese Prüfung liesse sich hier ein
         javascript:-Verweis hinterlegen, den anschliessend JEDER im Team
         mit einem Klick ausfuehrt -- der Link steht ja auf jeder
         Call-Karte. */
      if (!u || (u.protocol !== "https:" && u.protocol !== "http:")) {
        return res.status(400).json({ fehler: "Das ist keine gültige http(s)-Adresse." });
      }
      if (roh.length > 400) return res.status(400).json({ fehler: "Der Link ist zu lang." });
    }
    einstellungSetzen("call_link", roh, { ...req.person, ip: echteIp(req) });
    protokolliere("call_link_gesetzt", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: (roh || "geleert").slice(0, 120),
    });
    res.json({ ok: true, call_link: roh });
  } catch (fehler) {
    console.error("[workspace] Call-Link setzen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Protokoll löschen -------------------------------------------

   NUR DogFather (Wunsch 02.09.2026: "ich will auch dass ich die löschen
   kann. und nur ich kann die löschen sonst keiner").

   Bewusst istDogFather und nicht istLeitung: Ein Manager hat sonst
   überall dieselben Rechte, hier ausdrücklich nicht. Ein Protokoll ist
   die Gedächtnisstütze eines Gesprächs -- wer es entfernen darf, kann
   nachträglich bestimmen, was besprochen wurde.

   Gelöscht wird NUR das Protokoll, nicht das Gespräch. Der Termin bleibt
   im Kalender und erscheint danach wieder unter "Protokoll fehlt" -- die
   Handlung ist damit umkehrbar: neu schreiben, und alles ist wie vorher.

   Die daraus entstandenen AUFGABEN bleiben ebenfalls stehen. Sie sind
   echte Arbeit, die jemand übernommen hat; sie mit einem Klick auf ein
   Protokoll verschwinden zu lassen wäre ein stiller Datenverlust an
   einer ganz anderen Stelle. Die Verknüpfung fällt weg (ON DELETE
   CASCADE auf der Zwischentabelle), die Aufgaben selbst nicht. */
callRouter.delete("/workspace/api/calls/:id/protokoll", gleicheHerkunft, (req, res) => {
  try {
    if (!siehtAlles(req.person)) {
      return res.status(403).json({ fehler: "Nur DogFather darf ein Protokoll löschen." });
    }
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });

    /* Auch DogFather kommt nur an Gespräche, die er sehen darf -- die
       Sichtbarkeitsregel gilt hier wie überall. Bei ihm ist das "alles",
       aber die Abfrage steht trotzdem da: Ändert sich die Regel einmal,
       ändert sie sich hier mit. */
    const { wo, werte } = sichtbar(req.person);
    const call = db().prepare(
      `SELECT t.id, t.titel, pr.id AS protokoll_id
       FROM termine t LEFT JOIN protokolle pr ON pr.termin_id = t.id
       WHERE ${wo} AND t.id = ?`).get(...werte, id);
    if (!call) return res.status(404).json({ fehler: "nicht_gefunden" });
    if (!call.protokoll_id) return res.status(404).json({ fehler: "kein_protokoll" });

    db().prepare("DELETE FROM protokolle WHERE id = ?").run(call.protokoll_id);

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

callRouter.post("/workspace/api/calls/:id/protokoll", gleicheHerkunft, (req, res) => {
  const d = db();
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });

    const { wo, werte } = sichtbar(req.person);
    const termin = d.prepare(`
      SELECT t.id, t.titel, t.beginn, t.dauer_min, t.ort, t.art,
             t.creator_id, t.teilnehmer_id, pr.id AS protokoll_id
      FROM termine t LEFT JOIN protokolle pr ON pr.termin_id = t.id
      WHERE ${wo} AND t.id = ? AND t.art IN ('call','review')`).get(...werte, id);
    if (!termin) return res.status(404).json({ fehler: "nicht_gefunden" });

    const k = req.body || {};
    const punkte = String(k.punkte ?? "").trim().slice(0, TEXT_MAX) || null;
    const entscheidungen = String(k.entscheidungen ?? "").trim().slice(0, TEXT_MAX) || null;

    /* To-dos pruefen, BEVOR irgendetwas geschrieben wird. */
    const roh = Array.isArray(k.todos) ? k.todos : [];
    if (roh.length > TODOS_MAX) {
      return res.status(400).json({ fehler: `Höchstens ${TODOS_MAX} To-dos auf einmal.` });
    }
    const todos = [];
    for (const t of roh) {
      const titel = String(t?.titel ?? "").trim();
      if (!titel) continue;
      if (titel.length > TITEL_MAX) return res.status(400).json({ fehler: "Ein To-do ist zu lang." });
      const frist = String(t?.frist ?? "").trim();
      if (frist && (!/^\d{4}-\d{2}-\d{2}$/.test(frist) || Number.isNaN(Date.parse(frist)))) {
        return res.status(400).json({ fehler: "Frist eines To-dos ist ungültig." });
      }
      todos.push({ titel, frist: frist || null });
    }

    /* Nächster Termin, falls im Protokoll vereinbart. */
    const nb = String(k.naechster_beginn ?? "").trim();
    if (nb && !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/.test(nb)) {
      return res.status(400).json({ fehler: "Der nächste Termin hat kein gültiges Datum." });
    }
    let dauer = Number(k.naechster_dauer ?? termin.dauer_min ?? 30);
    if (!Number.isInteger(dauer) || dauer < 5 || dauer > 480) dauer = 30;

    if (!punkte && !entscheidungen && !todos.length) {
      return res.status(400).json({ fehler: "Ein leeres Protokoll hilft niemandem." });
    }

    /* Alles zusammen oder gar nicht -- sonst gaebe es Aufgaben ohne
       Protokoll oder umgekehrt. */
    let antwort;
    d.exec("BEGIN");
    try {
      let protokollId = termin.protokoll_id;
      if (protokollId) {
        d.prepare("UPDATE protokolle SET punkte = ?, entscheidungen = ?, geaendert = ? WHERE id = ?")
          .run(punkte, entscheidungen, jetzt(), protokollId);
      } else {
        protokollId = Number(d.prepare(`
          INSERT INTO protokolle (termin_id, punkte, entscheidungen, erstellt, erstellt_von)
          VALUES (?,?,?,?,?)`).run(id, punkte, entscheidungen, jetzt(), req.person.id).lastInsertRowid);
      }

      /* To-dos werden zu echten Aufgaben -- genau das ist der Punkt. */
      const neueAufgaben = [];
      for (const t of todos) {
        const a = Number(d.prepare(`
          INSERT INTO aufgaben
            (titel, beschreibung, status, prioritaet, creator_id, verantwortlich_id, frist, erstellt, erstellt_von)
          VALUES (?,?,'offen','mittel',?,?,?,?,?)`).run(
          t.titel, `Aus dem Gespräch „${termin.titel}"`,
          termin.creator_id, termin.teilnehmer_id ?? termin.creator_id,
          t.frist, jetzt(), req.person.id).lastInsertRowid);
        d.prepare("INSERT INTO protokoll_aufgaben (protokoll_id, aufgabe_id) VALUES (?,?)")
          .run(protokollId, a);
        neueAufgaben.push(a);
      }

      /* Nächster Termin als echter Kalendereintrag, mit demselben
         Gegenüber und demselben Meeting-Link. */
      let naechster = null;
      if (nb) {
        naechster = Number(d.prepare(`
          INSERT INTO termine
            (titel, beschreibung, art, beginn, dauer_min, ort, creator_id, teilnehmer_id, erstellt, erstellt_von, haus)
          VALUES (?,?,?,?,?,?,?,?,?,?,?)`).run(
          termin.titel, `Folgetermin zu „${termin.titel}"`, termin.art, nb, dauer,
          termin.ort, termin.creator_id, termin.teilnehmer_id, jetzt(), req.person.id,
          /* Ein Folgetermin erbt das Haus SEINES Vorgaengers und nicht
             das der Adresse: Wer ihn ansetzt, verlaengert etwas, das
             schon irgendwo wohnt. */
          termin.haus || req.person.haus || null).lastInsertRowid);
        d.prepare("UPDATE protokolle SET naechster_termin_id = ? WHERE id = ?").run(naechster, protokollId);
      }

      d.prepare("UPDATE termine SET erledigt = 1 WHERE id = ?").run(id);
      d.exec("COMMIT");
      antwort = { protokoll_id: protokollId, aufgaben: neueAufgaben.length, naechster_termin_id: naechster };
    } catch (fehler) {
      d.exec("ROLLBACK");
      throw fehler;
    }

    protokolliere("protokoll_geschrieben", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `Termin #${id}, ${antwort.aufgaben} To-do(s)`.slice(0, 120),
    });
    res.status(201).json(antwort);
  } catch (fehler) {
    console.error("[workspace] Protokoll schreiben:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});