dogfather-universe/server/pruef-anhaenge.mjs

/* =====================================================================
   Anhänge an Aufgaben (15.09.2026)

   Stufe 9: „Anhänge an Aufgaben". Eine Aufgabe „Vertrag prüfen" ohne
   den Vertrag daneben ist eine Aufforderung zum Suchen.

   ---------------------------------------------------------------------
   KEIN ZWEITER HOCHLADEWEG — UND GENAU DAS WIRD GEPRÜFT

   Dateien leben in der Dateiablage, mit ihrer Sichtbarkeit, ihren
   Freigaben, ihren Fassungen und ihrem Protokoll. Die Aufgabe bekommt
   keine eigene Ablage, sondern die Datei bekommt eine Spalte.

   Die drei Fragen, auf die es ankommt:

     1. Landet die Datei wirklich an der Aufgabe — und in der Ablage?
     2. Lässt sich eine Datei an eine FREMDE Aufgabe hängen?   (nein)
     3. Was passiert mit der Datei, wenn die Aufgabe gelöscht wird?

   Die zweite ist der Riegel: Wäre der Kopf `x-aufgabe` ungeprüft, wäre
   er ein Weg, die Existenz fremder Aufgaben zu erfahren — man müsste
   nur Zahlen durchprobieren.

   Die dritte ist die, die wehtun würde: `CASCADE` hätte beim Löschen
   einer Aufgabe den Vertrag mitgenommen.

   Aufrufen mit:  node server/pruef-anhaenge.mjs
   ===================================================================== */

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { request as httpAnfrage } from "node:http";
import { eigenerPort } from "./helfer-port.mjs";

const PORT = await eigenerPort(import.meta, "pruef-anhaenge");

const ordner = mkdtempSync(join(tmpdir(), "ws-anh-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = String(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";
await import("./index.js");
notbremse(180_000, "pruef-anhaenge");
await new Promise((r) => setTimeout(r, 700));

process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
process.on("unhandledRejection", (f) => { console.error("ABSTURZ (Versprechen):", f); process.exit(7); });

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

const HAUS = "workspace.dogfather-universe.com";

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

const oeffne = () => new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();

let idDogi, idLuna, idMax, idBen, aufgabeLuna, aufgabeMax, aufgabeHaus;
{
  const d = oeffne();
  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);
  const 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, code_kennung, aktiv, erstellt)"
      + " VALUES (?,?,?,?,?,?,1,?)")
      .run(name, rolle, hash, salt, 32768, createHmac("sha256", schluessel).update(code).digest("hex"), jetzt);
    return d.prepare("SELECT last_insert_rowid() AS id").get().id;
  };
  idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
  idLuna = anlegen("Luna", "creator", "CODE-CREA-0001");
  idMax = anlegen("Max", "creator", "CODE-CREA-0002");
  idBen = anlegen("Ben", "scout", "CODE-SCOU-0001");
  /* Ben betreut Luna, aber nicht Max -- das ist die Trennlinie, an der
     der Riegel gemessen wird. */
  d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
    .run(idLuna, idBen, jetzt);

  const auf = d.prepare(`INSERT INTO aufgaben (titel, status, prioritaet, creator_id, erstellt, erstellt_von)
      VALUES (?,'offen','mittel',?,?,?)`);
  auf.run("Vertrag pruefen (Luna)", idLuna, jetzt, idDogi);
  aufgabeLuna = d.prepare("SELECT last_insert_rowid() AS id").get().id;
  auf.run("Vertrag pruefen (Max)", idMax, jetzt, idDogi);
  aufgabeMax = d.prepare("SELECT last_insert_rowid() AS id").get().id;
  auf.run("Etwas fuers Haus", null, jetzt, idDogi);
  aufgabeHaus = d.prepare("SELECT last_insert_rowid() AS id").get().id;
  d.close();
}

