Bei "An alle" sieht man jetzt, wer sie hat und wer nicht

Filipe: "wenn ich eine aufgabe an alle verteile will ich dass dogfather
und die rechte hand individuel von jedem sehen wer es gemacht hat oder
nicht."

Vier Fehler, die zusammenhingen -- alle gemessen, keiner geraten:

1. "Alle" waehlen, "An alle" druecken, nichts passiert. Die Zeile
   verglich verantwortlich_id !== "alle"; niemand heisst so, also wurde
   jede Aufgabe uebersprungen und die Liste blieb leer. Die Aufgaben
   entstanden, man sah es nur nicht.

2. Der Vermerk an der Karte haette bei "alle" den Stand EINER fremden
   Person gezeigt -- welcher, haengt von der Reihenfolge der Daten ab.
   Jetzt steht dort, wie weit es ist, und darunter namentlich, wer sie
   hat: Offen / Erledigt / ueberfaellig / hat sie nicht. Das Wort steht
   immer dabei, die Farbe ist nur die Abkuerzung.

3. Die "An wen"-Reihe zeigte SECHS Personen, der Server belieferte VIER.
   Rechte und linke Hand gingen leer aus, ohne ein Wort; einzeln
   angeschrieben kam "Das gibt es nicht mehr, lade die Seite neu" zu
   jemandem, den es sehr wohl gibt. Empfaenger sind jetzt Modis UND
   linke Hand (Filipes Regel vom 22.09.), und die Menge steht EINMAL in
   workspace.js -- SQL-Abfrage, Annahme und Browserliste leiten sich
   daraus ab und koennen nicht mehr auseinanderlaufen.

4. Zweimal "An alle" legte alles doppelt an. Der Kommentar im Server
   behauptete das Gegenteil; aktiv war die Sperre nur beim Massenknopf.
   "An alle" fuellt jetzt Luecken. Die bewusste Wiederholung bleibt:
   Steht am Knopf "Nochmal" (weil wirklich alle sie haben), sagt der
   Browser das ausdruecklich, und dann legt der Server neu an.

Geprueft: pruef-modi-katalog 144 statt 133, 0 Fehler -- elf neue
Pruefungen fuer Empfaenger, Luecken und die Gegenprobe, dass ein
gewolltes "Nochmal" sehr wohl anlegt. Dazu mess-alle-einzelsicht.mjs
(eigene Wegwerf-Datenbank, nie die echte) mit Bildern bei 412 und
1280 px.

Co-Authored-By: Claude Opus 5 <[email protected]>

server/pruef-modi-katalog.mjs

@@ -444,7 +444,15 @@ console.log("\n=== 4. DogFather trägt für einen Modi ein ===\n");
     method: "POST", headers: jsonKopf,
     body: JSON.stringify({ art: "katalog", nr, gruppe: "monat", person_id: idCreat }),
   });
-  ok(b.status === 404, `an einen Creator dagegen nicht (${b.status})`);
+  /* STRENGER ALS VORHER (24.09.2026). Hier stand nur `status === 404`.
+     Das war zugleich die Antwort auf „die Person gibt es nicht" -- und
+     auf dem Bildschirm stand deshalb „Das gibt es nicht mehr, lade die
+     Seite neu" zu jemandem, den es sehr wohl gibt. Ein Neuladen half
+     nie. Seit heute trennt der Server die beiden Faelle, und geprueft
+     wird das WORT, nicht nur die Nummer: Ein Zahlendreher woanders
+     koennte sonst denselben Haken setzen. */
+  ok(b.status === 400 && b.daten?.fehler === "rolle_ohne_katalog",
+    `an einen Creator dagegen nicht (${b.status} ${b.daten?.fehler || ""})`);
 
   /* Und ohne Person gar nicht -- eine Aufgabe ohne Adressaten ist ein
      Zettel. */
@@ -1205,6 +1213,165 @@ console.log("\n=== 7. Gegenprobe: kann das hier ueberhaupt scheitern? ===\n");
   ok(e.status === 400, `und eine erfundene Vorlage in der Bewerbung (${e.status})`);
 }
 
