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`. -->
-
-
+
+
-
+