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";

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);
  `);
  bereit = true;
}

/* ---------------------------------------------------------------------
   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");

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

    res.json({
      darf_einstellen: darfMaterialEinstellen(req.person),
      sieht_wer: zeigtNamen,
      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,
      })),
    });
  } 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" });

      const { lastInsertRowid } = db().prepare(`
        INSERT INTO material (datei, dateiname, typ, art, groesse, text, von_id, erstellt)
        VALUES (?,?,?,?,?,?,?,?)
      `).run(datei, name, typ, art, req.body.length, text, req.person.id,
        new Date().toISOString());

      protokolliere(req.person.id, "material_eingestellt",
        `${art} "${name}" (${req.body.length} Bytes)`, 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(req.person.id, "material_genommen", `Material ${id}`, 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
   --------------------------------------------------------------------- */
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" });
    if (z.von_id !== req.person.id && !istDogFather(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(req.person.id, "material_entfernt", `Material ${id}`, 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);
});