+/* ---------- 8. Wer aus dem Katalog etwas bekommen kann --------------- *
+ *
+ * ER STEHT GANZ HINTEN, OBWOHL ER INHALTLICH ZU 4 GEHOERT.
+ *
+ * Grund: Er legt Aufgaben an, und Abschnitt 6 sieht im Browser nach,
+ * wie viele Karten noch einen "Bewerben"-Knopf tragen -- eine Karte,
+ * die man schon hat, traegt keinen. Stand er vorn, fiel diese Zahl von
+ * zehn auf neun, und eine Pruefung wurde rot, an der nichts kaputt war.
+ *
+ * Die Schwelle dort (knoepfe.length >= 10) ist eine feste Zahl und
+ * damit eine Rechnung von gestern -- wer dem Modi kuenftig Aufgaben
+ * gibt, bringt sie wieder zum Kippen. Das hier ist die kleine Loesung
+ * (nicht stoeren); die grosse waere, die Zahl dort abzuleiten statt sie
+ * zu setzen. Wer das anfasst, darf diesen Abschnitt zurueckschieben.
+ */
+/* =====================================================================
+   Filipe, 24.09.2026: „wenn ich eine aufgabe an alle verteile will ich
+   dass dogfather und die rechte hand individuel von jedem sehen wer es
+   gemacht hat oder nicht."
+
+   WARUM DIESER ABSCHNITT NEU IST. „An alle" gab es seit dem Vormittag,
+   und geprueft war davon genau ein Fall: dass eine erfundene Gruppe
+   abgelehnt wird. Der Weg, der tatsaechlich benutzt wird -- an alle
+   verteilen und nachsehen, wer sie hat --, lief ungeprueft.
+
+   UND DABEI LAG ER FALSCH: Die „An wen"-Reihe im Browser zeigte sechs
+   Personen (rechte Hand, linke Hand, vier Modis), der Server nahm aber
+   nur Modis an. „An alle 6" legte vier Aufgaben an, und die beiden
+   Haende gingen leer aus -- ohne ein Wort. Das ist kein Randfall: Es
+   ist der Normalfall dieses Knopfes.
+
+   GEPRUEFT WIRD IN BEIDE RICHTUNGEN. Wer etwas bekommen soll, bekommt
+   es (200); wer nicht, bekommt eine Absage MIT GRUND (400). Eine
+   Pruefung, die nur das Gelingen kennt, kann nicht scheitern -- und
+   bestaetigt damit nichts.
+   ===================================================================== */
+console.log("\n=== 8. Wer aus dem Katalog etwas bekommen kann ===\n");
+{
+  /* VORLAGEN, DIE IN DIESEM LAUF NOCH NIEMAND HAT -- gefragt, nicht
+     getippt. Im ersten Anlauf stand hier `gruppe === "monat"`; diese
+     Gruppe gibt es gar nicht (sie stammte aus einer Absage-Pruefung,
+     in der der Name nie geprueft wurde), und `frei[0]` war undefined.
+     Eine abgeschriebene Kategorie ist dieselbe Falle wie eine feste
+     Zahl. So gefragt bleibt die Pruefung richtig, auch wenn der
+     Katalog morgen andere Gruppen hat. */
+  /* EIN EIGENER, LESENDER GRIFF. Der von ganz oben ist seit Zeile 87
+     zu -- weiter oben machen es die Bewerbungen mit `d2` schon so. Ein
+     offen gelassener Griff waere schlimmer: Die Pruefung wuerde am
+     Ende nicht mehr enden. */
+  const { DatabaseSync: DB4 } = await import("node:sqlite");
+  const d4 = new DB4(process.env.WORKSPACE_DB, { readOnly: true });
+  const belegt = new Set(d4.prepare(
+    "SELECT DISTINCT vorlage AS v FROM aufgaben WHERE vorlage IS NOT NULL")
+    .all().map((x) => x.v));
+  d4.close();
+  const frei = katalog.aufgaben
+    .map((v, i) => ({ ...v, nr: i }))
+    .filter((v) => !belegt.has(v.schluessel));
+  ok(frei.length >= 2,
+    `es gibt genug unbenutzte Vorlagen zum Pruefen (${frei.length})`);
+
+  /* --- Die linke Hand GEHOERT DAZU (neu seit 24.09.2026) ------------
+     Filipes Regel vom 22.09.: „die modis und linke hand sollen ... sich
+     fuer aufgaben bewerben koennen aber die rechte hand oder dogfather
+     muessen annehmen oder ablehnen". Also ist sie Empfaengerin. */
+  const l = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
+    method: "POST", headers: jsonKopf,
+    body: JSON.stringify({ art: "katalog", nr: frei[0].nr, gruppe: frei[0].gruppe, person_id: idLinke }),
+  });
+  ok(l.status === 200 && l.daten?.angelegt === 1,
+    `an die linke Hand geht es (${l.status})`);
+
+  /* --- Die rechte Hand NICHT. Sie verteilt; stuende sie in ihrer
+     eigenen Verteilliste, waere „an alle" auch „an mich selbst". */
+  const h = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
+    method: "POST", headers: jsonKopf,
+    body: JSON.stringify({ art: "katalog", nr: frei[0].nr, gruppe: frei[0].gruppe, person_id: idHand }),
+  });
+  ok(h.status === 400 && h.daten?.fehler === "rolle_ohne_katalog",
+    `an die rechte Hand dagegen nicht (${h.status} ${h.daten?.fehler || ""})`);
+
+  /* --- Und jetzt „an alle" ------------------------------------------
+     Im Haus dieses Laufs gibt es genau EINEN Modi und EINE linke Hand.
+     „Alle" muss also ZWEI Aufgaben anlegen -- nicht eine (dann waere
+     die linke Hand wieder vergessen) und nicht drei (dann haette die
+     rechte Hand eine bekommen). Die Zahl allein reicht aber nicht:
+     Drei falsche Leute waeren auch drei. Deshalb wird danach
+     nachgesehen, WER sie wirklich hat. */
+  const alle = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
+    method: "POST", headers: jsonKopf,
+    body: JSON.stringify({ art: "katalog", nr: frei[1].nr, gruppe: frei[1].gruppe, person_id: "alle" }),
+  });
+  ok(alle.status === 200 && alle.daten?.angelegt === 2,
+    `„an alle" legt bei beiden Empfaengern an (${alle.status}, ${alle.daten?.angelegt})`);
+
+  const d5 = new DB4(process.env.WORKSPACE_DB, { readOnly: true });
+  const hats = new Set(d5.prepare(
+    "SELECT verantwortlich_id AS w FROM aufgaben WHERE vorlage = ?")
+    .all(frei[1].schluessel).map((x) => Number(x.w)));
+  ok(hats.has(idModi) && hats.has(idLinke),
+    `und zwar beim Modi UND bei der linken Hand (${[...hats].join(", ")})`);
+  ok(!hats.has(idHand) && !hats.has(idCreat),
+    "und bei niemandem sonst");
+  d5.close();
+
+  /* --- "AN ALLE" FUELLT LUECKEN, ES DOPPELT NICHT -------------------
+     Filipe, 24.09.2026: „Nur die 2 Fehlenden bekommen sie."
+     Derselbe Druck ein zweites Mal: Beide haben sie schon, also darf
+     KEINE dazukommen -- und der Server muss es SAGEN, sonst sieht ein
+     Knopf, der nichts tut, wie ein Fehler aus. Am 22.09. sind aus zwei
+     Klicks 112 Aufgaben geworden, weil niemand nachgezaehlt hat. */
+  const wieder = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
+    method: "POST", headers: jsonKopf,
+    body: JSON.stringify({ art: "katalog", nr: frei[1].nr, gruppe: frei[1].gruppe, person_id: "alle" }),
+  });
+  const zaehle = (schluessel) => {
+    const dz = new DB4(process.env.WORKSPACE_DB, { readOnly: true });
+    const n = dz.prepare(
+      "SELECT COUNT(*) AS n FROM aufgaben WHERE vorlage = ?").get(schluessel)?.n;
+    dz.close();
+    return Number(n);
+  };
+  ok(zaehle(frei[1].schluessel) === 2,
+    `ein zweiter Druck legt nichts dazu (${zaehle(frei[1].schluessel)} statt 2)`);
+  ok(wieder.daten?.uebersprungen === 2,
+    `und er sagt, dass er zwei uebersprungen hat (${wieder.daten?.uebersprungen})`);
+
+  /* --- ABER DIE GEGENPROBE: gemeint ist gemeint ---------------------
+     Eine Sperre, die sich nicht bewusst umgehen laesst, verbietet die
+     Wochenaufgabe. Steht am Knopf "Nochmal" (weil wirklich alle sie
+     haben), schickt der Browser `nochmal: true` -- und DANN muss die
+     Zahl steigen. Ohne diese Probe koennte die Sperre auch schlicht
+     alles blockieren und saehe von aussen genauso richtig aus. */
+  const absicht = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
+    method: "POST", headers: jsonKopf,
+    body: JSON.stringify({
+      art: "katalog", nr: frei[1].nr, gruppe: frei[1].gruppe,
+      person_id: "alle", nochmal: true,
+    }),
+  });
+  ok(absicht.status === 200 && zaehle(frei[1].schluessel) === 4,
+    `ein gewolltes "Nochmal" legt sehr wohl an (${zaehle(frei[1].schluessel)} statt 4)`);
+
+  /* --- Und eine LUECKE wird wirklich gefuellt ------------------------
+     Der eigentliche Fall: Einer hat sie, der andere nicht. Dann darf
+     genau EINE entstehen -- nicht null (dann waere die Sperre zu
+     scharf) und nicht zwei (dann doppelt sie). `frei[0]` liegt seit
+     oben bei der linken Hand, beim Modi nicht. */
+  const luecke = await hole(dogiAn.keks, "/workspace/api/vorlagen/uebernehmen", {
+    method: "POST", headers: jsonKopf,
+    body: JSON.stringify({ art: "katalog", nr: frei[0].nr, gruppe: frei[0].gruppe, person_id: "alle" }),
+  });
+  ok(luecke.daten?.angelegt === 1 && luecke.daten?.uebersprungen === 1,
+    `eine Luecke wird gefuellt, der Rest nicht gedoppelt `
+    + `(${luecke.daten?.angelegt} neu, ${luecke.daten?.uebersprungen} uebersprungen)`);
+  ok(zaehle(frei[0].schluessel) === 2,
+    `und danach hat sie jeder genau einmal (${zaehle(frei[0].schluessel)})`);
+}
+
 console.log(`\n${fehler ? "FEHLGESCHLAGEN" : "BESTANDEN"} -- `
   + `${geprueft} geprueft, ${fehler} Fehler, ${offen} nicht nachsehbar`);
 try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }