Termine, die von allein weiterlaufen -- bis man sie abstellt

Wunsch: "ich will dass ich da im kalender auch sachen machen die jede
woche jeden monat automatisiert immer weiter laufen so wie ich es
auswaehle bis ich es selber deaktiviere. aktiviere diese option fuer
jeden."

Acht Rhythmen (taeglich, werktags, woechentlich, alle zwei Wochen,
monatlich am Datum, am Monatsletzten, am n-ten Wochentag, jaehrlich),
wahlweise mit Enddatum oder ohne Ende. Fuer JEDE Rolle -- Creator und
Scouts legen sie fuer sich selbst an, mit denselben Grenzen wie beim
einzelnen Termin.

WARUM ECHTE TERMINE UND KEINE GERECHNETEN AUSPRAEGUNGEN

Der naheliegende Weg waere gewesen, die Wiederholung nur beim Anzeigen
auszurechnen. Das waere ein stiller Ausfall geworden: ACHT andere Stellen
lesen die Tabelle termine direkt -- Calls, Protokolle, Berichte,
Hinweise/Ampel, Suche, Aufgaben ("naechster Termin"), Uebersicht und die
Startseite. In all diesen Ansichten haette schlicht nichts gestanden, und
aufgefallen waere es erst Monate spaeter. Stattdessen macht ein
Nachfueller aus der Regel echte Zeilen (Horizont 180 Tage) -- jedes andere
Modul sieht sie mit, ohne dass dort eine Zeile geaendert werden musste.
Beim geplanten ICS-Abo gilt dasselbe.

KEIN ZEITGEBER. Der Nachfueller laeuft beim Serverstart, beim Anlegen und
Aendern und beim Oeffnen des Kalenders (dort hoechstens alle fuenf
Minuten). Er ist idempotent. Ein Cron waere eine weitere Sache gewesen,
die stillschweigend ausfallen kann.

WAS BEIM ABSTELLEN PASSIERT: Vergangene Termine und alles, was jemand von
Hand angefasst hat (verschoben, umbenannt, abgehakt), bleibt stehen. Nur
die unberuehrte Zukunft wird aus dem Kalender genommen. Wer einen
einzelnen Tag loescht, streicht nur diesen einen -- der Tag wird als
Ausnahme vermerkt, sonst legte der Nachfueller ihn wieder an.

ZEITUMSTELLUNG: Gerechnet wird auf reinen Datumstexten in UTC-Mittag, die
Uhrzeit wird als Text angehaengt. 18:00 bleibt dadurch 18:00 und wandert
im Oktober nicht auf 17:00.

DIE SICHTBARKEITSREGEL STEHT JETZT NUR NOCH EINMAL (workspace.js,
termineSichtbar) statt zweimal fast gleich. Zwei Fassungen waeren
auseinandergelaufen -- und dann haette eine Wiederholung jemandem etwas
gezeigt, was der einzelne Termin ihm verbirgt.

IN DER OBERFLAECHE beschriften sich die Rhythmen nach dem gewaehlten
Datum ("jeden Dienstag", "jeden Monat am letzten Dienstag") statt
abstrakt ("woechentlich"), inklusive des ehrlichen Hinweises, dass "jeden
31." den Februar auslaesst. Darunter steht der ganze Satz in Worten. Eine
neue Leiste "Laeuft von allein" zeigt alle laufenden Wiederholungen mit
Abstell-Schalter -- was von selbst weiterlaeuft, muss man sehen koennen.

GEPRUEFT: 67 Pruefungen (server/pruef-serien.mjs), darunter von Hand
nachgeschlagene Datumsangaben fuer jeden Takt (der letzte Dienstag im
Dezember 2026 ist der 29., nicht der 22.; der 29. Februar nur in
Schaltjahren) und vier GEGENPROBEN, die beweisen, dass die Pruefungen
auch "nicht in Ordnung" sagen koennen. Die Anzahl der Pruefungen steht in
der Bedingung, nicht nur im Meldetext. Bestehende Pruefungen unveraendert
gruen: Kalender 84, Sicht 48, Startansicht 133, Protokoll 52, Ampel 47,
Handy 50, Aufgabenbrett 44, Sprung 43, Personen-Loeschen 40, Uebersicht
33, Workspace-Seiten 32, Formulare 19, Betreuung 18, Grosscheck 15,
Lesbarkeit 14.

