dogfather-universe/server/pruef-team-stufen.mjs

/* =====================================================================
   DIE MITGLIEDER-KACHEL UND DIE DREI STUFEN (Blueprint Kapitel 4/4.1)

   Vier Fragen, und die dritte ist die, an der es schiefgeht:

     1. Stehen die Angaben aus Kapitel 4 in der Antwort -- Status,
        "dabei seit", Stufe?
     2. Erscheinen auch PAUSIERTE? Vorher stand in der Abfrage
        `AND aktiv = 1`: Wer jemanden pausierte, bei dem verschwand er
        samt seiner offenen Rueckmeldungen aus dem Eingang. Die
        warteten weiter auf eine Antwort, nur sah sie niemand mehr.
     3. WER DARF DIE STUFE SETZEN? Der Blueprint trennt das
        ausdruecklich: gleicher Ueberblick fuer die rechte Hand,
        "Verwaltungsrechte optional durch Owner freischaltbar" -- also
        standardmaessig aus. Eine Rechtegrenze, die man nicht misst,
        ist eine Absichtserklaerung.
     4. Ueberlebt die Stufe den naechsten Aufruf? Ein Wert, der nur im
        Browser steht, sieht bis zum Neuladen richtig aus.

   MIT GEGENPROBE: Am Ende wird dieselbe Person auf eine andere Stufe
   gesetzt und wieder zurueck. Ohne diesen Teil waere nicht bewiesen,
   dass die Pruefung ueberhaupt einen Unterschied bemerkt.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-stufen-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
   Ohne diese Zeile startet der eigene Server bei belegtem Port
   STILL nicht -- und alles Folgende misst gegen einen fremden
   Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
   als kaputt. */
const PORT = await eigenerPort(import.meta, "pruef-team-stufen");
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 }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { eigenerPort } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-team-stufen");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;

let fehler = 0, geprueft = 0, offen = 0;
const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };
const unklar = (t) => { offen++; console.log("  --   " + t); };

/* ---------- Personen ------------------------------------------------- */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();

const schluessel = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", schluessel, jetzt);

function anlegen(name, rolle, code, aktiv = 1, erstellt = jetzt) {
  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 (?,?,?,?,?,?,?,?)")
    .run(name, rolle, hash, salt, 32768,
      createHmac("sha256", schluessel).update(code).digest("hex"), aktiv, erstellt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}

/* Ein Datum weit genug zurueck, damit "seit ... Tagen dabei" etwas
   anderes ergibt als "seit heute" -- und RELATIV gerechnet, nicht fest
   hingeschrieben: Ein festes Datum waere in einem halben Jahr eine
   andere Aussage (Lehre vom 06.09.2026). */
const vor40Tagen = new Date(Date.now() - 40 * 86400000).toISOString();

const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idHand = anlegen("Rieke", "hand", "CODE-HAND-0001");
const idMarina = anlegen("Marina", "modi", "CODE-MODI-0001", 1, vor40Tagen);
const idKim = anlegen("Kim", "modi", "CODE-MODI-0002", 0);   // pausiert
const idCreator = anlegen("Tili", "creator", "CODE-TILI-0001");

async function anmelden(rolle, code) {
  const a = await fetch(`${BASIS}/workspace/api/anmelden`, {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle, code }),
  });
  return (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
}
const holeLage = (keks) => fetch(`${BASIS}/workspace/api/teamlage`, { headers: { Cookie: keks } });
const setzeStufe = (keks, person_id, stufe) =>
  fetch(`${BASIS}/workspace/api/teamlage/stufe`, {
    method: "PUT",
    headers: { Cookie: keks, "Content-Type": "application/json", Origin: BASIS },
    body: JSON.stringify({ person_id, stufe }),
  });

const keksDogi = await anmelden("admin", "CODE-DOGI-0001");
const keksHand = await anmelden("creator", "CODE-HAND-0001");
const keksModi = await anmelden("creator", "CODE-MODI-0001");
if (!keksDogi || !keksHand || !keksModi) {
  console.error("FEHLER: Anmeldung misslang -- ohne sie misst diese Datei nichts.");
  process.exit(1);
}

/* =====================================================================
   1. WAS IN DER ANTWORT STEHT
   ===================================================================== */
console.log("");
console.log("--- Die Mitglieder-Kachel (Kapitel 4) ---");

const a1 = await holeLage(keksDogi);
ok(a1.status === 200, `DogFather bekommt die Lage (${a1.status})`);
const lage = await a1.json();
const leute = lage.leute || [];