function ruf(pfad, methode, kopf = {}, koerper = null) {
  return new Promise((fertig, schief) => {
    const a = httpAnfrage({ host: "127.0.0.1", port: PORT, path: pfad, method: methode,
      headers: { Host: HAUS, ...kopf } }, (antwort) => {
      let text = "";
      antwort.on("data", (s) => { text += s; });
      antwort.on("end", () => fertig({ code: antwort.statusCode, text, kopf: antwort.headers }));
    });
    a.on("error", schief);
    if (koerper) a.write(koerper);
    a.end();
  });
}
const json = (a) => { try { return JSON.parse(a.text); } catch { return {}; } };
async function anmelden(rolle, code) {
  const r = await ruf("/workspace/api/anmelden", "POST",
    { "Content-Type": "application/json" }, JSON.stringify({ rolle, code }));
  return [].concat(r.kopf?.["set-cookie"] || []).map((c) => c.split(";")[0]).join("; ");
}
const kDogi = await anmelden("admin", "CODE-DOGI-0001");
const kBen = await anmelden("scout", "CODE-SCOU-0001");
ok(!!kDogi && !!kBen, "DogFather und ein Scout sind angemeldet");

/** Laedt hoch -- an eine Aufgabe oder frei. */
const hochladen = (name, inhalt, keks, aufgabeId) =>
  ruf("/workspace/api/dateien", "POST", {
    cookie: keks,
    "content-type": "text/plain",
    "x-dateiname": encodeURIComponent(name),
    ...(aufgabeId ? { "x-aufgabe": String(aufgabeId) } : {}),
    "content-length": Buffer.byteLength(inhalt),
  }, inhalt);

const anhaenge = async (aufgabeId, keks) =>
  json(await ruf(`/workspace/api/aufgaben/${aufgabeId}/dateien`, "GET", { cookie: keks })).dateien || [];

/* =======================================================================
   1. DIE DATEI LANDET AN DER AUFGABE — UND IN DER ABLAGE
   ======================================================================= */
melde("");
melde("=== 1. Angehängt ===");
{
  const a = await hochladen("vertrag.pdf", "Inhalt eins", kDogi, aufgabeLuna);
  ok(a.code === 201, `die Datei geht durch (${a.code}) ${a.code === 201 ? "" : a.text.slice(0, 120)}`);
  ok(json(a).aufgabe_id === aufgabeLuna,
    `und haengt an der Aufgabe (${json(a).aufgabe_id})`);

  const liste = await anhaenge(aufgabeLuna, kDogi);
  ok(liste.length === 1, `die Aufgabe kennt ${liste.length} Anhang`);
  ok(liste[0].name_original === "vertrag.pdf", `mit Namen (${liste[0].name_original})`);

  /* SIE IST KEINE ZWEITE ABLAGE: Dieselbe Datei steht auch in der
     Dateiliste, mit allem, was dort dazugehoert. */
  const alle = json(await ruf("/workspace/api/dateien", "GET", { cookie: kDogi })).dateien || [];
  const drin = alle.find((x) => x.id === json(a).id);
  ok(!!drin, "und sie steht ganz normal in der Dateiablage");
  ok(drin.status === "entwurf", `mit dem gewohnten Stand (${drin.status})`);

  /* DER CREATOR-BEZUG FOLGT DER AUFGABE -- sonst laege die Datei fuer
     die Sichtbarkeit woanders als die Aufgabe, an der sie haengt. */
  ok(drin.creator_id === idLuna,
    `und dem Creator-Bezug der Aufgabe (${drin.creator_id === idLuna ? "Luna" : drin.creator_id})`);

  /* GEGENPROBE: Eine Datei OHNE Aufgabe haengt an keiner. */
  const frei = await hochladen("lose.txt", "ohne Aufgabe", kDogi, null);
  ok(json(frei).aufgabe_id === null, "eine Datei ohne Aufgabe bleibt ohne");
  const nachher = await anhaenge(aufgabeLuna, kDogi);
  ok(nachher.length === 1, `und taucht nicht an der Aufgabe auf (${nachher.length})`);
}

/* =======================================================================
   2. DER RIEGEL: KEINE FREMDE AUFGABE

   Waere `x-aufgabe` ungeprueft, waere der Kopf ein Weg, die Existenz
   fremder Aufgaben zu erfahren -- man muesste nur Zahlen durchprobieren.
   ======================================================================= */
