DogFatherGitandClaude Opus 5
1386534051
Stufe 9 aus dem Plan. Eine Aufgabe "Vertrag pruefen" ohne den Vertrag daneben ist eine Aufforderung zum Suchen. KEIN ZWEITER HOCHLADEWEG Dateien leben in der Dateiablage -- mit ihrer Sichtbarkeit, ihren Freigaben, ihren Fassungen und ihrem Protokoll. Ein eigener Weg an der Aufgabe waere eine zweite Ablage mit einer zweiten Rechtelogik gewesen, und die zweite ist immer die, die etwas durchlaesst. Deshalb nur eine Spalte: Die Datei WEISS, zu welcher Aufgabe sie gehoert. Hochgeladen wird ueber denselben Weg wie immer, mit einem Kopf mehr. Alles andere bleibt, wo es schon richtig ist -- die Anhaenge tragen deshalb auch ihre Fassungsnummer und die Warnung "nicht mehr aktuell" mit, ohne dass dafuer eine Zeile geschrieben werden musste. DER RIEGEL Waere `x-aufgabe` ungeprueft, waere der Kopf ein Weg, die Existenz fremder Aufgaben zu erfahren -- man muesste nur Zahlen durchprobieren. Geprueft wird deshalb gegen dieselbe Schranke wie fuer die Datei selbst: `darfCreator`, die eine Stelle im Haus, an der diese Frage beantwortet wird. Eine eigene Herleitung hier waere eine zweite Meinung darueber gewesen. (Erster Anlauf: genau so eine Herleitung, mit einer Funktion, die gar nicht importiert war.) Gemessen: Ein Scout darf an die Aufgabe SEINER Creatorin, an die eines fremden Creators nicht -- mit wortgleicher Absage wie bei einer erfundenen Nummer. Der Unterschied waere sonst die Auskunft. Und es bleibt auch keine lose Datei liegen: Die Pruefung findet vor dem ersten Byte statt. ON DELETE SET NULL, NICHT CASCADE Der wichtigste Teil der Spalte: Wer eine Aufgabe loescht, will die Aufgabe loeschen, nicht den Vertrag, der daran hing. Die Datei verliert nur ihren Bezug und steht danach wieder in der Ablage. Gemessen. EIN EIGENER FEHLER, GEFUNDEN BEIM MESSEN Der Verweis am Anhang zeigte auf /workspace/api/dateien/:id -- den es gar nicht gibt, der Weg heisst /inhalt. Die Pruefung ruft ihn jetzt wirklich auf und erwartet 200, statt nur die Adresse zu vergleichen. PRUEFUNGEN: pruef-anhaenge neu mit 37, davon 8 im Browser. Co-Authored-By: Claude Opus 5 <[email protected]>
699 lines
30 KiB
JavaScript
699 lines
30 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,
|
||
ohneTeamDogi, ohneAgentur, 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) 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;
|
||
|
||
const { lastInsertRowid } = db().prepare(`
|
||
INSERT INTO dateien
|
||
(name_original, name_datei, groesse, typ, status, notiz,
|
||
creator_id, hochgeladen_von, erstellt, ersetzt_id, aufgabe_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);
|
||
|
||
/* 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 ------------------------------------------------ */
|
||
|
||
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" });
|
||
});
|