dogfather-universe/server/pruef-spenden.mjs

/* =====================================================================
   DIE SPENDEN (28.09.2026)

   Geprueft wird der ganze Weg aus Filipes Ansage:

       Betragsknoepfe -> PayPal -> melden -> wartet ->
       bestaetigen -> Karte im Bild

   ---------------------------------------------------------------------
   WARUM DIESE PRUEFUNG UEBER DIE HAUSADRESSE SPRICHT

   Dieselbe Begruendung wie bei der Reaction: Die Community meldet
   sich ueber den stillen Zugang an, und der ist auf einer
   Pruefadresse absichtlich abgeschaltet. `fetch` kann die
   Host-Kopfzeile nicht setzen, deshalb node:http.

   Aufrufen mit:  node server/pruef-spenden.mjs
   ===================================================================== */
import { mkdtempSync, rmSync, readFileSync, statSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, dirname } from "node:path";
import { fileURLToPath } from "node:url";
import { request } from "node:http";

const HIER = dirname(fileURLToPath(import.meta.url));
const ordner = mkdtempSync(join(tmpdir(), "ws-spend-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");

import { notbremse } from "./helfer-notbremse.mjs";
const { eigenerPort } = await import("./helfer-port.mjs");
const PORT = await eigenerPort(import.meta, "die Spenden-Pruefung");

process.env.PORT = `${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-spenden");
await new Promise((r) => setTimeout(r, 900));

let fehler = 0, geprueft = 0;
const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };
const melde = (t) => console.log(t);
process.on("exit", () => { try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ } });

const CREW = "crew.dogfather-universe.com";
const AGENTUR = "workspace.dogfather-universe.com";

/* ---------- Zugaenge anlegen -------------------------------------------- */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const nun = new Date().toISOString();
const kennSchluessel = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", kennSchluessel, nun);

/* 200 Tage alt: Der Treff hat Stufen, und wer neu ist, darf weniger.
   Fuer die Reaction spielt das keine Rolle -- aber ein Zugang von
   heute waere ein Sonderfall, den niemand im Blick hat. */
const ALT = new Date(Date.now() - 200 * 86400000).toISOString();
function anlegen(name, rolle, code) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, 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,"
    + " code_kennung, aktiv, erstellt) VALUES (?,?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768,
      createHmac("sha256", kennSchluessel).update(code).digest("hex"), ALT);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const ROLLEN = [["admin", "Filipe"], ["hand", "VanVan"], ["linke", "Funny"],
  ["modi", "Miss"], ["gast", "Nachtfalter"], ["gast2", "Lenny"], ["creator", "Luna"]];
const CODES = {}; const IDS = {};
for (const [i, [rolle, name]] of ROLLEN.entries()) {
  CODES[rolle] = `CODE-R${String(i).padStart(2, "0")}-000001`;
  IDS[rolle] = anlegen(name, rolle === "gast2" ? "gast" : rolle, CODES[rolle]);
}
d.close();

/* ---------- Sprechen mit Hausadresse ------------------------------------ */
/** `roher` schickt Bytes statt JSON.
 *
 *  Gebraucht fuer das Hochladen eines Bildes: Die Route nimmt
 *  `express.raw()` entgegen, und ein als JSON verpacktes Bild waere
 *  etwas anderes als das, was ein Browser schickt -- die Pruefung
 *  wuerde dann einen Weg pruefen, den es gar nicht gibt. */
function roh(host, pfad, { method = "GET", keks = "", rumpf = null, roher = null, origin } = {}) {
  return new Promise((fertig, schief) => {
    const daten = roher !== null ? roher
      : (rumpf === null ? null : Buffer.from(JSON.stringify(rumpf)));
    const a = request({
      host: "127.0.0.1", port: PORT, path: pfad, method,
      headers: {
        Host: host,
        Origin: origin === undefined ? `https://${host}` : origin,
        ...(keks ? { Cookie: keks } : {}),
        ...(daten ? {
          "Content-Type": roher !== null ? "application/octet-stream" : "application/json",
          "Content-Length": daten.length,
        } : {}),
      },
    }, (antwort) => {
      const teile = [];
      antwort.on("data", (s) => teile.push(s));
      antwort.on("end", () => {
        const text = Buffer.concat(teile).toString("utf8");
        let j = null; try { j = JSON.parse(text); } catch { /* kein JSON */ }
        fertig({ code: antwort.statusCode, text, j, kopf: antwort.headers });
      });
    });
    a.on("error", schief);
    if (daten) a.write(daten);
    a.end();
  });
}

async function anmelden(rolle, host) {
  const a = await roh(host, "/workspace/api/anmelden", {
    method: "POST", rumpf: { rolle: rolle === "gast2" ? "gast" : rolle,
      code: CODES[rolle], alter_ok: true },
  });
  const keks = [].concat(a.kopf["set-cookie"] || []).map((z) => z.split(";")[0]).join("; ");
  return a.code === 200 && keks ? keks : null;
}

const k = {};
for (const [rolle] of ROLLEN) k[rolle] = await anmelden(rolle, CREW);

/* =======================================================================
   1. DAS RECHNEN MIT GELD
   ======================================================================= */
melde("=== 1. Rechnen mit Geld ===");
{
  /* NIE MIT KOMMAZAHLEN. 0.1 + 0.2 ist in jeder Programmiersprache
     nicht 0.3, und bei Geld faellt das irgendwann jemandem auf --
     meistens dem, der zahlt. */
  const { mitBetrag, stufeFuer } = await import("./workspace-spenden.js");

  ok(mitBetrag("https://paypal.me/probe", 500) === "https://paypal.me/probe/5EUR",
    `runde Betraege ohne Nachkommastellen (${mitBetrag("https://paypal.me/probe", 500)})`);
  ok(mitBetrag("https://paypal.me/probe", 750) === "https://paypal.me/probe/7.50EUR",
    `krumme mit zweien (${mitBetrag("https://paypal.me/probe", 750)})`);
  ok(mitBetrag("https://paypal.me/probe/", 200) === "https://paypal.me/probe/2EUR",
    "ein Schraegstrich am Ende macht keinen doppelten");

  /* AN EINER FREMDEN ADRESSE WIRD NICHTS ANGEHAENGT. Ein Betrag an
     einer Seite, die ihn nicht versteht, fuehrt zu einer Seite, auf
     der etwas anderes steht als auf dem Knopf. */
  ok(mitBetrag("https://example.com/spenden", 500) === null,
    "an einer fremden Adresse wird nichts angehaengt");
  ok(mitBetrag("", 500) === null, "und an gar keiner auch nicht");

  /* DIE HOECHSTE STUFE, DIE NOCH PASST. */
  ok(stufeFuer(50) === null, "unter der kleinsten Stufe gibt es keine");
  ok(stufeFuer(100)?.name === "Danke", `0,1 Dogen ergibt ${stufeFuer(100)?.name}`);
  ok(stufeFuer(499)?.name === "Danke", "0,499 Dogen bleibt darunter");
  ok(stufeFuer(500)?.name === "Starke Runde", `0,5 Dogen ergibt ${stufeFuer(500)?.name}`);
  ok(stufeFuer(5000)?.name === "Rudel-Legende", `5 Dogen ergibt ${stufeFuer(5000)?.name}`);
}

/* =======================================================================
   2. DIE AGENTUR KENNT DIE SPENDEN NICHT
   ======================================================================= */
melde("");
melde("=== 2. Getrennte Haeuser ===");
{
  const kCreator = await anmelden("creator", AGENTUR);
  ok(!!kCreator, "eine Creatorin meldet sich im Agenturhaus an");
  const a = await roh(AGENTUR, "/workspace/api/spenden", { keks: kCreator });
  ok(a.code === 404, `und sieht die Spenden nicht (${a.code})`);

  /* GEGENPROBE: Im eigenen Haus geht derselbe Weg. Sonst koennte die
     404 auch daran liegen, dass es den Weg gar nicht gibt. */
  const b = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
  ok(b.code === 200, `im Teamhaus schon (${b.code})`);
}

/* =======================================================================
   3. DIE BETRAGSKNOEPFE
   ======================================================================= */
