dogfather-universe/server/workspace-dateien.js

/* =====================================================================
   workspace-dateien.js — Zentrale Ablage mit Freigabe-Ablauf.

   Aus dem Konzept, Seite 13: "Bilder / PDFs / Guides, Technik-Screenshots,
   Content-Material" und der Ablauf "Entwurf -> Review -> Freigabe ->
   finale Version markieren".

   OHNE NEUE ABHÄNGIGKEIT. Uploads laufen üblicherweise über multer o. ä.
   Hier schickt der Browser die Datei stattdessen roh im Rumpf
   (fetch(..., { body: datei })), der Name steht im Kopf. Express bringt
   mit express.raw() den passenden Empfänger schon mit -- kein Parsen von
   multipart/form-data von Hand, was an dieser Stelle heikel wäre.

   Sicherheit -- die drei Punkte, an denen Dateiablagen typischerweise
   scheitern:
     1. Die Dateien liegen AUSSERHALB des Repos. Lägen sie darin, würde
        express.static sie ohne jede Prüfung ans Netz geben.
     2. Auf der Platte bekommt jede Datei einen erzeugten Zufallsnamen.
        Der Originalname steht nur in der Datenbank und kann damit weder
        Pfade verlassen (../) noch etwas überschreiben.
     3. Ausgeliefert wird immer als Download (Content-Disposition:
        attachment) mit neutralem Typ. Sonst könnte eine hochgeladene
        HTML- oder SVG-Datei im Browser Code im Namen der Domain
        ausführen.
   ===================================================================== */

import express from "express";
import { randomBytes } from "node:crypto";
import { join, extname, basename } from "node:path";
import { mkdirSync, createReadStream, writeFileSync, unlinkSync, statSync } from "node:fs";
import {
  db, protokolliere, echteIp, sitzungLesen, DATEN_ORDNER, betreutWo, darfCreator,
} from "./workspace.js";

export const dateienRouter = express.Router();

const ORDNER = join(DATEN_ORDNER, "dateien");
const MAX_BYTES = 25 * 1024 * 1024;          // 25 MB je Datei
const NAME_MAX = 200;
const NOTIZ_MAX = 500;
const STATUS = ["entwurf", "review", "freigegeben"];

/* Wer Dateien ablegen darf. Creator ausdruecklich NICHT (Wunsch vom
   28.08.2026): Sie sehen und laden die Dateien ihres Bereichs, abgelegt
   werden sie vom Management oder von Scouts. */
const DARF_HOCHLADEN = new Set(["admin", "scout"]);

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

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

dateienRouter.use("/workspace/api/dateien", angemeldet);

/* Sichtbarkeit wie überall: an einer Stelle, damit keine Abfrage sie
   vergisst. */
export function sichtbar(person) {
  if (person.rolle === "admin") return { wo: "1=1", werte: [] };
  if (person.rolle === "creator") {
    return { wo: "(d.creator_id = ? OR d.hochgeladen_von = ?)", werte: [person.id, person.id] };
  }
  const b = betreutWo(person, "d.creator_id");
  return b
    ? { wo: `(d.hochgeladen_von = ? OR ${b.wo})`, werte: [person.id, ...b.werte] }
    : { wo: "d.hochgeladen_von = ?", werte: [person.id] };
}

const SPALTEN = `
  d.id, d.name_original, d.groesse, d.typ, d.status, d.notiz,
  d.creator_id, d.hochgeladen_von, d.erstellt, d.geaendert,
  pc.name AS creator_name, ph.name AS hochgeladen_name`;

const VERBUND = `
  FROM dateien d
  LEFT JOIN personen pc ON pc.id = d.creator_id
  LEFT JOIN personen ph ON ph.id = d.hochgeladen_von`;

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