Co-Authored-By: Claude Opus 5 <[email protected]>

server/workspace-kalender.js

@@ -13,8 +13,11 @@
 
 import express from "express";
 import {
-  db, protokolliere, echteIp, sitzungLesen, betreutWo, istLeitung, istDogFather, heuteLokal,
+  db, protokolliere, echteIp, sitzungLesen, istLeitung, termineSichtbar, heuteLokal,
 } from "./workspace.js";
+import {
+  nachfuellenAlle, serienPruefen, serieAnlegen, zuordnungErzwingen,
+} from "./workspace-serien.js";
 
 export const kalenderRouter = express.Router();
 
@@ -43,30 +46,22 @@ function gleicheHerkunft(req, res, next) {
 
 kalenderRouter.use("/workspace/api/termine", angemeldet);
 
-/* Wer sieht welchen Termin? Gleiche Logik wie bei den Aufgaben:
-   Management alles, sonst nur, woran man selbst beteiligt ist. */
-export function sichtbar(person) {
-  /* NUR DogFather sieht alles (01.09.2026). Vorher stand hier
-     istLeitung() -- damit sah auch jeder Manager jeden Creator. Ein
-     Manager faellt jetzt in dieselbe Regel wie ein Scout: nur die
-     Creator, die ihm zugeteilt sind. Ausdruecklicher Wunsch:
-     "NUR DIE ROLLE DOGFATHER SOLL WIRKLICH ALLEINE ALLES SEHEN."
+/* Wer sieht welchen Termin?
 
-     Geaendert wird ausschliesslich, wer was SIEHT. Was ein Manager
-     darf (freigeben, aendern, Personen verwalten), haengt weiterhin an
-     istLeitung und bleibt unveraendert -- sonst haette dieser eine
-     Wunsch stillschweigend seine halben Rechte mitgenommen. */
-  if (istDogFather(person)) return { wo: "1=1", werte: [] };
-  const eigen = "(t.creator_id = ? OR t.teilnehmer_id = ? OR t.erstellt_von = ?)";
-  const werte = [person.id, person.id, person.id];
-  const b = betreutWo(person, "t.creator_id");
-  if (!b) return { wo: eigen, werte };
-  return { wo: `(${eigen} OR ${b.wo})`, werte: [...werte, ...b.werte] };
-}
+   Die Regel selbst steht seit dem 02.09.2026 in workspace.js, weil die
+   Wiederholungen (workspace-serien.js) genau dieselbe brauchen -- nur
+   auf einer anderen Tabelle. Zwei fast gleiche Fassungen wären früher
+   oder später auseinandergelaufen, und dann hätte eine Wiederholung
+   jemandem etwas gezeigt, was der einzelne Termin ihm verbirgt.
+
+   Der Name bleibt hier stehen: workspace-calls.js, -hinweise.js und
+   -suche.js holen ihn von hier. */
+export const sichtbar = (person) => termineSichtbar(person, "t");
 
 const SPALTEN = `
   t.id, t.titel, t.beschreibung, t.art, t.beginn, t.dauer_min, t.ort,
   t.creator_id, t.teilnehmer_id, t.erledigt, t.erstellt, t.erstellt_von,
+  t.serie_id, t.serie_tag,
   pc.name AS creator_name, pt.name AS teilnehmer_name`;
 
 const VERBUND = `
@@ -78,6 +73,11 @@ const VERBUND = `
 
 kalenderRouter.get("/workspace/api/termine", (req, res) => {
   try {
+    /* Wiederkehrende Termine nachlegen, BEVOR gelesen wird -- sonst
+       fehlte im Kalender genau der Termin, für den man ihn öffnet.
+       Der Nachfüller bremst sich selbst (höchstens alle fünf Minuten)
+       und legt nur an, was noch fehlt. */
+    nachfuellenAlle();
     const { wo, werte } = sichtbar(req.sicht || req.person);
 
     /* Zeitraum. Ohne Angabe: ab heute 00:00, 90 Tage nach vorn -- das
@@ -189,6 +189,31 @@ kalenderRouter.post("/workspace/api/termine", gleicheHerkunft, (req, res) => {
       }
     }
 
+    /* Wurde im Formular ein Rhythmus gewählt, entsteht KEIN einzelner
+       Termin, sondern eine Regel -- und aus ihr sofort die Termine des
+       Horizonts, den ersten eingeschlossen. Beides anzulegen wäre der
+       naheliegende Fehler gewesen: Der erste Termin stünde dann doppelt
+       da, einmal von Hand und einmal aus der Serie.
+
+       Der Weg führt bewusst über dieselbe Prüfung und dieselbe
+       Anlege-Funktion wie die eigene Serien-Schnittstelle. Eine zweite,
+       verkürzte Fassung hier hätte irgendwann andere Grenzen gehabt. */
+    const w = req.body?.wiederholung;
+    if (w && w.takt) {
+      const serie = {
+        ...aus,
+        takt: w.takt,
+        start_tag: aus.beginn.slice(0, 10),
+        uhrzeit: aus.beginn.slice(11, 16),
+        ende_tag: w.ende_tag ?? null,
+      };
+      const gepruft = serienPruefen(serie, { neu: true });
+      if (gepruft.fehler.length) return res.status(400).json({ fehler: gepruft.fehler.join(" ") });
+      zuordnungErzwingen(gepruft.aus, req.person);
+      const { id, angelegt } = serieAnlegen(gepruft.aus, req.person);
+      return res.status(201).json({ serie_id: id, angelegt });
+    }
+
     const { lastInsertRowid } = db().prepare(`
       INSERT INTO termine
         (titel, beschreibung, art, beginn, dauer_min, ort, creator_id, teilnehmer_id,
@@ -227,8 +252,14 @@ kalenderRouter.patch("/workspace/api/termine/:id", gleicheHerkunft, (req, res) =
     const felder = Object.keys(aus);
     if (!felder.length) return res.status(400).json({ fehler: "nichts_zu_aendern" });
 
-    db().prepare(`UPDATE termine SET ${felder.map((f) => `${f} = ?`).join(", ")} WHERE id = ?`)
-      .run(...felder.map((f) => aus[f]), id);
+    /* Stammt der Termin aus einer Wiederholung, gilt er ab jetzt als
+       "angefasst". Das entscheidet später zweierlei: Beim Abstellen der
+       Serie bleibt er stehen, und beim Ändern der Regel wird er nicht
+       neu gebaut. Was jemand verschoben, umbenannt oder abgehakt hat,
+       räumt die Automatik ihm nicht weg. */
+    const beruehrt = termin.serie_id ? ", serie_beruehrt = 1" : "";
+    db().prepare(`UPDATE termine SET ${felder.map((f) => `${f} = ?`).join(", ")}${beruehrt}
+      WHERE id = ?`).run(...felder.map((f) => aus[f]), id);
 
     protokolliere("termin_geaendert", {
       personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
@@ -247,7 +278,8 @@ kalenderRouter.delete("/workspace/api/termine/:id", gleicheHerkunft, (req, res)
     if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
 
     const { wo, werte } = sichtbar(req.person);
-    const termin = db().prepare(`SELECT t.id, t.titel, t.erstellt_von ${VERBUND} WHERE ${wo} AND t.id = ?`)
+    const termin = db().prepare(
+      `SELECT t.id, t.titel, t.erstellt_von, t.serie_id, t.serie_tag ${VERBUND} WHERE ${wo} AND t.id = ?`)
       .get(...werte, id);
     if (!termin) return res.status(404).json({ fehler: "nicht_gefunden" });
 
@@ -258,6 +290,17 @@ kalenderRouter.delete("/workspace/api/termine/:id", gleicheHerkunft, (req, res)
       return res.status(403).json({ fehler: "nicht_erlaubt" });
     }
 
+    /* Eine einzelne Ausprägung zu löschen heisst "dieses eine Mal
+       nicht" -- nicht "die ganze Serie weg". Ohne diese Vormerkung
+       legte der Nachfüller den Termin beim nächsten Öffnen des
+       Kalenders wieder an, und der gelöschte Termin wäre kommentarlos
+       zurück. Der Sinn der Serie bleibt erhalten: Sie läuft weiter, nur
+       dieser Tag fällt aus. */
+    if (termin.serie_id && termin.serie_tag) {
+      db().prepare("INSERT OR IGNORE INTO termin_serien_aus (serie_id, tag) VALUES (?,?)")
+        .run(termin.serie_id, termin.serie_tag);
+    }
+
     db().prepare("DELETE FROM termine WHERE id = ?").run(id);
     protokolliere("termin_geloescht", {
       personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),