dogfather-universe/server/pruef-uebersicht.mjs

/* ===================================================================
   Pruefung: Dashboard (uebersicht.html + /api/uebersicht/creator)

   Startet einen echten Express-Server mit einer frischen Testdatenbank,
   legt DogFather, Manager, Scout und zwei Creator an und prueft dann,
   was jede Rolle sieht. Wichtig ist vor allem der NEGATIVE Fall: Der
   Scout darf den nicht betreuten Creator nirgends finden, und niemand
   ausser der Leitung darf den Review-Termin sehen.
   =================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { eigenerPort } from "./helfer-port.mjs";

const ordner = mkdtempSync(join(tmpdir(), "ws-uebersicht-"));
process.env.WORKSPACE_DB = join(ordner, "pruef.sqlite");
/* 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-uebersicht");
process.env.PORT = `${PORT}`;
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

const express = (await import("express")).default;
const echteCookie = express.response.cookie;
express.response.cookie = function (name, wert, opt) {
  return echteCookie.call(this, name, wert, { ...(opt || {}), secure: false });
};

await import("./index.js");
await new Promise((r) => setTimeout(r, 700));

const BASIS = `http://127.0.0.1:${PORT}`;

/* Notbremse. index.js faengt uncaughtException ab, damit die Website
   nicht an einem Einzelfehler stirbt -- im Test heisst das aber: ein
   Fehler bliebe stumm und der Lauf haenge fuer immer. */
const notbremse = setTimeout(() => {
  console.log("\nABBRUCH: Der Testlauf hing über 90 Sekunden.");
  process.exit(1);
}, 90_000);
notbremse.unref?.();

/* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des
   Benutzers; toISOString() liefert dagegen UTC und damit zwischen
   Mitternacht und 2 Uhr den VORTAG. In diesem Fenster schlug diese
   Pruefung fehl, ohne dass etwas kaputt war. */
const tagText = (d = new Date()) =>
  `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`
  + `-${String(d.getDate()).padStart(2, "0")}`;

let fehler = 0;
const ok = (bedingung, text) => {
  console.log((bedingung ? "  ok   " : "  FEHL ") + text);
  if (!bedingung) fehler++;
};

/* ---------- Testdaten direkt in die Datenbank ------------------------ */

/* Die Datenbank wird absichtlich erst beim ersten echten Zugriff
   geoeffnet -- ein Fehler dort soll nie die Website mitreissen. Fuer
   diesen Test heisst das: erst einen (scheiternden) Anmeldeversuch
   schicken, damit Schema und Umstellungen laufen. Ohne das faende die
   eigene Verbindung unten noch gar keine Tabellen. */
await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "gibt-es-nicht" }),
}).catch(() => {});

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");

const d = new DatabaseSync(process.env.WORKSPACE_DB);
const N = 32768;
function anlegen(name, rolle, code) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, salt, 64, { N, 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(name, rolle, hash, salt, N, new Date().toISOString());
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}

const idDogi    = anlegen("Test-DogFather", "admin",   "CODE-DOGI-0001");
const idManager = anlegen("Test-Manager",   "manager", "CODE-MANA-0001");
const idScout   = anlegen("Test-Scout",     "scout",   "CODE-SCOU-0001");
const idAnna    = anlegen("Anna Betreut",   "creator", "CODE-ANNA-0001");
const idBen     = anlegen("Ben Fremd",      "creator", "CODE-BENN-0001");

/* Anna wird vom Scout betreut, Ben nicht. */
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
  .run(idAnna, idScout, new Date().toISOString());

const jetzt = new Date().toISOString();
const gestern = tagText(new Date(Date.now() - 86400_000));
/* ORTSZEIT, wie alles Datumsbezogene hier.

   Die Umstellung auf Ortszeit hatte zuerst nur die ERWARTUNG erfasst
   (sie vergleicht mit slice(0,10)), nicht aber diese Zeile: Sie legt
   den Termin an und rechnete weiter in UTC. Erwartung und Testdaten
   zeigten damit auf zwei verschiedene Tage, und die Pruefung schlug
   fehl, ohne dass an der Anwendung etwas falsch war.

   Merksatz: Wer eine Datumsrechnung umstellt, muss BEIDE Seiten
   umstellen -- die, die schreibt, und die, die prueft. */
