dogfather-universe/server/workspace-material.js

/* =====================================================================
   MATERIAL — was das Team bereitstellt und die Community postet
   =====================================================================

   Auftrag vom 22.09.2026:

     *"ich brauch auch noch eine neue kachel im bereich community, wo
     wir als team also, dogfather, rechte hand, linke hand und modis
     bilder reinschicken können, mit text und wo die leute sei es
     community oder modis sich die bilder nehmen können zum posten.
     die community soll keine posten können in die kategorie, die
     sollen die runterladen können um die auf tiktok oder insta zu
     posten. sobald ein bild oder ein video was von uns gepostet
     wurde, runtergeladen wurde, soll direkt blockiert werden so dass
     man es nicht mehr runterladen kann, es soll direkt markiert
     werden als schon benutz, damit nie ein bild zwei mal gepostet
     wird ... und die rechte hand und dogfather, nur die beiden sollen
     auch immer sehen können wer das bild oder video runtergeladen
     hat."*

   ---------------------------------------------------------------------
   DER KERN IST DIE EINMALIGKEIT, und sie ist der Grund, warum das
   Nehmen und das Herunterladen ZWEI Schritte sind:

     "nehmen"   schreibt in EINER Abfrage fest, wer es hat -- mit der
                Bedingung `genommen_von IS NULL`. Wer zu spaet kommt,
                aendert null Zeilen und bekommt 409. Zwei Menschen
                koennen dasselbe Bild damit nicht gleichzeitig holen,
                auch wenn sie im selben Augenblick tippen.
     "datei"    liefert erst danach aus, und nur an den, der es
                genommen hat.

   Ein einziger Schritt ("laden und dabei markieren") haette dieselbe
   Luecke wie ein Pool ohne Sperre: Zwei Anfragen, beide sehen "frei",
   beide laden. Genau dieser Fall ist am 21.09. beim Aufgaben-Pool
   schon einmal gebaut und gemessen worden.

   ---------------------------------------------------------------------
   WER WAS DARF -- und warum nicht mehr:

     einstellen   Team Dogi: DogFather, rechte und linke Hand, Modis.
                  Die Community NICHT -- Filipe ausdruecklich.
     nehmen       alle, die den Treff sehen (also auch die Community).
     wer hat es   NUR DogFather und die rechte Hand. Nicht die linke,
                  nicht die Modis -- wer etwas genommen hat, soll sich
                  nicht beobachtet fuehlen.
     loeschen     wer es eingestellt hat, plus DogFather.

   ---------------------------------------------------------------------
   WAS AUSDRUECKLICH NICHT GEHT: ein genommenes Stueck wieder
   freigeben. Das waere der Weg, ueber den doch etwas zweimal
   gepostet wird -- und genau das soll nicht passieren. Wer sich
   vertan hat, sagt es; DogFather stellt es neu ein. Ein Klick, der
   eine Zusage zuruecknimmt, ist hier gefaehrlicher als ein Umweg.
   ===================================================================== */

import express from "express";
import { join, extname } from "node:path";
import { mkdirSync, writeFileSync, createReadStream, unlinkSync, statSync } from "node:fs";
import { randomBytes } from "node:crypto";
import {
  db, protokolliere, echteIp, sitzungLesen, DATEN_ORDNER,
  istDogFather, TEAM_DOGI_ROLLEN, TREFF_ROLLEN,
} from "./workspace.js";
/* DIE UHR DES HAUSES, nicht `new Date().toISOString().slice(0,10)`.
   Das waere UTC -- zwischen Mitternacht und zwei Uhr laege der Tag
   damit einen zurueck, und ein Stueck, das heute anfaengt, staende
   noch als "spaeter" da. */
import { tagLokal } from "./helfer-zeit.mjs";

export const materialRouter = express.Router();

const ORDNER = join(DATEN_ORDNER, "material");
const MAX_BYTES = 60 * 1024 * 1024;     /* 60 MB -- ein kurzes Video passt. */
const TEXT_MAX = 600;
const NAME_MAX = 160;

/* Was wir annehmen. Absichtlich eine kurze Liste: Alles, was ein
   Browser nicht von selbst als Bild oder Video anzeigt, ist hier
   entweder ein Versehen oder ein Versuch. */
const ARTEN = {
  "image/jpeg": "bild", "image/png": "bild", "image/webp": "bild",
  "image/gif": "bild", "image/avif": "bild",
  "video/mp4": "video", "video/quicktime": "video", "video/webm": "video",
};