melde("");
melde("=== 3. Die Betragsknoepfe ===");
{
  const ohne = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
  ok(Array.isArray(ohne.j?.knoepfe) && ohne.j.knoepfe.length === 0,
    `ohne hinterlegte Adresse gibt es keine Knoepfe (${ohne.j?.knoepfe?.length})`);
  ok(ohne.j?.paypal === null, "und auch keinen Weg");

  /* Jetzt eine eintragen -- ueber den echten Weg, nicht in die
     Datenbank. Genau diese Pruefungen sollen ja mitlaufen. */
  const wege = await roh(CREW, "/workspace/api/unterstuetzung", { keks: k.admin });
  const pp = (wege.j?.wege || wege.j?.liste || []).find((w) => w.schluessel === "paypal");
  ok(!!pp, "der PayPal-Weg steht in der Unterstuetzen-Liste");
  await roh(CREW, `/workspace/api/unterstuetzung/${pp.id}`, {
    method: "PUT", keks: k.admin,
    rumpf: { ziel: "https://paypal.me/probehase", knopf: "Dogi was ausgeben", sichtbar: true },
  });

  const mit = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
  ok(mit.j?.knoepfe?.length === 4, `jetzt gibt es vier (${mit.j?.knoepfe?.length})`);
  ok(mit.j?.knoepfe?.[0]?.ziel === "https://paypal.me/probehase/2EUR",
    `mit dem Betrag in der Adresse (${mit.j?.knoepfe?.[0]?.ziel})`);
  ok(mit.j?.paypal?.knopf === "Dogi was ausgeben",
    "und die Aufschrift kommt von der Unterstuetzen-Seite");

  /* WER NICHT DIE LEITUNG IST, SIEHT KEINE FREMDEN BETRAEGE. */
  ok(mit.j?.offen === null && mit.j?.letzte === null,
    "ein Zuschauer bekommt die Liste fremder Spenden NICHT");
  const alsChef = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
  ok(Array.isArray(alsChef.j?.offen), "die Leitung schon");
}

/* =======================================================================
   4. MELDEN — EINE BEHAUPTUNG, KEINE TATSACHE
   ======================================================================= */
melde("");
melde("=== 4. Melden ===");
{
  const mist = await roh(CREW, "/workspace/api/spenden/melden", {
    method: "POST", keks: k.gast, rumpf: { dogen_mille: 0 },
  });
  ok(mist.code === 400 && mist.j?.fehler === "betrag_unklar",
    `null Euro ist kein Betrag (${mist.code}/${mist.j?.fehler})`);
  const zuViel = await roh(CREW, "/workspace/api/spenden/melden", {
    method: "POST", keks: k.gast, rumpf: { dogen_mille: 99999999 },
  });
  ok(zuViel.code === 400, `und eine Million auch nicht (${zuViel.code})`);

  const a = await roh(CREW, "/workspace/api/spenden/melden", {
    method: "POST", keks: k.gast, rumpf: { dogen_mille: 1500, gruss: "Danke fuer alles" },
  });
  ok(a.code === 201 && a.j?.wartet === true,
    `die Meldung wird angenommen -- und sie WARTET (${a.code})`);

  /* EINE JE MINUTE. Nicht gegen Betrug -- die Leitung bestaetigt ja
     -- sondern gegen den Doppelklick und gegen eine Liste, die man
     nicht mehr durchsieht. */
  const zweite = await roh(CREW, "/workspace/api/spenden/melden", {
    method: "POST", keks: k.gast, rumpf: { dogen_mille: 1500 },
  });
  ok(zweite.code === 429, `zweimal in derselben Minute nicht (${zweite.code})`);

  const beiDerLeitung = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
  const wartet = (beiDerLeitung.j?.offen || [])[0];
  ok(wartet?.dogen_mille === 1500 && wartet?.stand === "offen",
    `sie steht im Pult und wartet (${wartet?.dogen_mille} Tausendstel, ${wartet?.stand})`);
  ok(wartet?.name === "Nachtfalter", `mit dem Namen der Person (${wartet?.name})`);
  ok(wartet?.stufe?.name === "Starke Runde",
    `und der Stufe, die zum Betrag passt (${wartet?.stufe?.name})`);

  const beiIhr = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
  ok(beiIhr.j?.offen === null, "sie selbst bekommt keine Liste");
}

/* =======================================================================
   5. NUR DIE LEITUNG ENTSCHEIDET
   ======================================================================= */
melde("");
melde("=== 5. Wer ueber Geld entscheidet ===");
{
  const offen = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
  const id = offen.j.offen[0].id;

  for (const rolle of ["linke", "modi", "gast"]) {
    const a = await roh(CREW, `/workspace/api/spenden/${id}/bestaetigen`, {
      method: "POST", keks: k[rolle],
    });
    ok(a.code === 403 && a.j?.fehler === "nur_leitung",
      `${rolle}: bestaetigt nichts (${a.code}/${a.j?.fehler})`);
    const b = await roh(CREW, "/workspace/api/spenden", {
      method: "POST", keks: k[rolle], rumpf: { dogen_mille: 100, name: "X" },
    });
    ok(b.code === 403, `${rolle}: traegt auch nichts ein (${b.code})`);
  }

  /* DER BETRAG DARF BEIM BESTAETIGEN BERICHTIGT WERDEN. Die Leitung
     hat die PayPal-Meldung vor sich und weiss es besser als die
     Behauptung. */
  const ja = await roh(CREW, `/workspace/api/spenden/${id}/bestaetigen`, {
    method: "POST", keks: k.hand, rumpf: { dogen_mille: 1200 },
  });
  ok(ja.code === 200 && ja.j?.stand === "bestaetigt" && ja.j?.dogen_mille === 1200,
    `die rechte Hand bestaetigt und berichtigt (${ja.j?.dogen_mille} Tausendstel)`);

  /* ZWEIMAL BESTAETIGEN IST KEIN FEHLER -- aber auch kein Grund, die
     Karte noch einmal zu zeigen. Zwei Leute tippen gleichzeitig. */
  const nochmal = await roh(CREW, `/workspace/api/spenden/${id}/bestaetigen`, {
    method: "POST", keks: k.admin,
  });
  ok(nochmal.code === 200 && nochmal.j?.dogen_mille === 1200,
    "ein zweites Mal aendert nichts und ist kein Fehler");

  const danach = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
  ok((danach.j?.offen || []).length === 0, "danach wartet nichts mehr");
  ok((danach.j?.letzte || []).some((z) => z.id === id), "und sie steht bei den gezeigten");
}

/* =======================================================================
   6. VON HAND EINTRAGEN — DER WEG, DER IMMER GEHT
   ======================================================================= */
melde("");
melde("=== 6. Von Hand eintragen ===");
{
  const ohneName = await roh(CREW, "/workspace/api/spenden", {
    method: "POST", keks: k.admin, rumpf: { dogen_mille: 500 },
  });
  ok(ohneName.code === 400 && ohneName.j?.fehler === "name_fehlt",
    `ohne Namen keine Karte -- er steht ja darauf (${ohneName.code})`);

  const a = await roh(CREW, "/workspace/api/spenden", {
    method: "POST", keks: k.admin,
    rumpf: { dogen_mille: 5000, name: "Miss", gruss: "Weiter so!" },
  });
  ok(a.code === 201 && a.j?.stand === "bestaetigt",
    `eingetragen gilt sofort (${a.code}/${a.j?.stand})`);
  ok(a.j?.stufe?.name === "Rudel-Legende" && a.j?.stufe?.dauer_ms === 11000,
    `mit der hoechsten Stufe und ihrer Dauer (${a.j?.stufe?.name}, ${a.j?.stufe?.dauer_ms} ms)`);

  const wieder = await roh(CREW, `/workspace/api/spenden/${a.j.id}/nochmal`, {
    method: "POST", keks: k.admin,
  });
  ok(wieder.code === 200, `und laesst sich noch einmal zeigen (${wieder.code})`);
  const ablehnen = await roh(CREW, `/workspace/api/spenden/${a.j.id}/ablehnen`, {
    method: "POST", keks: k.admin,
  });
  ok(ablehnen.code === 409 && ablehnen.j?.fehler === "nicht_offen",
    `was schon lief, laesst sich nicht mehr ablehnen (${ablehnen.code})`);
}

