From cebdd88e8d6a5c652001aa3cd59315dcd6ce93ae Mon Sep 17 00:00:00 2001 From: Dogfather Date: Fri, 25 Sep 2026 04:55:14 +0200 Subject: [PATCH] Support: der Melder hat das letzte Wort -- und die Kachel bekommt ihren eigenen Stil Filipe: "ich will dass die leute die mir was geschickt haben im support, auch meine notiz bekommen wenn ich fertig bin. 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." DER GANZE WEG, nicht nur der Schlusspunkt: 1. Die Leitung drueckt "Behoben - nachfragen ...". Der Knopf hiess vorher "Erledigt ..." und tat auch das; jetzt stellt er eine Frage, also heisst er auch so. Eine Beschriftung, die etwas anderes sagt als der Knopf tut, glaubt man genau einmal. 2. Die Meldung steht auf "wartet" -- ein vierter Stand zwischen "wird bearbeitet" und "erledigt". Beim Melder heisst er "geht es wieder?", weil er aus SEINER Sicht keine Wartezeit ist, sondern eine Frage. 3. Er sieht die Notiz und zwei Knoepfe. "Geht wieder" ohne Rueckfrage (der haeufige, harmlose Fall). "Noch nicht" verlangt ein Wort -- sonst faengt die Suche von vorn an und die naechste Runde waere dieselbe wie die letzte. 4. "Noch nicht" ist keine Beschwerde, sondern Runde 2: zurueck in Arbeit, Rundenzahl plus eins, Leitung bekommt eine Nachricht, und der Verlauf behaelt, was beim letzten Mal versucht wurde. Niemand faengt von vorn an -- genau der Fall, den Filipe genannt hat. 5. Erst sein "Geht wieder" schliesst die Meldung. Danach kann weder er noch die Leitung sie wieder aufmachen (409). NUR DER MELDER darf bestaetigen, ausdruecklich nicht die Leitung (`person_id !== req.person.id`, nicht "ist Leitung") -- sonst nickt sie ihre eigene Arbeit ab und der ganze Umweg waere Zierde. Eine fremde Meldung gibt 404, nicht 403: Wer sie nicht sehen darf, soll auch nicht erfahren, dass es sie gibt. DER VERLAUF STEHT UNTEREINANDER statt nur der letzten Antwort. Bei Runde drei war sonst nicht mehr zu sehen, was beim ersten Mal versucht wurde, und genau das loest einen wiederkehrenden Fehler. Meldungen von vor diesem Umbau haben keinen Verlauf -- die zeigen wie bisher ihre blosse Antwort, ein leerer Kasten waere schlechter als der alte Satz. DIE KACHEL SIEHT ANDERS AUS (zweiter Wunsch: "viel geiler viel profissioneller ... die hauptfarbe soll babyblau sein mit bissl lila"). `support-seite` traegt den Stil; alle Regeln haengen daran und gelten damit nur hier. Zwei weiche Lichter, Pillen statt Kaesten als Filter, eine leuchtende Naht ueber dem Meldefeld. Augenschonend: gedeckt, kein Neon, Kontrast geprueft. GEMESSEN: - pruef-support: 45 -> 58 Pruefungen, 0 Fehler. Der ganze Weg einmal durch, MIT einer Runde, die schiefgeht. Dazu drei Gegenproben: die Leitung kann nicht fuer den Melder bestaetigen (404), "noch nicht" ohne Wort wird abgelehnt (400), eine geschlossene Meldung bleibt zu (409, aus beiden Richtungen). - Die Schemaaenderung auf einer KOPIE der echten Datenbank durchgespielt: 72 Tabellen, keine Zeile und keine Spalte verloren, support_runden und `runde` da, 'wartet' in der CHECK-Regel. - pruef-css-klassen, pruef-deutsche-texte, pruef-code, pruef-glocke: alle gruen. Co-Authored-By: Claude Opus 5 --- server/pruef-support.mjs | 120 ++++++++++++++-- server/support-tabellen.js | 70 +++++++++- server/workspace-support.js | 187 ++++++++++++++++++++++++- server/workspace.js | 20 +++ workspace/anruf-probe.html | 10 +- workspace/app.webmanifest | 8 +- workspace/assets/css/support.css | 229 +++++++++++++++++++++++++++++++ workspace/assets/js/support.js | 143 +++++++++++++++++-- workspace/aufgaben.html | 38 ++--- workspace/automation.html | 32 ++--- workspace/befinden.html | 34 ++--- workspace/bereich.html | 44 +++--- workspace/bewerben.html | 38 ++--- workspace/bewerbungen.html | 36 ++--- workspace/calls.html | 34 ++--- workspace/chat.html | 40 +++--- workspace/content.html | 34 ++--- workspace/crew-index.html | 12 +- workspace/crew.webmanifest | 8 +- workspace/dateien.html | 34 ++--- workspace/entwicklung.html | 36 ++--- workspace/hilfe.html | 30 ++-- workspace/index.html | 10 +- workspace/kalender.html | 34 ++--- workspace/leistung.html | 32 ++--- workspace/material.html | 32 ++--- workspace/personen.html | 32 ++--- workspace/profil.html | 36 ++--- workspace/rechte.html | 34 ++--- workspace/report.html | 36 ++--- workspace/scouting.html | 32 ++--- workspace/start.html | 32 ++--- workspace/startcheck.html | 34 ++--- workspace/steckbrief.html | 36 ++--- workspace/support.html | 35 +++-- workspace/talente.html | 36 ++--- workspace/team.html | 32 ++--- workspace/teamlage.html | 34 ++--- workspace/teilen.html | 30 ++-- workspace/treff-moderation.html | 32 ++--- workspace/treff-regeln.html | 32 ++--- workspace/uebersicht.html | 32 ++--- workspace/unsere-seiten.html | 30 ++-- workspace/unterstuetzen.html | 32 ++--- workspace/werdegang.html | 32 ++--- workspace/willkommen.html | 30 ++-- workspace/wissen.html | 34 ++--- 47 files changed, 1377 insertions(+), 661 deletions(-) diff --git a/server/pruef-support.mjs b/server/pruef-support.mjs index c9f9d013..5d796e1d 100644 --- a/server/pruef-support.mjs +++ b/server/pruef-support.mjs @@ -414,20 +414,114 @@ melde("\n=== Sich kuemmern ==="); }); ok(zu.status === 200, `mit Satz geht es (${zu.status})`); - /* ERLEDIGT IST ERLEDIGT -- auch fuer die Leitung. */ - const nochmal = await hol("admin", `/workspace/api/support/${meldungMitBild}`, { - method: "PATCH", - headers: { "Content-Type": "application/json" }, - body: JSON.stringify({ stand: "in_arbeit", antwort: "doch nicht" }), - }); - ok(nochmal.status === 409, - `eine erledigte Meldung wird nicht wieder geoeffnet (${nochmal.status})`); + /* ===================================================================== + DER MELDER HAT DAS LETZTE WORT (25.09.2026) + ===================================================================== - /* Und der Melder sieht die Antwort. */ - const beimMelder = await (await hol("modi", "/workspace/api/support")).json(); - const meine = beimMelder.meldungen.find((m) => m.id === meldungMitBild); - ok(meine?.stand === "erledigt" && /Behoben/.test(meine?.antwort || ""), - "der Melder sieht Stand und Antwort"); + Filipe: „ich will dass die leute die mir was geschickt haben im + support, auch meine notiz bekommen wenn ich fertig bin. 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." + + HIER STAND, dass „erledigt" die Meldung zumacht und der Melder + danach Stand und Antwort sieht. Das war richtig -- und ist es seit + heute nicht mehr: „erledigt" schickt sie ZUERST an den Melder. + Erst sein Druck schliesst. + + GEMESSEN WIRD DER GANZE WEG, einmal durch, mit einer Runde, die + schiefgeht -- genau der Fall, den Filipe ausdruecklich genannt + hat („manchmal ... nicht sofort perfekt"). Eine Pruefung, die nur + den glatten Weg kennt, misst die Haelfte. + ===================================================================== */ + const standVon = async (wer, id) => { + const d = await (await hol(wer, "/workspace/api/support")).json(); + return (d.meldungen || []).find((m) => m.id === id) || null; + }; + + { + /* ---- Runde 1: die Leitung sagt „behoben" ---------------------- */ + const nach1 = await standVon("modi", meldungMitBild); + ok(nach1?.stand === "wartet", + `„erledigt" schickt die Meldung zuerst an den Melder (${nach1?.stand})`); + ok(/Behoben/.test(nach1?.antwort || "") && nach1?.darf_bestaetigen === true, + `er sieht die Notiz und darf bestaetigen (${nach1?.darf_bestaetigen})`); + ok((nach1?.verlauf || []).length === 1 && nach1.verlauf[0].nr === 1, + `und der Verlauf hat Runde 1 (${(nach1?.verlauf || []).length})`); + + /* GEGENPROBE: Die Leitung darf NICHT fuer ihn bestaetigen. Ohne + diese Zeile koennte sie ihre eigene Arbeit abnicken, und der + ganze Umweg waere Zierde. */ + const fremd = await hol("hand", `/workspace/api/support/${meldungMitBild}/rueckmeldung`, { + method: "POST", headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ geht: true }), + }); + ok(fremd.status === 404, + `Gegenprobe: die Leitung bestaetigt nicht fuer den Melder (${fremd.status})`); + + /* ---- „Noch nicht" -- und ohne Wort geht das nicht ------------- */ + const ohneWort = await hol("modi", `/workspace/api/support/${meldungMitBild}/rueckmeldung`, { + method: "POST", headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ geht: false }), + }); + ok(ohneWort.status === 400, + `„noch nicht" ohne Wort wird abgelehnt (${ohneWort.status})`); + + const zurueck = await hol("modi", `/workspace/api/support/${meldungMitBild}/rueckmeldung`, { + method: "POST", headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ geht: false, text: "Die Farbe ja, das Datum nicht." }), + }); + ok(zurueck.status === 200, `mit Wort geht es zurueck (${zurueck.status})`); + + const nach2 = await standVon("hand", meldungMitBild); + ok(nach2?.stand === "in_arbeit" && nach2?.runde === 2, + `die Meldung ist wieder in Arbeit, Runde 2 (${nach2?.stand}, ${nach2?.runde})`); + ok((nach2?.verlauf || [])[0]?.urteil === "nicht" + && /Datum/.test((nach2?.verlauf || [])[0]?.urteil_text || ""), + `und Runde 1 traegt sein Urteil (${(nach2?.verlauf || [])[0]?.urteil})`); + + /* ---- Runde 2: diesmal klappt es ------------------------------- */ + const zu2 = await hol("hand", `/workspace/api/support/${meldungMitBild}`, { + method: "PATCH", headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ stand: "erledigt", antwort: "Das Datum stimmt jetzt auch." }), + }); + ok(zu2.status === 200, `die Leitung antwortet ein zweites Mal (${zu2.status})`); + + const bestaetigt = await hol("modi", `/workspace/api/support/${meldungMitBild}/rueckmeldung`, { + method: "POST", headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ geht: true }), + }); + ok(bestaetigt.status === 200, `der Melder bestaetigt (${bestaetigt.status})`); + + const ende = await standVon("modi", meldungMitBild); + ok(ende?.stand === "erledigt", + `ERST JETZT ist die Meldung erledigt (${ende?.stand})`); + ok((ende?.verlauf || []).length === 2, + `und der ganze Weg steht da -- beide Runden (${(ende?.verlauf || []).length})`); + ok((ende?.verlauf || [])[1]?.urteil === "geht", + ` mit „geht" an der letzten (${(ende?.verlauf || [])[1]?.urteil})`); + + /* ERLEDIGT IST ERLEDIGT -- auch fuer die Leitung. */ + const nochmal = await hol("admin", `/workspace/api/support/${meldungMitBild}`, { + method: "PATCH", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ stand: "in_arbeit", antwort: "doch nicht" }), + }); + ok(nochmal.status === 409, + `eine erledigte Meldung wird nicht wieder geoeffnet (${nochmal.status})`); + + /* UND AUCH DER MELDER KANN NICHT NOCHMAL. Ohne diese Zeile liesse + sich eine geschlossene Sache durch ein zweites „noch nicht" + wieder aufmachen -- „zugemacht" waere dann eine Meinung. */ + const nochmal2 = await hol("modi", `/workspace/api/support/${meldungMitBild}/rueckmeldung`, { + method: "POST", headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ geht: false, text: "doch nicht" }), + }); + ok(nochmal2.status === 409, + ` und der Melder kann sie auch nicht wieder aufmachen (${nochmal2.status})`); + } } /* ===================================================================== diff --git a/server/support-tabellen.js b/server/support-tabellen.js index 98ac8590..bcea965c 100644 --- a/server/support-tabellen.js +++ b/server/support-tabellen.js @@ -71,6 +71,31 @@ export const SUPPORT_STAND = { neu: "neu", inArbeit: "in_arbeit", + /* ==== DER MELDER HAT DAS LETZTE WORT (25.09.2026) ================ + + Filipe: „ich will dass die leute die mir was geschickt haben im + support, auch meine notiz bekommen wenn ich fertig bin. 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." + + WAS VORHER FEHLTE, und es ist der haeufigste Ausgang einer + Fehlermeldung: Die Leitung macht zu, und niemand weiss, ob es + beim Melder wirklich geht. Der merkt es beim naechsten Mal -- und + meldet es nicht noch einmal, weil er denkt, es interessiert ja + doch niemanden. + + „wartet" heisst: die Leitung hat geantwortet, und die Sache liegt + beim MELDER. Er drueckt „geht wieder" (dann ist sie erledigt) + oder „noch nicht" (dann geht sie zurueck in Arbeit -- und zwar in + die naechste Runde, nicht an den Anfang). + + WARUM EINE VIERTE STUFE UND NICHT EIN HAEKCHEN AN „erledigt": + Eine Meldung, die auf eine Antwort wartet, ist ein anderer + Zustand als eine, die niemand angesehen hat -- sie gehoert in + eine eigene Spalte und in eine eigene Zahl. Ein Merkmal an + „erledigt" waere die Sorte Zustand, die man beim Zaehlen vergisst. */ + wartet: "wartet", erledigt: "erledigt", }; @@ -109,7 +134,17 @@ export function supportTabellen(d) { bild_breite INTEGER, bild_hoehe INTEGER, stand TEXT NOT NULL DEFAULT 'neu' - CHECK (stand IN ('neu','in_arbeit','erledigt')), + CHECK (stand IN ('neu','in_arbeit','wartet','erledigt')), + /* DIE WIEVIELTE RUNDE (25.09.2026). + + Filipe: „mit dem gedanken das manchmal sachen mehrmal nicht + sofort perfekt sein werden." + + Manches ist beim zweiten Anlauf immer noch nicht behoben. Die + Zahl steht deshalb an der Meldung und auf dem Bildschirm -- + „Runde 3" ist eine Auskunft, die man beim Lesen braucht, und + sie sagt ohne Vorwurf, dass hier etwas haengt. */ + runde INTEGER NOT NULL DEFAULT 1, antwort TEXT, erstellt TEXT NOT NULL, geaendert TEXT NOT NULL, @@ -117,6 +152,39 @@ export function supportTabellen(d) { erledigt_von INTEGER REFERENCES personen(id) ON DELETE SET NULL ); + /* ==== DER VERLAUF EINER MELDUNG (25.09.2026) ==================== + + Je Runde eine Zeile: was die Leitung geantwortet hat, und was + der Melder daraufhin gesagt hat. + + WARUM NICHT EINFACH DAS FELD antwort UEBERSCHREIBEN: Dann + staende bei der dritten Runde nur noch die dritte Antwort da -- + und die Frage „was haben wir beim ersten Mal versucht?" waere + nicht mehr zu beantworten. Genau die ist es, die einen + wiederkehrenden Fehler loest. + + DIE ZEILE ENTSTEHT BEIM ANTWORTEN, nicht beim Melden: Runde 1 + beginnt, wenn die Leitung das erste Mal sagt „so, probier + mal". */ + CREATE TABLE IF NOT EXISTS support_runden ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + meldung_id INTEGER NOT NULL + REFERENCES support_meldungen(id) ON DELETE CASCADE, + nr INTEGER NOT NULL, + antwort TEXT NOT NULL, + von_id INTEGER REFERENCES personen(id) ON DELETE SET NULL, + von_name TEXT, + am TEXT NOT NULL, + /* Was der Melder gesagt hat: 'geht' oder 'nicht'. NULL heisst + „er hat noch nicht geantwortet" -- und das ist ein eigener, + gueltiger Zustand, kein fehlender Wert. */ + urteil TEXT CHECK (urteil IN ('geht','nicht')), + urteil_text TEXT, + urteil_am TEXT + ); + CREATE INDEX IF NOT EXISTS idx_support_runden_meldung + ON support_runden (meldung_id, nr); + /* Die Leitung fragt „was ist offen?", der Melder „was ist meins?". Zwei Indizes für zwei Fragen. */ CREATE INDEX IF NOT EXISTS idx_support_stand diff --git a/server/workspace-support.js b/server/workspace-support.js index 3aedc53f..96f0392a 100644 --- a/server/workspace-support.js +++ b/server/workspace-support.js @@ -143,9 +143,40 @@ function nachDraussen(m, fuerLeitung) { 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: m.stand === SUPPORT_STAND.wartet, }; } +/** 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 ===================================================================== */ @@ -337,6 +368,113 @@ supportRouter.post("/workspace/api/support", * „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" }); + } + if (m.stand !== SUPPORT_STAND.wartet) { + 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) }); + } 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" }); @@ -380,22 +518,53 @@ supportRouter.patch("/workspace/api/support/:id(\\d+)", express.json(), (req, re /* 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 && antwort.length < 3) { + 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(wunsch, antwort || m.antwort || null, n, - wunsch === SUPPORT_STAND.erledigt ? n : null, - wunsch === SUPPORT_STAND.erledigt ? req.person.id : null, + .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) { + db().prepare(`INSERT INTO support_runden + (meldung_id, nr, antwort, von_id, von_name, am) + VALUES (?,?,?,?,?,?)`) + .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}`, @@ -405,8 +574,14 @@ supportRouter.patch("/workspace/api/support/:id(\\d+)", express.json(), (req, re hört, meldet beim nächsten Mal nichts mehr. */ if (m.person_id && m.person_id !== req.person.id) { benachrichtige(m.person_id, "support", { - titel: wunsch === SUPPORT_STAND.erledigt - ? "Deine Meldung ist erledigt" : "Jemand kümmert sich", + /* 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 */ }); diff --git a/server/workspace.js b/server/workspace.js index 63c9d498..69bf0b96 100644 --- a/server/workspace.js +++ b/server/workspace.js @@ -4140,6 +4140,13 @@ function umstellungen(d) { wird beim Schreiben, an der Stelle, die die Liste kennt. */ ["aufgaben", "aufwand", "TEXT"], + /* DIE RUNDE AN DER SUPPORT-MELDUNG (25.09.2026). Filipe: „mit dem + gedanken das manchmal sachen mehrmal nicht sofort perfekt sein + werden." Auf bestehenden Datenbanken gibt es die Spalte noch + nicht -- ohne sie liefe jede Meldung in einen SQL-Fehler statt + in eine Antwort. */ + ["support_meldungen", "runde", "INTEGER NOT NULL DEFAULT 1"], + /* AUS WELCHER BEOBACHTUNG DIESE AUFGABE ENTSTANDEN IST (15.09.2026). Der Schluessel aus dem Entwicklungskatalog, nichts weiter. Zusammen @@ -4423,6 +4430,19 @@ function umstellungen(d) { ["offen", "angenommen", "arbeit", "erledigt", "abgelehnt", "beworben"], jetztStempel); + /* DER MELDER HAT DAS LETZTE WORT (25.09.2026). + + Filipe: „erst wenn es funktioniert gedrueckt wird, will ich dass + alles richtig fertig ist." + + „wartet" ist der Stand zwischen „die Leitung hat geantwortet" und + „der Melder hat bestaetigt". Auf bestehenden Datenbanken laesst + die CHECK-Regel ihn noch nicht zu -- eine Meldung in diesen Stand + zu bringen wuerde dort abgewiesen, und zwar mit einem + Datenbankfehler statt einer Meldung. */ + checkListeErweitern(d, "support_meldungen", "stand", "wartet", + ["neu", "in_arbeit", "wartet", "erledigt"], jetztStempel); + /* WER ENTSCHIEDEN HAT, UND WAS ER DAZU GESAGT HAT. `grund` traegt weiterhin die Worte der Person selbst (beim Ablehnen ihre Begruendung, beim Bewerben ihr Anliegen). Der diff --git a/workspace/anruf-probe.html b/workspace/anruf-probe.html index cb0886cc..565325e5 100644 --- a/workspace/anruf-probe.html +++ b/workspace/anruf-probe.html @@ -16,15 +16,15 @@ verdeckt. Gefunden hat es pruef-struktur. Richtig sind `gate.css` (die Farbwerte des Hauses) und `haus.css`. --> - - + + - +