/* ---------------------------------------------------------------------
   DIE ABLAGE
   --------------------------------------------------------------------- */
let bereit = false;
function tabellen() {
  if (bereit) return;
  const d = db();
  d.exec(`
    CREATE TABLE IF NOT EXISTS material (
      id            INTEGER PRIMARY KEY AUTOINCREMENT,
      datei         TEXT NOT NULL,
      dateiname     TEXT NOT NULL,
      typ           TEXT NOT NULL,
      art           TEXT NOT NULL CHECK (art IN ('bild','video')),
      groesse       INTEGER NOT NULL DEFAULT 0,
      text          TEXT NOT NULL DEFAULT '',
      von_id        INTEGER REFERENCES personen(id) ON DELETE SET NULL,
      erstellt      TEXT NOT NULL,
      genommen_von  INTEGER REFERENCES personen(id) ON DELETE SET NULL,
      genommen_am   TEXT
    );
    CREATE INDEX IF NOT EXISTS idx_material_frei
      ON material (genommen_von, erstellt);
  `);

  /* VON WANN BIS WANN (22.09.2026).
     ===================================================================
     Filipe: "welche sind benutzt welche nicht welche sind noch offen,
     welche laufen von wan bis wann, das muss man auch machen koennen."

     Ein Bild zur Halloween-Aktion ist am 2. November kein Angebot mehr,
     sondern ein Stolperstein. Ohne Fenster bleibt es bis in alle
     Ewigkeit in der Liste, und irgendwann postet es jemand.

     BEIDE FELDER SIND FREIWILLIG. Der haeufigste Fall ist "gilt
     einfach" -- ein Pflichtfeld erzwaenge hier ein erfundenes Datum,
     und ein erfundenes Datum ist schlechter als keins.

     ERGAENZT STATT ANGENOMMEN: Die Tabelle steht auf echten Rechnern
     schon mit Daten. `ALTER TABLE` waere beim zweiten Start ein
     Fehler, ein neues CREATE wuerde die vorhandenen Zeilen nicht
     erreichen. Also nachsehen, was da ist, und nur ergaenzen, was
     fehlt -- dieselbe Bauart wie bei den Personen-Spalten. */
  /* ==== DAS HAUS GEHOERT IN DIESE LISTE, NICHT IN DIE ANDERE ======

     (25.09.2026.) Beim Bau der Haustrennung habe ich `["material",
     "haus", "TEXT"]` in die Spaltenliste von `workspace.js` gesetzt --
     dort stehen die anderen sieben Wurzeltabellen. `material` ist die
     einzige, die NICHT dort angelegt wird, sondern hier.

     Auf der echten Datenbank fiel das nicht auf: Die Tabelle gab es
     laengst, also hat `ALTER TABLE` gegriffen. Auf einer FRISCHEN
     Datenbank lief die Liste in workspace.js dagegen, bevor es die
     Tabelle gab -- sie wird dort uebersprungen --, und danach legte
     diese Datei sie ohne `haus` an. Ergebnis: 78 Fehlschlaege mit
     "table material has no column named haus", und zwar erst beim
     SCHREIBEN, nicht beim Starten.

     Gefunden hat das keine Ueberlegung, sondern `pruef-material`, weil
     sie mit einer frischen Datenbank arbeitet. Dieselbe Falle wie
     ueberall in diesem Haus: eine Liste an zwei Orten. */
  const NOETIG = [["gilt_ab", "TEXT"], ["gilt_bis", "TEXT"], ["haus", "TEXT"]];
  const da = new Set(d.prepare("PRAGMA table_info(material)").all().map((c) => c.name));
  for (const [spalte, form] of NOETIG) {
    if (da.has(spalte)) continue;
    try {
      d.exec(`ALTER TABLE material ADD COLUMN ${spalte} ${form}`);
      console.log(`[material] Spalte '${spalte}' ergaenzt.`);
    } catch (f) { console.error(`[material] Spalte '${spalte}':`, f?.message); }
  }

  /* NACHSEHEN, OB ES AUCH GEKLAPPT HAT -- und das ist keine Formalie.
     Im ersten Entwurf stand `bereit = true` UNBEDINGT hinter der
     Schleife, und das `catch` darueber schluckte den Fehler. Ein
     einziger misslungener Versuch (Datei gesperrt, Platte voll) haette
     die Umstellung damit fuer immer als erledigt vermerkt. Danach
     scheitert JEDE Liste an `SELECT ... m.gilt_ab` -- fuer alle, mit
     einem 503 und der Meldung "gerade nicht verfuegbar", die nirgends
     sagt, woran es liegt.

     Jetzt wird nachgezaehlt, der Vermerk nur bei Erfolg gesetzt (der
     naechste Aufruf versucht es also wieder), und der Fehler
     geworfen statt notiert: Ein Aufruf, der mit einer klaren Meldung
     scheitert, ist besser als hundert, die raetseln. */
  const jetzt = new Set(d.prepare("PRAGMA table_info(material)").all().map((c) => c.name));
  const fehlend = NOETIG.map(([n]) => n).filter((n) => !jetzt.has(n));
  if (fehlend.length) {
    throw new Error(`[material] Umstellung unvollstaendig, es fehlt: ${fehlend.join(", ")}`
      + " -- die Liste kann ohne diese Spalten nicht gelesen werden.");
  }
  bereit = true;
}