melde("");
melde("=== 2. Keine fremde Aufgabe ===");
{
  /* Ben betreut Luna -- an ihre Aufgabe darf er. */
  const eigen = await hochladen("bens-datei.txt", "darf", kBen, aufgabeLuna);
  ok(eigen.code === 201, `der Scout darf an die Aufgabe seiner Creatorin (${eigen.code})`);

  /* An die von Max nicht. */
  const fremd = await hochladen("heimlich.txt", "darf nicht", kBen, aufgabeMax);
  ok(fremd.code === 404, `an die eines fremden Creators nicht (${fremd.code})`);
  ok(json(fremd).fehler === "aufgabe_nicht_gefunden",
    `und die Absage verraet nichts ueber sie (${json(fremd).fehler})`);

  /* UND ES IST AUCH WIRKLICH NICHTS ENTSTANDEN -- eine Absage, nach der
     die Datei trotzdem in der Ablage liegt, waere die schlechteste. */
  const d = oeffne();
  const gibt = d.prepare("SELECT COUNT(*) AS n FROM dateien WHERE name_original = 'heimlich.txt'").get().n;
  d.close();
  ok(gibt === 0, `es liegt auch keine lose Datei herum (${gibt})`);

  /* Eine erfundene Nummer ergibt dieselbe Antwort wie eine fremde --
     sonst waere der Unterschied die Auskunft. */
  const erfunden = await hochladen("nummer.txt", "x", kBen, 999999);
  ok(erfunden.code === 404, `eine erfundene Nummer ebenso (${erfunden.code})`);
  ok(json(erfunden).fehler === json(fremd).fehler,
    "mit wortgleicher Absage — der Unterschied waere die Auskunft");

  /* Eine Aufgabe ohne Creator-Bezug gehoert dem Haus. */
  const haus = await hochladen("fuers-haus.txt", "x", kBen, aufgabeHaus);
  ok(haus.code === 201, `eine Aufgabe ohne Creator-Bezug steht allen offen (${haus.code})`);
}

/* =======================================================================
   3. WER DIE AUFGABE NICHT SEHEN DARF, SIEHT AUCH DIE ANHÄNGE NICHT
   ======================================================================= */
melde("");
melde("=== 3. Die Liste der Anhänge ===");
{
  await hochladen("max-vertrag.pdf", "geheim", kDogi, aufgabeMax);

  const beiDogi = await anhaenge(aufgabeMax, kDogi);
  ok(beiDogi.length >= 1, `DogFather sieht ${beiDogi.length} Anhang an Max' Aufgabe`);

  const beiBen = await anhaenge(aufgabeMax, kBen);
  ok(beiBen.length === 0, `der Scout sieht dort nichts (${beiBen.length})`);

  /* GEGENPROBE -- ohne sie beweist die Zeile darueber nichts: An der
     Aufgabe SEINER Creatorin sieht er sehr wohl etwas. */
  const seine = await anhaenge(aufgabeLuna, kBen);
  ok(seine.length >= 1, `an der Aufgabe seiner Creatorin schon (${seine.length})`);

  const ohne = await ruf(`/workspace/api/aufgaben/${aufgabeLuna}/dateien`, "GET");
  ok(ohne.code === 401, `ohne Anmeldung gar nichts (${ohne.code})`);
}

/* =======================================================================
   4. WIRD DIE AUFGABE GELÖSCHT, BLEIBT DIE DATEI

   Die Frage, die wehtun wuerde: CASCADE haette den Vertrag mitgenommen.
   ======================================================================= */
melde("");
melde("=== 4. Wenn die Aufgabe verschwindet ===");
{
  const a = await hochladen("bleibt.pdf", "wichtig", kDogi, aufgabeHaus);
  const dateiId = json(a).id;

  const d = oeffne();
  d.prepare("PRAGMA foreign_keys = ON").run();
  d.prepare("DELETE FROM aufgaben WHERE id = ?").run(aufgabeHaus);
  const uebrig = d.prepare("SELECT id, aufgabe_id, name_original FROM dateien WHERE id = ?").get(dateiId);
  d.close();

  ok(!!uebrig, "die Datei gibt es noch, obwohl die Aufgabe weg ist");
  ok(uebrig.aufgabe_id === null,
    `und der Bezug steht auf null statt ins Leere (${uebrig.aufgabe_id})`);
  ok(uebrig.name_original === "bleibt.pdf", "mit unverändertem Namen");

  const alle = json(await ruf("/workspace/api/dateien", "GET", { cookie: kDogi })).dateien || [];
  ok(alle.some((x) => x.id === dateiId), "sie steht wieder ganz normal in der Ablage");
}

/* =======================================================================
   5. FASSUNGEN GELTEN AUCH AM ANHANG

   Der eigentliche Nutzen: Wer an einer Aufgabe die alte Fassung
   herunterlaedt, merkt es sonst nicht.
   ======================================================================= */