const zeitLokal = (versatz) => {
  const d = new Date(Date.now() + versatz * 86400_000);
  const p2 = (n) => String(n).padStart(2, "0");
  return `${tagText(d)}T${p2(d.getHours())}:${p2(d.getMinutes())}`;
};
const morgen = zeitLokal(1);

/* Aufgaben: eine ueberfaellige, zwei offene, je eine in Arbeit, im
   Review und erledigt -- damit jede Zahl der Karte einen anderen Wert
   bekommt und eine vertauschte Spalte sofort auffiele. */
const aufgabe = (creator, status, frist, erledigt) =>
  d.prepare(
    "INSERT INTO aufgaben (titel, creator_id, status, frist, erledigt_am, erstellt, erstellt_von) VALUES (?,?,?,?,?,?,?)"
  ).run("Test", creator, status, frist, erledigt, jetzt, idDogi);

aufgabe(idAnna, "offen", gestern, null);          // ueberfaellig
aufgabe(idAnna, "offen", null, null);
aufgabe(idAnna, "arbeit", null, null);
aufgabe(idAnna, "review", null, null);
aufgabe(idAnna, "erledigt", null, jetzt);
aufgabe(idBen, "offen", gestern, null);

/* Ein dringender, offener Punkt in den Bereichen -- und einer, der
   erledigt ist. Der erledigte darf NICHT mitzaehlen. */
const eintrag = (creator, dringlichkeit, status) =>
  d.prepare(
    "INSERT INTO eintraege (bereich, art, titel, datum, dringlichkeit, status, creator_id, erstellt, erstellt_von) VALUES ('live','notiz','Test',?,?,?,?,?,?)"
  ).run(gestern, dringlichkeit, status, creator, jetzt, idDogi);
eintrag(idAnna, "hoch", "offen");
eintrag(idAnna, "hoch", "erledigt");
eintrag(idAnna, "mittel", "offen");

/* Termin morgen -- der naechste anstehende. Ein bereits erledigter und
   ein vergangener duerfen ihn nicht verdraengen. */
const termin = (beginn, erledigt) =>
  d.prepare(
    "INSERT INTO termine (titel, beginn, creator_id, erledigt, erstellt, erstellt_von) VALUES ('Test',?,?,?,?,?)"
  ).run(beginn, idAnna, erledigt, jetzt, idDogi);
termin(morgen, 0);
termin(zeitLokal(3), 0);
termin(zeitLokal(2), 1); // erledigt
termin("2020-01-01T10:00", 0);                                             // vergangen

/* Start-Check: drei geprueft, davon einer mit Handlungsbedarf. */
const check = (feld, punkt, bewertung) =>
  d.prepare(
    "INSERT INTO startcheck (creator_id, feld, punkt, bewertung, geaendert) VALUES (?,?,?,?,?)"
  ).run(idAnna, feld, punkt, bewertung, jetzt);
check("technik", "licht", "ok");
check("technik", "ton", "mittel");
check("inhalt", "plan", "handlung");
check("inhalt", "offen", null);   // angelegt, aber nicht bewertet -> zaehlt nicht

/* Review-Termin im Profil -- nur die Leitung darf ihn sehen. */
d.prepare("INSERT INTO profile (person_id, naechster_review) VALUES (?,?)")
  .run(idAnna, "2026-12-24");

d.close();

/* ---------- Hilfen --------------------------------------------------- */

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 }),
    redirect: "manual",
  });
  const keks = (a.headers.getSetCookie?.() || []).map((c) => c.split(";")[0]).join("; ");
  if (!a.ok || !keks) throw new Error(`Anmeldung ${rolle} gescheitert (${a.status})`);
  return keks;
}
const hole = (pfad, keks) =>
  fetch(BASIS + pfad, { headers: { cookie: keks }, redirect: "manual" });