/* ---------------------------------------------------------------------
   IN WELCHEM ZUSTAND IST EIN STUECK?
   ---------------------------------------------------------------------
   Filipe will die Liste nach Zustand sortieren koennen. Der Zustand
   wird GERECHNET und nicht gespeichert: Eine Spalte "zustand" muesste
   jemand taeglich nachfuehren, und am Tag, an dem das vergessen wird,
   steht "laeuft" an etwas, das seit drei Wochen abgelaufen ist.

   Vier Zustaende, und die Reihenfolge der Fragen entscheidet:
     benutzt    -- jemand hat es genommen. Schlaegt alles andere; ein
                   vergebenes Stueck ist weg, auch wenn sein Fenster
                   noch laeuft.
     spaeter    -- das Fenster faengt erst an.
     abgelaufen -- das Fenster ist vorbei.
     frei       -- alles andere. Auch alles ohne Fenster: "kein Datum"
                   heisst "gilt", nicht "gilt nicht".
   --------------------------------------------------------------------- */
export function zustandVon(z, heute) {
  if (z.genommen_von) return "benutzt";
  if (z.gilt_ab && z.gilt_ab > heute) return "spaeter";
  if (z.gilt_bis && z.gilt_bis < heute) return "abgelaufen";
  return "frei";
}

/** Ein Datum im Format JJJJ-MM-TT -- oder null. Nichts dazwischen. */
function datumOderNull(roh) {
  const t = String(roh ?? "").trim();
  if (!t) return null;
  if (!/^\d{4}-\d{2}-\d{2}$/.test(t)) return undefined;   /* undefined = ungueltig */
  const d = new Date(`${t}T12:00:00Z`);
  return Number.isNaN(d.getTime()) ? undefined : t;
}

/* ---------------------------------------------------------------------
   WER DARF WAS
   ---------------------------------------------------------------------

   ABGELEITET, NICHT ABGESCHRIEBEN: `TEAM_DOGI_ROLLEN` und
   `TREFF_ROLLEN` stehen in workspace.js und entscheiden dort schon,
   wer zum Team und wer zum Treff gehoert. Eine eigene Liste hier
   waere die, die beim naechsten neuen Rollennamen vergessen wird. */

/** Wer Material einstellen darf: das Team, nicht die Community. */
export const darfMaterialEinstellen = (person) =>
  !!person && (istDogFather(person) || TEAM_DOGI_ROLLEN.has(person.rolle));

/** Wer sich etwas nehmen darf: jeder, der den Treff sieht. */
export const darfMaterialNehmen = (person) =>
  !!person && TREFF_ROLLEN.has(person.rolle);

/** Wer sehen darf, WER sich etwas genommen hat. Nur diese zwei. */
export const siehtWerGenommenHat = (person) =>
  !!person && (istDogFather(person) || person.rolle === "hand");

