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");
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 }); };
await import("./index.js");
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})`);
  const b = await setzen(idPat, idDogi, kDogi);
  ok(b.status === 400,
     `Scout an DogFather geht nicht (${b.status}) – er sieht ohnehin alles, `
     + "und ein Eintrag ohne Wirkung wird spaeter fuer eine Wirkung gehalten");
  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})`);
}

/* ================================================================
   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(/direkt bei DogFather/.test(r.wahlen[0]?.erste || ""),
   `der Leer-Wert heisst, was er ist ("${r.wahlen[0]?.erste}") – `
   + '"niemand" waere falsch, ein Scout ohne Manager haengt an dir');
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: Ein Manager darf die Personenliste sehen -- aber diese
   Auswahl nicht. */
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,
}));
ok(rM.personen >= 7,
   `ein Manager sieht die ganze Personenliste (${rM.personen} Zeilen) – `
   + "die Personenverwaltung ist ihm nicht genommen worden");
ok(rM.wahlen === 0,
   `Gegenprobe: aber 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);