dogfather-universe/server/workspace-notizen.js

/* =====================================================================
   DER NOTIZBLOCK — die Wege (26.09.2026)

   Die Regeln und ihre Begründung stehen im Kopf von
   notiz-tabellen.js. Hier sind die Routen — und die vier Stellen, an
   denen etwas schiefgehen kann:

   1. EINE NOTIZ DARF NIE BEIM FALSCHEN LANDEN. Jede Abfrage hat
      `person_id = ?` fest eingebaut. Es gibt keine Rolle, die mehr
      sieht, und deshalb auch keinen Zweig, der die Bedingung
      weglassen könnte. `blattFuer()` gibt den Datensatz zurück oder
      `null` — nie `true`/`false`. So kann keine Route erst „darf
      sehen" beantworten und danach trotzdem das falsche Blatt laden.

   2. NUR AUF DER TEAM-ADRESSE. Der Block gehört zum Haus von Team
      Dogi. Auf der Agenturadresse ist er ein 404 — auch für
      DogFather, der in beiden Häusern arbeitet. Das ist dieselbe
      Trennung wie bei Chat, Kalender und Aufgaben, und sie wird hier
      geprüft und nicht nur in der Rechtetafel: Die Tafel beantwortet,
      wer die SEITE öffnen darf, nicht von welcher Adresse aus.

   3. GESPEICHERT WIRD OHNE KNOPF. Die Oberfläche schickt beim Tippen
      alle 800 ms. Das ist viel Verkehr für wenig Inhalt — deshalb
      antwortet PATCH knapp (nur Zeitstempel), und es gibt eine
      Schreibbremse, die ein hängendes Skript stoppt, ohne einen
      schnell Tippenden zu treffen.

   4. ENDGÜLTIG IST ENDGÜLTIG. Löschen legt ins Papierkorbfach;
      erst das zweite Löschen entfernt wirklich, und nur von dort.
      Ein direkter Weg von „auf dem Block" zu „weg" existiert nicht.
   ===================================================================== */

import express from "express";
import { db, sitzungLesen, protokolliere, echteIp } from "./workspace.js";
import { PAPIERKORB_TAGE, TEXT_MAX, BLAETTER_MAX, FARBEN, FARB_NAMEN }
  from "./notiz-tabellen.js";

export const notizenRouter = express.Router();

/** Wer einen Block hat.
 *
 *  Genau die vier Rollen aus Filipes Satz. Die Liste steht hier UND
 *  in rechte.js, und das ist kein Versehen: Die Tafel bewacht die
 *  Seite, diese Menge die Daten. Wer nur die Tafel prüfte, hätte eine
 *  Schnittstelle, die jeder Angemeldete aufrufen kann — die Seite ist
 *  nur HTML, die Daten sind die Sache.
 *
 *  pruef-notizen hält beide gegeneinander und wird rot, wenn sie
 *  auseinanderlaufen. */
const MIT_BLOCK = new Set(["admin", "hand", "linke", "modi"]);

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

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

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

/** Team-Adresse und passende Rolle — sonst gibt es diese Seite nicht.
 *
 *  404 UND NICHT 403: Ein „verboten" verrät, dass es hier etwas gibt.
 *  Auf der Agenturadresse soll der Block nicht einmal als verschlossene
 *  Tür sichtbar sein. */
function nurTeamDogi(req, res, next) {
  if (req.person?.haus !== "crew") return res.status(404).json({ fehler: "nicht_gefunden" });
  if (!MIT_BLOCK.has(req.person?.rolle)) return res.status(404).json({ fehler: "nicht_gefunden" });
  next();
}

/* Schutz gegen Anfragen von fremden Seiten -- wortgleich zu den
   übrigen Modulen. Fehlt der Kopf ganz (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();
}

/* ==== DIE SCHREIBBREMSE ================================================

   Automatisches Speichern heißt: Bei jedem Tippen kann eine Anfrage
   kommen. Die Oberfläche wartet 800 ms Ruhe ab, ein schneller
   Schreiber löst also höchstens rund 75 Anfragen je Minute aus, und
   das auch nur, wenn er die ganze Minute durchtippt.

   DIE GRENZE IST DAS VIERFACHE DAVON. Sie steht nicht gegen den
   Menschen, sondern gegen ein Skript, das in einer Schleife hängt --
   und sie ist absichtlich so hoch, dass niemand sie im Alltag je
   sieht. Eine Bremse, die beim normalen Arbeiten greift, wird
   umgangen und ist ab da wirkungslos (siehe die Hausregel dazu).

   Im Speicher und nicht in der Datenbank: Ein Neustart setzt sie
   zurück, und das ist richtig -- sie schützt vor einem laufenden
   Fehler, nicht vor einem Angreifer mit Geduld. */
