DogFatherGitandClaude Opus 5
4b14906371
Aus dem Plan im Vault. "Eure Clips und Bilder" zeigte Textkarten mit
einem Anhang darunter. Ein Bild als Anhang unter einer Ueberschrift ist
kein Highlight -- dieser Bereich lebt vom Sehen. Jetzt steht das Bild
OBEN, der Text ist Bildunterschrift.
ZWEI DINGE WAREN ANDERS ALS IM PLAN
1. "Anhaenge sind schon da" stimmte nicht. Sie hingen an AUFGABEN
(`dateien.aufgabe_id`); ein Eintrag konnte gar kein Bild tragen.
Neue Spalte `eintrag_id`.
2. UND DER WICHTIGE, ein Sicherheitsthema: Alles in dieser Ablage geht
bewusst als DOWNLOAD hinaus (`application/octet-stream`,
`Content-Disposition: attachment`). Eine hochgeladene HTML- oder
SVG-Datei wuerde sonst im Browser als Seite DIESER Domain laufen --
mit Zugriff auf die Sitzung. Eine Galerie braucht also einen
eigenen, engen Weg, keine Lockerung der alten Regel.
DIE FRAGE "IST DAS EIN BILD?" DARF NICHT `dateien.typ` BEANTWORTEN.
Diese Spalte traegt den vom Browser BEHAUPTETEN Typ
(`req.get("content-type")`) -- wer hochlaedt, bestimmt ihn selbst. Eine
Galerie, die ihm glaubt, liefert auf Zuruf alles inline aus. Erkannt
wird deshalb an den ERSTEN BYTES: PNG, JPEG, GIF, WEBP.
SVG IST AUSDRUECKLICH NICHT DABEI. Es ist ein Bildformat UND kann
Skript enthalten -- genau die Luecke, gegen die die Regel gebaut wurde.
Ein Format, das beides ist, gehoert nicht in die Ausnahme.
Kein Bild heisst 404, nicht 415: Eine eigene Antwort waere die Auskunft
"diese Nummer gibt es, sie ist nur kein Bild", und die laesst sich
durchzaehlen.
WESSEN REGEL GILT: Ein Bild am Community-Beitrag folgt dem BEITRAG,
nicht der Dateiablage. Deren Regel haengt an Creator-Zuordnungen, und
ein Gast hat keine -- er saehe sonst nie ein Highlight, obwohl es fuer
ihn gemacht ist.
NEU: pruef-galerie (26 Pruefungen)
Der Beweis steht in zwei Zeilen: Am Beitrag haengen VIER Dateien --
zwei echte PNGs, ein SVG und eine HTML-Datei, die sich als
"image/png" ausgibt. Im Raster stehen ZWEI. Die anderen beiden holt
der Browser, bekommt 404, und der error-Handler raeumt sie weg: kein
leerer Rahmen, kein kaputtes Symbol.
Dazu die Gegenprobe in die andere Richtung -- ein echtes PNG, das sich
als "text/plain" ausgibt, geht durch. Ohne sie hiesse "404" nur, dass
der Weg immer ablehnt. Und die Konsolenpruefung laesst genau die zwei
gewollten 404 zu und nichts sonst; ein pauschales "Konsole egal" haette
jeden echten Fehler mitversteckt.
EIN EIGENER FEHLER: Mein Test-PNG war kein dekodierbares Bild, nur ein
Dateikopf. Der Browser konnte es nicht zeichnen, der error-Handler
raeumte es weg, und die Pruefung fand im Raster nichts. Fehler in der
Pruefung, nicht im Haus -- aber ein nuetzlicher: Er hat nebenbei
gezeigt, dass ein kaputtes Bild keinen leeren Rahmen hinterlaesst.
pruef-anhaenge 37, pruef-treff 66, pruef-bereiche-lesend,
pruef-css-klassen: gruen.
Co-Authored-By: Claude Opus 5 <[email protected]>
818 lines
36 KiB
JavaScript
818 lines
36 KiB
JavaScript
/* =====================================================================
|
||
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,
|
||
openSync, readSync, closeSync } from "node:fs";
|
||
import {
|
||
db, protokolliere, echteIp, sitzungLesen, DATEN_ORDNER, betreutWo, darfCreator, betreuteIds, istLeitung, istDogFather, siehtAlles, istSpicy, ohneDogFather, ROLLEN_SORTIERUNG,
|
||
externSql, EXTERN_MAX, sichtbarePersonenIds,
|
||
ohneTeamDogi, ohneAgentur, siehtModis,
|
||
TREFF_BRETTER, TREFF_ROLLEN,
|
||
} 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);
|
||
|
||
/* =====================================================================
|
||
DIE UMHUELLUNG: was einem Modi gehoert, faellt hier heraus.
|
||
|
||
Sie sitzt UM die eigentliche Regel und nicht darin -- damit sie auch
|
||
fuer Regeln gilt, die es heute noch nicht gibt. Beim ersten Anlauf
|
||
war nur der eine bekannte Fall geflickt (Spicy Media); das haette den
|
||
naechsten Rollenzweig wieder offen gelassen, und niemand haette es
|
||
gemerkt, weil an der geaenderten Stelle nichts davon steht.
|
||
|
||
DogFather und die Modis gehen unveraendert durch.
|
||
===================================================================== */
|
||
export function sichtbar(person) {
|
||
const regel = sichtbarRoh(person);
|
||
if (!regel) return regel;
|
||
/* AUF DER ADRESSE VON TEAM DOGI NUR TEAM DOGI (10.09.2026).
|
||
|
||
Filipe: "die daten von dieser seite sollen nichts mit den daten am
|
||
hut haben von der workspace seite ... komplett von der anderen
|
||
getrennt sein."
|
||
|
||
Die Bedingung steht VOR der Regel fuer das andere Haus und nicht
|
||
danach: Beide schliessen sich aus, und wer sie hintereinander
|
||
haengt, bekommt auf der Team-Adresse eine Bedingung, die sich
|
||
selbst widerspricht -- und damit eine leere Seite, die aussieht
|
||
wie ein Fehler.
|
||
|
||
`person.haus` setzt sitzungLesen() aus der Adresse. Es aendert
|
||
keine Rechte, nur den Ausschnitt. */
|
||
if (person.haus === "crew") {
|
||
return {
|
||
wo: `(${regel.wo}) AND ${ohneAgentur("d", ["creator_id", "hochgeladen_von"])}`,
|
||
werte: regel.werte,
|
||
};
|
||
}
|
||
if (siehtModis(person)) return regel;
|
||
return {
|
||
wo: `(${regel.wo}) AND ${ohneTeamDogi("d", ["creator_id", "hochgeladen_von"])}`,
|
||
werte: regel.werte,
|
||
};
|
||
}
|
||
|
||
/* Sichtbarkeit wie überall: an einer Stelle, damit keine Abfrage sie
|
||
vergisst. */
|
||
function sichtbarRoh(person) {
|
||
/* NUR DogFather sieht alles (01.09.2026). Vorher stand hier
|
||
istLeitung() -- damit sah auch jeder Manager jeden Creator. Ein
|
||
Manager faellt jetzt in dieselbe Regel wie ein Scout: nur die
|
||
Creator, die ihm zugeteilt sind. Ausdruecklicher Wunsch:
|
||
"NUR DIE ROLLE DOGFATHER SOLL WIRKLICH ALLEINE ALLES SEHEN."
|
||
|
||
Geaendert wird ausschliesslich, wer was SIEHT. Was ein Manager
|
||
darf (freigeben, aendern, Personen verwalten), haengt weiterhin an
|
||
istLeitung und bleibt unveraendert -- sonst haette dieser eine
|
||
Wunsch stillschweigend seine halben Rechte mitgenommen. */
|
||
if (istSpicy(person)) return { wo: ohneDogFather("d", ["creator_id", "hochgeladen_von"]), werte: [] };
|
||
if (siehtAlles(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) {
|
||
/* Nicht die ROLLE, sondern die ZUTEILUNG entscheidet (03.09.2026).
|
||
Hier stand eine Abfrage ueber ALLE -- eine Managerin bekam damit
|
||
auch Namen und Daten von Creators, die ihr nie zugeteilt waren.
|
||
sichtbarePersonenIds/sichtbareCreatorIds liefern null fuer
|
||
DogFather (= keine Einschraenkung) und sonst genau die erlaubten
|
||
Nummern. */
|
||
const erlaubt = sichtbarePersonenIds(person);
|
||
if (erlaubt === null) {
|
||
return db().prepare(
|
||
"SELECT id, name, rolle FROM personen WHERE aktiv = 1 AND id <> ? ORDER BY " + ROLLEN_SORTIERUNG + ", name")
|
||
.all(person.id);
|
||
}
|
||
if (istLeitung(person)) {
|
||
const ohneMich = erlaubt.filter((x) => x !== person.id);
|
||
if (!ohneMich.length) return [];
|
||
return db().prepare(
|
||
`SELECT id, name, rolle FROM personen WHERE aktiv = 1
|
||
AND id IN (${ohneMich.map(() => "?").join(",")})
|
||
ORDER BY ` + ROLLEN_SORTIERUNG + ", name").all(...ohneMich);
|
||
}
|
||
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,
|
||
d.creator_extern, d.ersetzt_id, d.aufgabe_id,
|
||
${externSql("pc.name", "d.creator_extern")} 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`;
|
||
|
||
/* =====================================================================
|
||
WELCHE FASSUNG IST DAS? (15.09.2026)
|
||
|
||
Aus „ersetzt_id“ wird eine Kette. Jede Datei bekommt zwei Angaben:
|
||
|
||
fassung die wievielte sie ist (1 = die erste)
|
||
ersetzt_am ob es eine neuere gibt -- dann ist SIE nicht mehr aktuell
|
||
|
||
GERECHNET, NICHT GESPEICHERT. Eine Spalte "version" muesste beim
|
||
Loeschen einer mittleren Fassung nachgezogen werden, und genau das
|
||
vergisst man. Die Kette steht in den Verweisen; die Nummer folgt
|
||
daraus.
|
||
|
||
NUR AUS DER UEBERGEBENEN LISTE: Ist eine frueherere Fassung fuer
|
||
diese Person gar nicht sichtbar, zaehlt sie hier auch nicht mit --
|
||
eine Zahl, die eine unsichtbare Datei mitzaehlt, waere eine Auskunft
|
||
ueber etwas, das man nicht sehen darf.
|
||
===================================================================== */
|
||
function fassungenSetzen(liste) {
|
||
const nachId = new Map(liste.map((d) => [d.id, d]));
|
||
const ersetztVon = new Map();
|
||
for (const d of liste) if (d.ersetzt_id) ersetztVon.set(d.ersetzt_id, d.id);
|
||
|
||
for (const d of liste) {
|
||
/* Nach hinten zaehlen, bis keine Vorgaengerin mehr da ist. Die
|
||
Schranke ist keine Vorsicht, sondern Pflicht: Ein Ring in den
|
||
Daten (durch einen Fehler anderswo) wuerde die Seite sonst
|
||
einfrieren, und ein Stillstand ist schlimmer als ein Fehler. */
|
||
let n = 1;
|
||
let jetzige = d;
|
||
const gesehen = new Set([d.id]);
|
||
while (jetzige.ersetzt_id && nachId.has(jetzige.ersetzt_id)
|
||
&& !gesehen.has(jetzige.ersetzt_id) && n < 200) {
|
||
gesehen.add(jetzige.ersetzt_id);
|
||
jetzige = nachId.get(jetzige.ersetzt_id);
|
||
n++;
|
||
}
|
||
d.fassung = n;
|
||
d.ersetzt_durch = ersetztVon.get(d.id) ?? null;
|
||
}
|
||
}
|
||
|
||
/* =====================================================================
|
||
DIE VERKNUEPFUNG WIEDER LOESEN (15.09.2026)
|
||
|
||
Der Server verknuepft von selbst, wenn Name und Creator gleich sind.
|
||
Meistens stimmt das; manchmal nicht -- zwei verschiedene Dateien
|
||
koennen denselben Namen tragen.
|
||
|
||
EINE AUTOMATIK OHNE AUSWEG IST EINE BEHAUPTUNG. Deshalb dieser Weg:
|
||
ein Klick, und die Datei steht wieder fuer sich. NUR die Verknuepfung
|
||
geht, nie eine Datei -- der Weg kann also nichts anrichten, was sich
|
||
nicht in einem zweiten Klick zuruecknehmen liesse.
|
||
===================================================================== */
|
||
dateienRouter.delete("/workspace/api/dateien/:id(\\d+)/fassung", (req, res) => {
|
||
try {
|
||
const id = Number(req.params.id);
|
||
const { wo, werte } = sichtbar(req.sicht || req.person);
|
||
const d = db().prepare(
|
||
`SELECT d.id, d.name_original, d.ersetzt_id ${VERBUND} WHERE ${wo} AND d.id = ?`)
|
||
.get(...werte, id);
|
||
if (!d) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
if (!d.ersetzt_id) return res.status(409).json({ fehler: "keine_fassung" });
|
||
|
||
db().prepare("UPDATE dateien SET ersetzt_id = NULL WHERE id = ?").run(id);
|
||
protokolliere("datei_fassung_geloest", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `#${id} ${d.name_original} war Fassung von #${d.ersetzt_id}`.slice(0, 120),
|
||
});
|
||
res.json({ ok: true });
|
||
} catch (fehler) {
|
||
console.error("[dateien] Fassung loesen:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** Darf dieser Mensch diese Aufgabe sehen?
|
||
*
|
||
* BEWUSST EINFACH GEHALTEN und nicht aus workspace-aufgaben.js
|
||
* importiert: Dort haengt die Sichtbarkeit an einer laengeren Abfrage
|
||
* mit Betreuung und Sicht. Hier wird nur gefragt, ob die Datei an eine
|
||
* Aufgabe darf, und dafuer gilt dieselbe Schranke wie fuer die Datei
|
||
* selbst -- der Creator-Bezug. Wer den Creator sehen darf, darf die
|
||
* Aufgabe daran haengen.
|
||
*
|
||
* Waere hier mehr erlaubt als bei der Datei, entstuende genau das
|
||
* Leck, das die Spalte verhindern soll. */
|
||
function aufgabeSichtbar(aufgabe, person) {
|
||
if (!aufgabe) return false;
|
||
/* Eine Aufgabe ohne Creator-Bezug gehoert dem Haus -- sie ist fuer
|
||
alle sichtbar, die ueberhaupt Dateien sehen duerfen. */
|
||
if (!aufgabe.creator_id) return true;
|
||
/* `darfCreator` ist genau diese Frage, und sie steht an einer Stelle
|
||
im Haus. Eine eigene Herleitung hier waere eine zweite Meinung
|
||
darueber -- und die zweite ist immer die, die mehr durchlaesst.
|
||
(Erster Anlauf: eine handgebaute Abfrage plus sichtbareCreatorIds,
|
||
das gar nicht importiert war.) */
|
||
return darfCreator(person, aufgabe.creator_id);
|
||
}
|
||
|
||
/* ---------- Anhaenge einer Aufgabe --------------------------------------
|
||
Eigener Weg statt eines Filters auf der grossen Liste: Die Aufgabe
|
||
fragt nach IHREN Dateien, und die Antwort ist kurz genug, um sie beim
|
||
Oeffnen des Dialogs zu holen. */
|
||
dateienRouter.get("/workspace/api/aufgaben/:id(\\d+)/dateien", (req, res) => {
|
||
try {
|
||
const id = Number(req.params.id);
|
||
const { wo, werte } = sichtbar(req.sicht || req.person);
|
||
const liste = db().prepare(`
|
||
SELECT ${SPALTEN} ${VERBUND}
|
||
WHERE ${wo} AND d.aufgabe_id = ?
|
||
ORDER BY d.erstellt DESC`).all(...werte, id);
|
||
fassungenSetzen(liste);
|
||
res.json({ dateien: liste });
|
||
} catch (fehler) {
|
||
console.error("[dateien] Anhaenge:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* ---------- Liste ------------------------------------------------------- */
|
||
|
||
dateienRouter.get("/workspace/api/dateien", (req, res) => {
|
||
try {
|
||
const { wo, werte } = sichtbar(req.sicht || 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) || [];
|
||
fassungenSetzen(liste);
|
||
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 frei eingetragener Name statt einer Person -- eine Agentur,
|
||
eine Marke, ein Partner ohne Konto. Er kommt wie der Dateiname
|
||
URL-kodiert im Kopf, sonst zerbrechen Umlaute: Kopfzeilen sind
|
||
streng genommen nur ASCII, und "Müller" käme als "Müller" an.
|
||
Der Name schlaegt die Auswahl -- wer tippt, meint das Getippte.
|
||
Sichtbar bleibt die Datei ueber hochgeladen_von. */
|
||
let creatorExtern = null;
|
||
if (req.person.rolle !== "creator") {
|
||
let roh = "";
|
||
try { roh = decodeURIComponent(req.get("x-creator-extern") || ""); } catch { roh = ""; }
|
||
roh = roh.replace(/[\u0000-\u001f\u007f]/g, "").trim().slice(0, EXTERN_MAX);
|
||
if (roh) { creatorExtern = roh; creatorId = null; }
|
||
}
|
||
|
||
/* 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" });
|
||
|
||
/* ---- GEHOERT DIE DATEI ZU EINER AUFGABE? (15.09.2026) ---------
|
||
|
||
Die Nummer kommt im Kopf, wie der Dateiname auch. Geprueft wird
|
||
sie gegen die Aufgaben, die dieser Mensch ueberhaupt sehen
|
||
darf -- sonst waere der Kopf ein Weg, eine Datei an eine fremde
|
||
Aufgabe zu haengen und damit ihre Existenz zu verraten.
|
||
|
||
EINE UNBEKANNTE NUMMER IST EIN FEHLER, kein stilles Ignorieren:
|
||
Wer eine Datei an eine Aufgabe haengen wollte und sie liegt
|
||
danach lose in der Ablage, sucht sie spaeter an der Aufgabe. */
|
||
let aufgabeId = null;
|
||
const rohAufgabe = req.get("x-aufgabe");
|
||
if (rohAufgabe) {
|
||
const n = Number(rohAufgabe);
|
||
const gefunden = Number.isInteger(n) && n > 0
|
||
? db().prepare(`SELECT a.id, a.creator_id FROM aufgaben a WHERE a.id = ?`).get(n)
|
||
: null;
|
||
if (!gefunden || !aufgabeSichtbar(gefunden, req.sicht || req.person)) {
|
||
return res.status(404).json({ fehler: "aufgabe_nicht_gefunden" });
|
||
}
|
||
aufgabeId = gefunden.id;
|
||
/* Der Creator-Bezug folgt der Aufgabe, wenn keiner mitkam --
|
||
sonst laege die Datei fuer die Sichtbarkeit woanders als die
|
||
Aufgabe, an der sie haengt. */
|
||
if (creatorId === null && gefunden.creator_id) creatorId = gefunden.creator_id;
|
||
}
|
||
|
||
/* ---- IST DAS EINE NEUE FASSUNG? (15.09.2026) ------------------
|
||
|
||
AUTOMATISCH VERKNUEPFT, NICHT GEFRAGT -- und das ist eine
|
||
Abwaegung, keine Bequemlichkeit: Wer die Verknuepfung vergisst,
|
||
hat zwei Dateien gleichen Namens ohne Zusammenhang, und
|
||
irgendwann laedt jemand die alte herunter. Wer sie faelschlich
|
||
bekommt, sieht sie sofort ("Fassung 2, ersetzt ...") und kann
|
||
sie mit einem Klick loesen. Der stille Schaden ist groesser als
|
||
der sichtbare.
|
||
|
||
GENAU EINE Bedingung, und sie ist eng: gleicher Originalname,
|
||
gleicher Creator-Bezug, und die Vorgaengerin darf nicht selbst
|
||
schon ersetzt sein. Faende die Abfrage mehrere, wird NICHT
|
||
geraten -- dann bleibt die Datei eigenstaendig. */
|
||
const vorgaenger = db().prepare(`
|
||
SELECT id FROM dateien
|
||
WHERE name_original = ?
|
||
AND ((creator_id IS NULL AND ? IS NULL) OR creator_id = ?)
|
||
AND id NOT IN (SELECT ersetzt_id FROM dateien WHERE ersetzt_id IS NOT NULL)
|
||
ORDER BY id DESC`).all(name, creatorId, creatorId);
|
||
const ersetztId = vorgaenger.length === 1 ? vorgaenger[0].id : null;
|
||
|
||
/* AN EINEN COMMUNITY-BEITRAG (17.09.2026). Dieselbe Regel wie bei
|
||
der Aufgabe eine Ebene hoeher: Eine unbekannte Nummer ist ein
|
||
FEHLER, kein stilles Ignorieren -- wer ein Bild an ein Highlight
|
||
haengen wollte und es liegt danach lose in der Ablage, sucht es
|
||
spaeter am Highlight. */
|
||
let eintragId = null;
|
||
const rohEintrag = req.get("x-eintrag");
|
||
if (rohEintrag) {
|
||
const n = Number(rohEintrag);
|
||
const e = Number.isInteger(n) && n > 0
|
||
? db().prepare("SELECT id, bereich FROM eintraege WHERE id = ?").get(n)
|
||
: null;
|
||
if (!e || !TREFF_BRETTER.includes(e.bereich)) {
|
||
return res.status(404).json({ fehler: "eintrag_nicht_gefunden" });
|
||
}
|
||
eintragId = e.id;
|
||
}
|
||
|
||
const { lastInsertRowid } = db().prepare(`
|
||
INSERT INTO dateien
|
||
(name_original, name_datei, groesse, typ, status, notiz,
|
||
creator_id, hochgeladen_von, erstellt, ersetzt_id, aufgabe_id, eintrag_id)
|
||
VALUES (?,?,?,?,'entwurf',?,?,?,?,?,?,?)`).run(
|
||
name, dateiname, req.body.length,
|
||
(req.get("content-type") || "application/octet-stream").slice(0, 100),
|
||
notiz, creatorId, req.person.id, jetzt(), ersetztId, aufgabeId, eintragId);
|
||
|
||
/* 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), ersetzt_id: ersetztId, aufgabe_id: aufgabeId,
|
||
});
|
||
} 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 ------------------------------------------------ */
|
||
|
||
/* =====================================================================
|
||
EIN BILD INLINE AUSLIEFERN (17.09.2026)
|
||
|
||
Alles in dieser Ablage geht sonst als DOWNLOAD hinaus
|
||
(`application/octet-stream`, `Content-Disposition: attachment`), und
|
||
das ist richtig so: Eine hochgeladene HTML- oder SVG-Datei wuerde im
|
||
Browser als Seite DIESER Domain laufen -- mit Zugriff auf die
|
||
Sitzung.
|
||
|
||
Eine Galerie braucht Bilder im Bild. Also ein eigener, enger Weg --
|
||
und der beantwortet die Frage "ist das ein Bild?" NICHT so, wie man
|
||
es zuerst tut:
|
||
|
||
`dateien.typ` ist der vom Browser BEHAUPTETE Typ
|
||
(`req.get("content-type")`). Wer hochlaedt, bestimmt ihn selbst.
|
||
Eine Galerie, die ihm glaubt, liefert auf Zuruf alles inline aus.
|
||
|
||
Erkannt wird deshalb an den ERSTEN BYTES der Datei. Die kann niemand
|
||
behaupten; sie stehen da oder nicht.
|
||
|
||
UND SVG IST AUSDRUECKLICH NICHT DABEI. Es ist ein Bildformat, und es
|
||
kann Skript enthalten -- genau die Luecke, gegen die die Regel oben
|
||
gebaut wurde. Ein Format, das beides ist, gehoert nicht in die
|
||
Ausnahme. */
|
||
const BILD_KENNUNGEN = [
|
||
{ typ: "image/png", pruefe: (b) => b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47 },
|
||
{ typ: "image/jpeg", pruefe: (b) => b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff },
|
||
{ typ: "image/gif", pruefe: (b) => b.slice(0, 6).toString("latin1") === "GIF87a"
|
||
|| b.slice(0, 6).toString("latin1") === "GIF89a" },
|
||
{ typ: "image/webp", pruefe: (b) => b.slice(0, 4).toString("latin1") === "RIFF"
|
||
&& b.slice(8, 12).toString("latin1") === "WEBP" },
|
||
];
|
||
|
||
/** Welches Bildformat steht wirklich am Dateianfang? `null` heisst:
|
||
* kein Bild -- und dann wird nichts inline ausgeliefert. */
|
||
export function bildArtVon(anfang) {
|
||
if (!Buffer.isBuffer(anfang) || anfang.length < 12) return null;
|
||
for (const k of BILD_KENNUNGEN) {
|
||
try { if (k.pruefe(anfang)) return k.typ; } catch { /* naechste */ }
|
||
}
|
||
return null;
|
||
}
|
||
|
||
dateienRouter.get("/workspace/api/dateien/:id/bild", (req, res) => {
|
||
try {
|
||
const id = Number(req.params.id);
|
||
if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
|
||
|
||
const datei = db().prepare(
|
||
"SELECT id, name_datei, name_original, eintrag_id FROM dateien WHERE id = ?").get(id);
|
||
if (!datei) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
/* WESSEN REGEL GILT? Ein Bild an einem Community-Beitrag folgt dem
|
||
BEITRAG, nicht der Dateiablage: Wer das Brett sehen darf, sieht
|
||
das Bild. Die Ablage-Regel haengt an Creator-Zuordnungen, und ein
|
||
Gast hat keine -- er saehe sonst nie ein Highlight, obwohl es
|
||
fuer ihn gemacht ist. Alles ohne Beitrag faellt auf die normale
|
||
Regel zurueck. */
|
||
let erlaubt = false;
|
||
if (datei.eintrag_id) {
|
||
const e = db().prepare("SELECT bereich FROM eintraege WHERE id = ?").get(datei.eintrag_id);
|
||
erlaubt = !!e && TREFF_BRETTER.includes(e.bereich)
|
||
&& TREFF_ROLLEN.has((req.sicht || req.person)?.rolle);
|
||
}
|
||
if (!erlaubt) {
|
||
const { wo, werte } = sichtbar(req.person);
|
||
erlaubt = !!db().prepare(`SELECT d.id ${VERBUND} WHERE ${wo} AND d.id = ?`)
|
||
.get(...werte, id);
|
||
}
|
||
if (!erlaubt) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const pfad = join(ORDNER, datei.name_datei);
|
||
let anfang;
|
||
try {
|
||
const f = openSync(pfad, "r");
|
||
anfang = Buffer.alloc(16);
|
||
readSync(f, anfang, 0, 16, 0);
|
||
closeSync(f);
|
||
} catch { return res.status(410).json({ fehler: "Datei fehlt auf der Platte." }); }
|
||
|
||
const art = bildArtVon(anfang);
|
||
/* KEIN BILD HEISST 404, nicht 415. Eine eigene Antwort waere die
|
||
Auskunft "diese Nummer gibt es, sie ist nur kein Bild" -- und die
|
||
laesst sich durchzaehlen. */
|
||
if (!art) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
res.setHeader("Content-Type", art);
|
||
res.setHeader("X-Content-Type-Options", "nosniff");
|
||
res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
|
||
res.setHeader("Content-Disposition",
|
||
`inline; filename*=UTF-8''${encodeURIComponent(datei.name_original)}`);
|
||
res.setHeader("Cache-Control", "private, max-age=3600");
|
||
createReadStream(pfad).pipe(res);
|
||
} catch (fehler) {
|
||
console.error("[workspace] Bild ausliefern:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
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" });
|
||
});
|