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, betreuteIds, istLeitung, ROLLEN_SORTIERUNG,
} 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 (istLeitung(person)) return { wo: "1=1", werte: [] };

  /* Ausdrueckliche Freigabe -- gilt fuer jede Rolle gleich. Wer in der
     Liste steht, sieht die Datei, egal ob Creator oder Scout. */
  const freigabe = "EXISTS (SELECT 1 FROM datei_personen dp WHERE dp.datei_id = d.id AND dp.person_id = ?)";

  if (person.rolle === "creator") {
    return {
      wo: `(d.creator_id = ? OR d.hochgeladen_von = ? OR ${freigabe})`,
      werte: [person.id, person.id, person.id],
    };
  }
  const b = betreutWo(person, "d.creator_id");
  return b
    ? { wo: `(d.hochgeladen_von = ? OR ${freigabe} OR ${b.wo})`,
        werte: [person.id, person.id, ...b.werte] }
    : { wo: `(d.hochgeladen_von = ? OR ${freigabe})`, werte: [person.id, person.id] };
}

/* Wem eine Datei freigegeben ist -- fuer die Anzeige. */
export function freigabenZu(ids) {
  if (!ids.length) return new Map();
  const platz = ids.map(() => "?").join(",");
  const karte = new Map();
  for (const z of db().prepare(`
    SELECT dp.datei_id, p.id, p.name, p.rolle
    FROM datei_personen dp JOIN personen p ON p.id = dp.person_id
    WHERE dp.datei_id IN (${platz})
    ORDER BY ${ROLLEN_SORTIERUNG.replace('rolle', 'p.rolle')}, p.name`).all(...ids)) {
    if (!karte.has(z.datei_id)) karte.set(z.datei_id, []);
    karte.get(z.datei_id).push({ id: z.id, name: z.name, rolle: z.rolle });
  }
  return karte;
}

/* Wen darf diese Person ueberhaupt auswaehlen? DogFather jeden aktiven
   Menschen ausser sich selbst, ein Scout nur die Creator, die er
   betreut -- sonst koennte er sich ueber eine Freigabe Zugang zu
   fremden Bereichen verschaffen. */
export function moeglicheEmpfaenger(person) {
  if (istLeitung(person)) {
    return db().prepare(
      "SELECT id, name, rolle FROM personen WHERE aktiv = 1 AND id <> ? ORDER BY " + ROLLEN_SORTIERUNG + ", name")
      .all(person.id);
  }
  if (person.rolle === "scout") {
    const ids = betreuteIds(person);
    if (!ids.length) return [];
    return db().prepare(
      `SELECT id, name, rolle FROM personen WHERE aktiv = 1 AND id IN (${ids.map(() => "?").join(",")})
       ORDER BY name`).all(...ids);
  }
  return [];
}

/* Freigaben setzen. Prueft jede Id gegen die erlaubte Auswahl -- ein
   geschickter Aufruf soll keine Person erreichen, die im Formular gar
   nicht zur Wahl stand. */
export function freigabenSetzen(dateiId, ids, person) {
  const erlaubt = new Set(moeglicheEmpfaenger(person).map((p) => p.id));
  const sauber = [...new Set(ids.map(Number).filter((n) => Number.isInteger(n) && erlaubt.has(n)))];
  const d = db();
  d.prepare("DELETE FROM datei_personen WHERE datei_id = ?").run(dateiId);
  const einf = d.prepare("INSERT OR IGNORE INTO datei_personen (datei_id, person_id) VALUES (?,?)");
  for (const pid of sauber) einf.run(dateiId, pid);
  return sauber.length;
}

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);
    const liste = db().prepare(`
        SELECT ${SPALTEN} ${VERBUND}
        WHERE ${wo}
        ORDER BY d.erstellt DESC`).all(...werte);
    const karte = freigabenZu(liste.map((d) => d.id));
    for (const d of liste) d.freigaben = karte.get(d.id) || [];
    res.json({
      dateien: liste,
      empfaenger: moeglicheEmpfaenger(req.person),
      darf_freigeben: req.person.rolle !== "creator",
      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 DogFather 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 (istLeitung(req.person)) {
        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());

      /* Ausdrueckliche Freigaben. Der Kopf traegt eine Liste von Ids --
         geprueft wird jede einzelne gegen die erlaubte Auswahl. */
      let anzahl = 0;
      const roh = req.get("x-personen");
      if (roh) {
        anzahl = freigabenSetzen(Number(lastInsertRowid),
          String(roh).split(",").map((x) => x.trim()).filter(Boolean), req.person);
      }

      protokolliere("datei_hochgeladen", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${lastInsertRowid} ${name} (${Math.round(req.body.length / 1024)} KB)`
          + (anzahl ? `, freigegeben fuer ${anzahl}` : "").slice(0, 40),
      });
      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" });

    /* Freigaben aendern. Steht vor den Feldern, weil es eine eigene
       Tabelle ist und nicht in das UPDATE unten passt. Ein Creator darf
       das nie -- er wuerde sich sonst selbst Publikum verschaffen. */
    if (req.body?.freigaben !== undefined) {
      if (req.person.rolle === "creator") {
        return res.status(403).json({ fehler: "Freigeben darf nur DogFather oder ein Scout." });
      }
      if (!Array.isArray(req.body.freigaben)) {
        return res.status(400).json({ fehler: "Ungültige Auswahl." });
      }
      const n = freigabenSetzen(id, req.body.freigaben, req.person);
      protokolliere("datei_freigaben", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${id} an ${n} Person(en)`.slice(0, 120),
      });
      if (Object.keys(req.body).length === 1) return res.json({ ok: true });
    }

    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" && !istLeitung(req.person)) {
        return res.status(403).json({ fehler: "Freigeben darf nur DogFather." });
      }
      if (datei.status === "freigegeben" && !istLeitung(req.person)) {
        return res.status(403).json({ fehler: "Freigegebene Dateien ändert nur DogFather." });
      }
      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 (!istLeitung(req.person)) {
      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 DogFather." });
      }
    }

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