dogfather-universe/server/pruef-teilnehmer.mjs

/* MEHRERE TEILNEHMER AN EINEM TERMIN

   Wunsch Filipe (05.09.2026): *"wenn ich im kalender was eintrage will
   ich dass ich auch 2 leute markieren kann mit denen der call ist."*

   WARUM DAS EINE EIGENE PRUEFUNG BRAUCHT. An der Teilnehmerliste haengt
   die SICHTBARKEIT: Wer eingetragen ist, sieht den Termin. Damit ist
   jede Zeile hier gleichzeitig eine Rechteregel. Zwei Fehler waeren
   moeglich, und beide fallen im Alltag nicht auf:

     zu wenig   Ein Eingetragener sieht seinen eigenen Termin nicht.
                Er merkt es nur, wenn er ihn sucht -- und haelt es dann
                fuer sein eigenes Versehen.

     zu viel    Jemand traegt sich in einen fremden Termin ein und macht
                ihn sich damit sichtbar. Das ist ein Datenleck mit
                Selbstbedienung.

   Beides wird hier gemessen, nicht angenommen.

   DIE ANZAHL GEHOERT IN DIE BEDINGUNG -- ein Lauf, der keinen Termin
   angelegt hat, ist kein bestandener Lauf.

   GEGENPROBE: Am Ende muss nachgewiesen sein, dass diese Pruefung
   ueberhaupt "nicht sichtbar" erkennen kann. */

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { heuteLokal } from "./helfer-zeit.mjs";

const ordner = mkdtempSync(join(tmpdir(), "ws-teiln-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* Der Port muss frei sein -- sonst wird gegen einen fremden Server
   gemessen. Begruendung in helfer-port.mjs. */
const { eigenerPort } = await import("./helfer-port.mjs");
const PORT = await eigenerPort(import.meta, "die Teilnehmerpruefung");

process.env.PORT = `${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 }); };
await import("./index.js");
await new Promise((r) => setTimeout(r, 900));
const BASIS = `http://127.0.0.1:${PORT}`;

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

/* ---- Bestand ------------------------------------------------------------ */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
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();
/* ORTSZEIT, nicht UTC -- Begruendung in helfer-zeit.mjs. Mit
   `jetzt.slice(0, 10)` war diese Pruefung jede Nacht zwischen 00:00
   und 02:00 rot, weil sie ihre Termine auf gestern legte. */
const heute = heuteLokal();
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("Chef", "admin", "CODE-DOGI-0001");
const idPat = anlegen("Pat", "scout", "CODE-SCOU-0001");
const idBea = anlegen("Bea", "scout", "CODE-SCOU-0002");
const idLuna = anlegen("Luna", "creator", "CODE-CREA-0001");
const idNora = anlegen("Nora", "creator", "CODE-CREA-0002");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idPat, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idNora, idBea, jetzt);

/* EIN ALTER TERMIN, angelegt wie vor der Umstellung: nur
   teilnehmer_id, kein Eintrag in termin_teilnehmer. Er prueft, dass die
   Uebernahme beim Start wirklich gelaufen ist. */
d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, teilnehmer_id, erstellt, erstellt_von)
  VALUES ('Alter Termin von frueher','call',?,30,?,?,?)`)
  .run(heute + "T09:00", idLuna, jetzt, idDogi);
const idAlt = d.prepare("SELECT last_insert_rowid() AS id").get().id;
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 }) });
  const keks = (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
  if (!keks) throw new Error(`Anmeldung ${rolle} fehlgeschlagen (${a.status})`);
  return keks;
}
const K = {
  dogi: await anmelden("admin", "CODE-DOGI-0001"),
  pat: await anmelden("scout", "CODE-SCOU-0001"),
  bea: await anmelden("scout", "CODE-SCOU-0002"),
  luna: await anmelden("creator", "CODE-CREA-0001"),
  nora: await anmelden("creator", "CODE-CREA-0002"),
};

const ruf = async (art, pfad, rumpf, keks) => {
  const a = await fetch(BASIS + pfad, {
    method: art,
    headers: { "Content-Type": "application/json", cookie: keks, origin: BASIS },
    body: rumpf === undefined ? undefined : JSON.stringify(rumpf),
  });
  let text = ""; try { text = await a.text(); } catch { /* egal */ }
  let daten = null; try { daten = JSON.parse(text); } catch { /* kein JSON */ }
  return { status: a.status, text, daten };
};

/** Sieht diese Person den Termin mit dieser Nummer? */
async function siehtTermin(keks, id) {
  const a = await ruf("GET", "/workspace/api/termine?tage=30", undefined, keks);
  if (a.status !== 200) return false;
  return (a.daten?.termine || []).some((t) => t.id === id);
}

/* =======================================================================
   1. Die Uebernahme alter Termine
   ======================================================================= */
console.log("\n=== Alte Termine behalten ihren Teilnehmer ===");
{
  const a = await ruf("GET", "/workspace/api/termine?tage=30", undefined, K.dogi);
  const alt = (a.daten?.termine || []).find((t) => t.id === idAlt);
  ok(!!alt, "der alte Termin ist da");
  ok(Array.isArray(alt?.teilnehmer) && alt.teilnehmer.some((p) => p.id === idLuna),
    `sein Teilnehmer wurde uebernommen (${(alt?.teilnehmer || []).map((p) => p.name).join(", ") || "LEER"})`);
  ok(await siehtTermin(K.luna, idAlt), "und Luna sieht ihn weiterhin");
}

/* =======================================================================
   2. Zwei Teilnehmer anlegen
   ======================================================================= */
console.log("\n=== Ein Call mit zwei Leuten ===");
let idCall = 0;
{
  const a = await ruf("POST", "/workspace/api/termine", {
    titel: "Call zu dritt", art: "call", beginn: heute + "T14:00",
    teilnehmer_id: idLuna, teilnehmer: [idLuna, idPat],
  }, K.dogi);
  ok(a.status === 201, `angelegt (${a.status})`);
  idCall = a.daten?.id || 0;
  ok(idCall > 0, `hat eine Nummer bekommen (#${idCall})`);
  ok((a.daten?.teilnehmer || []).length === 2,
    `zwei Teilnehmer gespeichert (${(a.daten?.teilnehmer || []).length})`);

  const b = await ruf("GET", "/workspace/api/termine?tage=30", undefined, K.dogi);
  const t = (b.daten?.termine || []).find((x) => x.id === idCall);
  ok((t?.teilnehmer || []).length === 2,
    `und sie kommen zurueck: ${(t?.teilnehmer || []).map((p) => p.name).join(", ") || "LEER"}`);
}

