dogfather-universe/server/pruef-terminregel.mjs

/* =====================================================================
   ZWEI WEGE, EINE ANTWORT (17.09.2026)

   „Wann hat ein Zettel einen Termin?" wird an zwei Stellen gefragt:

     Der KALENDER fragt „welche gehoeren hinein?" -- als SQL, ueber die
     ganze Tabelle auf einmal.
     Die BRETTKARTE fragt „stehe ICH drin?" -- als JavaScript, je Zeile.

   Beide muessen dasselbe antworten. Tun sie es nicht, behauptet die
   Karte „steht im Kalender" und der Kalender zeigt nichts -- oder
   umgekehrt. Eine Anzeige, die etwas Falsches sagt, ist schlimmer als
   gar keine: Man glaubt ihr ja.

   Dass zwei Fassungen derselben Regel auseinanderlaufen, ist im Haus
   keine Theorie. Es ist dreimal passiert:
     11.09. eine abgeschriebene Spaltenliste warf drei Spalten samt
            Inhalt weg -- ohne Fehlermeldung, bei gleicher Zeilenzahl
     im Kalender eine zweite Artenliste neben ARTNAME -- ein BigMatch
            liess sich anlegen und war danach unsichtbar
     17.09. `.teilen` fuer zwei verschiedene Dinge

   Deshalb stehen beide Fassungen in EINER Datei (workspace-termin-
   regel.js), und deshalb prueft diese Datei sie GEGENEINANDER -- nicht
   jede fuer sich. Zwei Pruefungen, die je eine Seite bestaetigen,
   finden genau diesen Fehler nicht.

   Aufrufen mit:  node server/pruef-terminregel.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";
import { tagLokal } from "./helfer-tag.mjs";

const PORT = await eigenerPort(import.meta, "pruef-terminregel");
const ordner = mkdtempSync(join(tmpdir(), "ws-terminregel-"));
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-terminregel");
await new Promise((r) => setTimeout(r, 800));

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

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

const HEUTE = tagLokal(0);
const MORGEN = tagLokal(1);
const IN5 = tagLokal(5);
const GESTERN = tagLokal(-1);

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
const regel = await import("./workspace-termin-regel.js");

/* =======================================================================
   DIE FAELLE

   Jede Zeile beantwortet EINE Frage, und die Haelfte davon ist die
   Frage, ob etwas ZU RECHT wegbleibt. Eine Pruefung nur mit Treffern
   koennte auch dann gruen sein, wenn die Regel alles hereinlaesst.
   ======================================================================= */
const FAELLE = [
  // [name,           bereich,   datum,   uhrzeit, geplant, ende,  status,      soll]
  ["Zusage",          "wunsch",  HEUTE,   null,    IN5,     null,  "angenommen", true],
  ["Zukunft",         "content", IN5,     null,    null,    null,  "offen",      true],
  ["Mit Uhrzeit",     "live",    MORGEN,  "20:00", null,    null,  "offen",      true],
  ["Zeitraum",        "agentur", MORGEN,  null,    null,    IN5,   "offen",      true],
  ["Uhrzeit heute",   "live",    HEUTE,   "21:00", null,    null,  "offen",      true],
  ["Nur heute",       "ideen",   HEUTE,   null,    null,    null,  "offen",      false],
  ["Von gestern",     "ideen",   GESTERN, null,    null,    null,  "offen",      false],
  ["Erledigt",        "content", IN5,     null,    null,    null,  "erledigt",   false],
  ["Abgelehnt",       "wunsch",  HEUTE,   null,    IN5,     null,  "abgelehnt",  false],
];

