DogFatherGit/dogfather-universe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Support: der Melder hat das letzte Wort -- und die Kachel bekommt ihren eigenen Stil

Browse Source 
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 <[email protected]>
This commit is contained in:
DogFatherGit
2026-09-25 04:55:14 +02:00
co-authored by Claude Opus 5
parent 939aa6371b
commit cebdd88e8d
47 changed files with 1377 additions and 661 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/pruef-support.mjs
+107 -13
View File
@@ -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})`);
}
}
/* =====================================================================
server/support-tabellen.js
+69 -1
View File
@@ -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
server/workspace-support.js
+181 -6
View File
@@ -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 */ });
server/workspace.js
+20
View File
@@ -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