/* =======================================================================
   3. BEIDE sehen den Termin — das ist der Kern
   ======================================================================= */
console.log("\n=== Beide Eingetragenen sehen ihn ===");
ok(await siehtTermin(K.luna, idCall), "Luna sieht den Call (Haupt-Gegenueber)");
ok(await siehtTermin(K.pat, idCall), "Pat sieht den Call (zweiter Teilnehmer)");
ok(await siehtTermin(K.dogi, idCall), "DogFather sieht ihn ohnehin");

/* =======================================================================
   4. Und die anderen NICHT
   ======================================================================= */
console.log("\n=== Wer nicht dabei ist, sieht ihn nicht ===");
ok(!(await siehtTermin(K.nora, idCall)), "Nora (fremde Creatorin) sieht ihn nicht");
ok(!(await siehtTermin(K.bea, idCall)), "Bea (fremde Scoutin) sieht ihn nicht");

/* =======================================================================
   5. Niemand traegt sich selbst in fremde Termine ein
   ======================================================================= */
console.log("\n=== Kein Eintragen in fremde Termine ===");
{
  /* Nora versucht, sich in den Call einzutragen. Sie sieht ihn nicht --
     also muss schon das Aendern scheitern (404, nicht 403: Was man
     nicht sehen darf, existiert fuer einen nicht). */
  const a = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
    { teilnehmer: [idNora] }, K.nora);
  ok(a.status === 404, `Nora aendert den fremden Call -> ${a.status} (erwartet 404)`);
  ok(!(await siehtTermin(K.nora, idCall)), "und sie sieht ihn danach immer noch nicht");

  /* Pat SIEHT den Call (er ist Teilnehmer). Aendert er die Liste,
     darf das nichts bewirken -- Zuordnungen verschiebt nur die
     Leitung. */
  const b = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
    { teilnehmer: [idPat, idNora] }, K.pat);
  ok(b.status < 500, `Pat aendert die Liste -> ${b.status} (kein Serverfehler)`);
  ok(!(await siehtTermin(K.nora, idCall)),
    "Nora ist dadurch NICHT hineingekommen — ein Scout verschiebt keine Zuordnungen");
}

/* =======================================================================
   6. Aendern: jemanden hinzufuegen und wieder entfernen
   ======================================================================= */