{
  const d = new DatabaseSync(process.env.WORKSPACE_DB);
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync("CODE-DOGI-0001", 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("Filipe", "admin", hash, salt, 32768, new Date().toISOString());
  for (const [name, bereich, datum, uhrzeit, geplant, ende, status] of FAELLE) {
    d.prepare(`INSERT INTO eintraege (bereich, art, titel, text, datum, uhrzeit, geplant,
               event_ende, status, dringlichkeit, erstellt, erstellt_von)
               VALUES (?,?,?,?,?,?,?,?,?,'mittel',?,1)`)
      .run(bereich, "sonstiges", name, "Text", datum, uhrzeit, geplant, ende,
        status, new Date().toISOString());
  }
  d.close();
}

function roh(pfad, kopf = {}) {
  return new Promise((fertig, schief) => {
    const a = httpAnfrage({
      host: "127.0.0.1", port: PORT, path: pfad, method: "GET",
      headers: { Host: "workspace.dogfather-universe.com", ...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);
    a.end();
  });
}
function post(pfad, koerper) {
  return new Promise((fertig, schief) => {
    const a = httpAnfrage({
      host: "127.0.0.1", port: PORT, path: pfad, method: "POST",
      headers: { Host: "workspace.dogfather-universe.com", "Content-Type": "application/json" },
    }, (antwort) => {
      let text = "";
      antwort.on("data", (s) => { text += s; });
      antwort.on("end", () => fertig({ code: antwort.statusCode, text, kopf: antwort.headers }));
    });
    a.on("error", schief);
    a.write(JSON.stringify(koerper));
    a.end();
  });
}
const json = (a) => { try { return JSON.parse(a.text); } catch { return {}; } };

const an = await post("/workspace/api/anmelden", { rolle: "admin", code: "CODE-DOGI-0001" });
const keks = [].concat(an.kopf?.["set-cookie"] || []).map((c) => c.split(";")[0]).join("; ");

/* =======================================================================
   1. DIE JS-FASSUNG FUER SICH
   ======================================================================= */
melde("=== 1. terminVon() ===");
for (const [name, , datum, uhrzeit, geplant, ende, status, soll] of FAELLE) {
  const r = regel.terminVon({ datum, uhrzeit, geplant, event_ende: ende, status }, HEUTE);
  ok(!!r === soll, `${name.padEnd(14)} -> ${r ? `${r.grund} am ${r.tag}` : "kein Termin"}`);
}
{
  /* Die Rangfolge: Eine Zusage schlaegt alles andere. Wer „am 24."
     sagt, meint den 24. -- auch wenn der Zettel am 3. entstand und
     eine Uhrzeit traegt. */
  const r = regel.terminVon(
    { datum: HEUTE, uhrzeit: "20:00", geplant: IN5, event_ende: null, status: "offen" }, HEUTE);
  ok(r?.grund === "zugesagt" && r?.tag === IN5,
    `die Zusage schlaegt Uhrzeit und Erfassungstag (${r?.grund} am ${r?.tag})`);
}

/* =======================================================================
   2. DER KALENDER (SQL) UND DIE KARTE (JS) SAGEN DASSELBE

   Das ist der eigentliche Zweck dieser Datei.
   ======================================================================= */
melde("");
melde("=== 2. Beide Wege, verglichen ===");

const kal = json(await roh("/workspace/api/termine?tage=60", { cookie: keks }));
const imKalender = new Set((kal.brettsachen || []).map((b) => b.titel));
ok(imKalender.size > 0, `der Kalender liefert ${imKalender.size} Zettel`);

const bereiche = [...new Set(FAELLE.map((f) => f[1]))];
const mitMarke = new Set();
const tagLaut = new Map();
for (const b of bereiche) {
  const r = json(await roh(`/workspace/api/bereich/${b}`, { cookie: keks }));
  for (const e of r.eintraege || []) {
    if (e.termin) { mitMarke.add(e.titel); tagLaut.set(e.titel, e.termin.tag); }
  }
}
ok(mitMarke.size > 0, `die Bretter melden ${mitMarke.size} Zettel mit Termin`);

{
  const nurKalender = [...imKalender].filter((x) => !mitMarke.has(x));
  const nurKarte = [...mitMarke].filter((x) => !imKalender.has(x));
  ok(nurKalender.length === 0,
    nurKalender.length ? `steht im Kalender, aber die Karte sagt nichts: ${nurKalender.join(", ")}`
      : "kein Zettel steht im Kalender, ohne dass seine Karte es sagt");
  ok(nurKarte.length === 0,
    nurKarte.length ? `die Karte behauptet einen Termin, der Kalender zeigt ihn nicht: ${nurKarte.join(", ")}`
      : "und keine Karte behauptet einen Termin, den der Kalender nicht kennt");
}

/* UND DER TAG MUSS AUCH DERSELBE SEIN. Beide Seiten einig darueber,
   DASS etwas einen Termin hat, und uneinig ueber WANN -- das waere die
   unauffaelligste Art, falsch zu liegen. */
{
  const uneinig = (kal.brettsachen || [])
    .filter((b) => tagLaut.has(b.titel) && tagLaut.get(b.titel) !== b.wann)
    .map((b) => `${b.titel}: Kalender ${b.wann}, Karte ${tagLaut.get(b.titel)}`);
  ok(uneinig.length === 0,
    uneinig.length ? `verschiedene Tage: ${uneinig.join(" | ")}`
      : `beide nennen denselben Tag (${tagLaut.size} verglichen)`);
}

/* =======================================================================
   3. UND GEGEN DIE ERWARTUNG, NICHT NUR GEGENEINANDER

   Zwei Wege koennen sich einig sein und beide falsch liegen. Deshalb
   zusaetzlich gegen die Fallliste oben.
   ======================================================================= */
melde("");
melde("=== 3. Gegen die Erwartung ===");
for (const [name, , , , , , , soll] of FAELLE) {
  ok(imKalender.has(name) === soll,
    soll ? `„${name}" steht im Kalender` : `„${name}" bleibt draussen`);
}

/* =======================================================================
   4. IM BROWSER
   ======================================================================= */
melde("");
melde("=== 4. Was man sieht ===");
{
  let chromium;
  try {
    ({ chromium } = await import(
      "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs"));
  } catch { chromium = null; }

  if (!chromium) {
    unklar("kein Playwright gefunden -- die Oberflaeche wurde nicht angesehen");
  } else {
    const browser = await chromium.launch();
    try {
      const sicht = await browser.newContext({ viewport: { width: 1280, height: 900 } });
      await sicht.addCookies(keks.split("; ").map((c) => {
        const [name, ...rest] = c.split("=");
        return { name, value: rest.join("="), domain: "127.0.0.1", path: "/" };
      }));
      const seite = await sicht.newPage();
      const konsole = [];
      seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
      await seite.goto(`http://127.0.0.1:${PORT}/workspace/bereich.html?b=content`,
        { waitUntil: "domcontentloaded" });
      await seite.waitForTimeout(1600);

      /* SICHTBARKEIT, NICHT VORHANDENSEIN. `textContent` liefert auch,
         was `display: none` ausblendet -- und am Bildschirmfoto fiel
         auf, dass die Marke im Bild fehlte, obwohl die Zaehlung 1
         ergab. Ohne `offsetHeight` waere das nie aufgefallen. */
      const marken = await seite.evaluate(() =>
        [...document.querySelectorAll(".im-kalender")].map((a) => ({
          text: a.textContent.trim(), ziel: a.getAttribute("href"),
          grund: a.dataset.grund,
          sichtbar: a.offsetHeight > 0 && a.offsetWidth > 0,
          wo: a.closest(".eintrag-karte")?.querySelector("h3, .eintrag-titel")?.textContent
            || a.parentElement?.className || "?",
        })));
      ok(marken.length > 0, `auf dem Brett steht ${marken.length}x „im Kalender"`);
      ok(marken.length > 0 && marken.every((m) => m.sichtbar),
        `und man sieht sie auch (${marken.map((m) => `${m.wo}: ${m.sichtbar}`).join(", ")})`);
      ok(marken.every((m) => m.ziel === "kalender.html"),
        "und jede fuehrt in den Kalender");
      /* GEGENPROBE: NICHT an jeder Karte. „Erledigt" und „von gestern"
         liegen auf demselben Brett und duerfen die Marke nicht haben --
         sonst hiesse „steht im Kalender" nur, dass ueberall etwas steht. */
      const karten = await seite.locator(".eintrag-karte").count();
      ok(karten > marken.length,
        `aber nicht an allen (${marken.length} von ${karten} Karten)`);

      /* ---- Der Hinweis unter dem Datumsfeld ---- */
      const hinweis = async () => seite.evaluate(() => ({
        text: document.getElementById("hinweis-datum")?.textContent?.trim() || "",
        marke: document.getElementById("hinweis-datum")?.dataset.imkalender || "",
      }));
      /* Der Knopf heisst `neu-oeffnen`, nicht `neu-auf` -- beim ersten
         Lauf stand hier der falsche Name samt `.catch(() => {})`, und
         der Fehlgriff verschwand lautlos. Ein `.catch`, das einen
         Selektorfehler schluckt, macht aus einer kaputten Pruefung eine
         gruene: Danach stand im Hinweisfeld "" und die Zeile darunter
         war trotzdem in Ordnung, weil "" nun einmal nicht "ja" ist. */
      await seite.click("#neu-oeffnen");
      await seite.waitForTimeout(500);
      const h1 = await hinweis();
      ok(h1.text.length > 5, `beim Oeffnen steht ein Satz da ("${h1.text}")`);
      /* Die Anzahl gehoert in die BEDINGUNG: Ohne `h1.text` waere diese
         Zeile auch bei leerem Feld gruen. */
      ok(h1.text.length > 5 && h1.marke !== "ja",
        "und er sagt NICHT, dass es im Kalender landet -- heute ist heute");

      await seite.fill("#f-datum", IN5);
      await seite.waitForTimeout(300);
      const h2 = await hinweis();
      ok(h2.text.length > 5 && h2.marke === "ja" && /Kalender/.test(h2.text),
        `mit einem Tag in der Zukunft aendert er sich ("${h2.text}")`);

      await seite.fill("#f-datum", HEUTE);
      await seite.waitForTimeout(300);
      const h3 = await hinweis();
      ok(h3.text.length > 5 && h3.marke !== "ja",
        `und zurueck auf heute wieder ("${h3.text}")`);

      /* ---- UND AM HANDY (17.09.2026) ----------------------------------

         Der Hinweis haengt seit heute AUSSERHALB des Feldes (absolut,
         damit er die Eingaben nicht aus der Linie schiebt). Genau das
         kann am schmalen Bildschirm das naechste Feld ueberdecken --
         dort stehen die Felder untereinander, und dann liegt der
         schwebende Satz auf dem, was folgt.

         Gemessen wird die Ueberschneidung, nicht geschaetzt. */
      await seite.setViewportSize({ width: 390, height: 844 });
      await seite.waitForTimeout(500);
      const eng = await seite.evaluate(() => {
        const h = document.getElementById("hinweis-datum");
        if (!h || h.offsetHeight === 0) return { da: false };
        const a2 = h.getBoundingClientRect();
        const treffer = [...document.querySelectorAll(".neu__raster > *")]
          .filter((f) => !f.contains(h))
          .map((f) => f.getBoundingClientRect())
          .filter((b) => a2.left < b.right && b.left < a2.right
            && a2.top < b.bottom && b.top < a2.bottom);
        return { da: true, ueberdeckt: treffer.length, hoehe: Math.round(a2.height) };
      });
      ok(eng.da, "am Handy steht der Hinweis auch da");
      ok(eng.da && eng.ueberdeckt === 0,
        `und liegt auf keinem anderen Feld (${eng.ueberdeckt} Ueberschneidungen)`);
      await seite.setViewportSize({ width: 1280, height: 900 });
      await seite.waitForTimeout(400);

      ok(konsole.length === 0,
        konsole.length ? `Konsolenfehler: ${konsole[0]}` : "kein Konsolenfehler");

      /* EIN AUSSCHNITT DER KARTE, nicht nur die ganze Seite. Auf einem
         Vollbild von 2000 px Hoehe ist eine Pille von 28 px nicht zu
         beurteilen -- ich habe sie beim ersten Hinsehen schlicht
         uebersehen und fuer fehlend gehalten. Ein Bild, auf dem man
         nichts erkennen kann, ist keine Kontrolle. */
      const karteMitMarke = seite.locator(".eintrag-karte").filter(
        { has: seite.locator(".im-kalender") }).first();
      await karteMitMarke.screenshot({ path: "server/pruef-terminregel-marke.png" })
        .catch(() => {});
      await seite.screenshot({ path: "server/pruef-terminregel.png", fullPage: true });
      melde("  --   Bildschirmfoto: server/pruef-terminregel.png");
    } finally {
      await browser.close();
    }
  }
}

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