screen10: Der Tagesruf -- einmal am Tag, was noch offen ist
Wunsch Filipe: "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."
Ein Wecker-Knopf unter der Glocke, neben der Uhr. Eingeschaltet meldet
er sich einmal taeglich zur eingestellten Zeit -- aber nur, wenn
wirklich noch etwas offen ist. Der Satz nennt die Zahl und die
Ueberfaelligen: "3 Aufgaben sind noch offen / Davon eine ueberfaellig."
ALS EINZIGE ART MIT `vorgabe: false`, und das ist keine
Nachlaessigkeit. Alle anderen Benachrichtigungen antworten auf ein
Ereignis, das gerade passiert ist. Der Tagesruf kommt ungefragt zur
selben Zeit, ob es etwas Neues gibt oder nicht -- so etwas schaltet man
sich selbst ein, sonst ist es Werbung. Bei null offenen Aufgaben kommt
nichts: Eine taegliche Meldung "du hast nichts zu tun" ist der
schnellste Weg, dass man die naechste nicht mehr liest.
EIN FENSTER VON DREI STUNDEN. Der Takt laeuft alle fuenf Minuten; ein
einfaches "jetzt >= eingestellte Zeit" wuerde nach einem Serverausfall
den Ruf fuer neun Uhr um zwanzig Uhr zustellen. Wer eine Erinnerung an
einen vergangenen Tag bekommt, schaltet sie ab. Faellt der Tag aus, ist
das die ehrlichere Antwort.
VIER DINGE, DIE ERST DAS NACHMESSEN GEZEIGT HAT:
1. DER KNOPF VERSPRACH ETWAS, DAS ER NICHT HALTEN KONNTE. Chromium
meldet `Notification.permission === 'denied'` -- gemessen, nicht
vermutet. Der Knopf sah einladend aus ("Einmal am Tag melden…") und
sagte erst NACH dem Antippen ab. Ein Bedienelement, das den Grund
erst hinterher nennt, ist die schlechtere Haelfte einer
Fehlermeldung. Jetzt steht er im Titel, und der Knopf ist gedimmt.
2. EINE UHRZEIT IN DER RUHEZEIT WAERE EIN STILLES NICHTS. Der Server
laesst zwischen 22 und 7 Uhr nichts durch. Wer 23:00 einstellt,
bekaeme nie etwas und saehe nur einen Knopf auf "an". Jetzt steht
der Hinweis dort, wo man es einstellt -- mit den Grenzen VOM SERVER,
nicht mit hier getippten Zahlen.
3. `wert` UND `an` SIND ZWEI ENTSCHEIDUNGEN. Wer nur den Schalter
umlegt, schickt kein `wert` -- stumpf `req.body.wert` zu schreiben
haette bei jedem Aus- und Einschalten die Uhrzeit geloescht, und
beim naechsten Mal staende wieder neun Uhr da. Ein Datenverlust, den
niemand meldet, weil er wie eine Vorgabe aussieht. Genau dieser Weg
wird jetzt geprueft.
4. pruef-css-klassen HATTE ZWEIMAL RECHT. Der Stil lag in heim.css
(nur Startseite), die Zeichen entstehen aber in glocke.js (18
Seiten) -- auf 17 davon waere ein nackter Knopf gestanden. Und die
beiden neuen Schriftgroessen (10 und 11 px) haetten die Grundlinie
von 43 zu kleinen Stellen still auf 45 gehoben. Beides behoben:
Stil nach start.css, Schrift auf 12 px.
NEUE PRUEFUNG server/pruef-tagesruf.mjs, drei Schichten getrennt, weil
sie getrennt kaputtgehen: Oberflaeche im Browser, Schalten ueber die
Schnittstelle (aus der SEITE heraus, damit Sitzung und
Herkunftspruefung mitgehen), Zeitentscheidung als reine Rechnung. Die
Entscheidung wurde dafuer aus dem Rundgang herausgeloest -- dazwischen
steckend haette man zum Pruefen Datenbank und Push-Versand aufbauen
muessen, also haette man sie nicht geprueft.
Die Erwartung der ersten Schicht richtet sich nach der GEMESSENEN
Berechtigung statt sie vorauszusetzen: Erlaubt eine kuenftige
Chromium-Fassung Benachrichtigungen von sich aus, waere ein fest
verdrahtetes "muss blockiert sein" ein Fehlalarm ohne Fehler.
Gegenproben sind dabei: "99:99", "7:30" ohne fuehrende Null und ein
Wert an einer Art, die keinen kennt, muessen abgelehnt werden -- sonst
bewiese der Bereichstest nichts.
Der reservierte Platz waechst von 46 auf 104 px, damit der zweite Knopf
die Kachelreihe darunter nicht nach unten schiebt; das Zeitfeld schwebt
statt zu schieben. Beides derselbe Grund wie bei der Glocke: Ein
Sprung ist kein Schoenheitsfehler, sondern der Grund, warum man auf den
falschen Knopf drueckt.
Geprueft: pruef-tagesruf (neu, alles in Ordnung), pruef-push,
pruef-css-klassen, pruef-start-ansicht -- alle in Ordnung.
Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
Claude Opus 5
@@ -0,0 +1,314 @@
|
||||
/* =====================================================================
|
||||
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");
|
||||
process.env.PORT = "4186";
|
||||
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";
|
||||
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:4186";
|
||||
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);
|
||||
+156
-3
@@ -84,6 +84,21 @@ export const ARTEN = [
|
||||
die am haeufigsten kommt, und wer die Liste ueberfliegt, sucht
|
||||
zuerst sie. */
|
||||
{ schluessel: "chat_nachricht", name: "Neue Nachricht im Chat", vorgabe: true },
|
||||
/* DER TAGESRUF (08.09.2026, screen10). Filipe: "eine taetige meldung
|
||||
einmal am tag zu aktivieren wenn noch aufgaben auf sind."
|
||||
|
||||
ALS EINZIGE ART MIT `vorgabe: false`, und das ist keine
|
||||
Nachlaessigkeit: Er ist ausdruecklich etwas zum AKTIVIEREN. Alle
|
||||
anderen Arten antworten auf ein Ereignis, das gerade passiert ist
|
||||
(eine Aufgabe wird faellig, jemand schreibt). Der Tagesruf kommt
|
||||
ungefragt zur selben Zeit, ob es etwas Neues gibt oder nicht --
|
||||
so etwas schaltet man sich selbst ein, sonst ist es Werbung.
|
||||
|
||||
`wertVorgabe` ist die Uhrzeit. Neun Uhr, weil die Ruhezeit bis
|
||||
sieben geht und ein Ruf um 7:01 niemanden erreicht, der um acht
|
||||
aufsteht. */
|
||||
{ schluessel: "tagesruf", name: "Einmal am Tag: was noch offen ist",
|
||||
vorgabe: false, wertVorgabe: "09:00", wertArt: "uhrzeit" },
|
||||
{ schluessel: "test", name: "Probe-Benachrichtigung", vorgabe: true },
|
||||
];
|
||||
const ARTEN_SCHLUESSEL = new Set(ARTEN.map((a) => a.schluessel));
|
||||
@@ -164,6 +179,57 @@ export function willHaben(personId, art) {
|
||||
return ARTEN.find((a) => a.schluessel === art)?.vorgabe ?? true;
|
||||
}
|
||||
|
||||
/** Der eingestellte Wert einer Art -- oder die Vorgabe.
|
||||
*
|
||||
* Dieselbe Bauart wie `willHaben`: Fehlt die Zeile, gilt was in
|
||||
* `ARTEN` steht. Eine Vorgabe in der Datenbank waere eine zweite
|
||||
* Wahrheit, die bei jeder Aenderung vergessen wird.
|
||||
*/
|
||||
export function wertVon(personId, art) {
|
||||
const z = db().prepare(
|
||||
"SELECT wert FROM push_einstellungen WHERE person_id = ? AND art = ?").get(personId, art);
|
||||
const vorgabe = ARTEN.find((a) => a.schluessel === art)?.wertVorgabe ?? null;
|
||||
return z?.wert ?? vorgabe;
|
||||
}
|
||||
|
||||
/** Ist "hh:mm" eine Uhrzeit, die es gibt?
|
||||
*
|
||||
* Geprueft wird der BEREICH, nicht nur die Form: "99:99" passt auf
|
||||
* jedes naive Muster und ist trotzdem keine Uhrzeit. Aus dem Netz
|
||||
* kommt, was jemand schickt -- nicht, was die Oberflaeche anbietet.
|
||||
*/
|
||||
/** Ist der Tagesruf jetzt faellig? -- die Entscheidung allein.
|
||||
*
|
||||
* HERAUSGELOEST, DAMIT SIE PRUEFBAR IST. Im Rundgang steckte sie
|
||||
* zwischen einer Datenbankabfrage und einem Push-Versand; um sie zu
|
||||
* pruefen, haette man beides aufbauen muessen -- also haette man sie
|
||||
* nicht geprueft. Eine Entscheidung, die nur aus Zahlen besteht,
|
||||
* gehoert in eine Funktion, die nur aus Zahlen besteht.
|
||||
*
|
||||
* DAS FENSTER IST DREI STUNDEN BREIT. Der Takt laeuft alle fuenf
|
||||
* Minuten; ein einfaches "jetzt >= eingestellte Zeit" wuerde nach
|
||||
* einem Serverausfall den Ruf fuer neun Uhr um zwanzig Uhr
|
||||
* zustellen -- eine Erinnerung an einen Tag, der vorbei ist. Wer sie
|
||||
* um 21 Uhr bekommt, schaltet sie ab. Faellt der Tag aus, ist das die
|
||||
* ehrlichere Antwort als eine Meldung zur falschen Zeit.
|
||||
*
|
||||
* @param jetztMinuten Minuten seit Mitternacht, Ortszeit.
|
||||
* @param zeit "hh:mm", die eingestellte Uhrzeit.
|
||||
*/
|
||||
export const TAGESRUF_FENSTER = 180;
|
||||
export function tagesrufFaellig(jetztMinuten, zeit) {
|
||||
if (!istUhrzeit(zeit)) return false;
|
||||
const [h, m] = zeit.split(":").map(Number);
|
||||
const seit = jetztMinuten - (h * 60 + m);
|
||||
return seit >= 0 && seit <= TAGESRUF_FENSTER;
|
||||
}
|
||||
|
||||
export function istUhrzeit(t) {
|
||||
if (typeof t !== "string" || !/^\d{2}:\d{2}$/.test(t)) return false;
|
||||
const [h, m] = t.split(":").map(Number);
|
||||
return h >= 0 && h <= 23 && m >= 0 && m <= 59;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------
|
||||
VERSCHICKEN — der einzige Weg nach draussen.
|
||||
|
||||
@@ -266,6 +332,62 @@ export async function laufen() {
|
||||
});
|
||||
}
|
||||
|
||||
/* --- DER TAGESRUF: einmal am Tag, was noch offen ist --------------
|
||||
|
||||
Filipe (screen10): "eine taetige meldung einmal am tag zu
|
||||
aktivieren wenn noch aufgaben auf sind."
|
||||
|
||||
NUR WER IHN EINGESCHALTET HAT. Die Vorgabe ist `false`, also
|
||||
gibt es die Zeile nur, wenn jemand sie angelegt hat -- die
|
||||
Abfrage ist damit zugleich die Teilnehmerliste. Kein Rundgang
|
||||
ueber alle Personen, um dann 95 Prozent wieder wegzuwerfen.
|
||||
|
||||
EIN FENSTER VON DREI STUNDEN, und das ist der eigentliche
|
||||
Gedanke hier. Der Takt laeuft alle fuenf Minuten; ein einfaches
|
||||
"jetzt >= eingestellte Zeit" wuerde nach einem Serverausfall
|
||||
den Ruf fuer neun Uhr um zwanzig Uhr zustellen -- eine
|
||||
Erinnerung an einen Tag, der vorbei ist. Wer sie um 21 Uhr
|
||||
bekommt, schaltet sie ab. Also: bis drei Stunden danach ja,
|
||||
spaeter nicht mehr. Der Tag faellt dann aus, und das ist die
|
||||
ehrlichere Antwort als eine Meldung zur falschen Zeit.
|
||||
|
||||
Die Ruhezeit prueft `benachrichtige` selbst. Wer sechs Uhr
|
||||
einstellt, bekommt den Ruf um sieben (Ruhezeit bis 7) -- immer
|
||||
noch im Fenster.
|
||||
|
||||
"WENN NOCH AUFGABEN AUF SIND" heisst: bei null Aufgaben kommt
|
||||
nichts. Eine taegliche Meldung "du hast nichts zu tun" ist
|
||||
genau die Sorte Nachricht, die dazu fuehrt, dass man die
|
||||
naechste nicht mehr liest. */
|
||||
const n = new Date();
|
||||
const jetztMinuten = n.getHours() * 60 + n.getMinutes();
|
||||
for (const e of d.prepare(
|
||||
"SELECT person_id, wert FROM push_einstellungen WHERE art = 'tagesruf' AND an = 1").all()) {
|
||||
const zeit = e.wert || ARTEN.find((a) => a.schluessel === "tagesruf")?.wertVorgabe || "09:00";
|
||||
if (!tagesrufFaellig(jetztMinuten, zeit)) continue;
|
||||
|
||||
const z = d.prepare(`
|
||||
SELECT COUNT(*) AS offen,
|
||||
SUM(CASE WHEN frist IS NOT NULL AND frist < ? THEN 1 ELSE 0 END) AS spaet
|
||||
FROM aufgaben
|
||||
WHERE verantwortlich_id = ? AND status NOT IN ('erledigt', 'abgebrochen')`)
|
||||
.get(heute, e.person_id);
|
||||
if (!z || !z.offen) continue;
|
||||
|
||||
/* Der Satz nennt die Zahl und, wenn es sie gibt, die
|
||||
Ueberfaelligen -- das ist die Information, wegen der man
|
||||
hinsieht. "Du hast offene Aufgaben" allein zwingt zum
|
||||
Nachschauen und hilft niemandem. */
|
||||
const spaet = z.spaet || 0;
|
||||
await senden(e.person_id, "tagesruf", {
|
||||
titel: z.offen === 1 ? "Eine Aufgabe ist noch offen" : `${z.offen} Aufgaben sind noch offen`,
|
||||
text: spaet ? (spaet === 1 ? "Davon eine überfällig." : `Davon ${spaet} überfällig.`)
|
||||
: "Nichts davon ist überfällig.",
|
||||
ziel: "/workspace/aufgaben.html",
|
||||
merkmal: `tagesruf:${heute}`,
|
||||
});
|
||||
}
|
||||
|
||||
/* --- Termine in der naechsten Stunde ------------------------------ */
|
||||
const gleich = new Date(Date.now() + 60 * 60_000);
|
||||
const p = (n) => String(n).padStart(2, "0");
|
||||
@@ -443,6 +565,10 @@ pushRouter.get("/workspace/api/push/stand", (req, res) => {
|
||||
WHERE person_id = ? ORDER BY erstellt`).all(req.person.id);
|
||||
const arten = ARTEN.map((a) => ({
|
||||
...a, an: willHaben(req.person.id, a.schluessel),
|
||||
/* Nur dort, wo die Art ueberhaupt einen Wert kennt -- sonst
|
||||
staende bei sieben Arten ein `wert: null` in der Antwort und
|
||||
jemand baut irgendwann ein Eingabefeld dafuer. */
|
||||
...(a.wertArt ? { wert: wertVon(req.person.id, a.schluessel) } : {}),
|
||||
}));
|
||||
res.json({
|
||||
/* Nur die Anzahl und ein Kuerzel nach aussen -- der volle
|
||||
@@ -518,9 +644,36 @@ pushRouter.put("/workspace/api/push/art", gleicheHerkunft, express.json({ limit:
|
||||
const art = String(req.body?.art || "");
|
||||
if (!ARTEN_SCHLUESSEL.has(art)) return res.status(400).json({ fehler: "Diese Art gibt es nicht." });
|
||||
const an = req.body?.an ? 1 : 0;
|
||||
db().prepare(`INSERT INTO push_einstellungen (person_id, art, an) VALUES (?,?,?)
|
||||
ON CONFLICT(person_id, art) DO UPDATE SET an = excluded.an`).run(req.person.id, art, an);
|
||||
res.json({ ok: true, art, an: !!an });
|
||||
|
||||
/* DER WERT WIRD NUR ANGEFASST, WENN EINER MITKAM.
|
||||
|
||||
`undefined` und `null` sind hier zweierlei: Wer nur den Schalter
|
||||
umlegt, schickt kein `wert` -- die eingestellte Uhrzeit muss
|
||||
dann stehen bleiben. Wuerde ich hier stumpf `req.body.wert`
|
||||
schreiben, loeschte jedes Ein- und Ausschalten die Uhrzeit, und
|
||||
beim naechsten Einschalten staende wieder neun Uhr da. Ein
|
||||
stiller Datenverlust, den niemand meldet, weil er wie eine
|
||||
Vorgabe aussieht. */
|
||||
const definiert = Object.prototype.hasOwnProperty.call(req.body || {}, "wert");
|
||||
let wert = null;
|
||||
if (definiert) {
|
||||
const kennt = ARTEN.find((a) => a.schluessel === art)?.wertArt;
|
||||
if (!kennt) return res.status(400).json({ fehler: "Diese Art hat keinen Wert." });
|
||||
wert = req.body.wert;
|
||||
if (kennt === "uhrzeit" && !istUhrzeit(wert)) {
|
||||
return res.status(400).json({ fehler: "Das ist keine Uhrzeit (hh:mm)." });
|
||||
}
|
||||
}
|
||||
|
||||
if (definiert) {
|
||||
db().prepare(`INSERT INTO push_einstellungen (person_id, art, an, wert) VALUES (?,?,?,?)
|
||||
ON CONFLICT(person_id, art) DO UPDATE SET an = excluded.an, wert = excluded.wert`)
|
||||
.run(req.person.id, art, an, wert);
|
||||
} else {
|
||||
db().prepare(`INSERT INTO push_einstellungen (person_id, art, an) VALUES (?,?,?)
|
||||
ON CONFLICT(person_id, art) DO UPDATE SET an = excluded.an`).run(req.person.id, art, an);
|
||||
}
|
||||
res.json({ ok: true, art, an: !!an, wert: wertVon(req.person.id, art) });
|
||||
} catch (fehler) {
|
||||
console.error("[push] Art:", fehler?.message);
|
||||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||||
|
||||
@@ -357,6 +357,25 @@ function umstellungen(d) {
|
||||
["eintraege", "event_ende", "TEXT"],
|
||||
["eintraege", "event_aufgaben", "TEXT"],
|
||||
["eintraege", "event_regeln", "TEXT"],
|
||||
|
||||
/* DER TAGESRUF BRAUCHT MEHR ALS AN/AUS (08.09.2026, screen10).
|
||||
|
||||
Filipe: "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."
|
||||
|
||||
Eine Uhrzeit ist kein Schalter. Statt einer eigenen Tabelle fuer
|
||||
eine einzige Zahl bekommt `push_einstellungen` eine allgemeine
|
||||
Spalte `wert`: Wo eine Art mehr braucht als an/aus, steht es
|
||||
dort. Die vorhandenen Arten lassen sie leer und merken nichts
|
||||
davon.
|
||||
|
||||
KEIN `NOT NULL`, KEINE VORGABE IN DER DATENBANK: Die Vorgabe
|
||||
gehoert nach workspace-push.js zu den Arten, sonst stuende sie an
|
||||
zwei Stellen -- und die in der Datenbank wuerde bei einer
|
||||
Aenderung vergessen. Genau diese Sorte Doppelung hat mich heute
|
||||
schon dreimal aufgehalten. */
|
||||
["push_einstellungen", "wert", "TEXT"],
|
||||
]) {
|
||||
try {
|
||||
const vorhanden = d.prepare(`PRAGMA table_info(${tabelle})`).all().map((s) => s.name);
|
||||
|
||||
Reference in New Issue
Block a user