dogfather-universe/server/pruef-scout-zuteilung.mjs

/* Prueft die Zuteilung Manager -> Scouts.

   Wunsch vom 01.09.2026: "er soll nur die Scouts sehen, die ihm
   zugeteilt sind." Dazu entschieden: Ein Manager sieht dann AUCH die
   Creator dieser Scouts ("ja, alles seiner Scouts"), und zuteilen darf
   NUR DogFather.

   WARUM DAS DIE HEIKELSTE AENDERUNG DES TAGES IST.

   Diese Zuteilung ERWEITERT Sichtbarkeit. Alles andere heute hat sie
   eingeschraenkt -- ein Fehler dort zeigt jemandem zu wenig, und das
   faellt auf. Ein Fehler HIER zeigt jemandem zu viel, und das faellt
   niemandem auf. Deshalb steht der Missbrauch am Anfang:

     Darf ein Manager sich selbst Scouts zuteilen?   -> muss 404 sein
     Darf ein Scout das?                              -> muss 404 sein
     Kann man einen Scout an einen Scout haengen?     -> muss 400 sein
     Kann man einen Creator zuteilen?                 -> muss 404 sein

   Und danach die Kette in beide Richtungen: Was der Manager sehen SOLL,
   sieht er -- und was er nicht sehen soll, sieht er nicht. */

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-zut-"));
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. */
await portMussFreiSein(4217, "pruef-scout-zuteilung");
process.env.PORT = "4217";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
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 { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
   zwei Auffangnetze ein, die einen Absturz nur protokollieren --
   richtig fuer den Betrieb, fatal fuer eine Pruefung. Ohne diese
   Zeile bleibt der Prozess nach einem Fehler ewig stehen, weil der
   Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
notbremse(480_000, "pruef-scout-zuteilung");
await new Promise((r) => setTimeout(r, 700));
const BASIS = "http://127.0.0.1:4217";
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).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 = (b, t) => { console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
for (let i = 0; i < 60; i++) {
  try {
    const p = new DatabaseSync(process.env.WORKSPACE_DB);
    try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
  } catch { await new Promise((r) => setTimeout(r, 250)); }
}
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
const heute = tagText();
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, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idMara = anlegen("Mara", "manager", "CODE-MANA-0001");
const idNina = anlegen("Nina", "manager", "CODE-MANB-0001");
const idPat  = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idBen  = anlegen("Ben", "scout", "CODE-SCOB-0001");
const idTili = anlegen("Tili", "creator", "CODE-ANNA-0001");
const idLuna = anlegen("Luna", "creator", "CODE-LUNA-0001");

/* Patrick betreut Tili, Ben betreut Luna. Noch KEINE Scout-Zuteilung --
   die wird gleich ueber die Schnittstelle gesetzt, damit auch der Weg
   dorthin geprueft ist und nicht nur die Datenbank. */
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idTili, idPat, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idBen, jetzt);

const lead = (name, scout) =>
  d.prepare(`INSERT INTO leads (name, plattform, handle, status, prioritaet, scout_id, erstellt)
             VALUES (?,?,?,?,?,?,?)`)
    .run(name, "tiktok", "@" + name.toLowerCase(), "neu", "mittel", scout, jetzt);
lead("PATRICK-LEAD", idPat);
lead("BEN-LEAD", idBen);