/* WER FREMDES BEARBEITEN UND ENTFERNEN DARF (22.09.2026).
   ---------------------------------------------------------------------
   Filipe: "wenn wir in der kategorie material was hochladen will ich
   dass die rechte und linke hand es auch bearbeiten und loeschen
   koennen. dogfather auch fals es ein fehler gab."

   Bis heute kam nur der Einsteller selbst und DogFather an ein Stueck.
   Wer einen Tippfehler im Text hatte oder das falsche Bild erwischte,
   musste warten, bis jemand anders Zeit hat -- und in der Zwischenzeit
   steht das Falsche da, wo die Community sich bedient.

   NICHT ueber `darfMaterialEinstellen`: Dort stehen auch die Modis
   drin, und die sollen ihr eigenes Stueck zuruecknehmen koennen, aber
   nicht das von jemand anderem. Wer fremdes anfasst, ist die Leitung. */
export const darfFremdesVerwalten = (person) =>
  !!person && (istDogFather(person)
    || person.rolle === "hand" || person.rolle === "linke");

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  /* 404 UND NICHT 403: Wer "kein Zugriff" liest, weiss, dass es hier
     etwas gibt. Dieselbe Regel wie ueberall im Haus. */
  if (!darfMaterialNehmen(person)) return res.status(404).json({ fehler: "nicht_gefunden" });
  req.person = person;
  tabellen();
  next();
}

materialRouter.use("/workspace/api/material", angemeldet);

/* ---------------------------------------------------------------------
   DIE LISTE
   --------------------------------------------------------------------- */
