dogfather-universe/server/pruef-tagesruf.mjs

/* =====================================================================
   PRUEFUNG: Der Tagesruf -- der Wecker fuer offene Aufgaben (screen10)

   Wunsch Filipe (08.09.2026): "ich will das neben diesem kreis auch ein
   kleiner button ist fuer den wecker von den aufgaben, oder quasi eine
   taetige meldung einmal am tag zu aktivieren wenn noch aufgaben auf
   sind."

   DREI SCHICHTEN, GETRENNT GEPRUEFT -- weil sie getrennt kaputtgehen:

     1  DIE OBERFLAECHE, wenn der Browser Benachrichtigungen sperrt.
        Chromium meldet headless `Notification.permission === 'denied'`,
        und `grantPermissions` aendert daran nichts (nachgemessen). Das
        ist kein Hindernis, sondern genau der Fall eines Menschen, der
        einmal "Nicht zulassen" gedrueckt hat -- und der haeufigste
        Grund fuer "das funktioniert nicht".

     2  DAS SCHALTEN ueber die Schnittstelle, aus der SEITE heraus
        aufgerufen: So gehen Sitzung und Herkunftspruefung mit, ohne
        dass hier ein Geheimnis liegt. Geprueft wird vor allem, ob die
        eingestellte Uhrzeit ein Aus- und Einschalten ueberlebt -- der
        Weg, auf dem still Daten verlorengehen.

     3  DIE ZEITENTSCHEIDUNG als reine Rechnung. Sie steckte
        urspruenglich zwischen einer Datenbankabfrage und einem
        Push-Versand; um sie zu pruefen, haette man beides aufbauen
        muessen -- also haette man sie nicht geprueft.

   ZU JEDER SCHICHT GEHOERT EINE GEGENPROBE. Eine Pruefung, die immer
   bestaetigt, bestaetigt nichts: "99:99", "7:30" ohne fuehrende Null
   und ein Wert an einer Art, die keinen kennt, MUESSEN abgelehnt
   werden.
   ===================================================================== */
/* Browserpruefung der Startseite: Gruppen, Zeichen, Farbtoene, Zahlen auf
   den Kacheln -- und was jede Rolle davon zu sehen bekommt. */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-start-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
   Ohne diese Zeile startet der eigene Server bei belegtem Port
   STILL nicht -- und alles Folgende misst gegen einen fremden
   Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
   als kaputt. */
const PORT = await eigenerPort(import.meta, "pruef-tagesruf");
process.env.PORT = `${PORT}`;
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 }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { eigenerPort } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
   zwei Auffangnetze ein, die einen Absturz nur protokollieren --
   richtig fuer den Betrieb, fatal fuer eine Pruefung. Ohne diese
   Zeile bleibt der Prozess nach einem Fehler ewig stehen, weil der
   Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
notbremse(480_000, "pruef-start-ansicht");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 200_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();
const heute = tagText();
const gestern = tagText(new Date(Date.now() - 86400_000));
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 idScout = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idAnna  = anlegen("Tili", "creator", "CODE-ANNA-0001");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idAnna, idScout, jetzt);

/* Arbeit an mehreren Stellen -- damit auf den Kacheln wirklich Zahlen
   stehen und man sieht, ob sie an der richtigen landen. */
for (const [status, frist] of [["offen", gestern], ["offen", gestern], ["offen", heute],
                               ["arbeit", null], ["review", null]]) {
  d.prepare("INSERT INTO aufgaben (titel, status, creator_id, frist, erstellt, erstellt_von) VALUES ('Test',?,?,?,?,?)")
    .run(status, idAnna, frist, jetzt, idDogi);
}
d.prepare("INSERT INTO termine (titel, beginn, creator_id, erledigt, erstellt, erstellt_von) VALUES ('Heute',?,?,0,?,?)")
  .run(heute + "T18:00", idAnna, jetzt, idDogi);
d.prepare("INSERT INTO eintraege (bereich, art, titel, datum, dringlichkeit, status, creator_id, erstellt, erstellt_von) VALUES ('technik','problem','Ton weg',?,'hoch','offen',?,?,?)")
  .run(heute, idAnna, jetzt, idDogi);
d.close();