const SCHREIB_FENSTER_MS = 60_000;
const SCHREIB_MAX = 300;
const schreibZaehler = new Map();               // personId -> [Zeitpunkte]

function schreibBremse(req, res, next) {
  const id = req.person?.id;
  if (!id) return next();
  const jetztMs = Date.now();
  const liste = (schreibZaehler.get(id) || []).filter((t) => jetztMs - t < SCHREIB_FENSTER_MS);
  if (liste.length >= SCHREIB_MAX) {
    return res.status(429).json({
      fehler: "Zu viele Änderungen in kurzer Zeit. Warte einen Moment — "
        + "dein Text ist nicht verloren, er wird gleich erneut gesichert.",
    });
  }
  liste.push(jetztMs);
  schreibZaehler.set(id, liste);
  /* Damit die Karte nicht ewig wächst: Wer lange nichts geschrieben
     hat, fliegt beim nächsten Durchgang heraus. */
  if (schreibZaehler.size > 500) {
    for (const [k, v] of schreibZaehler) {
      if (!v.some((t) => jetztMs - t < SCHREIB_FENSTER_MS)) schreibZaehler.delete(k);
    }
  }
  next();
}

notizenRouter.use("/workspace/api/notizblock", angemeldet, nurTeamDogi);

/* ---------- Hilfen ------------------------------------------------------ */

/** Ein Blatt dieser Person — oder null.
 *
 *  Gibt den DATENSATZ zurück und nicht ein Ja/Nein: Eine Route, die
 *  erst fragt „darf ich?" und danach selbst lädt, kann die zweite
 *  Abfrage anders stellen als die erste. So kann sie es nicht. */
function blattFuer(person, id, { ausPapierkorb = false } = {}) {
  const n = Number(id);
  if (!Number.isInteger(n) || n <= 0) return null;
  const zeile = db().prepare("SELECT * FROM notizen WHERE id = ? AND person_id = ?")
    .get(n, person.id);
  if (!zeile) return null;
  if (ausPapierkorb ? !zeile.weg_am : zeile.weg_am) return null;
  return zeile;
}

/** Mehrzeiliger Text: Absätze bleiben, Leerzeilenwüsten nicht.
 *
 *  Kein `trim()` am Anfang jeder Zeile — Einrückung ist in einer
 *  Notiz Inhalt („  - Unterpunkt"). Entfernt werden nur Wagenrückläufe
 *  (damit die Länge überall dieselbe ist) und mehr als zwei leere
 *  Zeilen am Stück. */
function textSauber(s) {
  return String(s ?? "")
    .replace(/\r\n?/g, "\n")
    .replace(/\n{4,}/g, "\n\n\n")
    .slice(0, TEXT_MAX);
}

/** Die erste nicht leere Zeile, ohne ihre Auszeichnung.
 *
 *  Wird NUR für die Liste gebraucht (und für die Suche). Der Titel
 *  wird nicht gespeichert: Zwei Orte für dieselbe Sache laufen
 *  auseinander, sobald jemand die erste Zeile ändert und das Feld
 *  nicht. Hier wird er jedes Mal aus dem Text abgeleitet und ist
 *  damit immer der, der wirklich oben steht. */