materialRouter.get("/workspace/api/material", (req, res) => {
  try {
    const zeigtNamen = siehtWerGenommenHat(req.person);
    const reihen = db().prepare(`
      SELECT m.id, m.dateiname, m.art, m.groesse, m.text, m.erstellt,
             m.genommen_am, m.genommen_von, m.von_id, m.gilt_ab, m.gilt_bis,
             v.name AS von_name,
             g.name AS genommen_name
        FROM material m
        LEFT JOIN personen v ON v.id = m.von_id
        LEFT JOIN personen g ON g.id = m.genommen_von
       ORDER BY (m.genommen_von IS NOT NULL), m.erstellt DESC
    `).all();

    /* HEUTE WIRD EINMAL GERECHNET, NICHT JE ZEILE. Sonst koennte eine
       Liste, die ueber Mitternacht gelesen wird, zwei verschiedene
       Tage benutzen -- und ein Stueck waere in derselben Antwort
       gleichzeitig "laeuft" und "abgelaufen". */
    const heute = tagLokal(0);

    res.json({
      darf_einstellen: darfMaterialEinstellen(req.person),
      darf_verwalten: darfFremdesVerwalten(req.person),
      sieht_wer: zeigtNamen,
      heute,
      max_bytes: MAX_BYTES,
      material: reihen.map((z) => ({
        id: z.id,
        name: z.dateiname,
        art: z.art,
        groesse: z.groesse,
        text: z.text,
        von: z.von_name || "Jemand",
        erstellt: z.erstellt,
        genommen: !!z.genommen_von,
        /* WER ES GENOMMEN HAT, STEHT NUR FUER ZWEI DRIN. Fuer alle
           anderen fehlt das Feld ganz -- nicht `null`: Ein Feld, das
           da ist und leer bleibt, laedt dazu ein, es spaeter "zu
           fuellen". */
        ...(zeigtNamen && z.genommen_von
          ? { genommen_von: z.genommen_name || "Jemand", genommen_am: z.genommen_am }
          : {}),
        /* Und jeder sieht, ob ER es war -- sonst wuesste er nicht mehr,
           was er selbst schon geholt hat. */
        von_mir_genommen: z.genommen_von === req.person.id,
        gilt_ab: z.gilt_ab || null,
        gilt_bis: z.gilt_bis || null,
        zustand: zustandVon(z, heute),
        /* DARF ICH DIESES STUECK ANFASSEN? Die Antwort steht beim
           Stueck und wird nicht in der Oberflaeche nachgerechnet --
           zwei Rechnungen fuer dieselbe Frage laufen auseinander, und
           die im Browser ist die, der man nicht trauen darf. */
        darf_ich: z.von_id === req.person.id || darfFremdesVerwalten(req.person),
      })),
    });
  } catch (f) {
    console.error("[material] Liste:", f?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------------------------------------------------------------------
   EINSTELLEN
   ---------------------------------------------------------------------

   Die Datei kommt roh im Rumpf, Name und Text in Kopfzeilen -- genau
   wie in workspace-dateien.js. Kein Formularparser, keine neue
   Abhaengigkeit. */
materialRouter.post(
  "/workspace/api/material",
  (req, res, next) => {
    /* STEHT VOR express.raw: Wer nicht einstellen darf, soll nicht
       erst 60 MB hochladen duerfen, um dann eine Absage zu bekommen. */
    if (!darfMaterialEinstellen(req.person)) {
      return res.status(403).json({ fehler: "nur_team_stellt_ein" });
    }
    next();
  },
  express.raw({ type: "*/*", limit: MAX_BYTES }),
  (req, res) => {
    try {
      if (!req.body || !req.body.length) {
        return res.status(400).json({ fehler: "datei_fehlt" });
      }
      const typ = String(req.get("content-type") || "").split(";")[0].trim().toLowerCase();
      const art = ARTEN[typ];
      if (!art) return res.status(400).json({ fehler: "art_nicht_erlaubt" });

      let name = "";
      try { name = decodeURIComponent(req.get("x-datei-name") || ""); } catch { name = ""; }
      name = name.replace(/[\u0000-\u001f\u007f]/g, "").trim().slice(0, NAME_MAX)
        || (art === "bild" ? "Bild" : "Video");

      let text = "";
      try { text = decodeURIComponent(req.get("x-text") || ""); } catch { text = ""; }
      text = text.replace(/[\u0000-\u001f\u007f]/g, "").trim().slice(0, TEXT_MAX);

      mkdirSync(ORDNER, { recursive: true });
      const endung = (extname(name).match(/^\.[A-Za-z0-9]{1,8}$/) || [""])[0].toLowerCase();
      const datei = `${Date.now().toString(36)}-${randomBytes(8).toString("hex")}${endung}`;
      writeFileSync(join(ORDNER, datei), req.body, { flag: "wx" });

      /* DAS FENSTER KOMMT WIE NAME UND TEXT IN KOPFZEILEN.
         Derselbe Weg wie alles andere an diesem Aufruf -- die Datei
         liegt roh im Rumpf, also ist fuer Angaben nur der Kopf uebrig.
         Ein zweiter Aufruf danach waere ein zweiter Weg, der beim
         Abbrechen ein halbes Stueck hinterliesse. */
      const ab = datumOderNull(req.get("x-gilt-ab"));
      const bis = datumOderNull(req.get("x-gilt-bis"));
      if (ab === undefined || bis === undefined) {
        return res.status(400).json({ fehler: "datum_unbrauchbar" });
      }
      /* EIN FENSTER, DAS RUECKWAERTS LAEUFT, IST KEINS. Es waere in
         jedem Zustand gleichzeitig "spaeter" und "abgelaufen" -- und
         die Liste zeigte dann, was die Reihenfolge der Fragen
         zufaellig ergibt, statt was jemand gemeint hat. */
      if (ab && bis && ab > bis) {
        return res.status(400).json({ fehler: "fenster_verkehrt" });
      }

      const { lastInsertRowid } = db().prepare(`
        INSERT INTO material (datei, dateiname, typ, art, groesse, text, von_id, erstellt,
                              gilt_ab, gilt_bis, haus)
        VALUES (?,?,?,?,?,?,?,?,?,?,?)
      `).run(datei, name, typ, art, req.body.length, text, req.person.id,
        new Date().toISOString(), ab, bis,
        /* AM MATERIAL HAENGT NUR `von_id` -- ist das DogFather, gibt es
           sonst keinen Beleg. Genau deshalb steht das Haus hier. */
        req.person.haus || null);

      protokolliere("material_eingestellt", {
        personId: req.person.id,
        detail: `${art} "${name}" (${req.body.length} Bytes)`,
        ip: echteIp(req),
      });
      res.status(201).json({ id: Number(lastInsertRowid) });
    } catch (f) {
      console.error("[material] Einstellen:", f?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  },
);

/* ---------------------------------------------------------------------
   NEHMEN — der Schritt, der es einmalig macht
   --------------------------------------------------------------------- */
materialRouter.post("/workspace/api/material/:id/nehmen", (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "gibt_es_nicht" });

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

    /* EINE ABFRAGE ENTSCHEIDET. `genommen_von IS NULL` in der
       Bedingung heisst: Wer zu spaet kommt, aendert null Zeilen. Zwei
       Menschen koennen dasselbe Stueck damit nicht gleichzeitig
       holen, auch wenn sie im selben Augenblick tippen. */
    const wirkung = db().prepare(`
      UPDATE material SET genommen_von = ?, genommen_am = ?
       WHERE id = ? AND genommen_von IS NULL
    `).run(req.person.id, new Date().toISOString(), id);

    if (!wirkung.changes) {
      const wer = siehtWerGenommenHat(req.person)
        ? db().prepare(`SELECT p.name FROM material m
                          LEFT JOIN personen p ON p.id = m.genommen_von
                         WHERE m.id = ?`).get(id)?.name
        : null;
      return res.status(409).json({
        fehler: "schon_genommen",
        ...(wer ? { wer } : {}),
      });
    }

    protokolliere("material_genommen", {
      personId: req.person.id,
      detail: `Dogi-Media ${id}`,
      ip: echteIp(req),
    });
    res.json({ ok: true, weg: `/workspace/api/material/${id}/datei` });
  } catch (f) {
    console.error("[material] Nehmen:", f?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------------------------------------------------------------------
   DIE VORSCHAU — jeder darf SEHEN, was frei ist
   ---------------------------------------------------------------------

   Ohne sie muesste man blind entscheiden: Ein Dateiname sagt nicht, ob
   ein Bild zum eigenen Kanal passt. Und wer blind nimmt, verbrennt ein
   Stueck, das jemand anders gut gebrauchen koennte -- bei genau einem
   Versuch je Bild waere das teuer.

   SIE GILT NUR FUER FREIES MATERIAL. Was vergeben ist, wird nicht mehr
   ausgeliefert -- sonst waere die Vorschau der Weg, ein Bild doch noch
   zu bekommen (Rechtsklick, speichern), und die ganze Einmaligkeit
   waere eine Behauptung.

   AUSNAHME: Wer es selbst genommen hat, sieht es weiter -- sonst
   haette er nach dem Laden ein leeres Feld vor sich und wuesste nicht
   mehr, was er geholt hat. */
materialRouter.get("/workspace/api/material/:id/vorschau", (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(404).end();
    const z = db().prepare("SELECT * FROM material WHERE id = ?").get(id);
    if (!z) return res.status(404).end();
    if (z.genommen_von && z.genommen_von !== req.person.id
        && !istDogFather(req.person)) {
      return res.status(403).end();
    }
    const pfad = join(ORDNER, z.datei);
    try { statSync(pfad); } catch { return res.status(410).end(); }
    res.setHeader("Content-Type", z.typ);
    /* KURZ ZWISCHENSPEICHERN, ABER PRIVAT: Wer die Liste zweimal
       oeffnet, soll die Bilder nicht zweimal laden -- aber sie duerfen
       nie in einem gemeinsamen Zwischenspeicher landen. */
    res.setHeader("Cache-Control", "private, max-age=300");
    createReadStream(pfad).pipe(res);
  } catch (f) {
    console.error("[material] Vorschau:", f?.message);
    res.status(503).end();
  }
});

/* ---------------------------------------------------------------------
   DIE DATEI — nur an den, der sie genommen hat
   --------------------------------------------------------------------- */
materialRouter.get("/workspace/api/material/:id/datei", (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(404).json({ fehler: "nicht_gefunden" });
    const z = db().prepare("SELECT * FROM material WHERE id = ?").get(id);
    if (!z) return res.status(404).json({ fehler: "nicht_gefunden" });

    /* WER SIE BEKOMMT: der, der sie genommen hat -- und DogFather, der
       nachsehen koennen muss, was er verteilt hat. Sonst niemand;
       auch nicht, wer sie eingestellt hat, denn dann waere die Sperre
       ueber den Umweg "ich stelle es selbst ein" offen. */
    const meins = z.genommen_von === req.person.id;
    if (!meins && !istDogFather(req.person)) {
      return res.status(403).json({ fehler: "nicht_genommen" });
    }

    const pfad = join(ORDNER, z.datei);
    try { statSync(pfad); } catch { return res.status(410).json({ fehler: "datei_weg" }); }

    res.setHeader("Content-Type", z.typ);
    res.setHeader("Content-Disposition",
      `attachment; filename*=UTF-8''${encodeURIComponent(z.dateiname)}`);
    res.setHeader("Cache-Control", "private, no-store");
    createReadStream(pfad).pipe(res);
  } catch (f) {
    console.error("[material] Datei:", f?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------------------------------------------------------------------
   WEGNEHMEN
   --------------------------------------------------------------------- */
/* ---------------------------------------------------------------------
   BEARBEITEN (22.09.2026)
   ---------------------------------------------------------------------
   Filipe: "will ich dass die rechte und linke hand es auch bearbeiten
   und loeschen koennen. dogfather auch fals es ein fehler gab."

   GEAENDERT WERDEN TEXT UND FENSTER -- die DATEI nicht. Wer ein
   anderes Bild will, stellt ein anderes Stueck ein: Sonst zeigte die
   Liste nach der Aenderung etwas anderes als das, was jemand sich
   gerade angesehen hat, unter derselben Nummer.

   EIN VERGEBENES STUECK BLEIBT, WIE ES IST. Wer es genommen hat, hat
   sich auf diesen Text und dieses Fenster verlassen; es hinterher zu
   aendern hiesse, die Absprache nachtraeglich umzuschreiben.
   --------------------------------------------------------------------- */
materialRouter.patch("/workspace/api/material/:id", express.json({ limit: "32kb" }),
  (req, res) => {
    try {
      const id = Number(req.params.id);
      const z = db().prepare("SELECT * FROM material WHERE id = ?").get(id);
      if (!z) return res.status(404).json({ fehler: "nicht_gefunden" });
      if (z.von_id !== req.person.id && !darfFremdesVerwalten(req.person)) {
        return res.status(403).json({ fehler: "nicht_deins" });
      }
      /* EIGENER CODE, NICHT `schon_vergeben`: Der ist im Haus schon
         vergeben -- fuer Aufgaben ("die Aufgabe ist schon uebernommen").
         Ein Code, der zwei Dinge bedeutet, zeigt frueher oder spaeter
         an einer der beiden Stellen den falschen Satz an. */
      if (z.genommen_von) return res.status(409).json({ fehler: "schon_im_umlauf" });

      const text = String(req.body?.text ?? z.text ?? "").trim().slice(0, 600);
      const ab = req.body?.gilt_ab === undefined
        ? z.gilt_ab : datumOderNull(req.body.gilt_ab);
      const bis = req.body?.gilt_bis === undefined
        ? z.gilt_bis : datumOderNull(req.body.gilt_bis);
      if (ab === undefined || bis === undefined) {
        return res.status(400).json({ fehler: "datum_unbrauchbar" });
      }
      if (ab && bis && ab > bis) {
        return res.status(400).json({ fehler: "fenster_verkehrt" });
      }

      db().prepare("UPDATE material SET text = ?, gilt_ab = ?, gilt_bis = ? WHERE id = ?")
        .run(text, ab, bis, id);
      protokolliere("material_geaendert", {
        personId: req.person.id,
        detail: `Dogi-Media ${id}`,
        ip: echteIp(req),
      });
      res.json({ ok: true, id, text, gilt_ab: ab, gilt_bis: bis,
        zustand: zustandVon({ ...z, gilt_ab: ab, gilt_bis: bis }, tagLokal(0)) });
    } catch (f) {
      console.error("[material] Aendern:", f?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

materialRouter.delete("/workspace/api/material/:id", (req, res) => {
  try {
    const id = Number(req.params.id);
    const z = db().prepare("SELECT * FROM material WHERE id = ?").get(id);
    if (!z) return res.status(404).json({ fehler: "nicht_gefunden" });
    /* ERWEITERT AM 22.09.2026: auch rechte und linke Hand.
       Vorher kam nur der Einsteller und DogFather an ein Stueck. Wer
       das falsche Bild erwischt hatte, musste warten -- und bis dahin
       stand das Falsche dort, wo die Community sich bedient. */
    if (z.von_id !== req.person.id && !darfFremdesVerwalten(req.person)) {
      return res.status(403).json({ fehler: "nicht_deins" });
    }
    db().prepare("DELETE FROM material WHERE id = ?").run(id);
    try { unlinkSync(join(ORDNER, z.datei)); } catch { /* schon weg */ }
    protokolliere("material_entfernt", {
      personId: req.person.id,
      detail: `Dogi-Media ${id}`,
      ip: echteIp(req),
    });
    res.json({ ok: true });
  } catch (f) {
    console.error("[material] Entfernen:", f?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* Fehler aus express.raw -- eine zu grosse Datei ist kein Absturz. */
materialRouter.use("/workspace/api/material", (fehler, req, res, next) => {
  if (fehler?.type === "entity.too.large") {
    return res.status(413).json({ fehler: "datei_zu_gross" });
  }
  return next(fehler);
});