DogFatherGitandClaude Opus 5
138bcce80b
GEMESSEN, NICHT VERMUTET, und es war live: Aufgaben, Bereichs-Eintraege
und Dateien eines Modis waren fuer Spicy Media sichtbar. Die NAMEN der
Modis waren ueberall sauber verborgen -- ihre ZEILEN nicht. Eine halbe
Verborgenheit ist keine.
WARUM ES PASSIEREN KONNTE: Fuer Personen gibt es die Regel EINMAL
zentral (verborgeneIds). Fuer Zeilen gibt es sie DREIMAL -- in
workspace-aufgaben.js, workspace-bereiche.js und workspace-dateien.js --
und alle drei geben Spicy Media dasselbe: "alles ausser dem, was
DogFather gehoert" (ohneDogFather). Ein Modi-Eintrag gehoert ihm nicht,
also fiel er durch.
Manager, Scout und Creator waren nie betroffen, ihre Regeln sind enger.
Der Kalender auch nicht: termineSichtbar() gibt jedem nur Eigenes.
Beides nachgesehen, nicht angenommen.
GEFUNDEN HAT ES KEINE UEBERLEGUNG, sondern eine Pruefung, die etwas
ANLEGT und danach mit fremden Augen nachsieht. Vorher hatte ich nur
Namenslisten geprueft -- und die waren die ganze Zeit gruen. Der Anlass
war nicht einmal Misstrauen gegen diese Stelle: Ich wollte ein
Ideen-Board auf die Eintraege setzen und dabei wissen, wer sie sieht.
BEHOBEN mit ohneModi() als Gegenstueck zu ohneDogFather -- und zwar als
UMHUELLUNG um die drei Regeln, nicht als Flicken darin. Ein Flicken
haette den einen bekannten Zweig geschlossen und den naechsten
Rollenzweig wieder offen gelassen; gemerkt haette es niemand, weil an
der geaenderten Stelle nichts davon steht.
Dazu die `fuerAlle`-Ausnahme bei den Eintraegen: Sie haengt ein ODER an
und haette die Bedingung sonst wieder aufgemacht. Heute hat kein Modi
eine Kachel in einen solchen Bereich -- ein Aufruf an der Oberflaeche
vorbei braucht sie aber nicht. Eine Regel, die nur im Formular gilt,
ist keine Regel.
Nachgesehen, dass die Umhuellung nirgends das falsche Tabellenkuerzel
setzt: Alle Aufrufstellen in workspace-hinweise.js und workspace-suche.js
fuehren die Tabellen als a, d und e -- genau so, wie es dasteht.
NEBENBEI: Das Modi-Team teilt sich jetzt auch die Bereichs-Eintraege,
nicht nur die Aufgaben (Entscheidung Filipe, 09.09.2026: "sie sind
untereinander ein Team"). Ohne diesen Zweig saehe jeder Modi nur, was er
selbst geschrieben hat -- eine gemeinsame Sammlung waere keine.
ZWEI EIGENE FEHLER AUF DEM WEG DAHIN, beide festgehalten:
* Die neue Messung stand HINTER der Gegenprobe. Die macht eine Person
absichtlich zur Creatorin -- die Messung bekam 403 und meldete
"kann nichts anlegen". Gemessen wurde ein Zustand, den es im
Betrieb nicht gibt. Genau davor warnt der Kommentar, den ich selbst
zwei Tage vorher an diese Gegenprobe geschrieben hatte.
* Das "konnte nicht nachsehen" nannte KEINEN Grund. Damit ist der
dritte Ausgang nur dem Namen nach da -- man weiss danach so wenig
wie vorher. Erst mit der Fehlermeldung im Text kam ich auf die Spur.
GEPRUEFT: pruef-modi-verborgen (75, davon 18 neu ueber drei Tabellen und
fuenf Rollen), pruef-spicy (60), pruef-bereiche-lesend,
pruef-aufgabenbrett, pruef-modi-katalog (29).
Co-Authored-By: Claude Opus 5 <[email protected]>
506 lines
22 KiB
JavaScript
506 lines
22 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 } from "node:fs";
|
||
import {
|
||
db, protokolliere, echteIp, sitzungLesen, DATEN_ORDNER, betreutWo, darfCreator, betreuteIds, istLeitung, istDogFather, siehtAlles, istSpicy, ohneDogFather, ROLLEN_SORTIERUNG,
|
||
externSql, EXTERN_MAX, sichtbarePersonenIds,
|
||
ohneModi, siehtModis,
|
||
} 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 || siehtModis(person)) return regel;
|
||
return {
|
||
wo: `(${regel.wo}) AND ${ohneModi("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,
|
||
${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`;
|
||
|
||
/* ---------- 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) || [];
|
||
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" });
|
||
|
||
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" });
|
||
});
|