Fertige Vorschlaege lassen sich wechseln
Bisher kamen ALLE auf einmal -- damit gab es nichts zu wechseln, die Liste war entweder ganz da oder ganz weg. Bei 17 Vorschlaegen (Brett "regeln") ist eine Wand aus Karten ausserdem das Gegenteil von "uebernehmen, was passt". Jetzt vier auf einmal, und ein Knopf holt die naechsten vier. Der Server rechnet die Stelle mit Rest -- nach dem letzten kommt wieder der erste. Es gibt also keinen Zustand "durchgeklickt, jetzt leer". Bei hoechstens vier offenen Vorschlaegen erscheint der Knopf gar nicht: Ein Knopf, der dieselben Karten noch einmal malt, ist ein Knopf, der nichts tut. Was es NICHT ist: Die Vorschlaege werden nicht erzeugt. Sie sind ein geschriebener Vorrat von 113 Stueck auf 16 Brettern. pruef-vorschlaege.mjs: 21 Pruefungen. Die entscheidende vergleicht die Titel vorher und nachher -- ein Knopf, der nur gedrueckt werden kann, besteht jede Pruefung, die nur nach dem Knopf sucht. Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
Claude Opus 5
@@ -0,0 +1,178 @@
|
||||
/* =====================================================================
|
||||
pruef-vorschlaege.mjs — Die fertigen Vorschläge lassen sich wechseln
|
||||
|
||||
Filipe, 20.09.2026: „fertige vorschläge, überall auf der ganzen
|
||||
kompletten website, will ich dass man auch immer wieder neuladen
|
||||
kann, so dass wenn man alle benutzt hat man neue erstellen kann oder
|
||||
wenn keiner uns gefällt wir komplett neue erstellen können
|
||||
automatisch, mach das richtig geil dass es immer wieder möglich ist
|
||||
die liste zu wechseln wenn sie uns nicht gefällt oder leer ist."
|
||||
|
||||
---------------------------------------------------------------------
|
||||
WAS HIER DIE EIGENTLICHE FRAGE IST
|
||||
|
||||
Nicht „gibt es einen Knopf" — sondern „kommt nach dem Druck etwas
|
||||
ANDERES". Ein Knopf, der dieselben vier Karten noch einmal malt,
|
||||
besteht jede Prüfung, die nur nach dem Knopf sucht, und ist
|
||||
trotzdem wertlos. Deshalb werden hier die Titel VORHER und NACHHER
|
||||
verglichen.
|
||||
|
||||
UND DER RUNDLAUF: Wer oft genug drückt, muss wieder am Anfang
|
||||
landen statt vor einer leeren Liste. Das wird gemessen, indem so oft
|
||||
weitergeschaltet wird, dass der Vorrat sicher durch ist.
|
||||
|
||||
AUFRUF: node server/pruef-vorschlaege.mjs
|
||||
===================================================================== */
|
||||
|
||||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { portMussFreiSein } from "./helfer-port.mjs";
|
||||
import { notbremse } from "./helfer-notbremse.mjs";
|
||||
|
||||
const PORT = await portMussFreiSein(4436, "pruef-vorschlaege");
|
||||
const ordner = mkdtempSync(join(tmpdir(), "ws-vorschlag-"));
|
||||
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
||||
process.env.PORT = String(PORT);
|
||||
process.env.SITE_ACCESS_SECRET = "lokaler-test";
|
||||
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
|
||||
const express = (await import("express")).default;
|
||||
const ec = express.response.cookie;
|
||||
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
|
||||
await import("./index.js");
|
||||
notbremse(200_000, "pruef-vorschlaege");
|
||||
await new Promise((r) => setTimeout(r, 900));
|
||||
const BASIS = `http://127.0.0.1:${PORT}`;
|
||||
|
||||
process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
|
||||
process.on("unhandledRejection", (f) => { console.error("ABSTURZ (Versprechen):", f); process.exit(7); });
|
||||
|
||||
let fehler = 0, geprueft = 0;
|
||||
const ok = (b, t) => { geprueft++; console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
|
||||
|
||||
console.log("\n=== Fertige Vorschläge wechseln ===\n");
|
||||
|
||||
/* ---- Anmelden: ein Gast, denn nur wer NICHT schreiben darf, bekommt
|
||||
den Katalog ueberhaupt. Genau das ist der Sinn: Vorschlaege sind
|
||||
fuer leere Bretter da. ------------------------------------------ */
|
||||
const { DatabaseSync } = await import("node:sqlite");
|
||||
const { scryptSync, randomBytes } = await import("node:crypto");
|
||||
const d = new DatabaseSync(process.env.WORKSPACE_DB);
|
||||
const salt = randomBytes(16).toString("hex");
|
||||
const hash = scryptSync("CODE-DOGI-0001", salt, 64,
|
||||
{ N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
||||
d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt)"
|
||||
+ " VALUES (?,?,?,?,?,1,?)").run("Filipe", "admin", hash, salt, 32768, new Date().toISOString());
|
||||
d.close();
|
||||
|
||||
const an = await fetch(BASIS + "/workspace/api/anmelden", {
|
||||
method: "POST", headers: { "Content-Type": "application/json", Origin: BASIS },
|
||||
body: JSON.stringify({ rolle: "admin", code: "CODE-DOGI-0001" }),
|
||||
});
|
||||
const keks = (an.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
|
||||
ok(an.ok && !!keks, "angemeldet");
|
||||
|
||||
const hole = async (weg) => {
|
||||
const a = await fetch(BASIS + weg, { headers: { Cookie: keks } });
|
||||
return a.ok ? a.json() : null;
|
||||
};
|
||||
|
||||
/* ---- 1. Welches Brett hat den groessten Vorrat? ------------------- */
|
||||
/* NICHT geraten: gemessen. Ein fest eingetragener Bereichsname waere
|
||||
falsch, sobald jemand den Katalog umbaut -- und die Pruefung liefe
|
||||
dann auf einem Brett mit drei Vorschlaegen und koennte gar nichts
|
||||
ueber das Weiterschalten sagen. */
|
||||
const { STARTKATALOG } = await import("./workspace-bereiche.js")
|
||||
.then((m) => ({ STARTKATALOG: m.STARTKATALOG }))
|
||||
.catch(() => ({ STARTKATALOG: null }));
|
||||
|
||||
let bereich = null, vorrat = 0;
|
||||
for (const b of ["regeln", "mitmachen", "content", "community", "live", "technik", "schutz"]) {
|
||||
const r = await hole(`/workspace/api/bereich/${b}/start`);
|
||||
if (r && r.offen > vorrat) { bereich = b; vorrat = r.offen; }
|
||||
}
|
||||
/* DRITTER AUSGANG: Ohne ein Brett mit mehr als vier offenen
|
||||
Vorschlaegen ist die Frage "kommt etwas anderes" nicht zu
|
||||
beantworten -- und das muss ein FEHLER sein, kein Schweigen. */
|
||||
ok(!!bereich && vorrat > 4,
|
||||
`Brett mit genug Vorrat gefunden: "${bereich}" mit ${vorrat} offenen`);
|
||||
if (!bereich || vorrat <= 4) {
|
||||
console.log("\n KONNTE NICHT NACHSEHEN: Kein Brett hat mehr als vier offene");
|
||||
console.log(" Vorschlaege. Ohne das ist nicht messbar, ob das Weiterschalten");
|
||||
console.log(" etwas anderes liefert. Katalog pruefen: server/workspace-*-start.js\n");
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
/* ---- 2. Es kommt ein FENSTER, nicht die ganze Wand ---------------- */
|
||||
const s0 = await hole(`/workspace/api/bereich/${bereich}/start?ab=0`);
|
||||
ok(s0.vorschlaege.length < vorrat,
|
||||
`es kommen ${s0.vorschlaege.length} von ${vorrat} auf einmal - nicht alle`);
|
||||
ok(s0.vorschlaege.length === 4, `das Fenster ist vier gross (${s0.vorschlaege.length})`);
|
||||
ok(s0.mehr_da === true, "und der Server sagt, dass es mehr gibt (mehr_da)");
|
||||
ok(s0.offen === vorrat, `"offen" zaehlt weiterhin alle (${s0.offen}) - davon haengt "Alle N uebernehmen" ab`);
|
||||
|
||||
/* ---- 3. DIE EIGENTLICHE FRAGE: kommt etwas anderes? --------------- */
|
||||
const s1 = await hole(`/workspace/api/bereich/${bereich}/start?ab=4`);
|
||||
const t0 = s0.vorschlaege.map((v) => v.titel);
|
||||
const t1 = s1.vorschlaege.map((v) => v.titel);
|
||||
const gleich = t1.filter((t) => t0.includes(t)).length;
|
||||
ok(gleich === 0,
|
||||
`nach dem Weiterschalten ist KEINER der vier derselbe (${gleich} Ueberschneidungen)`);
|
||||
console.log(` vorher : ${t0.map((t) => t.slice(0, 22)).join(" | ")}`);
|
||||
console.log(` nachher: ${t1.map((t) => t.slice(0, 22)).join(" | ")}`);
|
||||
|
||||
/* GEGENPROBE: Dieselbe Abfrage OHNE Weiterschalten muss dieselben
|
||||
liefern. Sonst misst der Vergleich oben nur Zufall -- eine Liste,
|
||||
die sich bei jedem Abruf mischt, haette den Test auch bestanden und
|
||||
waere trotzdem kaputt (man findet einen Vorschlag nie wieder). */
|
||||
const s0b = await hole(`/workspace/api/bereich/${bereich}/start?ab=0`);
|
||||
ok(JSON.stringify(s0b.vorschlaege.map((v) => v.titel)) === JSON.stringify(t0),
|
||||
"Gegenprobe: ohne Weiterschalten kommen dieselben - die Liste wuerfelt nicht");
|
||||
|
||||
/* ---- 4. KEIN ENDE: der Vorrat laeuft im Kreis --------------------- */
|
||||
/* Weit ueber den Vorrat hinaus. Wer so oft drueckt, darf nicht vor
|
||||
einer leeren Liste stehen -- das war Filipes Punkt ("oder leer ist"). */
|
||||
const weit = await hole(`/workspace/api/bereich/${bereich}/start?ab=${vorrat * 3 + 2}`);
|
||||
ok((weit?.vorschlaege?.length || 0) === 4,
|
||||
`weit hinter dem Ende kommen immer noch vier (${weit?.vorschlaege?.length}) - kein leerer Bildschirm`);
|
||||
const rund = await hole(`/workspace/api/bereich/${bereich}/start?ab=${vorrat}`);
|
||||
ok(JSON.stringify(rund.vorschlaege.map((v) => v.titel)) === JSON.stringify(t0),
|
||||
"genau einmal herum gibt wieder den Anfang - der Rundlauf schliesst");
|
||||
|
||||
/* ---- 5. Unsinn in der Adresse darf nichts umwerfen ---------------- */
|
||||
for (const mies of ["-7", "abc", "9e99", "", "1.5"]) {
|
||||
const r = await hole(`/workspace/api/bereich/${bereich}/start?ab=${encodeURIComponent(mies)}`);
|
||||
ok((r?.vorschlaege?.length || 0) === 4, ` "ab=${mies}" liefert trotzdem vier`);
|
||||
}
|
||||
|
||||
/* ---- 6. Ein kleines Brett bekommt KEINEN Wechselknopf ------------- */
|
||||
/* Ein Knopf, der dieselben drei Karten noch einmal malt, ist ein
|
||||
Knopf, der nichts tut -- und der Verdacht, die Seite haenge, ist
|
||||
schlimmer als ein fehlender Knopf. */
|
||||
let klein = null;
|
||||
for (const b of ["highlight", "ansteht", "agentur", "wunsch", "ideen", "angebote"]) {
|
||||
const r = await hole(`/workspace/api/bereich/${b}/start`);
|
||||
if (r && r.offen > 0 && r.offen <= 4) { klein = { b, r }; break; }
|
||||
}
|
||||
ok(!!klein, `Brett mit hoechstens vier Vorschlaegen gefunden ("${klein?.b}", ${klein?.r?.offen})`);
|
||||
ok(klein?.r?.mehr_da === false,
|
||||
" und dort sagt der Server: nichts zu wechseln (mehr_da ist falsch)");
|
||||
ok((klein?.r?.vorschlaege?.length || 0) === klein?.r?.offen,
|
||||
` es kommen trotzdem alle ${klein?.r?.offen} auf einmal - nichts versteckt`);
|
||||
|
||||
/* ---- 7. Und die Seite baut den Knopf auch ------------------------- */
|
||||
const { readFileSync } = await import("node:fs");
|
||||
const { fileURLToPath } = await import("node:url");
|
||||
const { dirname } = await import("node:path");
|
||||
const HIER = dirname(fileURLToPath(import.meta.url));
|
||||
const js = readFileSync(join(HIER, "..", "workspace", "assets", "js", "bereich.js"), "utf8");
|
||||
ok(/katalogAb \+= Math\.max\(1, daten\.vorschlaege\.length\)/.test(js),
|
||||
"die Seite zaehlt um das weiter, was wirklich kam - keine zweite 4 im Code");
|
||||
ok(/if \(daten\.mehr_da\)/.test(js),
|
||||
"und zeigt den Knopf nur, wenn der Server sagt, dass es mehr gibt");
|
||||
ok(/let katalogAb = 0;[\s\S]{0,200}async function startkatalogZeigen/.test(js),
|
||||
"der Merker steht AUSSERHALB der Funktion - sonst spraenge die Liste nach jedem Uebernehmen zurueck");
|
||||
|
||||
console.log(`\n${fehler ? fehler + " FEHLER" : "Alles in Ordnung"} — ${geprueft} Prüfungen\n`);
|
||||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
|
||||
process.exit(fehler ? 1 : 0);
|
||||
@@ -1846,9 +1846,59 @@ bereicheRouter.get("/workspace/api/bereich/:bereich/start", (req, res) => {
|
||||
Wahrheit, und beim Umformulieren liefe sie auseinander. */
|
||||
const da = new Set(db().prepare(
|
||||
"SELECT titel FROM eintraege WHERE bereich = ?").all(bereich).map((z) => z.titel));
|
||||
|
||||
/* ==== EIN FENSTER STATT DER GANZEN LISTE (20.09.2026) ===========
|
||||
|
||||
Filipe: "fertige vorschlaege, ueberall auf der ganzen kompletten
|
||||
website, will ich dass man auch immer wieder neuladen kann, so
|
||||
dass wenn man alle benutzt hat man neue erstellen kann oder wenn
|
||||
keiner uns gefaellt wir komplett neue erstellen koennen
|
||||
automatisch ... dass es immer wieder moeglich ist die liste zu
|
||||
wechseln wenn sie uns nicht gefaellt oder leer ist."
|
||||
|
||||
BISHER KAMEN ALLE AUF EINMAL. Damit gab es nichts zu wechseln --
|
||||
die Liste war entweder ganz da oder ganz weg. Und bei 17
|
||||
Vorschlaegen (Brett "regeln") ist eine Wand aus Karten das
|
||||
Gegenteil von "uebernehmen, was passt".
|
||||
|
||||
JETZT: vier auf einmal, und ein Knopf holt die naechsten vier.
|
||||
Ist der Vorrat durch, faengt er von vorn an -- `ab` wird mit
|
||||
Rest gerechnet, es gibt also kein Ende und keine Sackgasse.
|
||||
|
||||
WAS ES NICHT IST: Die Vorschlaege werden nicht ERZEUGT. Sie sind
|
||||
ein geschriebener Vorrat (113 Stueck auf 16 Brettern), und das
|
||||
steht auch in der Antwort -- `vorrat` sagt, wie viele es
|
||||
insgesamt sind. Der Oberflaeche zu erlauben, "neue" zu
|
||||
versprechen, die es nicht gibt, waere eine Luege mit
|
||||
Fortschrittsanzeige. */
|
||||
const FENSTER = 4;
|
||||
const offeneListe = liste.map((v, nr) => ({ nr, ...v, schon: da.has(v.titel) }))
|
||||
.filter((v) => !v.schon);
|
||||
|
||||
const roh = Number(req.query?.ab);
|
||||
/* MODULO STATT GRENZE: Wer oft genug weiterklickt, landet wieder am
|
||||
Anfang -- statt vor einer leeren Liste zu stehen. */
|
||||
const ab = offeneListe.length
|
||||
? ((Number.isFinite(roh) ? Math.trunc(roh) : 0) % offeneListe.length
|
||||
+ offeneListe.length) % offeneListe.length
|
||||
: 0;
|
||||
|
||||
const fenster = [];
|
||||
for (let i = 0; i < Math.min(FENSTER, offeneListe.length); i++) {
|
||||
fenster.push(offeneListe[(ab + i) % offeneListe.length]);
|
||||
}
|
||||
|
||||
res.json({
|
||||
vorschlaege: liste.map((v, nr) => ({ nr, ...v, schon: da.has(v.titel) })),
|
||||
offen: liste.filter((v) => !da.has(v.titel)).length,
|
||||
vorschlaege: fenster,
|
||||
/* `offen` bleibt, was es war: wie viele es NOCH gibt. Die
|
||||
Oberflaeche zaehlt damit "Alle N uebernehmen" richtig. */
|
||||
offen: offeneListe.length,
|
||||
/* NEU: Gibt es ueberhaupt etwas zu wechseln? Ohne diese Angabe
|
||||
muesste die Seite rechnen, und ein Knopf, der nichts anderes
|
||||
zeigt, ist ein Knopf, der nichts tut. */
|
||||
mehr_da: offeneListe.length > FENSTER,
|
||||
ab,
|
||||
vorrat: liste.length,
|
||||
});
|
||||
} catch (fehler) {
|
||||
console.error("[workspace] Startkatalog:", fehler?.message);
|
||||
|
||||
Reference in New Issue
Block a user