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/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 */ });