dogfather-universe/server/pruef-bereiche-lesend.mjs

/* ===================================================================
   Pruefung: Ein Creator kann in den Bereichen NICHTS mehr schreiben.

   Wunsch Filipe 31.08.2026: "die creator sollen da nur die sehen die wir
   ihnen eintragen, also dogfather manager und scout."

   Der Schwerpunkt liegt auf den VERNEINENDEN Faellen -- dass DogFather
   schreiben darf, faellt sofort auf; dass ein Creator es nicht mehr kann,
   merkt man nur, wenn man es ausdruecklich versucht. Und zwar auf JEDEM
   Weg und in JEDEM der fuenf Bereiche, nicht nur in dem einen, den man
   gerade im Kopf hat.
   =================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-bereiche-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = "4183";
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 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:4183";
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 180_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");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().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, 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("Dogfather", "admin", "CODE-DOGI-0001");
const idScout = anlegen("Ein Scout", "scout", "CODE-SCOU-0001");
const idAnna  = anlegen("Anna", "creator", "CODE-ANNA-0001");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idAnna, idScout, jetzt);

/* Ein Eintrag, den ANNA sich frueher selbst haette anlegen koennen --
   damit auch das Loeschen "eigener" Eintraege geprueft wird. */
const eigenerId = (() => {
  d.prepare("INSERT INTO eintraege (bereich, art, titel, text, datum, status, creator_id, erstellt, erstellt_von) VALUES ('live','auswertung','Von Anna selbst','alt',?,'offen',?,?,?)")
    .run(tagText(), idAnna, jetzt, idAnna);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
})();
d.close();

const anmelden = async (rolle, code) => {
  const a = await fetch(BASIS + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle, code }), redirect: "manual" });
  return (a.headers.getSetCookie?.() || []).map((c) => c.split(";")[0]).join("; ");
};
const ruf = (pfad, keks, opt = {}) => fetch(BASIS + pfad, {
  ...opt, headers: { cookie: keks, "Content-Type": "application/json", ...(opt.headers || {}) },
});

const kDogi   = await anmelden("admin", "CODE-DOGI-0001");
const kScout  = await anmelden("scout", "CODE-SCOU-0001");
const kCreator = await anmelden("creator", "CODE-ANNA-0001");

const BEREICHE = ["live", "content", "technik", "community", "schutz"];

console.log("\n1) DogFather trägt in jedem Bereich ein");
const angelegt = {};
for (const b of BEREICHE) {
  const arten = { live: "auswertung", content: "idee", technik: "problem", community: "moderation", schutz: "vorfall" };
  const a = await ruf(`/workspace/api/bereich/${b}`, kDogi, {
    method: "POST",
    body: JSON.stringify({ art: arten[b], titel: "Von der Betreuung", text: "…",
      datum: tagText(), creator_id: idAnna }),
  });
  const j = await a.json().catch(() => ({}));
  angelegt[b] = j.id;
  ok(a.ok, `${b}: angelegt (${a.status})`);
}

console.log("\n2) Der Scout darf ebenfalls – er betreut Anna");
{
  const a = await ruf("/workspace/api/bereich/live", kScout, {
    method: "POST",
    body: JSON.stringify({ art: "vorbereitung", titel: "Vom Scout", datum: tagText(), creator_id: idAnna }),
  });
  ok(a.ok, `Scout darf eintragen (${a.status})`);
}

console.log("\n3) Der Creator SIEHT alles, was zu ihm gehört");
for (const b of BEREICHE) {
  const a = await ruf(`/workspace/api/bereich/${b}`, kCreator);
  const j = await a.json().catch(() => ({}));
  const anzahl = (j.eintraege || []).length;
  ok(a.ok && anzahl >= 1, `${b}: sichtbar, ${anzahl} Eintrag/Einträge (${a.status})`);
  if (b === "live") {
    ok((j.eintraege || []).some((e) => e.titel === "Von der Betreuung"),
       "der Eintrag der Betreuung ist dabei");
    ok((j.eintraege || []).some((e) => e.titel === "Vom Scout"),
       "der Eintrag des Scouts ist dabei");
  }
}

console.log("\n4) Der Creator kann NICHTS schreiben – in keinem Bereich, auf keinem Weg");
for (const b of BEREICHE) {
  const neu = await ruf(`/workspace/api/bereich/${b}`, kCreator, {
    method: "POST",
    body: JSON.stringify({ art: "idee", titel: "Selbst geschrieben", datum: tagText() }),
  });
  ok(neu.status === 403, `${b}: anlegen abgelehnt (${neu.status})`);

  const id = angelegt[b];
  const aend = await ruf(`/workspace/api/bereich/${b}/${id}`, kCreator, {
    method: "PATCH", body: JSON.stringify({ titel: "Umgeschrieben" }),
  });
  ok(aend.status === 403, `${b}: ändern abgelehnt (${aend.status})`);

  const weg = await ruf(`/workspace/api/bereich/${b}/${id}`, kCreator, { method: "DELETE" });
  ok(weg.status === 403, `${b}: löschen abgelehnt (${weg.status})`);
}

console.log("\n5) Auch den EIGENEN alten Eintrag nicht mehr");
{
  /* Das war vorher ausdruecklich erlaubt ("wer ihn selbst geschrieben
     hat"). Genau der Weg muss jetzt auch zu sein -- sonst bliebe ein
     Schlupfloch fuer alles, was vor der Umstellung entstanden ist. */
  const weg = await ruf(`/workspace/api/bereich/live/${eigenerId}`, kCreator, { method: "DELETE" });
  ok(weg.status === 403, `eigener Alteintrag lässt sich nicht löschen (${weg.status})`);
  const aend = await ruf(`/workspace/api/bereich/live/${eigenerId}`, kCreator, {
    method: "PATCH", body: JSON.stringify({ status: "erledigt" }) });
  ok(aend.status === 403, `und auch nicht auf erledigt setzen (${aend.status})`);
}

console.log("\n6) Nichts hat sich tatsächlich verändert");
{
  const a = await ruf("/workspace/api/bereich/live", kDogi);
  const { eintraege } = await a.json();
  ok(eintraege.some((e) => e.titel === "Von der Betreuung"), "der Eintrag steht unverändert da");
  ok(eintraege.some((e) => e.titel === "Von Anna selbst"), "der Alteintrag ist noch da");
  ok(!eintraege.some((e) => e.titel === "Selbst geschrieben"), "nichts vom Creator ist durchgerutscht");
  ok(!eintraege.some((e) => e.titel === "Umgeschrieben"), "nichts wurde umgeschrieben");
  ok(eintraege.every((e) => e.status === "offen"), "kein Status wurde verändert");
}

console.log("\n7) Die Antwort erklärt, was los ist");
{
  const a = await ruf("/workspace/api/bereich/live", kCreator, {
    method: "POST", body: JSON.stringify({ art: "idee", titel: "x", datum: tagText() }) });
  const j = await a.json();
  console.log("   ->", j.fehler);
  ok(/Betreuer/.test(j.fehler || ""), "die Meldung sagt, wer einträgt");
  ok(/siehst/.test(j.fehler || ""), "und dass er trotzdem alles sieht");
}

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