/* =======================================================================
   7. DIESELBE ZAHLUNG NUR EINMAL
   ======================================================================= */
melde("");
melde("=== 7. Keine Spende zweimal ===");
{
  /* Ein Webhook wird bei einer Stoerung wiederholt. Ohne diese
     Sperre stuende dieselbe Spende zweimal im Bild -- und zwar
     ausgerechnet dann, wenn das Netz hakt. */
  const { DatabaseSync: DB2 } = await import("node:sqlite");
  const d2 = new DB2(process.env.WORKSPACE_DB);
  const nun = new Date().toISOString();
  const rein = (nummer) => d2.prepare(
    "INSERT INTO spenden (betrag_cent, waehrung, name, herkunft, stand, fremd_id, erstellt)"
    + " VALUES (?,?,?,?,?,?,?)").run(300, "EUR", "Webhook", "paypal", "bestaetigt", nummer, nun);

  rein("PAY-1");
  let zweimal = false;
  try { rein("PAY-1"); zweimal = true; } catch { /* genau so soll es sein */ }
  ok(!zweimal, "dieselbe Zahlungsnummer laesst sich kein zweites Mal eintragen");

  /* GEGENPROBE: Ohne Nummer duerfen beliebig viele nebeneinander
     stehen -- sonst koennte man nur eine Spende von Hand eintragen. */
  let ohneNummer = 0;
  for (let i = 0; i < 3; i++) {
    d2.prepare("INSERT INTO spenden (betrag_cent, waehrung, name, herkunft, stand, erstellt)"
      + " VALUES (?,?,?,?,?,?)").run(100, "EUR", "Ohne", "hand", "bestaetigt", nun);
    ohneNummer++;
  }
  ok(ohneNummer === 3, "Gegenprobe: ohne Nummer stehen beliebig viele nebeneinander");
  d2.close();
}


/* =======================================================================
   8. DIE GESTALTUNG

   Filipe: „mach paar fertige und so dass ich auch hochladen kann.
   auch so dass ich das anders gestalten kann oder die groesse
   veraendern kann. ... auch spezielle sachen bei speziellen spenden."
   ======================================================================= */