const aufgabe = (titel, creator, verant) =>
  d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet,
    creator_id, verantwortlich_id, erstellt, erstellt_von) VALUES (?,?,?,?,?,?,?,?)`)
    .run(titel, "", "offen", "mittel", creator, verant, jetzt, idDogi);
aufgabe("TILI-AUFGABE", idTili, idPat);
aufgabe("LUNA-AUFGABE", idLuna, idBen);
d.close();

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((x) => x.split(";")[0]).join("; ");
}
const setzen = (scoutId, managerId, keks) =>
  fetch(`${BASIS}/workspace/api/verwaltung/scout-zuteilung/${scoutId}`, {
    method: "PUT",
    headers: { cookie: keks, "Content-Type": "application/json", origin: BASIS },
    body: JSON.stringify({ manager_id: managerId }),
  });
const holen = async (pfad, keks) => {
  const a = await fetch(BASIS + pfad, { headers: { cookie: keks } });
  return { status: a.status, daten: a.ok ? await a.json() : null };
};

const kDogi = await anmelden("admin", "CODE-DOGI-0001");
const kMara = await anmelden("manager", "CODE-MANA-0001");
const kNina = await anmelden("manager", "CODE-MANB-0001");
const kPat  = await anmelden("scout", "CODE-SCOU-0001");

/* ================================================================
   1. ZUERST DER MISSBRAUCH
   ================================================================ */
console.log("\n=== Nur DogFather darf zuteilen");

{
  const a = await setzen(idPat, idMara, kMara);
  ok(a.status === 404,
     `ein Manager kann sich NICHT selbst einen Scout zuteilen (${a.status}, 404 erwartet)`);
  /* 404 und nicht 403: Wer es nicht darf, soll nicht einmal erfahren,
     dass es diesen Weg gibt. */
  const b = await setzen(idPat, idMara, kPat);
  ok(b.status === 404, `ein Scout auch nicht (${b.status})`);

  /* Und wirklich nichts passiert? Eine abgewiesene Anfrage, die trotzdem
     schreibt, waere der schlimmste Fall -- deshalb wird nachgesehen. */
  const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
  const n = d2.prepare("SELECT COUNT(*) AS n FROM scout_zuteilung").get().n;
  d2.close();
  ok(n === 0, `und es wurde auch nichts geschrieben (${n} Zuteilungen)`);
}

console.log("\n=== Unsinnige Zuteilungen");
{
  const a = await setzen(idPat, idBen, kDogi);
  ok(a.status === 400, `Scout an Scout geht nicht (${a.status})`);
  /* SEIT 02.09.2026 ERLAUBT: "ich will die Rollen, welcher Scout welchem
     Manager ODER DOGFATHER gehoert, wie es bei den Creator ist."

     Vorher wurde das abgewiesen mit der Begruendung, DogFather sehe
     ohnehin alles -- der Eintrag bewirke also nichts. Das war zu eng
     gedacht: Er haelt die ZUSTAENDIGKEIT fest, und das ist genau die
     Frage "wen frage ich?". Bei den Creatorn steht DogFather aus
     demselben Grund seit dem 31.08. in der Auswahl.

     Geprueft wird deshalb beides: dass es geht -- und dass es an den
     RECHTEN nichts aendert. */
  const b = await setzen(idPat, idDogi, kDogi);
  ok(b.status === 200, `Scout an DogFather geht jetzt (${b.status})`);
  const c = await setzen(idTili, idMara, kDogi);
  ok(c.status === 404, `einen Creator kann man nicht zuteilen (${c.status})`);
  const e = await setzen(999999, idMara, kDogi);
  ok(e.status === 404, `eine erfundene Nummer ebenfalls nicht (${e.status})`);
}

/* Eine Zuteilung an DogFather darf NIEMANDEM mehr zeigen. Das ist der
   Unterschied zwischen "haelt die Zustaendigkeit fest" und "vergibt
   Sichtbarkeit" -- und wenn er je verschwimmt, faellt es hier auf. */
console.log("\n=== Eine Zuteilung an DogFather vergibt keine Sicht");
{
  const l = await holen("/workspace/api/leads", kMara);
  const a = await holen("/workspace/api/aufgaben", kMara);
  ok((l.daten?.leads || []).length === 0 && (a.daten?.aufgaben || []).length === 0,
     `Mara sieht dadurch nichts (${(l.daten?.leads || []).length} Leads, `
     + `${(a.daten?.aufgaben || []).length} Aufgaben)`);
  const lN = await holen("/workspace/api/leads", kNina);
  ok((lN.daten?.leads || []).length === 0, "und Nina auch nicht");
  /* Zuruecksetzen, damit die Kette darunter von vorn beginnt. */
  await setzen(idPat, null, kDogi);
}

/* ================================================================
   2. DIE KETTE: Manager -> Scout -> dessen Creator
   ================================================================ */
console.log("\n=== Vorher: Mara sieht nichts von Patrick");
{
  const l = await holen("/workspace/api/leads", kMara);
  ok((l.daten?.leads || []).length === 0,
     `ohne Zuteilung keine fremden Leads (${(l.daten?.leads || []).length})`);
  const a = await holen("/workspace/api/aufgaben", kMara);
  ok((a.daten?.aufgaben || []).length === 0,
     `und keine fremden Aufgaben (${(a.daten?.aufgaben || []).length})`);
}

console.log("\n=== DogFather teilt Patrick an Mara zu");
{
  const a = await setzen(idPat, idMara, kDogi);
  ok(a.status === 200, `die Zuteilung geht durch (${a.status})`);

  const l = await holen("/workspace/api/leads", kMara);
  const namen = (l.daten?.leads || []).map((x) => x.name).sort();
  ok(namen.length === 1 && namen[0] === "PATRICK-LEAD",
     `Mara sieht jetzt Patricks Lead (${namen.join(", ")})`);
  ok(!namen.includes("BEN-LEAD"),
     "  und NICHT den des anderen Scouts");

  /* DIE KETTE -- der eigentliche Punkt der Entscheidung: Sie sieht auch
     den Creator, den Patrick betreut, obwohl er ihr nie direkt zugeteilt
     wurde. */
  const auf = await holen("/workspace/api/aufgaben", kMara);
  const titel = (auf.daten?.aufgaben || []).map((x) => x.titel).sort();
  ok(titel.length === 1 && titel[0] === "TILI-AUFGABE",
     `und die Aufgaben von Patricks Creator (${titel.join(", ")})`);
  ok(!titel.includes("LUNA-AUFGABE"),
     "  aber nicht die des Creators vom anderen Scout");
}

console.log("\n=== Die zweite Managerin sieht davon nichts");
{
  const l = await holen("/workspace/api/leads", kNina);
  const a = await holen("/workspace/api/aufgaben", kNina);
  ok((l.daten?.leads || []).length === 0 && (a.daten?.aufgaben || []).length === 0,
     `Nina sieht weiterhin nichts (${(l.daten?.leads || []).length} Leads, `
     + `${(a.daten?.aufgaben || []).length} Aufgaben) – eine Zuteilung gilt nur fuer den, `
     + "dem zugeteilt wurde");
}

console.log("\n=== Auch Suche und Hinweise ziehen mit");
{
  /* Ein Hinweis oder Suchtreffer, der mehr verraet als die Seite
     dahinter, waere ein Leck -- deshalb dieselbe Regel, aus derselben
     Quelle. */
  const s = await holen("/workspace/api/suche?q=LEAD", kMara);
  const treffer = (s.daten?.gruppen || []).flatMap((g) => g.treffer.map((t) => t.titel || t.name));
  ok(!treffer.some((t) => String(t).includes("BEN")),
     `die Suche zeigt Mara keinen fremden Lead (${treffer.join(", ") || "nichts"})`);

  const sN = await holen("/workspace/api/suche?q=LEAD", kNina);
  const trefferN = (sN.daten?.gruppen || []).flatMap((g) => g.treffer.map((t) => t.titel || t.name));
  ok(trefferN.length === 0,
     `und Nina gar keinen (${trefferN.join(", ") || "nichts"})`);
}

/* ================================================================
   3. ZURUECKNEHMEN -- und die Sicht geht wirklich wieder weg
   ================================================================ */
console.log("\n=== Zuruecknehmen");
{
  const a = await setzen(idPat, null, kDogi);
  ok(a.status === 200, `die Zuteilung laesst sich loesen (${a.status})`);
  const l = await holen("/workspace/api/leads", kMara);
  const auf = await holen("/workspace/api/aufgaben", kMara);
  ok((l.daten?.leads || []).length === 0 && (auf.daten?.aufgaben || []).length === 0,
     `und Mara sieht danach wieder nichts (${(l.daten?.leads || []).length} Leads, `
     + `${(auf.daten?.aufgaben || []).length} Aufgaben)`);
}

/* Ein Scout gehoert zu HOECHSTENS einem Manager -- eine zweite Zuteilung
   ersetzt die erste, sie kommt nicht dazu. Sonst waere "wer ist
   zustaendig?" eine Frage ohne Antwort. */
console.log("\n=== Ein Scout gehoert zu genau einem Manager");
{
  await setzen(idPat, idMara, kDogi);
  await setzen(idPat, idNina, kDogi);
  const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
  const z = d2.prepare("SELECT COUNT(*) AS n FROM scout_zuteilung WHERE scout_id = ?").get(idPat);
  const wer = d2.prepare("SELECT manager_id FROM scout_zuteilung WHERE scout_id = ?").get(idPat);
  d2.close();
  ok(z.n === 1, `nach zwei Zuteilungen genau ein Eintrag (${z.n})`);
  ok(wer.manager_id === idNina, "  und zwar der zuletzt gesetzte");

  const lMara = await holen("/workspace/api/leads", kMara);
  ok((lMara.daten?.leads || []).length === 0,
     `die erste Managerin sieht Patricks Lead nicht mehr (${(lMara.daten?.leads || []).length})`);
}

/* ================================================================
   4. IM BROWSER: die Auswahl steht da -- und nur bei DogFather
   ================================================================ */
console.log("\n=== Die Auswahl in der Personenliste");
const { chromium } = await import(
  "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await chromium.launch();

async function seiteAls(rolle, code) {
  const kontext = await browser.newContext({ viewport: { width: 1280, height: 1100 } });
  const konsole = [];
  const seite = await kontext.newPage();
  seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("pageerror: " + e.message));
  await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
  await seite.click(`.rolle[data-rolle="${rolle}"]`);
  await seite.fill("#code", code);
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 15000 });
  await seite.goto(BASIS + "/workspace/personen.html", { waitUntil: "networkidle" });
  await seite.waitForTimeout(1200);
  /* DIE LISTE IST NACH ROLLEN ZUGEKLAPPT -- offen ist nur die eigene
     Gruppe. Der erste Anlauf dieser Pruefung mass deshalb genau eine
     Zeile ("Filipe (du)") und meldete, die Auswahl fehle. Sie fehlte
     nicht, sie war nur zugeklappt.

     Ein lehrreicher Fehlschlag: Er sah aus wie ein Produktfehler und war
     einer der Pruefung. Wer ihn ungeprueft geglaubt haette, haette am
     falschen Ende repariert. */
  await seite.click("#rest-schalter").catch(() => {});
  await seite.waitForTimeout(600);
  return { kontext, seite, konsole };
}

const bDogi = await seiteAls("admin", "CODE-DOGI-0001");
const r = await bDogi.seite.evaluate(() => ({
  personen: document.querySelectorAll(".person").length,
  /* Die Auswahl "Gehört zu" -- eine je Scout. */
  wahlen: [...document.querySelectorAll('select[id^="manager-"]')].map((s) => ({
    id: s.id,
    wert: s.value,
    erste: s.querySelector("option")?.textContent,
    anzahl: s.querySelectorAll("option").length,
  })),
  /* Die Zeilen sollen es auch in Worten sagen. */
  texte: [...document.querySelectorAll(".person__zeile")].map((z) => z.textContent),
  ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
}));
ok(r.personen === 7,
   `aufgeklappt stehen alle sieben Personen da (${r.personen}) – `
   + "sonst misst die Pruefung eine zugeklappte Liste");
ok(r.wahlen.length === 2, `zwei Scouts, zwei Auswahlfelder (${r.wahlen.length})`);
ok(/niemand/.test(r.wahlen[0]?.erste || ""),
   `der Leer-Wert heisst wie bei den Creatorn ("${r.wahlen[0]?.erste}")`);
/* DogFather MUSS in der Auswahl stehen -- das war der Wunsch. Und zwar
   ohne die doppelte Klammer "Dogfather (DogFather)". */
ok(r.wahlen[0]?.anzahl >= 4,
   `Manager UND DogFather stehen zur Wahl (${r.wahlen[0]?.anzahl} Eintraege)`);
ok(r.wahlen.some((w) => w.wert === String(idNina)),
   "die bestehende Zuteilung ist vorausgewaehlt");
ok(r.texte.some((t) => /gehört zu Nina/.test(t)),
   "und steht auch in Worten in der Zeile");
ok(r.texte.some((t) => /1 Scout zugeteilt/.test(t)),
   "beim Manager steht die Zahl seiner Scouts");
ok(r.ueber <= 0, `nichts steht ueber (${r.ueber}px)`);
ok(bDogi.konsole.length === 0,
   `keine Fehler in der Konsole${bDogi.konsole.length ? " -> " + bDogi.konsole.join(" | ") : ""}`);
await bDogi.seite.screenshot({ path: "pruef-scout-zuteilung.png", fullPage: false });
await bDogi.kontext.close();

/* GEGENPROBE, AM 02.09.2026 UMGEDREHT.

   Hier stand bis dahin: "ein Manager sieht die ganze Personenliste --
   die Personenverwaltung ist ihm nicht genommen worden". Das galt, war
   aber ein Widerspruch zur eigenen Rollenbeschreibung ("Manager:
   dieselben Rechte wie DogFather, AUSSER der Personenverwaltung").

   Filipe hat den Widerspruch am 02.09.2026 zugunsten der Beschreibung
   aufgeloest: "die manager sollen diese kategorien garnicht sehen."
   Seitdem fuehrt personen.html fuer ihn zurueck zur Startseite.

   AM 07.09.2026 EIN DRITTES MAL GEDREHT, und der Weg dorthin gehoert
   in die Akte: Manager sollen "creator und auch wirklich nur creator
   hinzufuegen koennen" -- dafuer muessen sie die Seite wieder oeffnen
   duerfen. Die Seite geht seither auf; die VERWALTUNG dahinter bleibt
   zu.

   Genau das ist jetzt die Aussage, und sie ist schaerfer als beide
   vorherigen: Nicht "er kommt rein" und nicht "er kommt nicht rein",
   sondern "er kommt rein UND sieht dort trotzdem keine einzige
   Personenzeile". Die beiden Zeilen darunter standen schon vorher da
   und waren die ganze Zeit die wichtigeren -- sie messen, dass er sich
   keine Sichtbarkeit zuteilen kann.

   Die Pruefung wird bei jeder Drehung umgeschrieben, nie geloescht:
   Eine geloeschte Pruefung hinterlaesst keine Spur davon, dass hier
   einmal etwas anderes galt -- und der neue Weg waere ab da ungeprueft. */
const bMara = await seiteAls("manager", "CODE-MANA-0001");
const rM = await bMara.seite.evaluate(() => ({
  wahlen: document.querySelectorAll('select[id^="manager-"]').length,
  personen: document.querySelectorAll(".person").length,
  wo: location.pathname,
}));
ok(rM.wo.endsWith("/personen.html"),
   `ein Manager kommt auf die Personenseite (${rM.wo.split("/").pop()})`);
ok(rM.personen === 0,
   `sieht dort aber keine einzige Personenzeile (${rM.personen})`);
ok(rM.wahlen === 0,
   `erst recht keine Zuteilungs-Auswahl (${rM.wahlen}) – er koennte sich sonst `
   + "seine eigene Sichtbarkeit vergeben");
await bMara.kontext.close();

await browser.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
console.log(fehler ? `\n${fehler} Prüfung(en) fehlgeschlagen.` : "\nAlles in Ordnung.");
process.exit(fehler ? 1 : 0);