console.log("\n=== Hinzufuegen und Entfernen ===");
{
  const a = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
    { teilnehmer: [idLuna, idPat, idBea] }, K.dogi);
  ok(a.status === 200, `dritte Person hinzugefuegt (${a.status})`);
  ok(await siehtTermin(K.bea, idCall), "Bea sieht den Call jetzt");

  const b = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
    { teilnehmer: [idLuna] }, K.dogi);
  ok(b.status === 200, `wieder entfernt (${b.status})`);
  ok(!(await siehtTermin(K.bea, idCall)), "Bea sieht ihn nicht mehr");
  ok(await siehtTermin(K.luna, idCall), "Luna weiterhin schon");

  /* Das Haupt-Gegenueber bleibt drin, auch wenn die Liste es nicht
     nennt -- sonst verlöre der Termin seinen eigentlichen Partner. */
  const c = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
    { teilnehmer: [] }, K.dogi);
  ok(c.status === 200, `leere Liste geschickt (${c.status})`);
  ok(await siehtTermin(K.luna, idCall),
    "das Haupt-Gegenueber bleibt trotzdem eingetragen");
}

/* =======================================================================
   7. Serien vererben ihre Teilnehmer
   ======================================================================= */
console.log("\n=== Wiederkehrende Termine ===");
{
  const a = await ruf("POST", "/workspace/api/serien", {
    titel: "Woechentlicher Team-Call", art: "call", takt: "woechentlich",
    start_tag: heute, uhrzeit: "11:00", dauer_min: 30,
    teilnehmer_id: idLuna, teilnehmer: [idLuna, idPat],
  }, K.dogi);
  ok(a.status === 201, `Serie angelegt (${a.status})`);
  ok((a.daten?.angelegt || 0) > 1, `${a.daten?.angelegt} Termine erzeugt`);

  const b = await ruf("GET", "/workspace/api/termine?tage=60", undefined, K.dogi);
  const ausSerie = (b.daten?.termine || []).filter((t) => t.titel === "Woechentlicher Team-Call");
  ok(ausSerie.length > 1, `${ausSerie.length} davon stehen im Kalender`);
  const alleMitBeiden = ausSerie.every((t) =>
    (t.teilnehmer || []).some((p) => p.id === idLuna)
    && (t.teilnehmer || []).some((p) => p.id === idPat));
  ok(alleMitBeiden, "JEDE Auspraegung hat beide Teilnehmer geerbt");

  const c = await ruf("GET", "/workspace/api/termine?tage=60", undefined, K.pat);
  const patSieht = (c.daten?.termine || []).filter((t) => t.titel === "Woechentlicher Team-Call");
  ok(patSieht.length === ausSerie.length,
    `Pat sieht alle ${patSieht.length} von ${ausSerie.length} — nicht nur den ersten`);
}

/* =======================================================================
   8. Unsinn in der Liste
   ======================================================================= */
console.log("\n=== Unsinn in der Teilnehmerliste ===");
{
  for (const [wie, wert] of [
    ["Text statt Nummern", ["abc", "xyz"]],
    ["negative Nummer", [-1]],
    ["null", [null]],
    ["gar keine Liste", "keine Liste"],
    ["riesige Liste", Array.from({ length: 500 }, (_, i) => i + 1)],
    ["doppelte Eintraege", [idLuna, idLuna, idLuna]],
    ["Person, die es nicht gibt", [999999]],
  ]) {
    const a = await ruf("PATCH", `/workspace/api/termine/${idCall}`,
      { teilnehmer: wert }, K.dogi);
    ok(a.status < 500, `${wie} -> ${a.status} (kein Serverfehler)`);
  }
  ok(await siehtTermin(K.luna, idCall),
    "nach all dem ist das Haupt-Gegenueber immer noch eingetragen");
}

/* =======================================================================
   GEGENPROBE — kann diese Pruefung "nicht sichtbar" erkennen?
   ======================================================================= */