melde("");
melde("=== 8. Die Gestaltung der Karten ===");
{
  /* Wie viele Spenden es gibt -- gebraucht fuer den Nachweis, dass
     die Probe KEINE anlegt. Gezaehlt wird in der Datenbank und nicht
     in einer Liste der Oberflaeche: Eine Liste zeigt nur, was sie
     zeigen soll. */
  const { DatabaseSync: DBZ } = await import("node:sqlite");
  const dz = new DBZ(process.env.WORKSPACE_DB, { readOnly: true });
  const zaehle = () => dz.prepare("SELECT COUNT(*) AS n FROM spenden").get().n;

  const { VORLAGEN, STUFEN_MAX, GROESSE_MIN, GROESSE_MAX, DAUER_MS_MIN, DAUER_MS_MAX }
    = await import("./spenden-tabellen.js");

  /* ---- Die Vorlagen sind an BEIDEN Enden dieselben ----
     Ein Name, den nur eine Seite kennt, waere eine Vorlage, die sich
     auswaehlen laesst und dann als Herz erscheint. */
  {
    const karte = readFileSync(
      join(HIER, "..", "workspace", "assets", "js", "spendenkarte.js"), "utf8");
    const block = karte.match(/const VORLAGEN = \{([\s\S]*?)\n  \};/);
    const inKarte = [...(block ? block[1] : "").matchAll(/^\s{4}([a-z]+):/gm)].map((m) => m[1]);
    ok(inKarte.length >= 5, `die Karte kennt ${inKarte.length} Zeichnungen`);
    /* „dogen" IST EINE VORLAGE, ABER KEINE ZEICHNUNG. Sie zeigt
       die Muenze des gewaehlten Satzes und steht deshalb nicht im
       Zeichnungsblock -- verglichen wird ohne sie. Dass die Karte
       sie trotzdem behandelt, prueft die Zeile darunter: Ohne sie
       waere „dogen" eine Auswahl, die als Herz erscheint. */
    const zeichnungen = VORLAGEN.filter((v) => v !== "dogen");
    const fehlt = zeichnungen.filter((v) => !inKarte.includes(v));
    const zuviel = inKarte.filter((v) => !zeichnungen.includes(v));
    ok(fehlt.length === 0 && zuviel.length === 0,
      (fehlt.length || zuviel.length)
        ? `UNGLEICH: fehlt ${fehlt.join(",")} / zuviel ${zuviel.join(",")}`
        : `Server und Karte kennen dieselben ${zeichnungen.length} Zeichnungen`);
    ok(VORLAGEN.includes("dogen") && /vorlage === 'dogen'/.test(karte),
      "und die Karte behandelt die Muenze als eigene Vorlage");
    ok(!VORLAGEN.includes("wolke"), "Gegenprobe: eine erfundene Zeichnung steht in keiner Liste");
  }

  /* ---- Wer gestalten darf ---- */
  const guteLeiter = {
    stufen: [
      { ab_mille: 100, name: "Danke", vorlage: "herz", farbe: "#8ec9ff", dauer_ms: 6000, groesse: 1 },
      { ab_mille: 2000, name: "Legende", vorlage: "krone", farbe: "#e0a13a", dauer_ms: 11000, groesse: 1.45 },
    ],
  };
  for (const rolle of ["linke", "modi", "gast"]) {
    const a = await roh(CREW, "/workspace/api/spenden/stufen", {
      method: "PUT", keks: k[rolle], rumpf: guteLeiter,
    });
    ok(a.code === 403, `${rolle}: gestaltet nicht (${a.code})`);
  }

  /* ---- Was eine Leiter sein muss ---- */
  const schlecht = [
    [{ stufen: [] }, 400, "keine_stufe", "eine leere Leiter"],
    [{ stufen: null }, 400, "stufen_fehlen", "gar keine Leiter"],
    [{ stufen: Array.from({ length: STUFEN_MAX + 1 }, (x, i) => ({
      ab_mille: (i + 1) * 100, name: `S${i}`, vorlage: "herz",
      farbe: "#8ec9ff", dauer_ms: 5000, groesse: 1 })) }, 400, "zu_viele_stufen",
    `${STUFEN_MAX + 1} Stufen`],
    [{ stufen: [{ ab_mille: 0, name: "X", vorlage: "herz", farbe: "#8ec9ff", dauer_ms: 5000, groesse: 1 }] },
      400, "stufe_betrag_unklar", "null Dogen"],
    [{ stufen: [{ ab_mille: 100, name: "  ", vorlage: "herz", farbe: "#8ec9ff", dauer_ms: 5000, groesse: 1 }] },
      400, "stufe_name_fehlt", "ein leerer Name"],
    [{ stufen: [{ ab_mille: 100, name: "X", vorlage: "wolke", farbe: "#8ec9ff", dauer_ms: 5000, groesse: 1 }] },
      400, "vorlage_unbekannt", "eine erfundene Zeichnung"],
    /* DIE FARBE IST DIE HEIKELSTE STELLE: Sie landet als CSS-Wert in
       der Karte. Ein freier Text waere dort eine Einschleusung. */
    [{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz",
      farbe: "red; background:url(javascript:1)", dauer_ms: 5000, groesse: 1 }] },
    400, "farbe_unklar", "eine eingeschleuste Farbe"],
    [{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz", farbe: "blau", dauer_ms: 5000, groesse: 1 }] },
      400, "farbe_unklar", "ein Farbwort"],
    [{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz", farbe: "#8ec9ff",
      dauer_ms: DAUER_MS_MAX + 1000, groesse: 1 }] }, 400, "dauer_unklar", "zu lange"],
    [{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz", farbe: "#8ec9ff",
      dauer_ms: DAUER_MS_MIN - 500, groesse: 1 }] }, 400, "dauer_unklar", "zu kurz"],
    [{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz", farbe: "#8ec9ff",
      dauer_ms: 5000, groesse: GROESSE_MAX + 1 }] }, 400, "groesse_unklar", "zu gross"],
    [{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz", farbe: "#8ec9ff",
      dauer_ms: 5000, groesse: GROESSE_MIN - 0.5 }] }, 400, "groesse_unklar", "zu klein"],
    [{ stufen: [
      { ab_mille: 500, name: "A", vorlage: "herz", farbe: "#8ec9ff", dauer_ms: 5000, groesse: 1 },
      { ab_mille: 500, name: "B", vorlage: "welle", farbe: "#a98bff", dauer_ms: 5000, groesse: 1 },
    ] }, 409, "stufe_doppelt", "zwei Stufen beim selben Betrag"],
  ];
  for (const [rumpf, code, wort, was] of schlecht) {
    const a = await roh(CREW, "/workspace/api/spenden/stufen", {
      method: "PUT", keks: k.admin, rumpf,
    });
    ok(a.code === code && a.j?.fehler === wort,
      `${was} wird abgelehnt (${a.code}/${a.j?.fehler})`);
  }

  /* NACH ALL DEN ABLEHNUNGEN MUSS DIE ALTE LEITER NOCH STEHEN.
     Eine Pruefung, die nur den Fehlercode ansieht, uebersieht genau
     das: Ein Abbruch mitten im Schreiben haette die Leiter halb
     geleert zurueckgelassen -- und dann faellt in der naechsten
     Sendung eine Spende in gar keine Stufe. */
  const heil = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
  ok((heil.j?.stufen || []).length >= 3,
    `die alte Leiter steht unveraendert (${heil.j?.stufen?.length} Stufen)`);

  /* ---- Und was geht ---- */
  const gut = await roh(CREW, "/workspace/api/spenden/stufen", {
    method: "PUT", keks: k.admin, rumpf: guteLeiter,
  });
  ok(gut.code === 200 && gut.j?.stufen?.length === 2,
    `zwei Stufen werden gespeichert (${gut.code})`);
  ok(gut.j?.stufen?.[0]?.ab_mille === 100 && gut.j?.stufen?.[1]?.ab_mille === 2000,
    "und stehen aufsteigend");
  ok(gut.j?.stufen?.[1]?.groesse === 1.45,
    `die Groesse kommt an (${gut.j?.stufen?.[1]?.groesse})`);

  /* ---- UMSORTIEREN MUSS GEHEN ----
     `ab_cent` ist eindeutig. Wer zwei vorhandene Stufen ihre Betraege
     TAUSCHEN laesst, stoesst beim Umschreiben auf sich selbst --
     obwohl das Ergebnis voellig in Ordnung waere. Gemessen ist genau
     das passiert („UNIQUE constraint failed"), und der ganze Vorgang
     brach mit 503 ab. */
  {
    const jetzige = gut.j.stufen;
    const getauscht = await roh(CREW, "/workspace/api/spenden/stufen", {
      method: "PUT", keks: k.admin,
      rumpf: { stufen: [
        { ...jetzige[0], ab_mille: 2000 },
        { ...jetzige[1], ab_mille: 100 },
      ] },
    });
    ok(getauscht.code === 200, `zwei Stufen tauschen ihre Betraege (${getauscht.code})`);
    ok(getauscht.j?.stufen?.[0]?.name === jetzige[1].name,
      `und die Leiter steht richtig herum (${getauscht.j?.stufen?.[0]?.name})`);
    /* Und wieder zurueck -- der Rest des Abschnitts rechnet damit. */
    await roh(CREW, "/workspace/api/spenden/stufen", {
      method: "PUT", keks: k.admin, rumpf: { stufen: jetzige },
    });
  }

  /* SPEZIELLE SACHEN BEI SPEZIELLEN SPENDEN: Die Stufe entscheidet
     sich am Betrag, und zwar immer die hoechste passende. */
  const { stufeFuer } = await import("./workspace-spenden.js");
  ok(stufeFuer(100)?.name === "Danke", "0,1 Dogen -> Danke");
  ok(stufeFuer(1999)?.name === "Danke", "1,999 Dogen -> immer noch Danke");
  ok(stufeFuer(2000)?.name === "Legende", "2 Dogen -> Legende");
  ok(stufeFuer(50000)?.name === "Legende", "50 Dogen -> Legende");
  ok(stufeFuer(99) === null, "unter der ersten Stufe gibt es keine");

  /* ---- Die Probe legt KEINE Spende an ----
     Der naheliegende Weg waere gewesen, eine Spende einzutragen und
     danach zu loeschen. In ein laufendes System kommen keine
     Testdaten -- und „geloescht" heisst bei Geld nicht „war nie da". */
  const vorher = zaehle();
  const probe = await roh(CREW, "/workspace/api/spenden/probe", {
    method: "POST", keks: k.admin, rumpf: { dogen_mille: 2000 },
  });
  ok(probe.code === 200 && probe.j?.karte?.stufe?.name === "Legende",
    `die Probe zeigt die richtige Stufe (${probe.j?.karte?.stufe?.name})`);
  ok(probe.j?.karte?.stand === "probe", "und ist als Probe gekennzeichnet");
  ok(zaehle() === vorher,
    `und es entsteht KEINE Spende daraus (${vorher} -> ${zaehle()})`);
  const probeNein = await roh(CREW, "/workspace/api/spenden/probe", {
    method: "POST", keks: k.modi, rumpf: { dogen_mille: 2000 },
  });
  ok(probeNein.code === 403, `ein Modi probiert nicht (${probeNein.code})`);

  /* ---- Das Bild ---- */
  const id = gut.j.stufen[1].id;
  const keinBild = await roh(CREW, `/workspace/api/spenden/stufe/${id}/bild`, {
    method: "POST", keks: k.admin, roher: Buffer.from("das ist kein Bild"),
  });
  ok(keinBild.code === 400 && keinBild.j?.fehler === "kein_bild",
    `Text statt Bild wird abgelehnt (${keinBild.code})`);

  /* EIN ECHTES PNG -- der kleinste gueltige, den es gibt. Ein
     erfundener Kopf wuerde nur beweisen, dass die Pruefung dieselbe
     Annahme macht wie der Code. */
  const png = Buffer.from(
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
    "base64");
  const hoch = await roh(CREW, `/workspace/api/spenden/stufe/${id}/bild`, {
    method: "POST", keks: k.admin, roher: png,
  });
  ok(hoch.code === 200 && /^\/workspace\/api\/buehne\/spendenbild\/[a-f0-9]{32}\.png$/
    .test(hoch.j?.bild || ""), `ein PNG wird angenommen (${hoch.j?.bild})`);

  /* DAS BILD MUSS OHNE ANMELDUNG ZU HOLEN SEIN. Die Spendentafel in
     OBS hat keine Sitzung -- ein 401 als JSON in einem <img> ergibt
     ein kaputtes Bild ohne jeden Hinweis. */
  const ohne = await roh(CREW, hoch.j.bild, {});
  ok(ohne.code === 200, `und ohne Anmeldung abrufbar (${ohne.code})`);
  ok(String(ohne.kopf["content-type"]).startsWith("image/png"),
    `als Bild und nicht als etwas anderes (${ohne.kopf["content-type"]})`);
  ok(ohne.kopf["x-content-type-options"] === "nosniff",
    "der Browser darf den Typ nicht selbst raten");

  /* KEIN AUSBRUCH AUS DEM ORDNER.
     GEPRUEFT WIRD, WAS HERAUSKOMMT -- nicht, welche Zahl dabeisteht.
     „../../workspace.db" wird vom Server zu „/workspace/api/workspace.db"
     zusammengefaltet, bevor diese Route ueberhaupt drankommt; die
     Antwort ist dann 401 von einer ganz anderen Stelle. Auf 404 zu
     bestehen hiesse, eine Nebensaechlichkeit zu pruefen und den
     eigentlichen Punkt zu verfehlen: Es darf keine Datei
     herauskommen. */
  for (const boes of ["../../workspace.db", "..%2f..%2fworkspace.db",
    "%2e%2e%2f%2e%2e%2fworkspace.db", "nicht-vorhanden.png"]) {
    const a = await roh(CREW, `/workspace/api/buehne/spendenbild/${boes}`, {});
    ok(a.code !== 200 && !a.text.includes("SQLite format"),
      `„${boes}" liefert keine Datei (${a.code})`);
  }
  /* GEGENPROBE: Die richtige Adresse liefert sehr wohl etwas --
     sonst waere die Pruefung oben eine, die immer bestaetigt. */
  {
    const a = await roh(CREW, hoch.j.bild, {});
    ok(a.code === 200 && a.text.length > 0,
      "Gegenprobe: die richtige Adresse liefert das Bild");
  }

  /* DAS BILD UEBERLEBT DAS NAECHSTE SPEICHERN. Wer nur den Namen
     aendert, soll sein Bild nicht verlieren. */
  const nochmal = await roh(CREW, "/workspace/api/spenden/stufen", {
    method: "PUT", keks: k.admin,
    rumpf: { stufen: gut.j.stufen.map((z) => ({ ...z, name: z.name + "!" })) },
  });
  const jetztBild = (nochmal.j?.stufen || []).find((z) => z.ab_mille === 2000)?.bild;
  ok(jetztBild === hoch.j.bild,
    `nach dem Umbenennen haengt das Bild noch dran (${jetztBild ? "ja" : "nein"})`);

  /* DIE KENNUNG MUSS DAS SPEICHERN UEBERLEBT HABEN. Vorher wurde
     beim Speichern geloescht und neu eingefuegt -- jede Stufe bekam
     dabei eine neue Kennung, und ein Bild-Hochladen gegen die eben
     noch gueltige antwortete mit 404. Im Alltag trifft das jeden,
     der einen zweiten Bildschirm offen hat. */
  const nachId = (nochmal.j?.stufen || []).find((z) => z.ab_mille === 2000)?.id;
  ok(nachId === id, `die Kennung bleibt ueber das Speichern hinweg (${id} -> ${nachId})`);

  const weg = await roh(CREW, `/workspace/api/spenden/stufe/${id}/bild`,
    { method: "DELETE", keks: k.admin });
  ok(weg.code === 200, `das Bild laesst sich wegnehmen (${weg.code})`);
  const fort = await roh(CREW, hoch.j.bild, {});
  ok(fort.code === 404, `und die Datei ist danach wirklich fort (${fort.code})`);

  /* ---- Was die Oberflaeche braucht, kommt vom Server ---- */
  const lage2 = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
  const g2 = lage2.j?.gestaltung;
  ok(!!g2 && Array.isArray(g2.vorlagen) && g2.stufen_max === STUFEN_MAX
     && g2.groesse_min === GROESSE_MIN && g2.groesse_max === GROESSE_MAX,
    "die Grenzen stehen im Stand und nicht nur in der Oberflaeche");
}


