From 939aa6371bc0f1b34e5ad9c25c02b709d8c1505e Mon Sep 17 00:00:00 2001 From: Dogfather Date: Fri, 25 Sep 2026 04:40:21 +0200 Subject: [PATCH] Zutragen geht jetzt direkt am Punkt -- ein Griff statt eines Fensters MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Filipe: "ich will sofort über diese aufgaben da spezifisch zuteilen kann bitte. bei allen personnen." DAS AUSWAHLFENSTER BLEIBT -- es ist der Weg, wenn man jemanden neu einrichtet und zwoelf Punkte auf einmal vergibt. Der Knopf am Punkt ist der andere Fall, und der haeufigere: Man liest eine Beobachtung, denkt "das soll er machen", und will es in dem Moment erledigen -- nicht ein Fenster aufmachen, in einer Liste von 68 denselben Punkt suchen und wieder zumachen. AUS DER MARKE WIRD DER SCHALTER. An derselben Stelle, an der bis eben nur "Aufgabe" stand, sitzt jetzt der Knopf, mit dem man es tut. Er steht IMMER da, auch wenn nichts zugetragen ist: Auf einem Handy gibt es kein Ueberfahren, und einen Knopf, der erst beim Zeigen erscheint, gibt es dort nicht. Im Ruhezustand ist er ein Umriss -- 68 gefuellte Kaestchen untereinander waeren ein Balken. EIN PUNKT, EIN AUFRUF -- und das ist nicht nur Bequemlichkeit: Wuerde dieser Knopf die ganze Liste schicken (wie das Fenster), loeschte er die Zutragung, die jemand anderes eine Sekunde vorher gemacht hat. Genau das misst die Pruefung: erst zutragen, dann nachsehen, ob die vorherigen unberuehrt sind. ZWEIMAL DASSELBE IST KEIN FEHLER. Wer zweimal tippt oder zwei Fenster offen hat, bekommt denselben Zustand -- nicht eine Absage und nicht einen doppelten Eintrag (`ON CONFLICT DO NOTHING`). DIE ZAHL KOMMT VOM SERVER ZURUECK und wird nicht im Browser weitergerechnet: Bei zwei offenen Fenstern waere die eigene falsch, und niemand saehe, warum. Kopf, Ring und Kachel ziehen damit sofort nach -- ohne Neuladen und ohne Sprung. EIN FUND AM WERKZEUG, eine Ebene tiefer: tools/_um.py stellt Anker auf die Zeilenenden der Datei um -- und entwicklung.css hat GEMISCHTE (Bestand CRLF, ein angehaengter Block LF). Der Anker wurde auf CRLF gestellt und traf den LF-Teil nicht; die Meldung lautete "Anker 0x", und man sucht den Fehler im Anker, obwohl er Zeichen fuer Zeichen stimmt. Genau die Sorte Fehlalarm, gegen die dieses Werkzeug gebaut wurde. Es probiert jetzt beide Arten und ersetzt mit der, die an der Fundstelle gilt. Geprueft: pruef-entwicklung 63 -> 70 Punkte, darunter zwei Gegenproben (ein erfundener Punkt wird abgewiesen, ein Modi traegt nichts zu). pruef-tippziele (11) und pruef-css-klassen unveraendert gruen. Co-Authored-By: Claude Opus 5 --- server/pruef-entwicklung.mjs | 49 ++++++++++++++++ server/workspace-entwicklung.js | 66 ++++++++++++++++++++++ workspace/anruf-probe.html | 10 ++-- workspace/app.webmanifest | 8 +-- workspace/assets/css/entwicklung.css | 46 ++++++++++++++- workspace/assets/js/entwicklung.js | 83 ++++++++++++++++++++++++---- 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 | 28 +++++----- 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 ++++++------ 45 files changed, 864 insertions(+), 642 deletions(-) diff --git a/server/pruef-entwicklung.mjs b/server/pruef-entwicklung.mjs index 440f7014..c438c92d 100644 --- a/server/pruef-entwicklung.mjs +++ b/server/pruef-entwicklung.mjs @@ -469,6 +469,55 @@ console.log("\n=== Punkte je Person aussuchen ==="); ok(vonHand.status === 200 && vonHand.daten?.zugeteilt === 5, `die rechte Hand sucht ebenfalls aus (HTTP ${vonHand.status}, ${vonHand.daten?.zugeteilt})`); + /* ---- 4b. EINZELN ZUTRAGEN, DIREKT AM PUNKT (25.09.2026) -------- + + Filipe: „ich will sofort über diese aufgaben da spezifisch + zuteilen kann bitte. bei allen personnen." + + Das Auswahlfenster setzt die GANZE Liste; dieser Weg setzt EINEN + Punkt. Der Unterschied ist nicht nur Bequemlichkeit: Wuerde der + Knopf am Punkt die ganze Liste schicken, loeschte er die + Zutragung, die jemand anderes eine Sekunde vorher gemacht hat. + Genau das wird hier gemessen -- erst zutragen, dann pruefen, dass + die vorherigen unberuehrt sind. */ + { + const einer = alle[20].schluessel; + const vorZahl = (await karte(dogi.keks))?.gesamt || 0; + const weg = (an, s = einer, keks = dogi.keks) => + hole(`/workspace/api/entwicklung/person/${idModi}/punkt/${s}`, + { host: CREW, keks, methode: "PUT", rumpf: JSON.stringify({ an }) }); + + const a1 = await weg(true); + ok(a1.status === 200 && a1.daten?.zugetragen === true, + `ein einzelner Punkt laesst sich direkt am Punkt zutragen (HTTP ${a1.status})`); + ok(a1.daten?.gesamt === vorZahl + 1, + `und die neue Zahl kommt vom Server zurueck (${vorZahl} -> ${a1.daten?.gesamt})`); + + const k1 = await karte(dogi.keks); + const markiert1 = (k1?.bloecke || []).flatMap((b) => b.punkte) + .filter((pt) => pt.zugetragen).map((pt) => pt.schluessel); + ok(markiert1.includes(einer) && markiert1.length === vorZahl + 1, + `die vorher zugetragenen bleiben unberuehrt (${markiert1.length})`); + + /* ZWEIMAL DASSELBE IST KEIN FEHLER. Wer zweimal tippt oder zwei + Fenster offen hat, bekommt denselben Zustand -- nicht eine + Absage und nicht einen doppelten Eintrag. */ + const a2 = await weg(true); + ok(a2.status === 200 && a2.daten?.gesamt === a1.daten?.gesamt, + `zweimal zutragen aendert nichts (${a2.daten?.gesamt})`); + + const a3 = await weg(false); + ok(a3.status === 200 && a3.daten?.gesamt === vorZahl, + `und einzeln wieder wegnehmen ebenso (${a3.daten?.gesamt})`); + + const quatsch = await weg(true, "gibt_es_nicht"); + ok(quatsch.status === 400, + `Gegenprobe: ein erfundener Punkt wird abgewiesen (${quatsch.status})`); + const vonModi2 = await weg(true, einer, ayla.keks); + ok(vonModi2.status >= 400, + `Gegenprobe: ein Modi traegt nichts zu (${vonModi2.status})`); + } + /* ---- Gegenproben ------------------------------------------------- */ /* EIN ERFUNDENER SCHLUESSEL WIRD VERWORFEN. Ohne diesen Abgleich liesse sich beliebiger Text in die Tabelle schreiben -- er stuende diff --git a/server/workspace-entwicklung.js b/server/workspace-entwicklung.js index b108fac5..1ecbd90a 100644 --- a/server/workspace-entwicklung.js +++ b/server/workspace-entwicklung.js @@ -951,6 +951,72 @@ entwicklungRouter.get("/workspace/api/entwicklung/person/:id/punkte", } }); +/* ==== EINEN EINZELNEN PUNKT ZUTRAGEN (25.09.2026) ================== + + Filipe: „ich will sofort über diese aufgaben da spezifisch zuteilen + kann bitte. bei allen personnen." + + DAS AUSWAHLFENSTER BLEIBT -- es ist der Weg, wenn man jemanden neu + einrichtet und zwoelf Punkte auf einmal vergibt. Dieser Weg hier ist + der andere Fall, und er ist der haeufigere: Man liest eine + Beobachtung, denkt „das soll er machen", und will es in dem Moment + erledigen -- nicht ein Fenster aufmachen, in einer Liste von 68 + denselben Punkt suchen und wieder zumachen. + + EIN PUNKT, EIN AUFRUF. Anders als beim Fenster, das die ganze Liste + setzt: Hier geht es um EINE Entscheidung, und die soll auch dann + ankommen, wenn zwei Leute gleichzeitig an derselben Karte sitzen. + Wuerde dieser Weg die ganze Liste schicken, loeschte er die + Zutragung, die der andere eine Sekunde vorher gemacht hat. + + `INSERT OR IGNORE` / `DELETE`: Zweimal zutragen ist kein Fehler, + zweimal wegnehmen auch nicht. Wer zweimal tippt (oder zwei Fenster + offen hat), bekommt denselben Zustand, nicht einen Fehler. + ================================================================== */ +entwicklungRouter.put("/workspace/api/entwicklung/person/:id/punkt/:schluessel", + gleicheHerkunft, nurLeitung, express.json({ limit: "4kb" }), (req, res) => { + try { + const id = nummer(req.params.id); + const p = id && db().prepare("SELECT id, name, rolle FROM personen WHERE id = ?").get(id); + if (!p || !KARTEN_ROLLEN.includes(p.rolle)) { + return res.status(404).json({ fehler: "nicht_gefunden" }); + } + const schluessel = String(req.params.schluessel || ""); + /* NUR EIN SCHLUESSEL, DEN ES WIRKLICH GIBT -- sonst liesse sich + ueber diesen Weg beliebiger Text in die Tabelle schreiben, der + danach in keiner Liste steht und auch nicht wegzubekommen + ist. Dieselbe Pruefung wie beim Fenster. */ + if (!ENTWICKLUNG_FREMD.some((pt) => pt.schluessel === schluessel)) { + return res.status(400).json({ fehler: "unbekannter_punkt" }); + } + const an = req.body?.an === true; + if (an) { + db().prepare(`INSERT INTO entwicklung_zuteilung + (person_id, schluessel, seit, von_id) VALUES (?,?,?,?) + ON CONFLICT(person_id, schluessel) DO NOTHING`) + .run(id, schluessel, jetzt(), req.person.id); + } else { + db().prepare( + "DELETE FROM entwicklung_zuteilung WHERE person_id = ? AND schluessel = ?") + .run(id, schluessel); + } + + protokolliere(an ? "entwicklung_punkt_zugetragen" : "entwicklung_punkt_zurueck", { + personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req), + detail: `${p.name}: ${schluessel}`.slice(0, 120), + }); + /* DIE NEUE ZAHL KOMMT MIT. Die Oberflaeche zeigt „3 von 12 + erledigt" -- rechnete sie selbst weiter, waere sie bei zwei + offenen Fenstern falsch, und niemand saehe, warum. */ + const gesamt = db().prepare( + "SELECT COUNT(*) AS n FROM entwicklung_zuteilung WHERE person_id = ?").get(id).n; + res.json({ ok: true, zugetragen: an, gesamt }); + } catch (f) { + console.error("[entwicklung] Punkt zutragen:", f?.message); + res.status(503).json({ fehler: "nicht_verfuegbar" }); + } + }); + entwicklungRouter.put("/workspace/api/entwicklung/person/:id/punkte", gleicheHerkunft, nurLeitung, express.json({ limit: "32kb" }), (req, res) => { try { diff --git a/workspace/anruf-probe.html b/workspace/anruf-probe.html index 932bf84f..cb0886cc 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`. --> - - + + - +