dateienRouter.get("/workspace/api/dateien", (req, res) => {
  try {
    const { wo, werte } = sichtbar(req.person);
    res.json({
      dateien: db().prepare(`
        SELECT ${SPALTEN} ${VERBUND}
        WHERE ${wo}
        ORDER BY d.erstellt DESC`).all(...werte),
      max_bytes: MAX_BYTES,
    });
  } catch (fehler) {
    console.error("[workspace] Dateien lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Hochladen ---------------------------------------------------- */

/* Der Name kommt im Kopf, nicht im Rumpf -- dort liegt die Datei selbst.
   Er wird als URI-Komponente kodiert übertragen, damit Umlaute und
   Leerzeichen unterwegs heil bleiben. */
function nameAusKopf(req) {
  const roh = req.get("x-dateiname") || "";
  let name;
  try { name = decodeURIComponent(roh); } catch { name = roh; }
  /* basename() entfernt alles, was nach Pfad aussieht -- danach kann der
     Name die Ablage nicht mehr verlassen. Zusätzlich werden Zeichen
     ersetzt, die in Dateinamen Ärger machen. */
  name = basename(name).replace(/[\x00-\x1f<>:"/\\|?*]/g, "_").trim();
  return name.slice(0, NAME_MAX) || "datei";
}

/* Steht bewusst VOR express.raw: Wer nicht hochladen darf, wird
   abgewiesen, bevor auch nur ein Byte der Datei entgegengenommen wird.
   Andernfalls wanderten bis zu 25 MB durch die Leitung, nur um danach
   verworfen zu werden. */
function darfHochladen(req, res, next) {
  if (!DARF_HOCHLADEN.has(req.person.rolle)) {
    return res.status(403).json({
      fehler: "Dateien legen das Management und die Scouts ab.",
    });
  }
  next();
}

dateienRouter.post("/workspace/api/dateien",
  gleicheHerkunft,
  darfHochladen,
  express.raw({ type: "*/*", limit: MAX_BYTES }),
  (req, res) => {
    try {
      if (!Buffer.isBuffer(req.body) || !req.body.length) {
        return res.status(400).json({ fehler: "Keine Datei empfangen." });
      }

      const name = nameAusKopf(req);
      let notiz = "";
      try { notiz = decodeURIComponent(req.get("x-notiz") || ""); } catch { notiz = ""; }
      notiz = notiz.slice(0, NOTIZ_MAX).trim() || null;

      /* Wer nicht Management ist, lädt immer in den eigenen Bereich --
         ein betreuender Scout in den seines Creators. */
      let creatorId = null;
      if (req.person.rolle === "scout") {
        const w = Number(req.get("x-creator"));
        if (w) {
          if (!darfCreator(req.person, w)) {
            return res.status(403).json({ fehler: "Dieser Creator ist dir nicht zugeteilt." });
          }
          creatorId = w;
        }
      } else if (req.person.rolle === "admin") {
        const w = req.get("x-creator");
        if (w) {
          const z = Number(w);
          if (!Number.isInteger(z) || z < 1) return res.status(400).json({ fehler: "Ungültige Zuordnung." });
          if (!db().prepare("SELECT 1 FROM personen WHERE id = ? AND aktiv = 1").get(z)) {
            return res.status(400).json({ fehler: "Zugeordnete Person gibt es nicht." });
          }
          creatorId = z;
        }
      }
      /* Ein Scout laedt ohne Bereichszuordnung ab -- die Datei sehen dann
         er selbst und das Management. Einem Creator direkt etwas in den
         Bereich zu legen bleibt dem Management vorbehalten, so wie im
         Konzept die Uebergabe ueber das Management laeuft. */

      mkdirSync(ORDNER, { recursive: true });
      /* Erzeugter Name auf der Platte. Die Endung wird aus dem
         Originalnamen übernommen, aber auf harmlose Zeichen begrenzt --
         sie dient nur der Wiedererkennung, ausgeliefert wird ohnehin
         immer als Download. */
      const endung = (extname(name).match(/^\.[A-Za-z0-9]{1,8}$/) || [""])[0].toLowerCase();
      const dateiname = `${Date.now().toString(36)}-${randomBytes(8).toString("hex")}${endung}`;
      writeFileSync(join(ORDNER, dateiname), req.body, { flag: "wx" });

      const { lastInsertRowid } = db().prepare(`
        INSERT INTO dateien
          (name_original, name_datei, groesse, typ, status, notiz,
           creator_id, hochgeladen_von, erstellt)
        VALUES (?,?,?,?,'entwurf',?,?,?,?)`).run(
        name, dateiname, req.body.length,
        (req.get("content-type") || "application/octet-stream").slice(0, 100),
        notiz, creatorId, req.person.id, jetzt());

      protokolliere("datei_hochgeladen", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${lastInsertRowid} ${name} (${Math.round(req.body.length / 1024)} KB)`.slice(0, 120),
      });
      res.status(201).json({ id: Number(lastInsertRowid) });
    } catch (fehler) {
      if (fehler?.type === "entity.too.large") {
        return res.status(413).json({ fehler: "Datei ist zu groß (max. 25 MB)." });
      }
      console.error("[workspace] Datei hochladen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* ---------- Herunterladen ------------------------------------------------ */

dateienRouter.get("/workspace/api/dateien/:id/inhalt", (req, res) => {
  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 datei = db().prepare(
      `SELECT d.name_original, d.name_datei ${VERBUND} WHERE ${wo} AND d.id = ?`).get(...werte, id);
    if (!datei) return res.status(404).json({ fehler: "nicht_gefunden" });

    const pfad = join(ORDNER, datei.name_datei);
    try { statSync(pfad); } catch { return res.status(410).json({ fehler: "Datei fehlt auf der Platte." }); }

    /* Immer als Download und immer mit neutralem Typ. Eine hochgeladene
       HTML- oder SVG-Datei würde sonst im Browser als Seite dieser Domain
       ausgeführt -- mit Zugriff auf die Sitzung. */
    res.setHeader("Content-Type", "application/octet-stream");
    res.setHeader("X-Content-Type-Options", "nosniff");
    res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
    res.setHeader("Content-Disposition",
      `attachment; filename*=UTF-8''${encodeURIComponent(datei.name_original)}`);

    protokolliere("datei_geladen", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${datei.name_original}`.slice(0, 120),
    });
    createReadStream(pfad).pipe(res);
  } catch (fehler) {
    console.error("[workspace] Datei ausliefern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Freigabe und Notiz ------------------------------------------- */

dateienRouter.patch("/workspace/api/dateien/:id", gleicheHerkunft, (req, res) => {
  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 datei = db().prepare(`SELECT d.* ${VERBUND} WHERE ${wo} AND d.id = ?`).get(...werte, id);
    if (!datei) return res.status(404).json({ fehler: "nicht_gefunden" });

    const setz = [];
    const daten = [];

    if (req.body?.status !== undefined) {
      if (!STATUS.includes(req.body.status)) return res.status(400).json({ fehler: "Unbekannter Status." });
      /* "freigegeben" ist eine Abnahme -- die trifft laut Konzept das
         Management, nicht der, der die Datei hochgeladen hat. */
      if (req.body.status === "freigegeben" && req.person.rolle !== "admin") {
        return res.status(403).json({ fehler: "Freigeben darf nur das Management." });
      }
      if (datei.status === "freigegeben" && req.person.rolle !== "admin") {
        return res.status(403).json({ fehler: "Freigegebene Dateien ändert nur das Management." });
      }
      setz.push("status = ?"); daten.push(req.body.status);
    }

    if (req.body?.notiz !== undefined) {
      const n = String(req.body.notiz ?? "").trim().slice(0, NOTIZ_MAX);
      setz.push("notiz = ?"); daten.push(n || null);
    }

    if (!setz.length) return res.status(400).json({ fehler: "nichts_zu_aendern" });
    setz.push("geaendert = ?"); daten.push(jetzt());

    db().prepare(`UPDATE dateien SET ${setz.join(", ")} WHERE id = ?`).run(...daten, id);
    protokolliere("datei_geaendert", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${req.body?.status || "notiz"}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Datei ändern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Löschen ------------------------------------------------------ */

dateienRouter.delete("/workspace/api/dateien/:id", gleicheHerkunft, (req, res) => {
  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 datei = db().prepare(
      `SELECT d.id, d.name_original, d.name_datei, d.status, d.hochgeladen_von ${VERBUND}
       WHERE ${wo} AND d.id = ?`).get(...werte, id);
    if (!datei) return res.status(404).json({ fehler: "nicht_gefunden" });

    if (req.person.rolle !== "admin") {
      if (datei.hochgeladen_von !== req.person.id) {
        return res.status(403).json({ fehler: "nicht_erlaubt" });
      }
      if (datei.status === "freigegeben") {
        return res.status(403).json({ fehler: "Freigegebene Dateien löscht nur das Management." });
      }
    }

    db().prepare("DELETE FROM dateien WHERE id = ?").run(id);
    /* Erst der Eintrag, dann die Datei: Bleibt eine verwaiste Datei auf
       der Platte liegen, ist das harmlos. Ein Eintrag ohne Datei wäre
       dagegen ein toter Verweis in der Liste. */
    try { unlinkSync(join(ORDNER, datei.name_datei)); } catch { /* schon weg */ }

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

/* ---------- Fehler aus express.raw --------------------------------------
   Ist der Rumpf zu gross, bricht express.raw ab, BEVOR der eigene Code
   laeuft -- das try/catch dort greift also nicht, und der Fehler landete
   im allgemeinen Behandler als HTTP 500. Fuer die Nutzerin sah das aus
   wie ein kaputter Server statt wie "Datei zu gross". Dieser Behandler
   muss ZULETZT stehen: Express erkennt ihn an den vier Parametern und
   ruft ihn nur fuer Fehler aus den Routen davor auf. */
// eslint-disable-next-line no-unused-vars
dateienRouter.use((fehler, req, res, next) => {
  if (!req.path.startsWith("/workspace/api/dateien")) return next(fehler);
  if (fehler?.type === "entity.too.large" || fehler?.status === 413) {
    return res.status(413).json({
      fehler: `Datei ist zu groß – erlaubt sind ${Math.round(MAX_BYTES / 1024 / 1024)} MB.`,
    });
  }
  console.error("[workspace] Dateien:", fehler?.message);
  res.status(503).json({ fehler: "nicht_verfuegbar" });
});