/* =======================================================================
   9. DOGEN STATT GELD, DER EIGENE TEXT UND DIE PUNKTE

   Filipe, 28.09.2026:
     „mann soll nie die summe sehen sondern die dogen auch mit dem
      symbol ... es soll auch nie geld da stehen sondern Dogen."
     „der text der dazu erscheint sollen die leute selber schreiben
      koennen ... es sollen personalisierte texte sein von den leuten
      selbst."
     „ich will dass die den leuten auch als punkte hinzugefuegt
      werden."
   ======================================================================= */
melde("");
melde("=== 9. Dogen, eigener Text und Punkte ===");
{
  const { CENT_JE_DOGE, MILLE, centInMille, milleInCent, GRUSS_MAX, KNOEPFE_MILLE }
    = await import("./spenden-tabellen.js");

  /* ---- DIE RECHNUNG ----
     Bewusst OHNE die Zahl 1000 in der Erwartung: Bei diesem Kurs ist
     ein Tausendstel Doge zufaellig genau ein Cent, und eine Pruefung,
     die auf diesem Zufall steht, wird gruen bleiben, wenn der Kurs
     sich aendert -- und dann nichts mehr pruefen. */
  ok(centInMille(CENT_JE_DOGE) === MILLE,
    `ein ganzer Doge sind ${CENT_JE_DOGE} Cent`);
  ok(milleInCent(MILLE) === CENT_JE_DOGE, "und zurueck genauso");
  ok(milleInCent(centInMille(CENT_JE_DOGE * 7)) === CENT_JE_DOGE * 7,
    "hin und zurueck aendert nichts");
  ok(centInMille(0) === 0 && centInMille(-5) <= 0,
    "Gegenprobe: null bleibt null");

  /* ---- KEIN GELD IM BROWSER ----
     Die wichtigste Pruefung dieses Abschnitts. Filipe hat „wirklich
     nirgends" gewaehlt, und die einzige Fassung davon, die haelt,
     ist: Was nicht gesendet wird, kann auch nicht angezeigt werden.
     Geprueft werden deshalb die FELDNAMEN der ganzen Antwort und
     nicht die Oberflaeche -- eine Oberflaeche kann man aendern,
     ohne daran zu denken. */
  const namen = (wert, raus = new Set()) => {
    if (Array.isArray(wert)) { for (const w of wert) namen(w, raus); return raus; }
    if (wert && typeof wert === "object") {
      for (const [n, w] of Object.entries(wert)) { raus.add(n); namen(w, raus); }
    }
    return raus;
  };
  /* ==== ZWEI AUSNAHMEN, UND NUR DIESE ZWEI =====================

     Am 28.09. stand hier „kein Geldfeld, fuer niemanden". Das war
     fuer alles richtig, was ANZEIGE ist -- und falsch fuer die eine
     Stelle, an der jemand KAUFT. Filipe: „die leute sollen nur
     sehen was dogen kosten. sonst wissen die ja nicht wie viel es
     kosten wird."

     Erlaubt sind jetzt GENAU zwei Dinge, und die Pruefung nennt sie
     beim Namen statt die Regel aufzuweichen:
       `knoepfe[].cent`        fuer alle -- der Preis am Kaufknopf
       `kurs_cent_je_doge`     nur fuer die Leitung
     Alles andere bleibt verboten. Eine Ausnahmeliste, die man
     aufzaehlen kann, ist eine Regel; „irgendwo darf Geld stehen"
     waere keine. */
  const ERLAUBT = new Set(["cent", "kurs_cent_je_doge"]);
  for (const [wer, keks, kursErlaubt] of [
    ["die Leitung", k.admin, true],
    ["ein Zuschauer", k.gast, false],
  ]) {
    const a = await roh(CREW, "/workspace/api/spenden", { keks });
    const felder = namen(a.j);
    const geld = [...felder].filter((n) => /cent|waehrung|euro|eur$/i.test(n))
      .filter((n) => !ERLAUBT.has(n));
    ok(geld.length === 0,
      geld.length ? `UNERLAUBTES GELDFELD (${wer}): ${geld.join(", ")}`
        : `kein unerlaubtes Geldfeld im Stand (${wer}, ${felder.size} Felder)`);
    ok(felder.has("dogen_max_mille") && felder.has("gruss_max"),
      "und die Grenzen stehen als Dogen und Zeichen darin");

    /* ---- Der Preis steht am Kaufknopf -- fuer alle ---- */
    const knopf = a.j?.knoepfe?.[0];
    ok(typeof knopf?.cent === "number" && knopf.cent > 0,
      `der Preis steht am Knopf (${wer}: ${knopf?.cent} Cent)`);

    /* ---- Und der Kurs nur bei der Leitung ----
       Er ist der Generalschluessel: Wer ihn hat, kann JEDEN
       Dogenwert in Geld umrechnen. Genau deshalb steckt die
       Erlaubnis in den Daten und nicht in einem `if` der
       Oberflaeche -- eine fehlende Zahl kann man nicht vergessen. */
    const kurs = a.j?.kurs_cent_je_doge;
    ok(kursErlaubt ? typeof kurs === "number" && kurs > 0 : kurs === null,
      `der Kurs ${kursErlaubt ? "kommt mit" : "bleibt weg"} (${wer}: ${kurs})`);

    /* Ausser an den Knoepfen darf nirgends ein Eurozeichen stehen --
       auch nicht in einem Text, den jemand eingetippt hat. */
    const ohneKnoepfe = { ...a.j, knoepfe: undefined };
    ok(!JSON.stringify(ohneKnoepfe).includes("€"), `kein Eurozeichen (${wer})`);
  }
  ok([...namen({ a: [{ betrag_cent: 1 }] })].includes("betrag_cent"),
    "Gegenprobe: ein Geldfeld wuerde gefunden");

  /* ==== DIE KARTE TRAEGT WEITERHIN KEINEN CENT ==================
     Sie geht auch an die Buehnentafel, und die steht im Stream. Ein
     Betrag, der dort ankommt, waere Geld im Bild -- genau das, was
     nirgends stehen soll. Der Preis gehoert an den Kaufknopf und
     nirgendwo sonst. */
  {
    const probe = await roh(CREW, "/workspace/api/spenden/probe", {
      method: "POST", keks: k.admin, rumpf: { dogen_mille: 500 },
    });
    const felder = namen(probe.j?.karte);
    const geld = [...felder].filter((n) => /cent|waehrung|euro|eur$/i.test(n));
    ok(geld.length === 0,
      geld.length ? `GELD AUF DER KARTE: ${geld.join(", ")}`
        : `die Karte traegt keinen Betrag (${felder.size} Felder)`);
  }

  /* ---- DIE KNOEPFE FUEHREN ZU EINEM EURO-BETRAG, ZEIGEN ABER DOGEN ----
     Der Euro entsteht erst in der PayPal-Adresse, weil PayPal ihn
     braucht. Das ist der einzige Ort, an dem er ueberhaupt noch
     auftaucht. */
  {
    const a = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
    const knopf = a.j?.knoepfe?.[0];
    ok(knopf?.mille === KNOEPFE_MILLE[0],
      `der erste Knopf steht auf ${knopf?.mille} Tausendsteln`);
    ok(knopf?.ziel?.endsWith("EUR"),
      `und fuehrt zu einer Zahlung (${knopf?.ziel})`);
    /* ==== UND DER PREIS STEHT DABEI ============================
       Hier stand bis zum 28.09. das Gegenteil: „der Euro-Betrag
       selbst kommt nicht mit". Das war die Regel „nie Geld", bis
       eine Stelle ihr widersprach -- die einzige, an der jemand
       BEZAHLT. Wer auf „0,2 Dogen" drueckt, muss vorher wissen,
       dass ihn das zwei Euro kostet; den Preis erst auf der
       Zahlseite zu erfahren ist keiner.
       Die Zahl muss zur Adresse PASSEN -- sonst steht am Knopf ein
       Preis und bei PayPal ein anderer, und das merkt niemand
       vorher. */
    ok(knopf?.cent === milleInCent(knopf?.mille),
      `und der Preis dazu (${knopf?.cent} Cent) passt zur Zahlung`);
  }

  /* ---- DER TEXT KOMMT VON DEM, DER GIBT ---- */
  const langer = "A".repeat(GRUSS_MAX + 60);
  /* Die Bremse von einer Meldung je Minute gilt je Person -- deshalb
     meldet hier der ZWEITE Gast. */
  const gemeldet = await roh(CREW, "/workspace/api/spenden/melden", {
    method: "POST", keks: k.gast2,
    rumpf: { dogen_mille: 700, name: "Lenny vom Rudel", gruss: langer },
  });
  ok(gemeldet.code === 201, `ein Zuschauer meldet mit eigenem Text (${gemeldet.code})`);
  const wartend = (await roh(CREW, "/workspace/api/spenden", { keks: k.admin }))
    .j?.offen?.find((z) => z.name === "Lenny vom Rudel");
  ok(!!wartend, "die Meldung steht im Pult");
  ok(wartend?.gruss?.length === GRUSS_MAX,
    `ein zu langer Text wird auf ${GRUSS_MAX} gekuerzt (${wartend?.gruss?.length})`);
  ok(wartend?.dogen_mille === 700, `und traegt Dogen (${wartend?.dogen_mille})`);

  /* ---- DIE LEITUNG DARF IHN BERICHTIGEN ----
     Das ist die Schranke vor dem Stream. Ohne sie bliebe nur „ganz
     ablehnen" -- und dann faellt wegen eines Wortes eine echte
     Spende unter den Tisch. */
  const berichtigt = await roh(CREW, `/workspace/api/spenden/${wartend.id}/bestaetigen`, {
    method: "POST", keks: k.admin,
    rumpf: { name: "Lenny", gruss: "Bleibt so" },
  });
  ok(berichtigt.code === 200 && berichtigt.j?.name === "Lenny"
     && berichtigt.j?.gruss === "Bleibt so",
    `Name und Text lassen sich beim Bestaetigen aendern (${berichtigt.j?.gruss})`);
  ok(berichtigt.j?.dogen_mille === 700,
    "und der Betrag bleibt dabei stehen, wenn keiner mitkommt");

  /* ---- DIE PUNKTE ----
     Gemessen werden UNTERSCHIEDE und keine absoluten Staende: Vor
     diesem Abschnitt sind schon Spenden durchgelaufen, und eine
     Pruefung, die eine feste Zahl erwartet, bricht beim naechsten
     Test, der davor eingefuegt wird. */
  const standVon = async (keks) =>
    (await roh(CREW, "/workspace/api/spenden", { keks })).j?.ich?.dogen_mille ?? -1;

  const lenny = await standVon(k.gast2);
  ok(lenny === 700, `die bestaetigte Meldung wurde gutgeschrieben (${lenny})`);

  /* NOCHMAL ZEIGEN DARF NICHT NOCHMAL GUTSCHREIBEN. Die Sperre ist
     ein eindeutiger Index in der Datenbank und keine Bedingung im
     Programm -- deshalb wird sie hier auch wirklich angegriffen. */
  await roh(CREW, `/workspace/api/spenden/${wartend.id}/nochmal`,
    { method: "POST", keks: k.admin });
  await roh(CREW, `/workspace/api/spenden/${wartend.id}/bestaetigen`,
    { method: "POST", keks: k.admin });
  ok(await standVon(k.gast2) === lenny,
    "nochmal zeigen und nochmal bestaetigen aendern nichts daran");

  /* ---- VON HAND, MIT UND OHNE PERSON ---- */
  const vorher = await standVon(k.gast2);
  const mitPerson = await roh(CREW, "/workspace/api/spenden", {
    method: "POST", keks: k.admin,
    rumpf: { dogen_mille: 300, name: "Lenny", person_id: IDS.gast2 },
  });
  ok(mitPerson.code === 201, `von Hand mit Person (${mitPerson.code})`);
  ok(await standVon(k.gast2) === vorher + 300,
    `die Dogen landen bei der Person (${vorher} -> ${await standVon(k.gast2)})`);

  const ohnePerson = await roh(CREW, "/workspace/api/spenden", {
    method: "POST", keks: k.admin,
    rumpf: { dogen_mille: 400, name: "Irgendwer vom Handy" },
  });
  ok(ohnePerson.code === 201, "von Hand ohne Person geht auch");
  ok(await standVon(k.gast2) === vorher + 300,
    "und schreibt niemandem etwas gut -- geratene Punkte waeren schlimmer als keine");

  /* ---- UND NICHT UEBER DIE HAUSGRENZE ----
     `creator` gehoert der Agentur. Eine Gutschrift dorthin waere
     genau die Vermischung, die seit dem 24.09. nicht mehr sein darf
     -- auch nicht durch einen Tippfehler in einer Zahl. */
  const fremd = await roh(CREW, "/workspace/api/spenden", {
    method: "POST", keks: k.admin,
    rumpf: { dogen_mille: 100, name: "X", person_id: IDS.creator },
  });
  ok(fremd.code === 400 && fremd.j?.fehler === "person_unbekannt",
    `eine Person aus dem anderen Haus wird abgelehnt (${fremd.code})`);

  /* ---- WER DIE STAENDE SIEHT ----
     Filipe hat „jeder nur seine eigenen, du alle" gewaehlt. Eine
     oeffentliche Rangliste macht aus Unterstuetzung einen
     Wettbewerb, und wer wenig geben kann, staende jeden Abend
     darin. */
  const alsLeitung = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
  const alsGast = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
  ok(Array.isArray(alsLeitung.j?.staende) && alsLeitung.j.staende.length > 0,
    `die Leitung sieht ${alsLeitung.j?.staende?.length} Staende`);
  ok(alsGast.j?.staende === null, "ein Zuschauer sieht keine Rangliste");
  ok(alsGast.j?.personen === null, "und auch keine Namensliste");
  ok(typeof alsGast.j?.ich?.dogen_mille === "number",
    `aber seinen eigenen Stand (${alsGast.j?.ich?.dogen_mille})`);
  ok(alsLeitung.j.staende.every((z) => typeof z.mille === "number" && z.mille !== 0),
    "und in der Liste steht nur, wer wirklich etwas hat");

  /* ---- DAS ZEICHEN ---- */
  /* SEIT DEM 28.09. IST `zeichen` EINE AUSWAHL UND KEINE ADRESSE:
     drei Muenzen und zwei Grenzen. Das Hochgeladene steht darin als
     `eigen`. Die Saetze selbst prueft Abschnitt 10; hier geht es nur
     um den Weg des eigenen Bildes. */
  const ohneZeichen = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
  ok(ohneZeichen.j?.zeichen?.eigen === "", "ohne Hochladen gibt es kein eigenes Zeichen");

  const png = Buffer.from(
    "89504e470d0a1a0a0000000d494844520000000100000001080600000"
    + "01f15c4890000000a49444154789c6360000002000100ffff0300000600"
    + "0557bfabd40000000049454e44ae426082", "hex");
  const hochZ = await roh(CREW, "/workspace/api/spenden/zeichen", {
    method: "POST", keks: k.admin, roher: png,
  });
  ok(hochZ.code === 200
     && /\/spendenbild\/[a-f0-9]{32}\.png$/.test(hochZ.j?.zeichen?.eigen || ""),
    `das Zeichen laesst sich hochladen (${hochZ.code})`);
  const eigenAdresse = hochZ.j?.zeichen?.eigen || "";
  const abrufbar = await roh(CREW, eigenAdresse, {});
  ok(abrufbar.code === 200,
    `und ist OHNE Anmeldung abrufbar (${abrufbar.code}) -- sonst fehlte es im Stream`);

  const mitZeichen = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
  ok(mitZeichen.j?.zeichen?.eigen === eigenAdresse,
    "es steht im Stand, und zwar fuer alle");
  ok(mitZeichen.j?.zeichen?.niedrig === eigenAdresse,
    "und gilt fuer alle drei Stufen gleich");
  const probe = await roh(CREW, "/workspace/api/spenden/probe", {
    method: "POST", keks: k.admin, rumpf: { dogen_mille: 500 },
  });
  ok(probe.j?.karte?.zeichen?.eigen === eigenAdresse,
    "und reist mit jeder Karte mit");

  const keinBild = await roh(CREW, "/workspace/api/spenden/zeichen", {
    method: "POST", keks: k.admin, roher: Buffer.from("ich bin kein bild, wirklich nicht"),
  });
  ok(keinBild.code === 400 && keinBild.j?.fehler === "kein_bild",
    `etwas, das kein Bild ist, wird abgelehnt (${keinBild.code})`);
  const fremdeHand = await roh(CREW, "/workspace/api/spenden/zeichen", {
    method: "POST", keks: k.modi, roher: png,
  });
  ok(fremdeHand.code === 403, `ein Modi setzt das Zeichen nicht (${fremdeHand.code})`);

  const wegZ = await roh(CREW, "/workspace/api/spenden/zeichen",
    { method: "DELETE", keks: k.admin });
  ok(wegZ.code === 200 && wegZ.j?.zeichen?.eigen === "",
    `es laesst sich wieder wegnehmen (${wegZ.code})`);
  const fortZ = await roh(CREW, eigenAdresse, {});
  ok(fortZ.code === 404, `und die Datei ist danach fort (${fortZ.code})`);
}