/* ---------- Pruefungen ------------------------------------------------ */

console.log("\n1) Ohne Anmeldung");
{
  const a = await fetch(BASIS + "/workspace/uebersicht.html", { redirect: "manual" });
  ok(a.status === 302, `Seite leitet um statt sie auszuliefern (${a.status})`);
  const b = await fetch(BASIS + "/workspace/api/uebersicht/creator", { redirect: "manual" });
  ok(b.status === 401, `Schnittstelle antwortet 401 (${b.status})`);
}

console.log("\n2) DogFather sieht alle");
const kDogi = await anmelden("admin", "CODE-DOGI-0001");
{
  const a = await hole("/workspace/uebersicht.html", kDogi);
  ok(a.status === 200, `Seite wird ausgeliefert (${a.status})`);
  const d2 = await (await hole("/workspace/api/uebersicht/creator", kDogi)).json();
  ok(d2.creator.length === 2, `beide Creator (${d2.creator.length})`);
  ok(d2.eigen === false, "eigen = false");
  ok(d2.check_gesamt === 16, "Start-Check-Gesamtzahl mitgeliefert");
  const anna = d2.creator.find((c) => c.name === "Anna Betreut");
  ok(anna.ueberfaellig === 1, `Anna: 1 ueberfaellig (${anna.ueberfaellig})`);
  ok(anna.offen === 2, `Anna: 2 offen (${anna.offen})`);
  ok(anna.arbeit === 1, `Anna: 1 in Arbeit (${anna.arbeit})`);
  ok(anna.review === 1, `Anna: 1 im Review (${anna.review})`);
  ok(anna.erledigt30 === 1, `Anna: 1 erledigt in 30 Tagen (${anna.erledigt30})`);
  ok(anna.dringend === 1, `Anna: 1 dringend, Erledigtes zaehlt nicht mit (${anna.dringend})`);
  ok(anna.check_geprueft === 3, `Anna: 3 Punkte bewertet (${anna.check_geprueft})`);
  ok(anna.check_handlung === 1, `Anna: 1 Punkt mit Handlungsbedarf (${anna.check_handlung})`);
  ok(String(anna.naechster_termin).startsWith(
       tagText(new Date(Date.now() + 86400_000))),
     `Anna: naechster Termin ist morgen, nicht der erledigte (${anna.naechster_termin})`);
  ok(anna.betreuer === "Test-Scout", `Anna: Betreuer steht dran (${anna.betreuer})`);
  ok(anna.naechster_review === "2026-12-24", "Leitung sieht den Review-Termin");
  ok(anna.hat_profil === 1, "Profil erkannt");
  const ben = d2.creator.find((c) => c.name === "Ben Fremd");
  ok(ben.betreuer === null, "Ben hat keinen Betreuer");
  ok(ben.hat_profil === 0, "Ben hat kein Profil");
}

/* AM 03.09.2026 UMGESCHRIEBEN. Hier stand "Manager sieht dasselbe" --
   also alle Creator, wie DogFather.

   Wunsch vom 03.09.2026: "jeder manager soll auch immer nur seine und
   die seiner scouts zugeteilten creator und creator daten sehen. und
   nicht die der anderen." Ein Manager OHNE Zuteilung sieht seitdem
   keinen einzigen Creator -- und das ist kein Fehler, sondern die
   Regel.

   Die Pruefung wird nicht geloescht, sondern gedreht: Erst der leere
   Fall, dann derselbe Manager MIT Zuteilung. Sonst waere aus einer
   Pruefung "sieht alles" eine Pruefung "sieht nichts" geworden -- und
   die haette nicht bemerkt, wenn er auch seine eigenen verliert. */