/* SEIT DEM 11.09.2026 GEHOERT DIE RECHTE HAND DAZU.

   Filipe: "die rechte hand ist da um mir zu helfen aber auch wie die
   modis um mir zu sagen was passt und nicht." Damit steht sie in
   derselben Liste -- sonst kaemen ihre Rueckmeldungen nirgends an.

   Die Zahl steht hier trotzdem, und zwar mit der Rechnung dahinter:
   zwei Modis (einer pausiert) plus die rechte Hand, minus die Person,
   die gerade liest. Eine Pruefung, die nur `> 0` verlangt, haette den
   Umbau nicht bemerkt. */
ok(leute.length === 3,
  `beide Modis und die rechte Hand stehen da, auch der pausierte (${leute.length})`);
ok(!leute.some((p) => p.id === idDogi),
  "und DogFather selbst nicht -- er liest die Seite, er steht nicht darauf");
ok(leute.some((p) => p.id === idHand),
  "die rechte Hand steht wirklich darin (sonst waere die 3 oben Zufall)");

const marina = leute.find((m) => m.id === idMarina);
const kim = leute.find((m) => m.id === idKim);
ok(!!marina && !!kim, "beide sind namentlich wiederzufinden");

ok(marina?.aktiv === true && kim?.aktiv === false,
  `Status stimmt (Marina aktiv: ${marina?.aktiv}, Kim aktiv: ${kim?.aktiv})`);
/* AKTIVE ZUERST -- wer pausiert ist, steht unten und nicht mittendrin.

   GEPRUEFT WIRD DIE EIGENSCHAFT, NICHT DIE POSITION (berichtigt
   20.09.2026). Hier stand `leute[0]?.id === idMarina` -- und das wurde
   rot, sobald die rechte Hand nach vorn sortiert wurde. Richtig wurde
   es dadurch nicht: Die Aussage "die Aktiven stehen oben" hat mit
   Marinas Platz nichts zu tun. Eine Pruefung, die eine Position
   festnagelt, verbietet jede Umsortierung -- auch die gewollte. */
const letzteAktive = leute.map((m) => m.aktiv).lastIndexOf(true);
const ersteInPause = leute.map((m) => m.aktiv).indexOf(false);
ok(ersteInPause === -1 || letzteAktive < ersteInPause,
  `die Aktiven stehen oben (letzte aktive Stelle ${letzteAktive}, erste Pause ${ersteInPause})`);

/* ==== UND DIE RECHTE HAND VOR DEN MODIS (20.09.2026) ================

   Filipe: "ich will dass hier wie ueberall die reihenfolge immer
   rechte hand und dan erst die modis."

   Vorher sortierte die Abfrage nur nach Namen -- die Rolle wurde nicht
   einmal mitgelesen. Damit stand die Reihenfolge im Alphabet, und das
   ist keine. */
const platzHand = leute.findIndex((m) => m.id === idHand);
const ersterModi = leute.findIndex((m) => m.id !== idHand && m.aktiv);
ok(platzHand >= 0 && (ersterModi === -1 || platzHand < ersterModi),
  `die rechte Hand steht vor den Modis (Platz ${platzHand} vor ${ersterModi})`);
ok(leute.every((m) => typeof m.rolle === "string" && m.rolle),
  "und jede Karte weiss, welche Rolle sie hat — sonst kann die Seite sie nicht unterscheiden");

ok(typeof marina?.seit === "string" && marina.seit.startsWith(vor40Tagen.slice(0, 10)),
  `"dabei seit" kommt mit (${(marina?.seit || "").slice(0, 10)})`);

/* NULL HEISST PROBE, nicht "unbekannt" -- an EINER Stelle im Server
   abgebildet. Beide Modis wurden ohne Stufe angelegt. */
ok(marina?.stufe === "probe" && kim?.stufe === "probe",
  `ohne Eintrag ist die Stufe "Probe" (${marina?.stufe} / ${kim?.stufe})`);

/* Die Liste der Stufen kommt VOM SERVER -- eine zweite im Browser
   waere die Stelle, an der beim naechsten Mal eine fehlt. */
const stufen = (lage.stufen || []).map((s) => s.wert);
ok(JSON.stringify(stufen) === JSON.stringify(["probe", "standard", "senior"]),
  `die drei Stufen kommen mit, in ihrer Reihenfolge (${stufen.join(", ")})`);
ok((lage.stufen || []).every((s) => s.name && s.name !== s.wert),
  "und jede hat einen lesbaren Namen");

/* =====================================================================
   2. WER DARF SIE SETZEN
   ===================================================================== */
console.log("");
console.log("--- Wer die Stufe setzen darf ---");

const gesetzt = await setzeStufe(keksDogi, idMarina, "senior");
ok(gesetzt.status === 200, `DogFather darf (${gesetzt.status})`);

/* DIE RECHTE HAND SIEHT ALLES UND SETZT NICHTS. Blueprint 3.1:
   "Verwaltungsrechte optional durch Owner freischaltbar" -- also aus.
   404 und nicht 403: Wer nicht darf, muss nicht erfahren, dass es den
   Weg gibt. */
