/* ===================================================================== DER SUPPORT (24.09.2026) Filipe: „da fehlt auch eine support kachel. die jeder sieht. jeder benutzen kann. jeder kann da probleme von der seite melden und hinweisen. fotos mit schicken mit einem text. es soll alles hoch profissionell gemacht werden aber so einfach wie möglich, will nichts kompliziertes oder zu viel. kurz und knapp … also bei dogfather und der rechten hand soll die kachel anders gebaut sein weil die sind die die sich um die probleme kümmern." Die Regeln und ihre Begründung stehen im Kopf von support-tabellen.js. Hier sind die Wege — und die vier Stellen, an denen etwas schiefgehen kann: 1. EINE MELDUNG DARF NIE BEIM FALSCHEN LANDEN. Jede Leseroute geht über `meldungFuer()`, das den Datensatz zurückgibt oder `null` — nie `true`/`false`. So kann keine Route „darf sehen" beantworten und danach trotzdem den falschen Datensatz laden. Dasselbe Muster wie im vertraulichen Meldeweg. 2. DER TYP EINES BILDES KOMMT AUS DEM INHALT. `dateiErkennen()` liest die ersten Bytes; Dateiname und Content-Type kommen vom Absender und sind frei erfunden. Die Funktion wird aus workspace-chat.js IMPORTIERT und nicht abgeschrieben: Eine zweite Fassung wäre die, die beim nächsten Dateiformat vergessen wird — und an ihr hängt die ganze Sicherheit der Uploads. 3. DER RUMPF WIRD ERST ANGENOMMEN, WENN DIE BERECHTIGUNG STEHT. Wer nicht angemeldet ist, kommt gar nicht bis zur Datei. 4. ERLEDIGT IST ERLEDIGT. Auch für die Leitung — eine geschlossene Meldung wird nicht stillschweigend wieder geöffnet und anders beantwortet. ===================================================================== */ import express from "express"; import { createReadStream, statSync, writeFileSync, mkdirSync, unlinkSync } from "node:fs"; import { join } from "node:path"; import { randomBytes } from "node:crypto"; import { db, protokolliere, DATEN_ORDNER, echteIp } from "./workspace.js"; import { SUPPORT_STAND, AUFBEWAHRUNG_TAGE } from "./support-tabellen.js"; import { dateiErkennen } from "./workspace-chat.js"; import { benachrichtige } from "./workspace-push.js"; export const supportRouter = express.Router(); /** Wer alle Meldungen sieht und sie bearbeitet. * * GENAU ZWEI ROLLEN, wie bestellt: DogFather und die rechte Hand. * Dieselbe Menge wie im vertraulichen Meldeweg — und aus einem * ähnlichen Grund: Wer sich kümmert, muss alles sehen; wer nur * meldet, sieht seine eigene Meldung. */ const LEITUNG = new Set(["admin", "hand"]); const istLeitung = (person) => LEITUNG.has(person?.rolle); const TEXT_MAX = 2000; const SEITE_MAX = 120; const GERAET_MAX = 200; const ANTWORT_MAX = 2000; /** Zwölf Megabyte — dieselbe Grenze wie bei Chat-Anhängen. * Ein Bildschirmfoto vom Handy liegt bei 2 bis 5 MB. */ const BILD_MAX = 12 * 1024 * 1024; /** Wie viele offene Meldungen eine Person gleichzeitig haben darf. * * Zehn, und damit deutlich großzügiger als die drei im vertraulichen * Meldeweg. Dort ist die Grenze ein Schutz vor Überforderung auf * beiden Seiten; hier wäre sie eine Bremse für genau die Person, die * sich die Mühe macht, fünf kleine Fehler einzeln zu melden. Sie * steht nur da, damit ein hängendes Skript nicht tausend Zeilen * anlegt. */ const OFFEN_MAX = 10; /* Der Ordner steht über join(DATEN_ORDNER, …) — genau dieses Muster liest tools/wiederherstellung-proben.mjs aus, um zu prüfen, ob die Sicherung ihn mitnimmt. Eine gepflegte Liste wäre die, die beim nächsten Ordner vergessen wird. */ const BILD_ORDNER = join(DATEN_ORDNER, "support-bilder"); const jetzt = () => new Date().toISOString(); function sauber(s, max) { return String(s ?? "").replace(/\s+/g, " ").trim().slice(0, max); } /** Mehrzeiliger Text: Absätze bleiben, Leerzeilenwüsten nicht. * * Beim Melden schreibt man „Schritt 1 … Schritt 2 …" untereinander. * Das über `\s+` plattzumachen wie einen Betreff würde genau die * Struktur zerstören, die den Fehler nachvollziehbar macht. */ function textSauber(s, max) { return String(s ?? "") .replace(/\r\n/g, "\n") .replace(/[ \t]+/g, " ") .replace(/\n{3,}/g, "\n\n") .trim() .slice(0, max); } /** Darf diese Person diese Meldung sehen? * * Gibt die Meldung zurück oder `null`. NIE `true`/`false` — dasselbe * Muster wie `fallFuer()` im vertraulichen Meldeweg, und aus * demselben Grund. */ function meldungFuer(person, id) { const m = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(Number(id)); if (!m) return null; if (istLeitung(person)) return m; return m.person_id === person?.id ? m : null; } /** Darf DIESE Person bei DIESER Meldung jetzt bestätigen? * * AN EINER STELLE, weil es zwei Stellen gibt, die es wissen müssen: * die Route, die die Antwort annimmt, und die Anzeige, die die * Knöpfe zeigt. Standen sie getrennt da, driften sie — und genau das * ist am 25.09.2026 im ersten Anlauf passiert: Der Server lehnte die * Leitung richtig mit 404 ab, die Karte zeigte ihr die Knöpfe * trotzdem. Zwei Knöpfe, die nur eine Fehlermeldung können, sind * schlimmer als gar keine. * * ES IST DER MELDER, NICHT „WER NICHT LEITUNG IST": Die Leitung darf * ihre eigene Meldung sehr wohl selbst bestätigen — sie hat sie ja * geschrieben. Verboten ist nur, FREMDE Arbeit abzunicken. */ function darfBestaetigen(m, personId) { return !!m && m.person_id === personId && m.stand === SUPPORT_STAND.wartet; } /** Wie eine Meldung nach draußen aussieht. * * AN EINER STELLE, weil vier Routen sie ausgeben. Vier Stellen wären * vier Gelegenheiten, ein Feld zu vergessen — oder eines zu viel * mitzuschicken. * * `fuerLeitung` entscheidet nur über die Zusatzangaben, nicht über * den Inhalt: Wer meldet, sieht seine eigene Meldung vollständig, * auch den Namen, den er selbst trägt. * * `werFragtId` ist Pflicht, seit es die Knöpfe des Melders gibt — * ohne sie ist `darf_bestaetigen` eine Aussage über die Meldung * statt über den Betrachter, und die Leitung bekommt Knöpfe, die sie * nicht drücken darf. */ function nachDraussen(m, fuerLeitung, werFragtId) { return { id: m.id, text: m.text, stand: m.stand, antwort: m.antwort || null, erstellt: m.erstellt, 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, von: m.von_name || null, von_rolle: m.von_rolle || null, /* Nur die Leitung braucht zu wissen, mit welchem Gerät gemeldet wurde. Für den Melder ist es seine eigene Angabe und nur Rauschen. */ geraet: fuerLeitung ? (m.geraet || null) : undefined, /* ==== DER WEG BIS HIERHER (25.09.2026) ========================= Filipe: „mit dem gedanken das manchmal sachen mehrmal nicht sofort perfekt sein werden." Die Runde und der ganze Verlauf gehen mit. Nur die letzte Antwort zu schicken hiesse: Bei Runde drei ist nicht mehr zu sehen, was beim ersten Mal versucht wurde -- und genau das loest einen wiederkehrenden Fehler. BEIDE SEITEN BEKOMMEN DENSELBEN VERLAUF. Der Melder soll lesen koennen, was schon probiert wurde; die Leitung, was er dazu gesagt hat. Es gibt hier nichts zu verbergen -- es sind seine eigenen Worte und die Antworten darauf. */ runde: m.runde || 1, verlauf: verlaufVon(m.id), /* DARF ICH JETZT BESTAETIGEN? Vom Server beantwortet, nicht im Browser nachgerechnet: Dort stuende die Regel ein zweites Mal, und die zweite Fassung waere ab der naechsten Aenderung falsch. */ darf_bestaetigen: darfBestaetigen(m, 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 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, })); } /* ===================================================================== LESEN ===================================================================== */ /** Die eigenen Meldungen — oder für die Leitung alle. * * EINE ROUTE FÜR BEIDE, nicht zwei. Zwei Routen hießen zwei Stellen, * an denen die Sichtbarkeitsregel gepflegt werden muss — und eine * davon läuft irgendwann auseinander. */ supportRouter.get("/workspace/api/support", (req, res) => { try { const leitung = istLeitung(req.person); const zeilen = leitung ? db().prepare(`SELECT * FROM support_meldungen ORDER BY /* Offene zuerst, und darin die ältesten oben: Was am längsten wartet, gehört nach vorn. Erledigte danach, das Neueste zuerst. */ CASE stand WHEN 'neu' THEN 0 WHEN 'in_arbeit' THEN 1 ELSE 2 END, CASE WHEN stand = 'erledigt' THEN -id ELSE id END LIMIT 300`).all() : db().prepare(`SELECT * FROM support_meldungen WHERE person_id = ? ORDER BY id DESC LIMIT 100`).all(req.person.id); res.json({ leitung, meldungen: zeilen.map((m) => nachDraussen(m, leitung, req.person.id)), /* Die Zahlen stehen in der Antwort und werden nicht im Browser nachgezählt: Die Liste ist bei 300 abgeschnitten, eine Zählung darauf wäre ab der 301. Meldung still falsch. */ offen: leitung ? db().prepare("SELECT COUNT(*) AS n FROM support_meldungen WHERE stand <> 'erledigt'") .get().n : db().prepare(`SELECT COUNT(*) AS n FROM support_meldungen WHERE person_id = ? AND stand <> 'erledigt'`).get(req.person.id).n, hoechstens_bytes: BILD_MAX, text_max: TEXT_MAX, }); } catch (fehler) { console.error("[support] Liste:", fehler?.message); res.status(503).json({ fehler: "nicht_verfuegbar" }); } }); /** Das Bild einer Meldung. * * 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) => { 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); 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("X-Content-Type-Options", "nosniff"); res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox"); res.setHeader("Cache-Control", "private, max-age=86400"); createReadStream(pfad).pipe(res); } catch (fehler) { console.error("[support] Bild:", fehler?.message); res.status(503).json({ fehler: "nicht_verfuegbar" }); } }); /* ===================================================================== MELDEN ===================================================================== */ /** Vor express.raw: Darf diese Person überhaupt melden? * * Angemeldet sein genügt — „die jeder sieht, jeder benutzen kann". * Die Prüfung steht trotzdem VOR der Annahme des Rumpfes, sonst * wanderten zwölf Megabyte durch die Leitung, bevor irgendjemand * fragt, wer da schickt. */ function darfMelden(req, res, next) { if (!req.person?.id) return res.status(401).json({ fehler: "nicht_angemeldet" }); const offen = db().prepare(`SELECT COUNT(*) AS n FROM support_meldungen WHERE person_id = ? AND stand <> 'erledigt'`).get(req.person.id).n; if (offen >= OFFEN_MAX) { return res.status(429).json({ fehler: `Du hast schon ${offen} offene Meldungen. Warte kurz ab, ` + "bis sich jemand darum gekümmert hat.", }); } next(); } /** Eine Meldung abschicken. * * EIN WEG FÜR BEIDES — mit Bild und ohne. Der Text reist im Kopf * (`x-text`, prozentkodiert), das Bild im Rumpf. Zwei Routen zu * bauen („/support" für Text, "/support/bild" für Bild) wäre die * naheliegende Aufteilung und hätte einen Zustand dazwischen: eine * Meldung, die schon existiert, während das Bild noch hochlädt — * und bei einem Abbruch für immer ohne Bild dasteht. * * Ein leerer Rumpf ist zulässig: Dann gibt es eben kein Bild. */ supportRouter.post("/workspace/api/support", darfMelden, express.raw({ type: "*/*", limit: BILD_MAX }), (req, res) => { let geschrieben = null; try { let text = ""; try { text = decodeURIComponent(req.get("x-text") || ""); } catch { text = ""; } text = textSauber(text, TEXT_MAX); if (text.length < 5) { return res.status(400).json({ fehler: "Schreib bitte kurz, was los ist – ein Satz reicht.", }); } 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 n = jetzt(); 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 (?,?,?,?,?,?,?,?,?,?,?,?,?)`) .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); protokolliere("support_gemeldet", { personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req), detail: `#${id} ${text.slice(0, 80)}`, }); /* DIE LEITUNG ERFÄHRT ES SOFORT. Eine Meldung, die erst auffällt, wenn jemand die Seite zufällig öffnet, ist keine Meldung, sondern ein Zettel im Schrank. NICHT DRINGEND: Ein kaputter Knopf weckt niemanden um drei Uhr nachts. Die Ruhezeit gilt (siehe workspace-push.js). */ for (const p of db().prepare( `SELECT id FROM personen WHERE aktiv = 1 AND rolle IN ('admin','hand')`).all()) { benachrichtige(p.id, "support", { titel: "Neue Support-Meldung", text: text.slice(0, 120), ziel: `/workspace/support.html?meldung=${id}`, }).catch(() => { /* eine ausgefallene Benachrichtigung darf die Meldung nicht verhindern */ }); } const frisch = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(id); res.status(201).json({ 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 */ } } console.error("[support] Melden:", fehler?.message); res.status(503).json({ fehler: "nicht_verfuegbar" }); } }); /* ===================================================================== SICH KÜMMERN — nur die Leitung ===================================================================== */ /** Stand ändern und antworten. * * EINE ROUTE FÜR BEIDES, weil es in der Oberfläche eine Handlung ist: * „erledigt, und zwar deshalb". Zwei Routen hießen zwei Anfragen, und * bei der zweiten kann das Netz abbrechen — dann steht die Meldung * auf „erledigt" ohne den Satz, der sie erklärt. */ /* ===================================================================== DER MELDER ANTWORTET: GEHT WIEDER ODER NOCH NICHT (25.09.2026) ===================================================================== Filipe: „damit die bescheid wissen und dan anklicken koennen, es funktioniert, oder noch nicht. und erst wenn es funktioniert gedrueckt wird, will ich dass alles richtig fertig ist. perfektionier den ganzen weg und mit dem gedanken das manchmal sachen mehrmal nicht sofort perfekt sein werden." NUR DER MELDER, und zwar ausdruecklich NICHT die Leitung: Sonst koennte sie ihre eigene Arbeit bestaetigen, und der ganze Umweg waere Zierde. Deshalb steht hier `person_id !== req.person.id` -- nicht „ist Leitung". „NOCH NICHT" IST KEINE BESCHWERDE, SONDERN DIE NAECHSTE RUNDE. Die Meldung geht zurueck in Arbeit, die Rundenzahl waechst um eins, und der Verlauf behaelt, was beim letzten Mal versucht wurde. Nichts wird geloescht, und niemand faengt von vorn an. EIN WORT DAZU IST BEI „NOCH NICHT" PFLICHT. „Geht immer noch nicht" ohne Zusatz erzeugt genau die Rueckfrage, die dieser ganze Weg sparen soll. Bei „geht wieder" ist es freiwillig -- da gibt es nichts mehr zu klaeren. `:id` OHNE MUSTER, dafuer mit einer Pruefung in der Zeile darunter: Ein Muster im Pfad ist eine zweite Stelle, an der eine Zahl geprueft wird -- und die im Code ist die, die man liest. ===================================================================== */ supportRouter.post("/workspace/api/support/:id/rueckmeldung", express.json(), (req, res) => { try { const id = Number(req.params.id); if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" }); const m = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(id); /* 404 UND NICHT 403: Wer eine fremde Meldung nicht sehen darf, soll auch nicht erfahren, dass es sie gibt. Dieselbe Ueberlegung wie ueberall im Haus. */ if (!m || m.person_id !== req.person.id) { return res.status(404).json({ fehler: "nicht_gefunden" }); } /* 404 oben war die SICHTBARKEITSFRAGE, das hier ist die STANDFRAGE -- zwei verschiedene Auskünfte, deshalb zwei Codes. Gefragt wird mit derselben Funktion, die auch die Knöpfe zeigt: Was der Bildschirm anbietet und was der Server annimmt, ist damit ein Satz und nicht zwei. */ if (!darfBestaetigen(m, req.person.id)) { return res.status(409).json({ fehler: "Hier wartet gerade nichts auf deine Antwort.", }); } const geht = req.body?.geht === true; const wort = textSauber(req.body?.text, ANTWORT_MAX); if (!geht && wort.length < 3) { return res.status(400).json({ fehler: "Schreib kurz, was noch nicht geht – sonst fängt die Suche von vorn an.", }); } const n = jetzt(); const runde = m.runde || 1; db().prepare(`UPDATE support_runden SET urteil = ?, urteil_text = ?, urteil_am = ? WHERE meldung_id = ? AND nr = ?`) .run(geht ? "geht" : "nicht", wort || null, n, m.id, runde); if (geht) { db().prepare(`UPDATE support_meldungen SET stand = ?, geaendert = ?, erledigt_am = ?, erledigt_von = ? WHERE id = ?`) .run(SUPPORT_STAND.erledigt, n, n, req.person.id, m.id); } else { /* ZURUECK IN ARBEIT UND EINE RUNDE WEITER. Nicht auf „neu": Es hat ja schon jemand hingesehen, und „neu" waere die Sorte Zahl, die morgens laut ist und nichts meint. */ db().prepare(`UPDATE support_meldungen SET stand = ?, runde = ?, geaendert = ?, erledigt_am = NULL, erledigt_von = NULL WHERE id = ?`) .run(SUPPORT_STAND.inArbeit, runde + 1, n, m.id); } protokolliere(geht ? "support_bestaetigt" : "support_nochmal", { personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req), detail: `#${m.id} Runde ${runde}`, }); /* UND DIE LEITUNG ERFAEHRT ES. Ohne diese Zeile merkt niemand, dass etwas zurueckgekommen ist -- die Meldung stuende wieder in der Liste, aber keiner saehe hin. */ if (!geht) { const leitung = db().prepare( "SELECT id FROM personen WHERE rolle IN ('admin','hand') AND aktiv = 1").all(); for (const l of leitung) { benachrichtige(l.id, "support", { titel: "Geht noch nicht – Runde " + (runde + 1), text: wort.slice(0, 120), ziel: `/workspace/support.html?meldung=${m.id}`, }).catch(() => { /* eine Meldung, die nicht ankommt, darf die Antwort nicht verhindern */ }); } } const frisch = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(m.id); res.json({ meldung: nachDraussen(frisch, false, req.person.id) }); } catch (fehler) { console.error("[support] Rueckmeldung:", fehler?.message); res.status(503).json({ fehler: "nicht_verfuegbar" }); } }); supportRouter.patch("/workspace/api/support/:id(\\d+)", express.json(), (req, res) => { try { if (!istLeitung(req.person)) return res.status(404).json({ fehler: "nicht_gefunden" }); const m = db().prepare("SELECT * FROM support_meldungen WHERE id = ?") .get(Number(req.params.id)); if (!m) return res.status(404).json({ fehler: "nicht_gefunden" }); /* ERLEDIGT IST ERLEDIGT. Eine geschlossene Meldung wird nicht stillschweigend wieder geöffnet und anders beantwortet — sonst ist „zugemacht" eine Meinung und keine Tatsache. Dieselbe Regel wie im vertraulichen Meldeweg. */ if (m.stand === SUPPORT_STAND.erledigt) { return res.status(409).json({ fehler: "Diese Meldung ist erledigt. Für etwas Neues bitte eine neue.", }); } const wunsch = String(req.body?.stand || ""); if (!Object.values(SUPPORT_STAND).includes(wunsch)) { /* EIN SATZ, KEINE KENNUNG (24.09.2026, gefunden von pruef-meldungen am selben Tag, an dem diese Datei entstand). Hier stand `fehler: "ungueltiger_stand"`. Das Haus verlangt zu jeder Kennung einen Satz in meldung.js -- sonst steht auf dem Bildschirm ein Wort mit Unterstrichen. Diesen Fall trifft ein Mensch zwar nie (die Oberflaeche schickt nur gueltige Staende), aber "trifft nie ein" ist genau die Begruendung, mit der solche Stellen stehen bleiben, bis sie doch jemand sieht. Ein Satz direkt hier statt eines Eintrags in der Tabelle: Die anderen Absagen dieser Route machen es ebenso, und ein Wort, das nur an einer Stelle vorkommt, braucht keine Uebersetzung an einer zweiten. */ return res.status(400).json({ fehler: "Diesen Stand gibt es nicht. Moeglich sind: neu, " + "in Arbeit, erledigt.", }); } const antwort = textSauber(req.body?.antwort, ANTWORT_MAX); /* WER ZUMACHT, SAGT WARUM. Nicht als Schikane: Der Melder sieht nur, dass seine Sache zu ist — ohne einen Satz weiß er nicht, ob sie behoben wurde oder ob niemand Lust hatte. */ if ((wunsch === SUPPORT_STAND.erledigt || wunsch === SUPPORT_STAND.wartet) && antwort.length < 3) { return res.status(400).json({ fehler: "Schreib kurz dazu, was daraus geworden ist – der Melder sieht nur das.", }); } /* ==== DER MELDER MACHT ZU, NICHT DIE LEITUNG (25.09.2026) ====== Filipe: „damit die bescheid wissen und dan anklicken koennen, es funktioniert, oder noch nicht. und erst wenn es funktioniert gedrueckt wird, will ich dass alles richtig fertig ist." Wer „erledigt" waehlt, schickt die Meldung deshalb nicht zu, sondern ZURUECK AN DEN MELDER. Er sieht die Antwort und sagt, ob es bei ihm wirklich geht. Erst sein Druck schliesst. DIE AUSNAHME IST NOETIG, SONST HAENGT ES EWIG: Wenn die Leitung ihre EIGENE Meldung bearbeitet -- oder der Zugang des Melders geloescht wurde --, gibt es niemanden, der bestaetigen koennte. Dann bleibt „erledigt" erledigt. Ohne diese Zeile waere jede solche Meldung dauerhaft offen, und die Zahl oben stimmte nie wieder. */ const braucht = wunsch === SUPPORT_STAND.erledigt && m.person_id && m.person_id !== req.person.id; const stand = braucht ? SUPPORT_STAND.wartet : wunsch; const n = jetzt(); db().prepare(`UPDATE support_meldungen SET stand = ?, antwort = ?, geaendert = ?, erledigt_am = ?, erledigt_von = ? WHERE id = ?`) .run(stand, antwort || m.antwort || null, n, stand === SUPPORT_STAND.erledigt ? n : null, stand === SUPPORT_STAND.erledigt ? req.person.id : null, m.id); /* DIE RUNDE WIRD FESTGEHALTEN, sobald die Leitung antwortet. Sie entsteht hier und nicht beim Melden: Runde 1 beginnt mit dem ersten „so, probier mal", nicht mit dem Problem. */ if (stand === SUPPORT_STAND.wartet && antwort) { /* NACHLEGEN ERSETZT, ES VERDOPPELT NICHT. Antwortet die Leitung ein zweites Mal, waehrend die Meldung schon beim Melder liegt („ach, und noch etwas ..."), gehoert das in DIESELBE Runde. Ohne diese Zeile stuenden zwei „Runde 1" untereinander, und sein spaeteres Urteil traefe beide gleichzeitig. */ db().prepare(`INSERT INTO support_runden (meldung_id, nr, antwort, von_id, von_name, am) VALUES (?,?,?,?,?,?) ON CONFLICT (meldung_id, nr) DO UPDATE SET antwort = excluded.antwort, von_id = excluded.von_id, von_name = excluded.von_name, am = excluded.am`) .run(m.id, m.runde || 1, antwort, req.person.id, req.person.name, n); } protokolliere("support_bearbeitet", { personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req), detail: `#${m.id} -> ${wunsch}`, }); /* DER MELDER ERFÄHRT ES. Wer etwas meldet und nie wieder davon hört, meldet beim nächsten Mal nichts mehr. */ if (m.person_id && m.person_id !== req.person.id) { benachrichtige(m.person_id, "support", { /* DER TITEL SAGT, WER JETZT DRAN IST. „Deine Meldung ist erledigt" waere bei „wartet" eine Luege -- sie ist es ja erst, wenn er es bestaetigt. Und ein Hinweis, der nicht sagt, dass man etwas tun soll, wird weggewischt. */ titel: stand === SUPPORT_STAND.wartet ? "Geht es wieder? Kurz bestätigen" : (stand === SUPPORT_STAND.erledigt ? "Deine Meldung ist erledigt" : "Jemand kümmert sich"), text: antwort ? antwort.slice(0, 120) : m.text.slice(0, 120), ziel: `/workspace/support.html?meldung=${m.id}`, }).catch(() => { /* siehe oben */ }); } const frisch = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(m.id); res.json({ meldung: nachDraussen(frisch, true, req.person.id) }); } catch (fehler) { console.error("[support] Bearbeiten:", fehler?.message); res.status(503).json({ fehler: "nicht_verfuegbar" }); } }); /* ===================================================================== AUFRÄUMEN ===================================================================== */ /** Erledigte Meldungen nach der Aufbewahrungsfrist entfernen. * * Wird aus dem Rundgang aufgerufen, nicht beim Lesen — sonst hängt * das Aufräumen davon ab, dass jemand die Seite öffnet, und auf einem * ruhigen System wächst der Bilderordner still weiter. * * DIE DATEI GEHT MIT DER ZEILE. Ein Bild ohne Meldung zeigt auf * nichts und niemand findet es je wieder. */ 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 WHERE stand = 'erledigt' AND erledigt_am IS NOT NULL AND erledigt_am < ?`).all(grenze); if (!alt.length) return 0; for (const m of alt) { if (m.bild_datei) { try { unlinkSync(join(BILD_ORDNER, m.bild_datei)); } catch { /* schon weg */ } } db().prepare("DELETE FROM support_meldungen WHERE id = ?").run(m.id); } console.log(`[support] ${alt.length} erledigte Meldungen aelter als ` + `${AUFBEWAHRUNG_TAGE} Tage entfernt.`); return alt.length; } catch (fehler) { console.error("[support] Aufraeumen:", fehler?.message); return 0; } }