function titelVon(text) {
  const zeile = String(text || "").split("\n").find((z) => z.trim().length) || "";
  return zeile
    .replace(/^\s*#{1,3}\s*/, "")
    .replace(/^\s*[-*]\s+/, "")
    .replace(/^\s*\[[ xX]\]\s*/, "")
    .trim()
    .slice(0, 120);
}

function nachDraussen(z) {
  return {
    id: z.id,
    text: z.text,
    titel: titelVon(z.text),
    farbe: z.farbe,
    angeheftet: !!z.angeheftet,
    erstellt: z.erstellt,
    geaendert: z.geaendert,
    weg_am: z.weg_am || null,
  };
}

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

/** Der Block: alle eigenen Blätter, angeheftete zuerst. */
notizenRouter.get("/workspace/api/notizblock", (req, res) => {
  try {
    const zeilen = db().prepare(`
      SELECT * FROM notizen
       WHERE person_id = ? AND weg_am IS NULL
       ORDER BY angeheftet DESC, geaendert DESC
       LIMIT ?`).all(req.person.id, BLAETTER_MAX);
    /* DIE ZAHL KOMMT AUS DER DATENBANK, nicht aus der Liste oben: Die
       ist bei BLAETTER_MAX abgeschnitten, und eine Zählung darauf
       wäre ab dem 301. Blatt still falsch. */
    const imKorb = db().prepare(`SELECT COUNT(*) AS n FROM notizen
       WHERE person_id = ? AND weg_am IS NOT NULL`).get(req.person.id).n;
    res.json({
      notizen: zeilen.map(nachDraussen),
      papierkorb: imKorb,
      text_max: TEXT_MAX,
      blaetter_max: BLAETTER_MAX,
      papierkorb_tage: PAPIERKORB_TAGE,
      farben: FARBEN,
    });
  } catch (fehler) {
    console.error("[notizen] Liste:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Was im Papierkorb liegt — mit dem Tag, an dem es von selbst geht. */
notizenRouter.get("/workspace/api/notizblock/papierkorb", (req, res) => {
  try {
    const zeilen = db().prepare(`
      SELECT * FROM notizen
       WHERE person_id = ? AND weg_am IS NOT NULL
       ORDER BY weg_am DESC LIMIT ?`).all(req.person.id, BLAETTER_MAX);
    res.json({
      notizen: zeilen.map((z) => ({
        ...nachDraussen(z),
        /* WANN ES WIRKLICH WEG IST -- gerechnet und nicht „in 30
           Tagen" geschrieben. Wer gestern geloescht hat, will wissen,
           wie viel Zeit er noch hat, und nicht, wie lang die Frist
           ist. */
        endgueltig_am: new Date(Date.parse(z.weg_am) + PAPIERKORB_TAGE * 86400000)
          .toISOString(),
      })),
      papierkorb_tage: PAPIERKORB_TAGE,
    });
  } catch (fehler) {
    console.error("[notizen] Papierkorb:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Schreiben ----------------------------------------------------- */

/** Ein neues Blatt. */
notizenRouter.post("/workspace/api/notizblock", gleicheHerkunft, schreibBremse,
  express.json({ limit: "256kb" }), (req, res) => {
    try {
      const offen = db().prepare(`SELECT COUNT(*) AS n FROM notizen
         WHERE person_id = ? AND weg_am IS NULL`).get(req.person.id).n;
      if (offen >= BLAETTER_MAX) {
        return res.status(429).json({
          fehler: `Dein Block hat ${BLAETTER_MAX} Blätter — mehr gehen nicht. `
            + "Räum ein paar in den Papierkorb, dann geht es weiter.",
        });
      }
      const text = textSauber(req.body?.text);
      const farbe = FARB_NAMEN.includes(req.body?.farbe) ? req.body.farbe : FARB_NAMEN[0];
      const n = jetzt();
      const { lastInsertRowid } = db().prepare(`
        INSERT INTO notizen (person_id, text, farbe, angeheftet, erstellt, geaendert)
        VALUES (?,?,?,0,?,?)`).run(req.person.id, text, farbe, n, n);
      const frisch = db().prepare("SELECT * FROM notizen WHERE id = ?").get(lastInsertRowid);
      res.status(201).json({ notiz: nachDraussen(frisch) });
    } catch (fehler) {
      console.error("[notizen] Anlegen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/** Ändern: Text, Farbe, angeheftet. Einzeln oder zusammen.
 *
 *  ANTWORTET KNAPP. Diese Route läuft beim Tippen alle 800 ms; das
 *  ganze Blatt zurückzuschicken wäre bei einer langen Notiz
 *  zwanzigtausend Zeichen je Tastendruckpause, für eine Information,
 *  die der Browser schon hat. Zurück kommt der Zeitstempel — das
 *  Einzige, was er NICHT weiß. */
notizenRouter.patch("/workspace/api/notizblock/:id(\\d+)", gleicheHerkunft, schreibBremse,
  express.json({ limit: "256kb" }), (req, res) => {
    try {
      const z = blattFuer(req.person, req.params.id);
      if (!z) return res.status(404).json({ fehler: "nicht_gefunden" });

      const felder = [], werte = [];
      if (req.body?.text !== undefined) {
        felder.push("text = ?"); werte.push(textSauber(req.body.text));
      }
      if (req.body?.farbe !== undefined) {
        if (!FARB_NAMEN.includes(req.body.farbe)) {
          return res.status(400).json({ fehler: "Diese Papierfarbe gibt es nicht." });
        }
        felder.push("farbe = ?"); werte.push(req.body.farbe);
      }
      if (req.body?.angeheftet !== undefined) {
        felder.push("angeheftet = ?"); werte.push(req.body.angeheftet ? 1 : 0);
      }
      if (!felder.length) return res.status(400).json({ fehler: "Nichts zu ändern." });

      const n = jetzt();
      felder.push("geaendert = ?"); werte.push(n);
      werte.push(z.id, req.person.id);
      db().prepare(`UPDATE notizen SET ${felder.join(", ")}
         WHERE id = ? AND person_id = ?`).run(...werte);
      res.json({ geaendert: n });
    } catch (fehler) {
      console.error("[notizen] Aendern:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/** In den Papierkorb. */
notizenRouter.delete("/workspace/api/notizblock/:id(\\d+)", gleicheHerkunft, schreibBremse,
  (req, res) => {
    try {
      const z = blattFuer(req.person, req.params.id);
      if (!z) return res.status(404).json({ fehler: "nicht_gefunden" });
      const n = jetzt();
      db().prepare("UPDATE notizen SET weg_am = ?, angeheftet = 0 WHERE id = ? AND person_id = ?")
        .run(n, z.id, req.person.id);
      res.json({ weg_am: n, papierkorb_tage: PAPIERKORB_TAGE });
    } catch (fehler) {
      console.error("[notizen] Wegtun:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/** Wieder heraus. */
notizenRouter.post("/workspace/api/notizblock/:id(\\d+)/zurueck", gleicheHerkunft, schreibBremse,
  (req, res) => {
    try {
      const z = blattFuer(req.person, req.params.id, { ausPapierkorb: true });
      if (!z) return res.status(404).json({ fehler: "nicht_gefunden" });
      const offen = db().prepare(`SELECT COUNT(*) AS n FROM notizen
         WHERE person_id = ? AND weg_am IS NULL`).get(req.person.id).n;
      if (offen >= BLAETTER_MAX) {
        return res.status(429).json({
          fehler: `Dein Block ist voll (${BLAETTER_MAX} Blätter). `
            + "Tu erst eines weg, dann kommt dieses zurück.",
        });
      }
      db().prepare("UPDATE notizen SET weg_am = NULL, geaendert = ? WHERE id = ? AND person_id = ?")
        .run(jetzt(), z.id, req.person.id);
      const frisch = db().prepare("SELECT * FROM notizen WHERE id = ?").get(z.id);
      res.json({ notiz: nachDraussen(frisch) });
    } catch (fehler) {
      console.error("[notizen] Zurueck:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/** Endgültig — und nur aus dem Papierkorb.
 *
 *  Es gibt keinen Weg von „auf dem Block" direkt zu „weg". Wer
 *  danebentippt, landet im Papierkorb; erst wer dort noch einmal
 *  drückt, meint es. */
notizenRouter.delete("/workspace/api/notizblock/:id(\\d+)/endgueltig", gleicheHerkunft,
  schreibBremse, (req, res) => {
    try {
      const z = blattFuer(req.person, req.params.id, { ausPapierkorb: true });
      if (!z) return res.status(404).json({ fehler: "nicht_gefunden" });
      db().prepare("DELETE FROM notizen WHERE id = ? AND person_id = ?")
        .run(z.id, req.person.id);
      /* PROTOKOLLIERT WIRD NUR DAS UNWIDERRUFLICHE -- und ohne eine
         Silbe des Inhalts. Jede Textänderung zu protokollieren würde
         aus einem privaten Block eine Aktivitätsspur machen, die
         andere lesen können; genau das soll er nicht sein. Dass etwas
         endgültig verschwunden ist, gehört dagegen in die Ablage:
         Sonst sucht jemand eines Tages eine Zeile, die niemand
         vermisst hat. */
      protokolliere("notiz_endgueltig_weg", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${z.id}`,
      });
      res.json({ weg: true });
    } catch (fehler) {
      console.error("[notizen] Endgueltig:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* =====================================================================
   AUFRAEUMEN

   Wird aus der Aufbewahrungsliste gerufen (workspace-aufbewahrung.js)
   und nirgends sonst. Das ist die einzige Stelle im Haus, die
   wirklich räumt — eine Frist ohne Eintrag dort ist kein Versprechen,
   sondern ein Satz in einem Kommentar.
   ===================================================================== */
export function notizenAufraeumen() {
  const grenze = new Date(Date.now() - PAPIERKORB_TAGE * 86400000).toISOString();
  const weg = db().prepare("DELETE FROM notizen WHERE weg_am IS NOT NULL AND weg_am < ?")
    .run(grenze);
  return Number(weg?.changes || 0);
}

/* Für die Prüfung: dieselbe Menge, die `nurTeamDogi` benutzt. Sie
   wird exportiert, damit pruef-notizen sie gegen die Rechtetafel
   halten kann, statt sie abzuschreiben. */
export const ROLLEN_MIT_BLOCK = MIT_BLOCK;