Zwei bis drei Bilder je Supportmeldung -- und zwei Funde unterwegs
VanVan im Support, Meldung #11, VIERMAL gemeldet: „Hier im Supportbereich kann man immer nur ein Bild hinzufuegen bei einer Meldung. 2-3 waeren besser." Und in der zweiten Runde der Satz, auf den es ankommt: „wenn man es nacheinander versucht hinzuzufuegen wird das Bild immer nur ersetzt." EINE TABELLE STATT NEUER SPALTEN `support_bilder` haelt ab jetzt JEDES Supportbild -- das der Meldung (`runde_nr` NULL) und das einer Antwort (`runde_nr` = Runde). Die Alternative waere `bild2_datei`, `bild3_datei` gewesen, und beim vierten Bild wieder. Eine Zeile je Bild kennt keine Obergrenze im Schema; die Grenze steht an EINER Stelle im Code (`BILDER_MAX = 3`) und kommt von dort in die Oberflaeche, statt dort ein zweites Mal zu stehen. DIE ACHT VORHANDENEN BILDER WANDERN MIT. Ohne diesen Schritt haette die neue Tabelle ab heute recht und die alten Bilder waeren unsichtbar -- ohne Fehler, ohne rote Zeile, nur acht leere Karten. Der Umzug steht NACH der Spaltennachruestung: Er liest `urteil_bild_datei`, und die gibt es in einer bestehenden Datenbank erst, nachdem sie ergaenzt wurde. Stuende er davor, scheiterte er genau dort, wo es darauf ankommt -- live, waehrend lokal alles gruen bliebe, weil jede Pruefung ihre Datenbank frisch anlegt. DREI BILDER IN EINER ANFRAGE `x-bilder: 20481,15320` sagt, wo zu schneiden ist, der Rumpf ist die Aneinanderreihung. `multipart/form-data` haette einen Zerleger gebraucht, den dieses Haus nicht hat; drei Anfragen nacheinander haetten den Zustand „Meldung da, Bild zwei laedt noch" erzeugt -- genau den, gegen den die Kommentare an dieser Route schon vorher argumentieren. Die Summe muss auf das Byte stimmen, und jedes Stueck wird einzeln an seinen ersten Bytes erkannt: Wer falsch schneidet, bekommt eine Absage, kein verfaelschtes Bild. Ohne den Kopf gilt der ganze Rumpf als ein Bild -- derselbe Satz mit einer Laenge, damit eine Seite aus dem Zwischenspeicher weiterlaeuft. EINE ROUTE STATT DREI. `/:id/bild` und `/:id/runde/:nr/bild` sind weg; es gibt `/:id/bild/:bid`. Wohin ein Bild gehoert, steht in seiner Zeile -- der Weg muss es nicht wiederholen. Die Meldungsnummer bleibt trotzdem im Pfad: Sie ist die Sichtbarkeitsfrage, und beides muss zusammenpassen (gemessen). ZWEI FUNDE, DIE DIE PRUEFUNG GEMACHT HAT UND NICHT ICH 1. UEBER DIE SEITE KAM GAR KEIN BILD MEHR AN. Beim Melden stand kein `Content-Type`. Das ging gut, solange der Rumpf eine einzelne Datei war -- ein `File` bringt seinen Typ mit. Ein `Blob` aus mehreren hat keinen, `fetch` schickt die Zeile dann gar nicht, `express.raw` fuehlt sich nicht zustaendig, und der Server bekam einen leeren Rumpf. Die Meldung waere durchgegangen, der Text angekommen, die Bilder weg -- ohne Fehlermeldung. Alle Pruefungen am Server waren dabei gruen; gefunden hat es erst der echte Browser. 2. DAS KREUZ DES DRITTEN BILDES LAG AUF DEM ZWEITEN. Der Entfernen-Knopf ist 44 px breit und absolut gesetzt, der Kasten aber nur so breit wie sein Bild. Bei einem schmalen Bild ragt er darueber hinaus -- wer „das zweite weg" antippt, loescht das dritte. `min-width`/`min-height` loesen das an der Ursache: Ein Kasten ist nie schmaler als der Knopf in ihm. WAS ICH FALSCH ANGENOMMEN HATTE: Ich hatte eingebaut, dass ein Nachtrag in derselben Runde die Bilder ersetzt. Die Pruefung dazu wurde rot -- zu Recht: Eine zweite Antwort in derselben Runde kann es nicht geben, die erste verlaesst den Stand „wartet". Der Code waere nie gelaufen und damit nie pruefbar gewesen. Er ist weg; an seiner Stelle steht der Beweis, dass er nicht fehlt. DREI WEITERE ROTE ZEILEN, DIE NICHT ZU DIESEM UMBAU GEHOERTEN * `manager-ziele.js` hatte einen ZWEITEN Notnagel (`frageNach ? … : confirm(…)`). `nachfrage.js` hat denselben laengst, und zwar mit dem vollstaendigen Text; der hiesige war der kuerzere und haette gewonnen. Zwei Antworten auf dieselbe Frage -- gemeldet von `pruef-nachfrage`. * Zwei Mittelpunkte in `reaktion.css` standen woertlich im `content`. Sie liegen im Latin-1-Block, wo `pruef-zeichen` die Truemmer einer verunglueckten Kodierung sucht. Jetzt als Escape -- im Browser nachgemessen, es steht Zeichen fuer Zeichen dasselbe da. * Das Aufraeumen nach 90 Tagen loeschte nur das EINE Bild der Meldung; die Bilder aus den Antwortrunden blieben ohne Zeile auf der Platte liegen. Die Liste kommt jetzt aus einer Abfrage statt aus einer Spalte und kann deshalb nicht wieder unvollstaendig sein. GEPRUEFT pruef-support 78 -> 104 ok darunter: der Umzug der alten Bilder auf einer eigenen Wegwerf-Datenbank -- zweimal und dreimal gestartet, nichts verdoppelt, Datum von damals erhalten pruef-support-bilder NEU, 36 ok (echter Browser) dreimal nacheinander waehlen ergibt drei, das vierte wird mit einem Satz abgelehnt, dasselbe zaehlt nicht doppelt, einzeln entfernen laesst die anderen stehen, alle drei laden wirklich (naturalWidth), Kreuze 44x44 und keines verdeckt (mit Gegenprobe per Deckel), nichts ragt auf 390 px heraus pruef-nachfrage 69 -> 74 ok pruef-struktur 102 ok, 413 Routen (vorher 414: zwei weg, eine neu) pruef-zeichen 7 ok (vorher 1 Fehler) pruef-aufbewahrung 45 ok pruef-manager-ziele 216 ok pruef-ports 10 ok · pruef-portnummern 41 ok (die neue Pruefdatei verschiebt die abgeleiteten Nummern) NUR DAS AGENTURHAUS IST BETROFFEN. Die Supportseite liegt unter `/workspace`; am Crew-Haus aendert sich keine Zeile. Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
Claude Opus 5
+315
-113
@@ -64,6 +64,19 @@ const ANTWORT_MAX = 2000;
|
||||
* Ein Bildschirmfoto vom Handy liegt bei 2 bis 5 MB. */
|
||||
const BILD_MAX = 12 * 1024 * 1024;
|
||||
|
||||
/** Wie viele Bilder an EINE Meldung oder EINE Antwort dürfen.
|
||||
*
|
||||
* VanVan im Support, Meldung #11 — viermal gemeldet: „Hier im
|
||||
* Supportbereich kann man immer nur ein Bild hinzufügen bei einer
|
||||
* Meldung. 2-3 wären besser." Also drei, ihre eigene Obergrenze.
|
||||
*
|
||||
* DIE ZAHL STEHT AN EINER STELLE und nirgends sonst. Im Schema gibt
|
||||
* es sie nicht (eine Zeile je Bild kennt keine Grenze), in der
|
||||
* Oberfläche wird sie vom Server geholt. Eine zweite Zahl im Browser
|
||||
* wäre die, die beim Erhöhen vergessen wird — genau das Muster, das
|
||||
* am 06.09. den Umbruch bei 380 px gekostet hat. */
|
||||
const BILDER_MAX = 3;
|
||||
|
||||
/** Wie viele offene Meldungen eine Person gleichzeitig haben darf.
|
||||
*
|
||||
* Zehn, und damit deutlich großzügiger als die drei im vertraulichen
|
||||
@@ -100,6 +113,160 @@ function textSauber(s, max) {
|
||||
.slice(0, max);
|
||||
}
|
||||
|
||||
/* =====================================================================
|
||||
MEHRERE BILDER — EIN RUMPF, DIE LÄNGEN IM KOPF (02.10.2026)
|
||||
=====================================================================
|
||||
|
||||
VanVan, Meldung #11: „2-3 wären besser." Und in der zweiten Runde
|
||||
der Grund, warum der erste Versuch nicht reichte: „wenn man es
|
||||
nacheinander versucht hinzuzufügen wird das Bild immer nur
|
||||
ersetzt."
|
||||
|
||||
WIE DREI BILDER IN EINE ANFRAGE KOMMEN. Bisher war der Rumpf EIN
|
||||
Bild — roh, ohne Verpackung, und `dateiErkennen` sah an den ersten
|
||||
Bytes, was es ist. Für mehrere braucht es eine Grenze dazwischen.
|
||||
Drei Wege standen zur Wahl:
|
||||
|
||||
1. `multipart/form-data`. Der übliche Weg — und er braucht einen
|
||||
Zerleger, den dieses Haus nicht hat. Ein Paket mehr, um eine
|
||||
Zahl zu übertragen, die auch in einen Kopf passt.
|
||||
2. Drei Anfragen nacheinander. Das ist genau der Zustand, gegen
|
||||
den die Kommentare bei `POST /support` schon argumentieren:
|
||||
eine Meldung, die es gibt, während Bild zwei noch lädt — und
|
||||
bei Abbruch für immer unvollständig.
|
||||
3. DIE LÄNGEN IM KOPF, die Bilder hintereinander im Rumpf.
|
||||
|
||||
Es ist 3 geworden: `x-bilder: 20481,15320` sagt, wo zu schneiden
|
||||
ist, und der Rumpf ist die Aneinanderreihung. Dieselbe Linie wie
|
||||
bisher („Text im Kopf, Bild im Rumpf"), nur eine Angabe weiter.
|
||||
|
||||
EINE FALSCHE LÄNGE KANN NICHTS KAPUTTMACHEN. Die Summe muss auf
|
||||
das Byte stimmen, sonst 400 — und jedes Stück wird danach einzeln
|
||||
von `dateiErkennen` an seinen ersten Bytes gemessen. Wer falsch
|
||||
schneidet, bekommt kein verfälschtes Bild, sondern eine Absage.
|
||||
|
||||
OHNE DEN KOPF IST ES DER ALTE WEG — ein Bild, der ganze Rumpf.
|
||||
Das ist keine zweite Tür, sondern derselbe Satz mit einer Länge:
|
||||
`[rumpf.length]`. Dadurch funktioniert eine Seite, die noch im
|
||||
Zwischenspeicher des Browsers liegt, unverändert weiter. */
|
||||
|
||||
/** Den Rumpf in einzelne Bilder zerlegen.
|
||||
*
|
||||
* Gibt `{ teile }` oder `{ fehler: { code, text } }` zurück — nie
|
||||
* beides und nie `null` für „ging schief". Der Aufrufer soll den
|
||||
* Fehler weiterreichen können, ohne ihn selbst zu formulieren;
|
||||
* sonst steht derselbe Satz an zwei Routen und altert einmal. */
|
||||
function rumpfZerlegen(req) {
|
||||
const rumpf = Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0);
|
||||
if (!rumpf.length) return { teile: [] };
|
||||
|
||||
const kopf = String(req.get("x-bilder") || "").trim();
|
||||
let laengen;
|
||||
if (!kopf) {
|
||||
laengen = [rumpf.length];
|
||||
} else {
|
||||
laengen = kopf.split(",").map((s) => Number(s.trim()));
|
||||
if (laengen.some((n) => !Number.isInteger(n) || n <= 0)) {
|
||||
return { fehler: { code: 400, text: "Die Bildlängen sind unbrauchbar." } };
|
||||
}
|
||||
}
|
||||
if (laengen.length > BILDER_MAX) {
|
||||
return {
|
||||
fehler: {
|
||||
code: 400,
|
||||
text: `Mehr als ${BILDER_MAX} Bilder gehen nicht – nimm die wichtigsten.`,
|
||||
},
|
||||
};
|
||||
}
|
||||
if (laengen.some((n) => n > BILD_MAX)) {
|
||||
return { fehler: { code: 413, text: "Ein Bild ist größer als 12 MB." } };
|
||||
}
|
||||
const summe = laengen.reduce((a, b) => a + b, 0);
|
||||
/* AUF DAS BYTE. Ein „ungefähr" hieße, dass das letzte Bild
|
||||
abgeschnitten ankommt und trotzdem gespeichert wird. */
|
||||
if (summe !== rumpf.length) {
|
||||
return { fehler: { code: 400, text: "Die Bilder sind unterwegs beschädigt worden." } };
|
||||
}
|
||||
|
||||
const teile = [];
|
||||
let ab = 0;
|
||||
for (const n of laengen) { teile.push(rumpf.subarray(ab, ab + n)); ab += n; }
|
||||
return { teile };
|
||||
}
|
||||
|
||||
/** Die Stücke prüfen und auf die Platte legen.
|
||||
*
|
||||
* Gibt `{ bilder }` oder `{ fehler }`. Was schon geschrieben wurde,
|
||||
* räumt sie bei einem späteren Fehlschlag SELBST weg — sonst
|
||||
* sammelt der Ordner Dateien an, auf die keine Zeile zeigt und die
|
||||
* deshalb niemand je wieder zuordnen kann. */
|
||||
function bilderAblegen(teile) {
|
||||
const bilder = [];
|
||||
try {
|
||||
for (const stueck of teile) {
|
||||
const erkannt = dateiErkennen(stueck);
|
||||
/* NUR BILDER. `dateiErkennen` kennt auch PDF und Ton — hier geht
|
||||
es um Bildschirmfotos, und alles andere wäre eine Tür, nach
|
||||
der niemand gefragt hat. */
|
||||
if (!erkannt || erkannt.art !== "bild") {
|
||||
for (const b of bilder) {
|
||||
try { unlinkSync(join(BILD_ORDNER, b.datei)); } catch { /* egal */ }
|
||||
}
|
||||
return {
|
||||
fehler: {
|
||||
code: 415,
|
||||
text: "Als Anhang geht ein Foto – PNG, JPEG, WebP oder GIF.",
|
||||
},
|
||||
};
|
||||
}
|
||||
mkdirSync(BILD_ORDNER, { recursive: true });
|
||||
const datei = `${Date.now()}-${randomBytes(8).toString("hex")}${erkannt.endung}`;
|
||||
writeFileSync(join(BILD_ORDNER, datei), stueck);
|
||||
bilder.push({
|
||||
datei, typ: erkannt.typ,
|
||||
breite: erkannt.breite || 0, hoehe: erkannt.hoehe || 0,
|
||||
});
|
||||
}
|
||||
} catch (fehler) {
|
||||
for (const b of bilder) {
|
||||
try { unlinkSync(join(BILD_ORDNER, b.datei)); } catch { /* egal */ }
|
||||
}
|
||||
throw fehler;
|
||||
}
|
||||
return { bilder };
|
||||
}
|
||||
|
||||
/** Die Zeilen schreiben — zur Meldung (`rundeNr === null`) oder zu
|
||||
* einer Antwort. EINE Tabelle für beides, siehe support-tabellen.js. */
|
||||
function bilderEintragen(meldungId, rundeNr, bilder, wann) {
|
||||
const satz = db().prepare(`INSERT INTO support_bilder
|
||||
(meldung_id, runde_nr, datei, typ, breite, hoehe, erstellt)
|
||||
VALUES (?,?,?,?,?,?,?)`);
|
||||
for (const b of bilder) {
|
||||
satz.run(meldungId, rundeNr, b.datei, b.typ, b.breite, b.hoehe, wann);
|
||||
}
|
||||
}
|
||||
|
||||
/** Die Bilder einer Meldung oder einer Runde, in der Reihenfolge des
|
||||
* Hochladens.
|
||||
*
|
||||
* DER WEG, NICHT DER DATEINAME. Was auf der Platte liegt, geht
|
||||
* niemanden etwas an, der nur ein Bild anzeigen will — dieselbe
|
||||
* Entscheidung wie beim Chat-Anhang. */
|
||||
function bilderVon(meldungId, rundeNr) {
|
||||
const zeilen = rundeNr === null
|
||||
? db().prepare(`SELECT id, breite, hoehe FROM support_bilder
|
||||
WHERE meldung_id = ? AND runde_nr IS NULL ORDER BY id`).all(meldungId)
|
||||
: db().prepare(`SELECT id, breite, hoehe FROM support_bilder
|
||||
WHERE meldung_id = ? AND runde_nr = ? ORDER BY id`).all(meldungId, rundeNr);
|
||||
return zeilen.map((z) => ({
|
||||
id: z.id,
|
||||
weg: `/workspace/api/support/${meldungId}/bild/${z.id}`,
|
||||
breite: z.breite || 0,
|
||||
hoehe: z.hoehe || 0,
|
||||
}));
|
||||
}
|
||||
|
||||
/** Darf diese Person diese Meldung sehen?
|
||||
*
|
||||
* Gibt die Meldung zurück oder `null`. NIE `true`/`false` — dasselbe
|
||||
@@ -153,13 +320,15 @@ function nachDraussen(m, fuerLeitung, werFragtId) {
|
||||
geaendert: m.geaendert,
|
||||
erledigt_am: m.erledigt_am || null,
|
||||
seite: m.seite || null,
|
||||
/* Das Bild als fertige ADRESSE, nicht als Dateiname — sonst setzt
|
||||
jede Stelle im Browser denselben Pfad zusammen, und eine davon
|
||||
setzt ihn irgendwann anders. Dieselbe Entscheidung wie beim
|
||||
Chat-Anhang. */
|
||||
bild: m.bild_datei ? `/workspace/api/support/${m.id}/bild` : null,
|
||||
bild_breite: m.bild_breite || 0,
|
||||
bild_hoehe: m.bild_hoehe || 0,
|
||||
/* ==== EINE LISTE, AUCH WENN NUR EINES DRAN HÄNGT (02.10.2026) ==
|
||||
|
||||
Hier standen `bild`, `bild_breite`, `bild_hoehe` — drei Felder
|
||||
für genau ein Bild. Daneben eine Liste zu stellen hieße: zwei
|
||||
Auskünfte auf dieselbe Frage, und die zweite wird irgendwann
|
||||
nicht mehr mitgepflegt. Deshalb nur noch `bilder` — leer,
|
||||
eines oder bis zu drei. Die Oberfläche schleift darüber und
|
||||
muss den Sonderfall „genau eines" nicht kennen. */
|
||||
bilder: bilderVon(m.id, null),
|
||||
von: m.von_name || null,
|
||||
von_rolle: m.von_rolle || null,
|
||||
/* Nur die Leitung braucht zu wissen, mit welchem Gerät gemeldet
|
||||
@@ -191,18 +360,16 @@ function nachDraussen(m, fuerLeitung, werFragtId) {
|
||||
|
||||
/** Der Verlauf einer Meldung -- eine Zeile je Runde. */
|
||||
function verlaufVon(id) {
|
||||
return db().prepare(`SELECT nr, antwort, von_name, am, urteil, urteil_text, urteil_am,
|
||||
urteil_bild_datei
|
||||
return db().prepare(`SELECT nr, antwort, von_name, am, urteil, urteil_text, urteil_am
|
||||
FROM support_runden WHERE meldung_id = ? ORDER BY nr`).all(id)
|
||||
.map((r) => ({
|
||||
nr: r.nr, antwort: r.antwort, von: r.von_name || null, am: r.am,
|
||||
urteil: r.urteil || null, urteil_text: r.urteil_text || null,
|
||||
urteil_am: r.urteil_am || null,
|
||||
/* DER WEG, NICHT DER DATEINAME. Wie beim Bild der Meldung eine
|
||||
Zeile weiter oben: Was auf der Platte liegt, geht niemanden
|
||||
etwas an, der nur ein Bild anzeigen will. */
|
||||
urteil_bild: r.urteil_bild_datei
|
||||
? `/workspace/api/support/${id}/runde/${r.nr}/bild` : null,
|
||||
/* AUCH HIER EINE LISTE und dieselbe Form wie bei der Meldung —
|
||||
die Oberfläche hat dadurch EINE Funktion für beide Stellen
|
||||
statt zweier, die auseinanderlaufen. */
|
||||
bilder: bilderVon(id, r.nr),
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -241,6 +408,11 @@ supportRouter.get("/workspace/api/support", (req, res) => {
|
||||
: db().prepare(`SELECT COUNT(*) AS n FROM support_meldungen
|
||||
WHERE person_id = ? AND stand <> 'erledigt'`).get(req.person.id).n,
|
||||
hoechstens_bytes: BILD_MAX,
|
||||
/* WIE VIELE BILDER GEHEN — vom Server gesagt, nicht im Browser
|
||||
gewusst. Dieselbe Überlegung wie bei `hoechstens_bytes` eine
|
||||
Zeile darüber: Eine zweite Zahl in der Oberfläche wäre die,
|
||||
die beim Ändern vergessen wird. */
|
||||
bilder_max: BILDER_MAX,
|
||||
text_max: TEXT_MAX,
|
||||
});
|
||||
} catch (fehler) {
|
||||
@@ -249,20 +421,45 @@ supportRouter.get("/workspace/api/support", (req, res) => {
|
||||
}
|
||||
});
|
||||
|
||||
/** Das Bild einer Meldung.
|
||||
/** EIN Bild — egal ob es zur Meldung oder zu einer Antwort gehört.
|
||||
*
|
||||
* ==== EINE ROUTE STATT DREI (02.10.2026) ==========================
|
||||
*
|
||||
* Hier standen zwei: `/:id/bild` für das Bild der Meldung und
|
||||
* `/:id/runde/:nr/bild` für das der Antwort. Mit bis zu drei Bildern
|
||||
* je Stelle hätte jede eine laufende Nummer dazubekommen — zwei
|
||||
* Routen, die dasselbe tun, und eine dritte Zählung, die zu nichts
|
||||
* gehört außer zur Reihenfolge in der Anzeige.
|
||||
*
|
||||
* Jetzt hat jedes Bild eine eigene Nummer (die Zeile in
|
||||
* `support_bilder`), und die Adresse nennt sie. Wohin es gehört,
|
||||
* steht in der Zeile — der Weg muss es nicht noch einmal sagen.
|
||||
*
|
||||
* DIE MELDUNGSNUMMER BLEIBT TROTZDEM IM PFAD, obwohl die Bildnummer
|
||||
* allein eindeutig wäre. Sie ist die SICHTBARKEITSFRAGE: Wer die
|
||||
* Meldung sehen darf, sieht ihre Bilder. Stünde sie nicht im Pfad,
|
||||
* müsste die Route sie aus der Bildzeile nachschlagen — dasselbe
|
||||
* Ergebnis, aber ein Blick in den Quelltext mehr, um es zu wissen.
|
||||
* Beides muss zusammenpassen, sonst 404.
|
||||
*
|
||||
* Dieselben Kopfzeilen wie beim Chat-Anhang: der Typ aus der
|
||||
* ERKENNUNG (nicht der eingeschickte), nosniff, und eine Richtlinie,
|
||||
* die dem Dokument jede Ausführung nimmt. */
|
||||
supportRouter.get("/workspace/api/support/:id(\\d+)/bild", (req, res) => {
|
||||
* die dem Dokument jede Ausführung nimmt.
|
||||
*
|
||||
* 404 UND NICHT 403, wie überall im Haus: Wer eine fremde Meldung
|
||||
* nicht sehen darf, soll auch nicht erfahren, dass es sie gibt. */
|
||||
supportRouter.get("/workspace/api/support/:id(\\d+)/bild/:bid(\\d+)", (req, res) => {
|
||||
try {
|
||||
const m = meldungFuer(req.person, req.params.id);
|
||||
if (!m || !m.bild_datei) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||||
const pfad = join(BILD_ORDNER, m.bild_datei);
|
||||
if (!m) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||||
const b = db().prepare("SELECT datei, typ FROM support_bilder WHERE id = ? AND meldung_id = ?")
|
||||
.get(Number(req.params.bid), m.id);
|
||||
if (!b) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||||
const pfad = join(BILD_ORDNER, b.datei);
|
||||
try { statSync(pfad); } catch {
|
||||
return res.status(410).json({ fehler: "Das Bild fehlt auf der Platte." });
|
||||
}
|
||||
res.setHeader("Content-Type", m.bild_typ || "image/png");
|
||||
res.setHeader("Content-Type", b.typ || "image/png");
|
||||
res.setHeader("X-Content-Type-Options", "nosniff");
|
||||
res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
|
||||
res.setHeader("Cache-Control", "private, max-age=86400");
|
||||
@@ -308,9 +505,16 @@ function darfMelden(req, res, next) {
|
||||
* Ein leerer Rumpf ist zulässig: Dann gibt es eben kein Bild. */
|
||||
supportRouter.post("/workspace/api/support",
|
||||
darfMelden,
|
||||
express.raw({ type: "*/*", limit: BILD_MAX }),
|
||||
/* DREIMAL DIE EINZELGRENZE. Das Paket darf so groß sein wie drei
|
||||
erlaubte Bilder — mehr nicht. Hier `BILD_MAX` stehen zu lassen
|
||||
hieße: Wer zwei Bildschirmfotos schickt, bekommt eine Absage von
|
||||
express, bevor irgendeine Zeile dieses Hauses davon erfährt, und
|
||||
sie lautete „request entity too large" statt eines Satzes, mit
|
||||
dem jemand etwas anfangen kann. Die Grenze JE BILD prüft
|
||||
`rumpfZerlegen` weiterhin selbst. */
|
||||
express.raw({ type: "*/*", limit: BILD_MAX * BILDER_MAX }),
|
||||
(req, res) => {
|
||||
let geschrieben = null;
|
||||
let geschrieben = [];
|
||||
try {
|
||||
let text = "";
|
||||
try { text = decodeURIComponent(req.get("x-text") || ""); } catch { text = ""; }
|
||||
@@ -321,38 +525,33 @@ supportRouter.post("/workspace/api/support",
|
||||
});
|
||||
}
|
||||
|
||||
let bildDatei = null, bildTyp = null, bildBreite = 0, bildHoehe = 0;
|
||||
if (Buffer.isBuffer(req.body) && req.body.length) {
|
||||
const erkannt = dateiErkennen(req.body);
|
||||
/* NUR BILDER. dateiErkennen kennt auch PDF und Ton — hier geht
|
||||
es um Bildschirmfotos, und alles andere wäre eine Tür, die
|
||||
niemand bestellt hat. */
|
||||
if (!erkannt || erkannt.art !== "bild") {
|
||||
return res.status(415).json({
|
||||
fehler: "Als Anhang geht ein Foto – PNG, JPEG, WebP oder GIF.",
|
||||
});
|
||||
}
|
||||
mkdirSync(BILD_ORDNER, { recursive: true });
|
||||
bildDatei = `${Date.now()}-${randomBytes(8).toString("hex")}${erkannt.endung}`;
|
||||
writeFileSync(join(BILD_ORDNER, bildDatei), req.body);
|
||||
geschrieben = join(BILD_ORDNER, bildDatei);
|
||||
bildTyp = erkannt.typ;
|
||||
bildBreite = erkannt.breite || 0;
|
||||
bildHoehe = erkannt.hoehe || 0;
|
||||
const zerlegt = rumpfZerlegen(req);
|
||||
if (zerlegt.fehler) {
|
||||
return res.status(zerlegt.fehler.code).json({ fehler: zerlegt.fehler.text });
|
||||
}
|
||||
const abgelegt = bilderAblegen(zerlegt.teile);
|
||||
if (abgelegt.fehler) {
|
||||
return res.status(abgelegt.fehler.code).json({ fehler: abgelegt.fehler.text });
|
||||
}
|
||||
geschrieben = abgelegt.bilder.map((b) => join(BILD_ORDNER, b.datei));
|
||||
|
||||
const n = jetzt();
|
||||
/* DIE ALTEN BILDSPALTEN WERDEN NICHT MEHR GEFÜLLT (02.10.2026).
|
||||
Sie stehen noch in der Tabelle, weil sie wegzunehmen hieße,
|
||||
sie neu zu bauen — und genau dabei gingen am 11.09. drei
|
||||
Spalten verloren. Ihr Inhalt ist beim Start nach
|
||||
`support_bilder` gewandert; von dort wird ab jetzt gelesen,
|
||||
und nur von dort. */
|
||||
const info = db().prepare(`INSERT INTO support_meldungen
|
||||
(person_id, von_name, von_rolle, text, seite, geraet,
|
||||
bild_datei, bild_typ, bild_breite, bild_hoehe,
|
||||
stand, erstellt, geaendert)
|
||||
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)`)
|
||||
VALUES (?,?,?,?,?,?,?,?,?)`)
|
||||
.run(req.person.id, req.person.name || null, req.person.rolle || null,
|
||||
text, sauber(req.get("x-seite"), SEITE_MAX) || null,
|
||||
sauber(req.get("user-agent"), GERAET_MAX) || null,
|
||||
bildDatei, bildTyp, bildBreite, bildHoehe,
|
||||
SUPPORT_STAND.neu, n, n);
|
||||
const id = Number(info.lastInsertRowid);
|
||||
bilderEintragen(id, null, abgelegt.bilder, n);
|
||||
|
||||
protokolliere("support_gemeldet", {
|
||||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||||
@@ -380,10 +579,13 @@ supportRouter.post("/workspace/api/support",
|
||||
meldung: nachDraussen(frisch, istLeitung(req.person), req.person.id),
|
||||
});
|
||||
} catch (fehler) {
|
||||
/* DIE DATEI GEHT MIT, WENN DIE ZEILE NICHT ZUSTANDE KAM. Sonst
|
||||
sammelt der Ordner Bilder an, zu denen es keine Meldung gibt —
|
||||
und niemand merkt es, weil nichts darauf zeigt. */
|
||||
if (geschrieben) { try { unlinkSync(geschrieben); } catch { /* egal */ } }
|
||||
/* DIE DATEIEN GEHEN MIT, WENN DIE ZEILE NICHT ZUSTANDE KAM.
|
||||
Sonst sammelt der Ordner Bilder an, zu denen es keine Meldung
|
||||
gibt — und niemand merkt es, weil nichts darauf zeigt.
|
||||
ALLE DREI, nicht nur das letzte: Hier stand eine einzelne
|
||||
Variable, und mit mehreren Bildern wäre genau das die stille
|
||||
Lücke geworden. */
|
||||
for (const p of geschrieben) { try { unlinkSync(p); } catch { /* egal */ } }
|
||||
console.error("[support] Melden:", fehler?.message);
|
||||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||||
}
|
||||
@@ -449,8 +651,8 @@ supportRouter.post("/workspace/api/support",
|
||||
EIN LEERER RUMPF IST ZULÄSSIG. Wer kein Bildschirmfoto hat, soll
|
||||
trotzdem antworten können; ein Bild ist Hilfe, keine Hürde. */
|
||||
supportRouter.post("/workspace/api/support/:id/rueckmeldung",
|
||||
express.raw({ type: "*/*", limit: BILD_MAX }), (req, res) => {
|
||||
let geschrieben = null;
|
||||
express.raw({ type: "*/*", limit: BILD_MAX * BILDER_MAX }), (req, res) => {
|
||||
let geschrieben = [];
|
||||
try {
|
||||
const id = Number(req.params.id);
|
||||
if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
|
||||
@@ -482,39 +684,51 @@ supportRouter.post("/workspace/api/support/:id/rueckmeldung",
|
||||
});
|
||||
}
|
||||
|
||||
/* DAS BILD -- dieselbe Erkennung und dieselbe Absage wie beim
|
||||
Melden. `dateiErkennen` kennt auch PDF und Ton; hier geht es
|
||||
um Bildschirmfotos, und alles andere wäre eine Tür, nach der
|
||||
niemand gefragt hat. */
|
||||
let bildDatei = null, bildTyp = null, bildBreite = 0, bildHoehe = 0;
|
||||
if (Buffer.isBuffer(req.body) && req.body.length) {
|
||||
const erkannt = dateiErkennen(req.body);
|
||||
if (!erkannt || erkannt.art !== "bild") {
|
||||
return res.status(415).json({
|
||||
fehler: "Als Anhang geht ein Foto – PNG, JPEG, WebP oder GIF.",
|
||||
});
|
||||
}
|
||||
mkdirSync(BILD_ORDNER, { recursive: true });
|
||||
bildDatei = `${Date.now()}-${randomBytes(8).toString("hex")}${erkannt.endung}`;
|
||||
writeFileSync(join(BILD_ORDNER, bildDatei), req.body);
|
||||
geschrieben = join(BILD_ORDNER, bildDatei);
|
||||
bildTyp = erkannt.typ;
|
||||
bildBreite = erkannt.breite || 0;
|
||||
bildHoehe = erkannt.hoehe || 0;
|
||||
/* DIE BILDER -- derselbe Weg und dieselbe Absage wie beim
|
||||
Melden, und zwar wörtlich dieselben zwei Funktionen. Eine
|
||||
eigene Fassung hier wäre die, die beim nächsten Dateityp
|
||||
vergessen wird. */
|
||||
const zerlegt = rumpfZerlegen(req);
|
||||
if (zerlegt.fehler) {
|
||||
return res.status(zerlegt.fehler.code).json({ fehler: zerlegt.fehler.text });
|
||||
}
|
||||
const abgelegt = bilderAblegen(zerlegt.teile);
|
||||
if (abgelegt.fehler) {
|
||||
return res.status(abgelegt.fehler.code).json({ fehler: abgelegt.fehler.text });
|
||||
}
|
||||
geschrieben = abgelegt.bilder.map((b) => join(BILD_ORDNER, b.datei));
|
||||
|
||||
const n = jetzt();
|
||||
const runde = m.runde || 1;
|
||||
db().prepare(`UPDATE support_runden
|
||||
SET urteil = ?, urteil_text = ?, urteil_am = ?,
|
||||
urteil_bild_datei = COALESCE(?, urteil_bild_datei),
|
||||
urteil_bild_typ = COALESCE(?, urteil_bild_typ),
|
||||
urteil_bild_breite = COALESCE(?, urteil_bild_breite),
|
||||
urteil_bild_hoehe = COALESCE(?, urteil_bild_hoehe)
|
||||
SET urteil = ?, urteil_text = ?, urteil_am = ?
|
||||
WHERE meldung_id = ? AND nr = ?`)
|
||||
.run(geht ? "geht" : "nicht", wort || null, n,
|
||||
bildDatei, bildTyp, bildDatei ? bildBreite : null,
|
||||
bildDatei ? bildHoehe : null, m.id, runde);
|
||||
.run(geht ? "geht" : "nicht", wort || null, n, m.id, runde);
|
||||
|
||||
/* ==== EINFACH EINTRAGEN -- OHNE „ERSETZEN" (02.10.2026) ======
|
||||
|
||||
Hier stand zuerst: alte Bilder dieser Runde löschen, dann die
|
||||
neuen eintragen. Begründung war „wer nachlegt, ersetzt seine
|
||||
Antwort, die Bilder müssen mitziehen". Das klang richtig und
|
||||
WAR ES NICHT -- die Prüfung dazu ist rot geworden, und zwar
|
||||
zu Recht: Der Fall gibt es nicht.
|
||||
|
||||
NACHGEMESSEN: Eine zweite Antwort IN DERSELBEN RUNDE ist
|
||||
unmöglich. `darfBestaetigen` verlangt den Stand „wartet", und
|
||||
diese Antwort hier verlässt ihn in jedem Fall -- bei „geht"
|
||||
nach „erledigt", bei „noch nicht" nach „in Arbeit" UND eine
|
||||
Runde weiter. Der Melder bekommt beim zweiten Versuch 409;
|
||||
genau das prüft `pruef-support` an zwei Stellen.
|
||||
|
||||
Also wäre das Löschen Code gewesen, der nie läuft -- und
|
||||
damit Code, den niemand je prüfen kann. Das ist dieselbe
|
||||
Sorte wie die Prüfung, die immer bestätigt: Sie sieht nach
|
||||
Sorgfalt aus und trägt nichts.
|
||||
|
||||
DIE GRENZE VON DREI STEHT DAMIT AN EINER STELLE: in
|
||||
`rumpfZerlegen`, je Anfrage -- und eine Anfrage je Runde ist
|
||||
alles, was es gibt. */
|
||||
bilderEintragen(m.id, runde, abgelegt.bilder, n);
|
||||
|
||||
if (geht) {
|
||||
db().prepare(`UPDATE support_meldungen
|
||||
@@ -556,49 +770,23 @@ supportRouter.post("/workspace/api/support/:id/rueckmeldung",
|
||||
const frisch = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(m.id);
|
||||
res.json({ meldung: nachDraussen(frisch, false, req.person.id) });
|
||||
} catch (fehler) {
|
||||
/* DIE DATEI WIEDER WEG, wenn das Schreiben danach scheitert --
|
||||
/* DIE DATEIEN WIEDER WEG, wenn das Schreiben danach scheitert --
|
||||
derselbe Handgriff wie beim Melden. Ohne ihn sammelt der
|
||||
Bildordner Dateien an, zu denen es keine Zeile gibt, und
|
||||
niemand kann sie je zuordnen. */
|
||||
if (geschrieben) { try { unlinkSync(geschrieben); } catch { /* egal */ } }
|
||||
for (const p of geschrieben) { try { unlinkSync(p); } catch { /* egal */ } }
|
||||
console.error("[support] Rueckmeldung:", fehler?.message);
|
||||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||||
}
|
||||
});
|
||||
|
||||
/* Das Bild zu EINER Runde.
|
||||
/* HIER STAND `/:id/runde/:nr/bild` (02.10.2026 entfernt).
|
||||
*
|
||||
* EIGENE ROUTE UND NICHT `/:id/bild` MIT ZUSATZ: Das Bild der
|
||||
* Meldung und das einer Antwort sind zwei verschiedene Dinge mit
|
||||
* verschiedenen Nummern. Eine Route, die mal das eine und mal das
|
||||
* andere liefert, braucht beim Lesen jedes Mal einen Blick in den
|
||||
* Quelltext.
|
||||
*
|
||||
* SICHTBARKEIT: dieselbe Regel wie beim Verlauf -- wer die Meldung
|
||||
* sehen darf, sieht auch ihre Bilder. 404 und nicht 403, damit
|
||||
* niemand an der Antwort ablesen kann, dass es die Meldung gibt. */
|
||||
supportRouter.get("/workspace/api/support/:id(\\d+)/runde/:nr(\\d+)/bild", (req, res) => {
|
||||
try {
|
||||
const m = meldungFuer(req.person, req.params.id);
|
||||
if (!m) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||||
const r = db().prepare(`SELECT urteil_bild_datei, urteil_bild_typ
|
||||
FROM support_runden WHERE meldung_id = ? AND nr = ?`)
|
||||
.get(m.id, Number(req.params.nr));
|
||||
if (!r || !r.urteil_bild_datei) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||||
const pfad = join(BILD_ORDNER, r.urteil_bild_datei);
|
||||
try { statSync(pfad); } catch {
|
||||
return res.status(410).json({ fehler: "Das Bild fehlt auf der Platte." });
|
||||
}
|
||||
res.setHeader("Content-Type", r.urteil_bild_typ || "image/png");
|
||||
res.setHeader("X-Content-Type-Options", "nosniff");
|
||||
res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
|
||||
res.setHeader("Cache-Control", "private, max-age=86400");
|
||||
liefereDatei(req, res, pfad);
|
||||
} catch (fehler) {
|
||||
console.error("[support] Rundenbild:", fehler?.message);
|
||||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||||
}
|
||||
});
|
||||
* Sie lieferte das EINE Bild einer Antwort und hätte für drei eine
|
||||
* laufende Nummer dazubekommen müssen. Statt zwei fast gleicher
|
||||
* Routen mit je einer Zählung gibt es jetzt eine einzige weiter
|
||||
* oben: `/:id/bild/:bid`. Wohin ein Bild gehört, steht in seiner
|
||||
* Zeile — der Weg muss es nicht wiederholen. */
|
||||
|
||||
supportRouter.patch("/workspace/api/support/:id(\\d+)", express.json(), (req, res) => {
|
||||
try {
|
||||
@@ -743,13 +931,27 @@ supportRouter.patch("/workspace/api/support/:id(\\d+)", express.json(), (req, re
|
||||
export function supportAufraeumen() {
|
||||
try {
|
||||
const grenze = new Date(Date.now() - AUFBEWAHRUNG_TAGE * 86400000).toISOString();
|
||||
const alt = db().prepare(`SELECT id, bild_datei FROM support_meldungen
|
||||
const alt = db().prepare(`SELECT id FROM support_meldungen
|
||||
WHERE stand = 'erledigt' AND erledigt_am IS NOT NULL AND erledigt_am < ?`).all(grenze);
|
||||
if (!alt.length) return 0;
|
||||
const dazu = db().prepare("SELECT datei FROM support_bilder WHERE meldung_id = ?");
|
||||
for (const m of alt) {
|
||||
if (m.bild_datei) {
|
||||
try { unlinkSync(join(BILD_ORDNER, m.bild_datei)); } catch { /* schon weg */ }
|
||||
/* ALLE BILDER DER MELDUNG, auch die aus den Antwortrunden
|
||||
(02.10.2026). Hier stand `m.bild_datei` — das EINE Bild der
|
||||
Meldung. Die Bilder zu den Antworten blieben damit auf der
|
||||
Platte liegen, ohne Zeile, die auf sie zeigt; aufgefallen ist
|
||||
es beim Umbau auf mehrere Bilder, nicht im Betrieb. Dass die
|
||||
Liste jetzt aus einer Abfrage kommt statt aus einer Spalte,
|
||||
ist der Grund, warum sie beim nächsten Ort nicht wieder
|
||||
unvollständig sein kann. */
|
||||
for (const b of dazu.all(m.id)) {
|
||||
try { unlinkSync(join(BILD_ORDNER, b.datei)); } catch { /* schon weg */ }
|
||||
}
|
||||
/* Die Zeilen in `support_bilder` gehen über ON DELETE CASCADE
|
||||
mit — vorausgesetzt, die Fremdschlüssel sind eingeschaltet.
|
||||
Deshalb hier zusätzlich von Hand: Eine Aufräumfunktion, die
|
||||
von einer Einstellung abhängt, räumt irgendwann nicht auf. */
|
||||
db().prepare("DELETE FROM support_bilder WHERE meldung_id = ?").run(m.id);
|
||||
db().prepare("DELETE FROM support_meldungen WHERE id = ?").run(m.id);
|
||||
}
|
||||
console.log(`[support] ${alt.length} erledigte Meldungen aelter als `
|
||||
|
||||
Reference in New Issue
Block a user