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]>

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