Zutragen geht jetzt direkt am Punkt -- ein Griff statt eines Fensters

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 <[email protected]>
2026-09-25 04:40:21 +02:00
parent 177c3c012a
commit 939aa6371b
45 changed files with 864 additions and 642 deletions
@@ -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
@@ -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 {