console.log("\n=== Gegenprobe ===");
{
  /* SEIT DEM 07.09.2026 IST EIN TERMIN OHNE TEILNEHMER DER ÖFFENTLICHE
     FALL, nicht der geheime (siehe termineSichtbar in workspace.js):
     "Wer niemanden einträgt, meint alle." Hier stand deshalb vorher
     das Gegenteil — ein teilnehmerloser Termin, von dem erwartet
     wurde, dass Luna ihn NICHT sieht.

     Für eine Gegenprobe braucht es aber weiterhin einen Termin, den
     sie wirklich nicht sehen darf. Das ist jetzt der Termin MIT einem
     anderen Gegenüber: eine Verabredung zwischen zwei anderen. */
  const a = await ruf("POST", "/workspace/api/termine", {
    titel: "Verabredung ohne Luna", art: "termin", beginn: heute + "T20:00",
    teilnehmer: [idBea],
  }, K.dogi);
  const geheim = a.daten?.id;
  ok(geheim > 0, `ein Termin mit Bea, ohne Luna, angelegt (#${geheim})`);
  ok(await siehtTermin(K.dogi, geheim), "DogFather sieht ihn — er hat ihn angelegt");
  ok(!(await siehtTermin(K.luna, geheim)),
    "Luna sieht ihn NICHT — die Messung erkennt also 'nicht sichtbar'");

  const b = await ruf("PATCH", `/workspace/api/termine/${geheim}`,
    { teilnehmer: [idBea, idLuna] }, K.dogi);
  ok(b.status === 200, `Luna dazugenommen (${b.status})`);
  ok(await siehtTermin(K.luna, geheim),
    "jetzt sieht sie ihn — die Messung erkennt auch 'sichtbar'");

  /* UND DER FALL, DER SICH AM SELBEN TAG NOCH EINMAL GEDREHT HAT:
     Ein Termin OHNE Teilnehmer ist nicht „für alle", sondern privat.
     Hier stand zwischenzeitlich das Gegenteil -- Filipe hat an seinem
     „Manager Meeting" in Cigdems Kalender gezeigt, warum das falsch
     war. Die Teilnehmerliste ist jetzt die einzige Art, jemanden zu
     beteiligen; deshalb gehört genau dieser Fall hierher. */
  const c = await ruf("POST", "/workspace/api/termine", {
    titel: "Nur fuer mich", art: "termin", beginn: heute + "T21:30",
  }, K.dogi);
  ok(!(await siehtTermin(K.luna, c.daten?.id)),
    "einen Termin ganz ohne Teilnehmer sieht nur, wer ihn angelegt hat");

  /* ================================================================
     AENDERN DARF NUR, WER IHN EINGETRAGEN HAT (07.09.2026)

     Filipe: "jeder der in seinem kalender was eintraegt soll es auch
     bearbeiten koennen, nur diese person selber."

     Der Prueffall ist ein Termin MIT einem zweiten Teilnehmer: Der
     sieht ihn, darf ihn aber nicht umschreiben. Vorher durfte jeder
     aendern, der ihn ueberhaupt sah -- bei einem Termin mit mehreren
     Beteiligten also alle.
     ================================================================ */
  const meiner = await ruf("POST", "/workspace/api/termine", {
    titel: "Lunas eigener Termin", art: "termin", beginn: heute + "T09:15",
    /* PAT, nicht Bea. Luna darf nur einladen, wer zu ihr gehoert -- Bea
       betreut Nora. Mein erster Aufbau nahm Bea, und die Pruefung
       meldete brav 404 statt 403: Bea sah den Termin gar nicht. Der
       Fehler lag im Aufbau, nicht im Code -- und die Pruefung hat
       genau das richtig gemeldet. */
    teilnehmer: [idPat],
  }, K.luna);
  ok(meiner.status === 201, `Luna legt einen Termin an (${meiner.status})`);

  const selbst = await ruf("PATCH", `/workspace/api/termine/${meiner.daten?.id}`,
    { titel: "Lunas Termin, umbenannt" }, K.luna);
  ok(selbst.status === 200, `sie selbst darf ihn umbenennen (${selbst.status})`);

  ok(await siehtTermin(K.pat, meiner.daten?.id), "Pat sieht ihn (er ist eingetragen)");
  const fremd = await ruf("PATCH", `/workspace/api/termine/${meiner.daten?.id}`,
    { titel: "von Pat umbenannt" }, K.pat);
  ok(fremd.status === 403,
    `darf ihn aber nicht umbenennen (${fremd.status})`);

  /* Und die Ausnahme, die es dabei geben MUSS: Ein Haken "erledigt"
     ist eine Rueckmeldung zum Termin, keine Aenderung an ihm. Ohne
     diese Zeile muesste jeder Beteiligte den Anleger bitten, den
     eigenen Call abzuhaken. */
  const haken = await ruf("PATCH", `/workspace/api/termine/${meiner.daten?.id}`,
    { erledigt: true }, K.pat);
  ok(haken.status === 200, `abhaken darf sie aber (${haken.status})`);
  ok(await siehtTermin(K.dogi, c.daten?.id),
    "  – der nämlich schon, sonst wäre die Zeile darüber wertlos");
}

console.log(`\n${fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`}`);
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
process.exit(fehler ? 1 : 0);