/* =======================================================================
   10. DIE DREI MUENZSAETZE

   Filipe, 28.09.2026: „ich werde die drei varianten schicken fuer
   niedrige spenden. mittlere und hohe spenden. alle drei varianten
   will ich drauf so dass ich sie aussuchen kann wie ich will. aber
   pass sie sofort diesen 3 kategorien an."
   ======================================================================= */
melde("");
melde("=== 10. Die drei Muenzsaetze ===");
{
  const { DOGEN_SAETZE, DOGEN_STUFEN, muenzeAdresse }
    = await import("./spenden-tabellen.js");

  ok(DOGEN_SAETZE.length === 3,
    `es gibt ${DOGEN_SAETZE.length} Saetze: ${DOGEN_SAETZE.map((x) => x.name).join(", ")}`);
  ok(DOGEN_STUFEN.length === 3 && DOGEN_STUFEN[0] === "niedrig"
     && DOGEN_STUFEN[2] === "hoch",
    `und drei Stufen: ${DOGEN_STUFEN.join(", ")}`);

  /* ---- JEDE MUENZE MUSS ES AUCH GEBEN ----
     Die wichtigste Pruefung hier. Ein fehlendes Bild waere ein
     kaputtes Zeichen neben JEDER Zahl -- im Saal und im Stream, und
     gemerkt haette man es erst im Livestream. */
  {
    const fehlend = [];
    const zuGross = [];
    for (const satz of DOGEN_SAETZE) {
      for (const stufe of DOGEN_STUFEN) {
        const pfad = join(HIER, "..", muenzeAdresse(satz.schluessel, stufe)
          .replace(/^\//, "").split("/").join("/"));
        try {
          const gross = statSync(pfad).size;
          if (gross > 100 * 1024) zuGross.push(`${satz.schluessel}-${stufe} ${Math.round(gross / 1024)} KB`);
        } catch { fehlend.push(`${satz.schluessel}-${stufe}`); }
      }
    }
    ok(fehlend.length === 0,
      fehlend.length ? `ES FEHLEN: ${fehlend.join(", ")}`
        : `alle ${DOGEN_SAETZE.length * DOGEN_STUFEN.length} Muenzen liegen im Baum`);
    /* UND KEINE DARF SCHWER SEIN. Filipes Vorlagen waren je drei
       Megabyte; gezeigt wird die Muenze zwischen 24 und 110 Pixeln.
       Ohne diese Grenze rutscht irgendwann wieder ein Original
       herein, und dann laedt die Karte laenger, als sie steht. */
    ok(zuGross.length === 0,
      zuGross.length ? `ZU SCHWER: ${zuGross.join(", ")}`
        : "und keine ist schwerer als 100 KB");
  }

  /* ---- UND SIE MUESSEN OHNE ANMELDUNG ZU HABEN SEIN ----
     Die Spendentafel in OBS hat keine Sitzung. Eine Muenze hinter
     der Schranke fehlte ausgerechnet im Stream. */
  {
    const a = await roh(CREW, muenzeAdresse("klassik", "hoch"), {});
    ok(a.code === 200, `eine Muenze kommt ohne Anmeldung (${a.code})`);
    const b = await roh(CREW, "/workspace/assets/dogen/gibtesnicht-hoch.webp", {});
    ok(b.code === 404, `Gegenprobe: eine erfundene Muenze gibt es nicht (${b.code})`);
  }

  /* ---- WAS DER STAND SAGT ---- */
  const lage = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
  const z = lage.j?.zeichen;
  ok(!!z && typeof z.satz === "string" && z.niedrig && z.mittel && z.hoch,
    `der Stand traegt einen Satz („${z?.satz}“) mit drei Muenzen`);
  /* KLEINER ODER GLEICH, nicht echt kleiner. Bei genau ZWEI Stufen
     fallen die beiden Grenzen absichtlich zusammen: Dann gibt es
     niedrig und hoch, und nichts dazwischen. Eine Pruefung auf „echt
     kleiner" haette hier einen Fehler gemeldet, wo das Verhalten
     richtig ist -- und genau das hat sie beim ersten Lauf getan. */
  ok(Array.isArray(z?.grenzen) && z.grenzen.length === 2 && z.grenzen[0] <= z.grenzen[1],
    `und zwei Grenzen (${z?.grenzen?.join(" / ")})`);
  /* DIE GRENZEN KOMMEN AUS DER STUFENLEITER UND NICHT AUS EINER
     ZWEITEN LISTE. Bei drei Stufen ist das genau eine Muenze je
     Stufe. */
  const leiter = (lage.j?.stufen || []).map((x) => x.ab_mille);
  ok(leiter.length < 3
     || (z.grenzen[0] === leiter[Math.floor(leiter.length / 3)]
       && z.grenzen[1] === leiter[Math.floor((2 * leiter.length) / 3)]),
    `sie sind aus der Leiter abgeleitet (Leiter ${leiter.join(", ")})`);

  ok(Array.isArray(lage.j?.saetze) && lage.j.saetze.length >= 3,
    `die Leitung bekommt ${lage.j?.saetze?.length} Saetze zum Aussuchen`);
  const gast = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
  ok(gast.j?.saetze === null, "ein Zuschauer bekommt die Auswahl nicht");
  ok(!!gast.j?.zeichen?.niedrig, "aber die Muenzen selbst schon");

  /* ---- DIE KARTE TRAEGT DEN SATZ ----
     Eine Form ueberall: Die Karte bekommt dieselbe Auswahl wie der
     Stand und sucht sich daraus die Muenze zu ihrer Zahl. Schickte
     der Server hier EINE Adresse, gaebe es zwei Formen desselben
     Dinges. */
  const probe = await roh(CREW, "/workspace/api/spenden/probe", {
    method: "POST", keks: k.admin, rumpf: { dogen_mille: 2500 },
  });
  ok(!!probe.j?.karte?.zeichen?.hoch && Array.isArray(probe.j.karte.zeichen.grenzen),
    "und jede Karte bekommt ihn mit");

  /* ---- AUSSUCHEN ---- */
  for (const satz of DOGEN_SAETZE) {
    const a = await roh(CREW, "/workspace/api/spenden/zeichen/satz", {
      method: "PUT", keks: k.admin, rumpf: { satz: satz.schluessel },
    });
    ok(a.code === 200 && a.j?.zeichen?.satz === satz.schluessel,
      `„${satz.name}“ laesst sich waehlen (${a.code})`);
    ok((a.j?.zeichen?.hoch || "").includes(`${satz.schluessel}-hoch`),
      `und die hohe Muenze kommt aus diesem Satz`);
  }
  const quatsch = await roh(CREW, "/workspace/api/spenden/zeichen/satz", {
    method: "PUT", keks: k.admin, rumpf: { satz: "platin" },
  });
  ok(quatsch.code === 400 && quatsch.j?.fehler === "satz_unbekannt",
    `ein erfundener Satz wird abgelehnt (${quatsch.code})`);
  /* „eigen" OHNE HOCHGELADENES BILD GIBT ES NICHT -- sonst stuende
     neben jeder Zahl ein Bild, das 404 antwortet. */
  const ohneEigenes = await roh(CREW, "/workspace/api/spenden/zeichen/satz", {
    method: "PUT", keks: k.admin, rumpf: { satz: "eigen" },
  });
  ok(ohneEigenes.code === 400,
    `„eigen“ ohne eigenes Bild wird abgelehnt (${ohneEigenes.code})`);
  const fremd = await roh(CREW, "/workspace/api/spenden/zeichen/satz", {
    method: "PUT", keks: k.modi, rumpf: { satz: "neon" },
  });
  ok(fremd.code === 403, `ein Modi waehlt den Satz nicht (${fremd.code})`);

  /* ---- EIN EIGENES ZEICHEN GILT SOFORT UND FAELLT SAUBER ZURUECK ---- */
  const png = Buffer.from(
    "89504e470d0a1a0a0000000d494844520000000100000001080600000"
    + "01f15c4890000000a49444154789c6360000002000100ffff0300000600"
    + "0557bfabd40000000049454e44ae426082", "hex");
  const hoch = await roh(CREW, "/workspace/api/spenden/zeichen", {
    method: "POST", keks: k.admin, roher: png,
  });
  ok(hoch.code === 200 && hoch.j?.zeichen?.satz === "eigen",
    `ein hochgeladenes Zeichen gilt sofort (${hoch.j?.zeichen?.satz})`);
  ok(hoch.j?.zeichen?.niedrig === hoch.j?.zeichen?.hoch,
    "es gilt fuer alle drei Stufen gleich");
  ok((hoch.j?.saetze || []).some((x) => x.schluessel === "eigen"),
    "und steht ab jetzt in der Auswahl");

  const weg = await roh(CREW, "/workspace/api/spenden/zeichen",
    { method: "DELETE", keks: k.admin });
  ok(weg.code === 200 && weg.j?.zeichen?.satz === DOGEN_SAETZE[0].schluessel,
    `nach dem Loeschen gilt wieder ein Satz, den es gibt (${weg.j?.zeichen?.satz})`);
  ok(!(weg.j?.saetze || []).some((x) => x.schluessel === "eigen"),
    "und „eigen“ steht nicht mehr zur Wahl");

  /* ==== DIE MUENZEN HAENGEN VON ANFANG AN AN DEN DREI STUFEN ====

     Filipe: „aber pass sie sofort diesen 3 kategorien an."

     GEPRUEFT WIRD AUF EINER FRISCHEN DATENBANK und nicht auf dieser:
     Die Leiter hier ist in Abschnitt 8 umgebaut worden, und danach
     steht sie so da, wie die Pruefung sie gesetzt hat -- nicht so,
     wie ein frisches Haus sie bekommt. Eine Pruefung, die den
     eigenen Kollateralschaden misst, misst sich selbst.

     Und die zweite Haelfte ist die wichtigere: Eine Stufe, die
     jemand SELBST gewaehlt hat, wird nicht ueberschrieben. Eine
     Verteilung, die sich gegen den Benutzer durchsetzt, wird
     abgeschafft. */
  {
    const { mkdtempSync: neuerOrdner } = await import("node:fs");
    const { tmpdir: tmp2 } = await import("node:os");
    const { DatabaseSync: DBM } = await import("node:sqlite");
    const { spendenTabellen } = await import("./spenden-tabellen.js");
    const ordner2 = neuerOrdner(join(tmp2(), "muenzen-"));
    const d2 = new DBM(join(ordner2, "probe.db"));
    d2.exec(`CREATE TABLE einstellungen (schluessel TEXT PRIMARY KEY,
        wert TEXT NOT NULL, geaendert TEXT, von INTEGER);
      CREATE TABLE personen (id INTEGER PRIMARY KEY);`);
    spendenTabellen(d2);
    const frisch = d2.prepare("SELECT ab_cent, vorlage FROM spenden_stufen ORDER BY ab_cent")
      .all();
    ok(frisch.length === 3 && frisch.every((x) => x.vorlage === "dogen"),
      `ein frisches Haus zeigt die Muenze auf allen ${frisch.length} Stufen `
      + `(${frisch.map((x) => x.vorlage).join(", ")})`);

    /* Gegenprobe: eine selbst gewaehlte Vorlage bleibt stehen -- auch
       wenn die Verteilung noch einmal laufen wuerde. */
    d2.exec("UPDATE spenden_stufen SET vorlage = 'stern' WHERE ab_cent = 500");
    d2.exec("DELETE FROM einstellungen WHERE schluessel = 'dogen_muenzen_verteilt'");
    spendenTabellen(d2);
    const nachDemZweiten = d2.prepare("SELECT vorlage FROM spenden_stufen WHERE ab_cent = 500")
      .get();
    ok(nachDemZweiten?.vorlage === "stern",
      `Gegenprobe: eine selbst gewaehlte Vorlage bleibt (${nachDemZweiten?.vorlage})`);
    d2.close();
    rmSync(ordner2, { recursive: true, force: true });
  }
}

melde("");
melde(`${geprueft} Pruefungen, ${fehler} Fehler`);
melde(fehler === 0 ? "ALLES IN ORDNUNG" : "NICHT IN ORDNUNG");
process.exit(fehler === 0 ? 0 : 1);