console.log("\n3) Manager sieht NUR seine zugeteilten Creator");
{
  const k = await anmelden("manager", "CODE-MANA-0001");
  const leer = await (await hole("/workspace/api/uebersicht/creator", k)).json();
  ok(leer.creator.length === 0,
     `ohne Zuteilung kein einziger Creator (${leer.creator.length})`);

  /* Jetzt einen zuteilen -- und zwar mit denselben Mitteln wie die
     Anwendung selbst, nicht per SQL am System vorbei. */
  /* WICHTIG: einen Creator nehmen, der noch KEINEN Betreuer hat.
     `betreuung` haelt genau einen Betreuer je Creator -- ein
     INSERT OR REPLACE auf einen bereits betreuten Creator nimmt dem
     Scout seinen weg. Genau das ist beim ersten Anlauf passiert, und
     Abschnitt 4 fiel daraufhin um: Die Pruefung hatte sich selbst die
     Grundlage entzogen. */
  const dd = new DatabaseSync(process.env.WORKSPACE_DB);
  const mara = dd.prepare("SELECT id FROM personen WHERE rolle = 'manager'").get().id;
  const einer = dd.prepare(`
    SELECT id, name FROM personen
    WHERE rolle = 'creator' AND id NOT IN (SELECT creator_id FROM betreuung)
    ORDER BY id`).get();
  if (!einer) throw new Error("Testaufbau: kein unbetreuter Creator vorhanden");
  dd.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
    .run(einer.id, mara, new Date().toISOString());
  dd.close();

  const d2 = await (await hole("/workspace/api/uebersicht/creator", k)).json();
  ok(d2.creator.length === 1,
     `mit Zuteilung genau einer (${d2.creator.length}) – nicht alle, nicht keiner`);
  ok(d2.creator[0]?.name === einer.name,
     `und zwar der zugeteilte (${d2.creator[0]?.name})`);
  ok(d2.creator[0]?.naechster_review !== undefined, "Manager sieht Review-Termine");
}

console.log("\n4) Scout sieht nur die betreute Person");
{
  const k = await anmelden("scout", "CODE-SCOU-0001");
  const a = await hole("/workspace/uebersicht.html", k);
  ok(a.status === 200, `Seite wird ausgeliefert (${a.status})`);
  const d2 = await (await hole("/workspace/api/uebersicht/creator", k)).json();
  ok(d2.creator.length === 1, `genau ein Creator (${d2.creator.length})`);
  ok(d2.creator[0].name === "Anna Betreut", "und zwar die betreute");
  ok(!d2.creator.some((c) => c.name === "Ben Fremd"), "Ben taucht NICHT auf");
  ok(!("naechster_review" in d2.creator[0]), "Scout sieht KEINEN Review-Termin");
}

console.log("\n5) Creator sieht nur sich selbst");
{
  const k = await anmelden("creator", "CODE-ANNA-0001");
  const a = await hole("/workspace/uebersicht.html", k);
  ok(a.status === 200, `Seite wird ausgeliefert (${a.status})`);
  const d2 = await (await hole("/workspace/api/uebersicht/creator", k)).json();
  ok(d2.eigen === true, "eigen = true");
  ok(d2.creator.length === 1, `genau ein Eintrag (${d2.creator.length})`);
  ok(d2.creator[0].name === "Anna Betreut", "und zwar er selbst");
  ok(!("naechster_review" in d2.creator[0]), "Creator sieht KEINEN Review-Termin");
}

console.log("\n6) Scout ohne Zuteilung bekommt eine leere, keine fremde Liste");
{
  const d3 = new DatabaseSync(process.env.WORKSPACE_DB);
  d3.prepare("DELETE FROM betreuung WHERE creator_id = ?").run(idAnna);
  d3.close();
  const k = await anmelden("scout", "CODE-SCOU-0001");
  const d2 = await (await hole("/workspace/api/uebersicht/creator", k)).json();
  ok(d2.creator.length === 0, `leer statt alle (${d2.creator.length})`);
}

console.log(`\n${fehler === 0 ? "Alles in Ordnung." : fehler + " Prüfung(en) fehlgeschlagen."}`);
/* Windows gibt die Datei erst frei, wenn der Server sie loslaesst -- das
   Aufraeumen darf den Lauf deshalb nicht zum Scheitern bringen. Der
   Ordner liegt im Temp-Verzeichnis und verschwindet ohnehin. */
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
process.exit(fehler === 0 ? 0 : 1);