const { chromium } = await import(
  "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await chromium.launch();

async function anmelden(kontext, rolle, code) {
  const seite = await kontext.newPage();
  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.waitForTimeout(900);
  return seite;
}

const kontext = await browser.newContext({ viewport: { width: 1500, height: 1000 }, deviceScaleFactor: 2 });
/* OHNE DIESE ZEILE PRUEFT DER LAUF DAS FALSCHE. Chromium meldet ohne
   Erlaubnis `Notification.permission === 'denied'`; der Knopf lehnt
   dann korrekt ab, und der Test haette nie den Normalfall gesehen. */
await kontext.grantPermissions(['notifications'], { origin: BASIS });
const seite = await anmelden(kontext, "admin", "CODE-DOGI-0001");
await seite.waitForTimeout(1500);

const lies = () => seite.evaluate(() => {
  const k = document.getElementById('tagesruf');
  const f = document.querySelector('.tagesruf__feld');
  const g = document.getElementById('glocke');
  const platz = document.getElementById('glocke-platz');
  if (!k) return { fehlt: 'tagesruf' };
  const rk = k.getBoundingClientRect(), rp = platz.getBoundingClientRect();
  const rf = f ? f.getBoundingClientRect() : null;
  const kachel = document.querySelector('.willkommen').getBoundingClientRect();
  return {
    an: k.dataset.an, gedrueckt: k.getAttribute('aria-pressed'), aus: k.disabled,
    text: k.querySelector('.tagesruf__text').textContent,
    titel: k.title,
    knopfGroesse: [Math.round(rk.width), Math.round(rk.height)],
    platzGroesse: [Math.round(rp.width), Math.round(rp.height)],
    glockeDa: !!g,
    feldSichtbar: f ? !f.hidden : null,
    feldImBild: rf && rf.width ? (rf.left >= kachel.left && rf.right <= kachel.right
      && rf.top >= kachel.top && rf.bottom <= kachel.bottom) : null,
    feldWert: f ? f.querySelector('input')?.value : null,
    ueberlappt: (() => {
      const u = document.querySelector('.uhr')?.getBoundingClientRect();
      if (!u || !rf || !rf.width) return null;
      return !(rf.right < u.left || rf.left > u.right || rf.bottom < u.top || rf.top > u.bottom);
    })(),
  };
});
seite.on('console', (m) => { if (m.type() === 'warning' || m.type() === 'error') console.log('  [Browser]', m.text()); });
seite.on('dialog', async (d) => { console.log('  [Meldung]', d.message().slice(0, 70)); await d.dismiss(); });
console.log('Lage im Browser:', JSON.stringify(await seite.evaluate(() => ({
  push: 'PushManager' in window, sw: 'serviceWorker' in navigator,
  recht: window.Notification ? Notification.permission : 'keine API',
}))));
const zeige = (n, w) => console.log(`  ${n.padEnd(22)} an=${w.an} text=${w.text} feld=${w.feldSichtbar} wert=${w.feldWert}`);

/* ---- SCHICHT 1: die Oberflaeche, wenn der Browser NEIN sagt --------
   Chromium meldet headless `Notification.permission === 'denied'`, und
   `grantPermissions` aendert daran nichts. Das ist kein Hindernis,
   sondern ein Testfall: Genau so sieht es bei jemandem aus, der
   Benachrichtigungen einmal abgelehnt hat. */
console.log('');
/* DIE ERWARTUNG RICHTET SICH NACH DER LAGE, statt sie vorauszusetzen.

   Heute meldet Chromium headless 'denied'. Erlaubt eine kuenftige
   Fassung Benachrichtigungen von sich aus, waere ein fest verdrahtetes
   "muss blockiert sein" ein Fehlalarm ohne Fehler -- dieselbe Sorte
   Zeitbombe wie eine Pruefung, die ein Datum als "jetzt" annimmt. Also
   erst nachsehen, dann pruefen, was in DIESER Lage richtig ist. */
const recht = await seite.evaluate(() => (window.Notification ? Notification.permission : 'keine'));
console.log(`SCHICHT 1 -- Berechtigung im Browser: ${recht}`);
const g = await lies();
zeige('Grundzustand', g);
let fehl1 = 0;
const pruefe = (gut, satz, sonst) => {
  if (gut) console.log(`  OK  ${satz}`);
  else { fehl1++; console.log(`  FEHL ${sonst}`); }
};
pruefe(g.an === 'nein', 'der Knopf steht am Anfang auf aus (Vorgabe: nicht eingeschaltet)',
  'er steht am Anfang schon auf an');

if (recht === 'denied') {
  pruefe(/blockiert/.test(g.titel), 'der Grund steht VOR dem Klick im Titel',
    `der Titel verspricht etwas, das nicht geht: "${g.titel.slice(0, 60)}"`);
  pruefe(g.feldSichtbar === false, 'kein Zeitfeld, wo ohnehin nichts ankaeme',
    'das Zeitfeld steht offen, obwohl nichts zugestellt wuerde');
  await seite.click('#tagesruf');
  await seite.waitForTimeout(400);
  pruefe((await lies()).an === 'nein', 'ein Klick schaltet nichts ein, was nicht ankaeme',
    'der Klick hat trotz Sperre eingeschaltet');
} else {
  pruefe(!/blockiert|nicht|geht/.test(g.titel), 'der Titel beschreibt, was der Knopf tut',
    `der Titel meldet ein Hindernis, obwohl keins da ist: "${g.titel.slice(0, 60)}"`);
  await seite.click('#tagesruf');
  await seite.waitForTimeout(600);
  const n = await lies();
  pruefe(n.an === 'ja', 'ein Klick schaltet ein', 'der Klick hat nicht eingeschaltet');
  pruefe(n.feldSichtbar === true, 'eingeschaltet erscheint das Zeitfeld',
    'das Zeitfeld bleibt aus, obwohl eingeschaltet');
  await seite.click('#tagesruf');
  await seite.waitForTimeout(600);
  pruefe((await lies()).an === 'nein', 'ein zweiter Klick schaltet wieder aus',
    'der zweite Klick hat nicht ausgeschaltet');
}

/* ---- SCHICHT 2: das Schalten selbst, ueber die Schnittstelle -------
   Aus der SEITE heraus aufgerufen, nicht von node: So gehen Sitzung
   und Herkunftspruefung mit, ohne dass ich ein Geheimnis anfassen
   muss. Geprueft wird der Weg, an dem hier wirklich etwas
   schiefgehen kann -- ob die Uhrzeit ein Aus- und Einschalten
   ueberlebt. */
console.log('');
console.log('SCHICHT 2 -- Schalten und Merken');
const api = (koerper) => seite.evaluate(async (k) => {
  const a = await fetch('/workspace/api/push/art', {
    method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(k) });
  return { code: a.status, ...(await a.json().catch(() => ({}))) };
}, koerper);
const stand = () => seite.evaluate(async () => {
  const a = await fetch('/workspace/api/push/stand');
  const s = await a.json();
  return (s.arten || []).find((x) => x.schluessel === 'tagesruf');
});

console.log('  Vorgabe:', JSON.stringify(await stand()));
console.log('  an + 07:30:', JSON.stringify(await api({ art: 'tagesruf', an: true, wert: '07:30' })));
console.log('  aus (ohne wert):', JSON.stringify(await api({ art: 'tagesruf', an: false })));
const nachAus = await stand();
console.log(nachAus.wert === '07:30'
  ? '  OK  die Uhrzeit hat das Abschalten ueberlebt'
  : `  FEHL die Uhrzeit ist beim Abschalten verlorengegangen (${nachAus.wert})`);
console.log('  wieder an:', JSON.stringify(await api({ art: 'tagesruf', an: true })));
const nachAn = await stand();
console.log(nachAn.wert === '07:30' && nachAn.an
  ? '  OK  beim Einschalten steht wieder 07:30 da'
  : `  FEHL ${JSON.stringify(nachAn)}`);

/* Gegenprobe: Kann die Pruefung ueberhaupt FEHL sagen? Eine ungueltige
   Uhrzeit muss abgelehnt werden -- sonst prueft der Bereichstest
   nichts. */
const falsch = await api({ art: 'tagesruf', an: true, wert: '99:99' });
console.log(falsch.code === 400 ? '  OK  "99:99" wird abgelehnt (400)' : `  FEHL "99:99" ging durch: ${JSON.stringify(falsch)}`);
const falsch2 = await api({ art: 'tagesruf', an: true, wert: '7:30' });
console.log(falsch2.code === 400 ? '  OK  "7:30" ohne fuehrende Null wird abgelehnt' : `  FEHL ${JSON.stringify(falsch2)}`);
const ohneWert = await api({ art: 'aufgabe_faellig', an: true, wert: '08:00' });
console.log(ohneWert.code === 400 ? '  OK  eine Art ohne Wert nimmt keinen an' : `  FEHL ${JSON.stringify(ohneWert)}`);
const unversehrt = await stand();
console.log(unversehrt.wert === '07:30' ? '  OK  nach drei Ablehnungen steht 07:30 unveraendert da' : `  FEHL ${unversehrt.wert}`);

await seite.screenshot({ path: 'ruf.png', clip: await seite.$eval('.willkommen__rechts', (e) => {
  const r = e.getBoundingClientRect();
  return { x: r.x - 40, y: r.y - 20, width: r.width + 60, height: r.height + 40 }; }) });

console.log('');
console.log('SCHICHT 3 -- wann er faellig ist (reine Rechnung)');
const { tagesrufFaellig, TAGESRUF_FENSTER } = await import('./workspace-push.js');
const M = (h, m) => h * 60 + m;
let fehl3 = 0;
for (const [jetzt, zeit, soll, was] of [
  [M(9, 0),   '09:00', true,  'genau zur eingestellten Zeit'],
  [M(9, 4),   '09:00', true,  'vier Minuten spaeter (ein Takt)'],
  [M(12, 0),  '09:00', true,  'genau am Ende des Fensters'],
  [M(12, 1),  '09:00', false, 'eine Minute zu spaet -- der Tag faellt aus'],
  [M(20, 0),  '09:00', false, 'abends fuer morgens -- faellt aus'],
  [M(8, 59),  '09:00', false, 'eine Minute zu frueh'],
  [M(0, 0),   '00:00', true,  'Mitternacht auf Mitternacht'],
  [M(0, 10),  '23:30', false, 'ueber Mitternacht hinweg -- kein Rueckwaertsfenster'],
  [M(9, 0),   '9:00',  false, 'ohne fuehrende Null (Gegenprobe)'],
  [M(9, 0),   '99:99', false, 'keine Uhrzeit (Gegenprobe)'],
  [M(9, 0),   null,    false, 'nichts eingestellt (Gegenprobe)'],
]) {
  const ist = tagesrufFaellig(jetzt, zeit);
  if (ist !== soll) { fehl3++; console.log(`  FEHL ${was}: ${ist} statt ${soll}`); }
  else console.log(`  OK  ${was}`);
}
console.log(`  (Fenster: ${TAGESRUF_FENSTER} Minuten)`);

/* Die Ruhezeit und das Fenster muessen zusammenpassen: Wer eine Zeit
   in der Ruhezeit einstellt, bekommt nie etwas. Der Browser warnt
   davor -- hier wird geprueft, dass es die Warnung ueberhaupt gibt. */
const ruhe = await seite.evaluate(async () => (await (await fetch('/workspace/api/push/stand')).json()).ruhe);
console.log(`  Ruhezeit laut Server: ${ruhe.ab}:00 bis ${ruhe.bis}:00`);
await seite.evaluate(async () => {
  await fetch('/workspace/api/push/art', { method: 'PUT', headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ art: 'tagesruf', an: true, wert: '23:00' }) });
});
await seite.reload({ waitUntil: 'domcontentloaded' });
await seite.waitForTimeout(1400);
const warnt = await seite.evaluate(() => {
  const h = document.querySelector('.tagesruf__warnung');
  return { da: !!h, sichtbar: h ? !h.hidden : false, text: h?.textContent || '' };
});
console.log(warnt.da ? `  --  Warnung vorhanden: "${warnt.text}"`
  : '  --  (Warnung nur sichtbar, wenn Benachrichtigungen erlaubt sind -- hier gesperrt)');

await seite.screenshot({ path: 'ruf.png', clip: await seite.$eval('.willkommen__rechts', (e) => {
  const r = e.getBoundingClientRect();
  return { x: r.x - 40, y: r.y - 20, width: r.width + 60, height: r.height + 40 }; }) });
await browser.close();
console.log('');
const fehl = fehl1 + fehl3;
console.log(fehl === 0 ? 'Alles in Ordnung.' : fehl + ' Pruefung(en) fehlgeschlagen.');

process.exit(fehl === 0 ? 0 : 1);