const handSieht = await holeLage(keksHand);
ok(handSieht.status === 200, `die rechte Hand sieht die Lage (${handSieht.status})`);
const handSetzt = await setzeStufe(keksHand, idMarina, "probe");
ok(handSetzt.status === 404, `aber sie setzt keine Stufe (${handSetzt.status})`);

const modiSetzt = await setzeStufe(keksModi, idMarina, "probe");
ok(modiSetzt.status === 404, `ein Modi erst recht nicht (${modiSetzt.status})`);
const modiSieht = await holeLage(keksModi);
ok(modiSieht.status === 404, `und er sieht die Seite gar nicht (${modiSieht.status})`);

/* =====================================================================
   3. WAS ABGEWIESEN WIRD
   ===================================================================== */
console.log("");
console.log("--- Was nicht durchgeht ---");

const erfunden = await setzeStufe(keksDogi, idMarina, "chef");
ok(erfunden.status === 400, `eine erfundene Stufe wird abgewiesen (${erfunden.status})`);

/* An einem Creator hat die Stufe nichts verloren -- sie stuende in der
   Datenbank und wuerde nirgends angezeigt. */
const anCreator = await setzeStufe(keksDogi, idCreator, "senior");
ok(anCreator.status === 404, `an einem Creator geht sie nicht (${anCreator.status})`);
const nachCreator = d.prepare("SELECT stufe FROM personen WHERE id = ?").get(idCreator);
ok(!nachCreator?.stufe, "und es steht auch nichts in der Datenbank");

const anNiemand = await setzeStufe(keksDogi, 99999, "senior");
ok(anNiemand.status === 404, `an einer unbekannten Nummer auch nicht (${anNiemand.status})`);

/* =====================================================================
   4. UEBERLEBT SIE DEN NAECHSTEN AUFRUF?
   ===================================================================== */
console.log("");
console.log("--- Beim naechsten Laden ---");

const a2 = await holeLage(keksDogi);
const marina2 = ((await a2.json()).leute || []).find((m) => m.id === idMarina);
ok(marina2?.stufe === "senior", `die neue Stufe kommt zurueck (${marina2?.stufe})`);
const inDb = d.prepare("SELECT stufe FROM personen WHERE id = ?").get(idMarina);
ok(inDb?.stufe === "senior", `und steht in der Datenbank (${inDb?.stufe})`);

/* Eine Personalentscheidung gehoert ins Protokoll -- gerade wenn
   jemand zurueckgestuft wird, muss spaeter nachvollziehbar sein, wer
   das wann getan hat. */
const spur = d.prepare(
  "SELECT COUNT(*) AS n FROM protokoll WHERE aktion = 'stufe_gesetzt'").get()?.n || 0;
ok(spur >= 1, `die Entscheidung steht im Protokoll (${spur})`);

/* =====================================================================
   DIE GEGENPROBE

   Bis hierhin koennte alles auch dann gruen sein, wenn der Server
   jeden Wert einfach annimmt und die Anzeige ihn nie wieder aendert.
   Also zurueckstufen und noch einmal nachsehen.
   ===================================================================== */
console.log("");
console.log("--- Gegenprobe: wieder zurueck ---");

const zurueck = await setzeStufe(keksDogi, idMarina, "standard");
ok(zurueck.status === 200, `zurueckstufen geht (${zurueck.status})`);
const a3 = await holeLage(keksDogi);
const marina3 = ((await a3.json()).leute || []).find((m) => m.id === idMarina);
ok(marina3?.stufe === "standard",
  `und die Anzeige folgt (${marina3?.stufe}) -- sie bleibt also nicht auf "senior" stehen`);

/* Dieselbe Stufe noch einmal: kein Fehler, aber auch keine zweite
   Protokollzeile -- sonst waere das Protokoll nach einem Tag Klicken
   unlesbar. */
const vorher = d.prepare(
  "SELECT COUNT(*) AS n FROM protokoll WHERE aktion = 'stufe_gesetzt'").get()?.n || 0;
const nochmal = await setzeStufe(keksDogi, idMarina, "standard");
const nachher = d.prepare(
  "SELECT COUNT(*) AS n FROM protokoll WHERE aktion = 'stufe_gesetzt'").get()?.n || 0;
ok(nochmal.status === 200 && nachher === vorher,
  `dieselbe Stufe noch einmal aendert nichts (${vorher} -> ${nachher} Zeilen)`);

/* ---------- Ende ------------------------------------------------------ */
d.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Windows haelt manchmal */ }

console.log("");
console.log(`${fehler === 0 ? "BESTANDEN" : "FEHLGESCHLAGEN"}`
  + ` -- ${geprueft} geprueft, ${fehler} Fehler, ${offen} nicht nachsehbar`);
process.exit(fehler === 0 ? 0 : 1);