dogfather-universe/server/pruef-vorschlaege.mjs

/* =====================================================================
   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 { eigenerPort } from "./helfer-port.mjs";
import { notbremse } from "./helfer-notbremse.mjs";

const PORT = await eigenerPort(import.meta, "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");

/* =======================================================================
   WER ENTSCHEIDET -- steht der Satz ueberall, wo Vorschlaege sind?
   =======================================================================

   Filipe am 21.09.2026: "bei diesen vorschlägen ist sehr wichtig dass
   immer wenn es um was geht was ich machen soll oder so dass immer
   erwähnt wird dass ich immer am ende entscheide ob ich was mache oder
   nicht. ich kann immer annehmen oder ablehnen. über all auf der
   website soll dass bei den vorschlägen erwähnt werden."

   WARUM DAS EINE PRUEFUNG BRAUCHT: Ein Satz, den man an zwei Stellen
   einbaut, ist beim naechsten Brett an einer davon vergessen. Und
   gerade dieser faellt nicht auf, wenn er fehlt -- eine Seite ohne ihn
   sieht vollkommen normal aus. Sie sieht nur nicht mehr wie ein
   Vorschlag aus, sondern wie eine Zusage.

   ZWEI ORTE, EINE QUELLE: ueber den Vorschlagskarten (das Team sieht
   sie beim Auswaehlen) und auf dem Brett selbst (dort liest die
   Community, was daraus geworden ist). Beide holen denselben Text aus
   VORSCHLAG_HINWEIS.
   ======================================================================= */
{
  const { VORSCHLAG_HINWEIS } = await import("./workspace-treff-start.js");

  ok(/entscheidet/i.test(VORSCHLAG_HINWEIS)
    && /ablehnen/i.test(VORSCHLAG_HINWEIS),
    `der Satz sagt beides -- entscheiden UND ablehnen ("${VORSCHLAG_HINWEIS}")`);

  /* JEDES BRETT MIT VORSCHLAEGEN, nicht ein ausgewaehltes. Die Liste
     kommt aus dem Katalog selbst; ein neues Brett ist damit
     automatisch mitgeprueft, ohne dass es jemand hier eintraegt. */
  const { TREFF_START } = await import("./workspace-treff-start.js");
  const { ARBEIT_START } = await import("./workspace-arbeit-start.js").catch(() => ({}));
  const ARBEIT_HAT = Object.keys(ARBEIT_START || {});
  const bretter = Object.keys(TREFF_START);
  ok(bretter.length >= 3, `${bretter.length} Bretter haben Vorschlaege`);

  const ohneKarten = [];
  const ohneBrett = [];
  for (const b of bretter) {
    const k = await hole(`/workspace/api/bereich/${b}/start?ab=0`);
    if (k.status === 200 && k.daten?.hinweis !== VORSCHLAG_HINWEIS) ohneKarten.push(b);
    const e = await hole(`/workspace/api/bereich/${b}`);
    if (e.status === 200 && e.daten?.einstellung?.entscheidung !== VORSCHLAG_HINWEIS) {
      ohneBrett.push(b);
    }
  }
  ok(ohneKarten.length === 0,
    ohneKarten.length ? `ueber den Karten fehlt er bei: ${ohneKarten.join(", ")}`
      : `er steht ueber den Karten aller ${bretter.length} Bretter`);
  ok(ohneBrett.length === 0,
    ohneBrett.length ? `auf dem Brett fehlt er bei: ${ohneBrett.join(", ")}`
      : "und auf jedem Brett selbst -- dort, wo die Community liest");

  /* GEGENPROBE: Ein Brett OHNE Vorschlaege darf ihn NICHT tragen. Ein
     Hinweis, der ueberall steht, wird nirgends gelesen -- und diese
     Zeile beweist zugleich, dass die Pruefung darueber ueberhaupt
     unterscheiden kann. */
  const { BEREICHE } = await import("./workspace-bereiche.js");
  const ohneKatalog = Object.keys(BEREICHE || {})
    .filter((b) => !bretter.includes(b) && !ARBEIT_HAT.includes(b));
  /* DRITTER AUSGANG: Gaebe es gar kein Brett ohne Vorschlaege, waere
     diese Gegenprobe nicht durchfuehrbar -- und das ist kein "in
     Ordnung", sondern "konnte nicht nachsehen". */
  if (!ohneKatalog.length) {
    console.log("  --   Gegenprobe nicht moeglich: jedes Brett hat Vorschlaege");
  } else {
    const ohne = await hole(`/workspace/api/bereich/${ohneKatalog[0]}`);
    ok(ohne.status !== 200 || !ohne.daten?.einstellung?.entscheidung,
      `Gegenprobe: "${ohneKatalog[0]}" hat keine Vorschlaege und traegt ihn nicht `
      + `(${ohne.status}, ${JSON.stringify(ohne.daten?.einstellung?.entscheidung)})`);
  }

  /* Und die Oberflaeche zeigt ihn wirklich an -- ein Feld, das der
     Server schickt und niemand rendert, ist kein Hinweis. */
  const seite = readFileSync(new URL("../workspace/bereich.html", import.meta.url), "utf8");
  ok(/id="brett-entscheidung"/.test(seite),
    "die Brettseite hat den Platz dafuer");
  const js2 = readFileSync(
    new URL("../workspace/assets/js/bereich.js", import.meta.url), "utf8");
  ok(/brett-entscheidung/.test(js2) && /startkatalog__entscheidung/.test(js2),
    "und das Skript fuellt beide Stellen");
}

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);