melde("");
melde("=== 5. Fassungen am Anhang ===");
{
  const eins = await hochladen("konzept.pdf", "eins", kDogi, aufgabeLuna);
  const zwei = await hochladen("konzept.pdf", "zwei", kDogi, aufgabeLuna);
  ok(json(zwei).ersetzt_id === json(eins).id, "die zweite Fassung wird auch am Anhang erkannt");

  const liste = await anhaenge(aufgabeLuna, kDogi);
  const alt = liste.find((x) => x.id === json(eins).id);
  const neu = liste.find((x) => x.id === json(zwei).id);
  ok(alt?.ersetzt_durch === neu?.id, "die alte weiss, dass sie ersetzt wurde");
  ok(neu?.fassung === 2, `die neue ist Fassung ${neu?.fassung}`);
  ok(neu?.ersetzt_durch === null, "und wird von niemandem ersetzt");
}

/* =======================================================================
   6. IM BROWSER
   ======================================================================= */
melde("");
melde("=== 6. Im Browser ===");
{
  const { chromium } = await import(
    "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await chromium.launch();
  const kontext = await browser.newContext({ viewport: { width: 1280, height: 900 } });
  const seite = await kontext.newPage();
  const konsole = [];
  seite.on("console", (m) => { if (m.type() === "error" && !/favicon|ERR_/i.test(m.text())) konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));

  await seite.goto(`http://127.0.0.1:${PORT}/workspace/`, { waitUntil: "domcontentloaded" });
  await seite.click('.rolle[data-rolle="admin"]');
  await seite.fill("#code", "CODE-DOGI-0001");
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 20000 });
  await seite.goto(`http://127.0.0.1:${PORT}/workspace/aufgaben.html`, { waitUntil: "networkidle" });
  await seite.waitForTimeout(900);

  /* Den Dialog der Aufgabe mit den Anhaengen oeffnen. */
  const geoeffnet = await seite.evaluate((titel) => {
    const karten = [...document.querySelectorAll(".aufgabe, .karte, article")];
    const k = karten.find((x) => x.textContent.includes(titel));
    const stift = k?.querySelector("button");
    if (!stift) return false;
    stift.click();
    return true;
  }, "Vertrag pruefen (Luna)");
  ok(geoeffnet === true, "der Bearbeiten-Dialog lässt sich öffnen");
  await seite.waitForTimeout(900);

  const stand = await seite.evaluate(() => ({
    abschnitt: !!document.getElementById("b-anhaenge"),
    dateien: document.querySelectorAll(".anhaenge__datei").length,
    knopf: !!document.getElementById("b-datei"),
    alt: document.querySelectorAll(".anhaenge__alt").length,
    ziele: [...document.querySelectorAll(".anhaenge__datei")].map((a) => a.getAttribute("href")),
  }));
  ok(stand.abschnitt === true, "der Abschnitt „Anhänge“ steht im Dialog");
  ok(stand.dateien >= 3, `${stand.dateien} Anhänge werden gezeigt`);
  ok(stand.knopf === true, "und es gibt einen Weg, eine Datei anzuhängen");
  ok(stand.alt >= 1, `${stand.alt} davon sind als „nicht mehr aktuell“ gekennzeichnet`);
  /* DER VERWEIS MUSS AUF DEN ECHTEN WEG ZEIGEN. Beim ersten Anlauf
     stand dort /dateien/:id -- den es gar nicht gibt. */
  ok(stand.ziele.every((h) => /\/workspace\/api\/dateien\/\d+\/inhalt$/.test(h || "")),
    `jeder Verweis zeigt auf den Herunterlade-Weg (${stand.ziele[0]})`);

  /* Und er trifft auch wirklich etwas -- gemessen, nicht angenommen. */
  const antwort = await seite.evaluate(async (h) => {
    const a = await fetch(h, { credentials: "same-origin" });
    return a.status;
  }, stand.ziele[0]);
  ok(antwort === 200, `und liefert die Datei aus (${antwort})`);

  ok(konsole.length === 0,
    konsole.length ? "Fehler im Browser: " + konsole[0].slice(0, 90) : "keine Fehler im Browser");
  await browser.close();
}

/* ------------------------------------------------------------------- */
melde("");
melde(`${geprueft} Pruefungen, ${fehler} Fehler`);
melde(fehler ? "NICHT IN ORDNUNG" : "ALLES IN ORDNUNG");
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Aufraeumrest */ }
process.exit(fehler ? 1 : 0);