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]>

server/workspace-push.js

@@ -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" });