Terminplaner: Loeschung abgeschalteter Funktionen seitenweise, Rest an Folgetagen

loescheAbgeschaltete liest je abgeschalteter Funktion (disabledAt vor 30 Tagen) Seiten zu 100
(neu buchungen.ersteBuchungen: nur $id, limit, nie Gastfelder) und loescht sie ueber arbeiteSeiten
samt Zellen, bis die Seite leer ist. Die Funktion wird nach jedem Lesen einer Seite und alle 50
Buchungen frisch geprueft (nochAbgeschaltet); wird sie wieder eingeschaltet, endet die Loeschung
fuer sie sofort. Deckel config.termine.loeschDeckel je Funktion: am Deckel bleibt die Funktion
disabled mit altem disabledAt, eine Warnung ohne Kennungen steht im Log, der naechste Tag macht
weiter, die uebrigen Funktionen kommen im selben Lauf dran. Die Einstellung (termineConfig) wird
nur nach leerer Seite ohne Fehler und mit letzter Pruefung unter termine-cfg:<id> geloescht.
loescheAbgeschalteteFunktionen liefert { funktionen, buchungen, gedeckelt }; taeglicherJob traegt
gedeckelt.abgeschaltet getrennt vom Loeschzaehler ein (Tagesbericht: Loeschlaeufe am Deckel).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

server/services/termine/buchungen.js

@@ -210,6 +210,18 @@ export async function loeschKandidaten(status, vor, { featureId = null, limit =
 /** Feld der Bezugszeit einer Loeschfrist (siehe loeschKandidaten); undefined fuer Status, die nicht automatisch geloescht werden. */
 export const loeschBezugsfeld = (status) => (Object.hasOwn(LOESCH_BEZUG, status) ? LOESCH_BEZUG[status] : undefined)
 
+/**
+ * Eine Seite Buchungen einer Funktion (jeder Status, auch Sperren): hoechstens `limit` (Standard 100), nur mit der Kennung ($id),
+ * nie mit Gastfeldern. Fuer die Loeschung abgeschalteter Funktionen: wer loescht, liest die Liste danach neu (Geloeschtes fehlt).
+ * Ohne Funktion oder mit ungueltiger Grenze: TypeError (nie eine Abfrage ohne Funktionsfilter oder ohne Grenze, die Treffer werden
+ * unwiderruflich geloescht).
+ */
+export async function ersteBuchungen(featureId, limit = LOESCH_SEITE) {
+  if (typeof featureId !== 'string' || featureId === '') throw new TypeError('ersteBuchungen: featureId muss ein nicht leerer Text sein')
+  if (!Number.isInteger(limit) || limit < 1) throw new TypeError(`ersteBuchungen: limit muss eine ganze Zahl ab 1 sein, nicht ${limit}`)
+  return listDocuments(col(), [Query.equal('featureId', featureId), Query.limit(limit), Query.select(['$id'])])
+}
+
 /** Zahl der offenen Anfragen (Status angefragt) einer Funktion. */
 export async function zaehleAnfragen(featureId) {
   return (await listAllDocuments(col(), [Query.equal('featureId', featureId), Query.equal('status', 'angefragt')])).length

server/services/termine/jobs.js

@@ -6,6 +6,7 @@ import {
   abgelaufeneHaltungen,
   aendere,
   erinnerungsKandidaten,
+  ersteBuchungen,
   hole,
   loesche,
   loeschBezugsfeld,
@@ -44,7 +45,8 @@ import { gibZellenFrei, raeumeVerwaisteZellen } from './zellen.js'
  * - Loeschlaeufe (Aufbewahrung) arbeiten seitenweise (arbeiteSeiten): eine Seite hoechstens 100 Buchungen ohne Gastfelder,
  *   Frist in der Abfrage, danach neu lesen. Ein Schritt loescht hoechstens config.termine.loeschDeckel Buchungen je Lauf (erledigt
  *   und nichterschienen zusammen je Funktion), alle Schritte eines Laufs zusammen hoechstens config.termine.loeschDeckelGesamt;
- *   der Rest folgt am naechsten Tag und wird gezaehlt (`gedeckelt`), nie still uebersprungen.
+ *   der Rest folgt am naechsten Tag und wird gezaehlt (`gedeckelt`), nie still uebersprungen. Ebenso die Loeschung abgeschalteter
+ *   Funktionen: je Funktion Seiten zu 100, hoechstens config.termine.loeschDeckel je Lauf, die Einstellung erst nach einer leeren Seite.
  */
 
 const MIN_MS = 60 * 1000
@@ -471,55 +473,89 @@ async function nochAbgeschaltet(lauf, funktionId, grenze) {
   return false
 }
 
+/**
+ * Buchungen EINER abgeschalteten Funktion seitenweise loeschen (arbeiteSeiten): Seite lesen (hoechstens 100, nur Kennungen), jede
+ * Buchung samt Zellen unter ihrer Sperre loeschen, neu lesen, bis die Seite leer ist. Die Funktion wird frisch gelesen
+ * (nochAbgeschaltet) vor jeder Seite nach dem Lesen und nach jeweils 50 Buchungen; gilt sie nicht mehr als abgeschaltet, endet die
+ * Loeschung fuer sie sofort (Log, kein Wurf). Am Deckel config.termine.loeschDeckel endet der Lauf mit Warnung (der Rest folgt am
+ * naechsten Tag). Die Einstellung wird nur nach einer leeren Seite ohne Fehler geloescht, mit letzter Pruefung unter der Sperre
+ * termine-cfg:<id>; sonst bleibt die Funktion samt altem disabledAt stehen und der naechste Tag macht weiter.
+ * => { geloescht, gedeckelt, einstellungWeg }
+ */
+async function loescheAbgeschalteteFunktion(lauf, funktionId, grenze) {
+  const deckel = config.termine.loeschDeckel
+  let abgebrochen = false // die Funktion gilt nicht mehr als abgeschaltet (oder war nicht lesbar): nichts mehr loeschen
+  let begonnen = 0 // Buchungen, deren Loeschung begonnen wurde
+  let geprueftBei = 0 // Stand von `begonnen` bei der letzten Pruefung
+  const pruefe = async () => {
+    geprueftBei = begonnen
+    if (!(await nochAbgeschaltet(lauf, funktionId, grenze))) abgebrochen = true
+    return !abgebrochen
+  }
+
+  const seiten = await schritt(
+    lauf,
+    'Buchungen abgeschalteter Funktion',
+    () =>
+      arbeiteSeiten(lauf, {
+        was: 'Löschung abgeschalteter Funktion',
+        deckel,
+        deckelText: `von ${deckel} je Funktion`,
+        holeSeite: async () => {
+          if (abgebrochen) return []
+          const seite = await ersteBuchungen(funktionId)
+          // vor dem Loeschen der Seite frisch pruefen: das Personal kann die Funktion zwischen Lesen und Loeschen wieder einschalten
+          return seite.length > 0 && !(await pruefe()) ? [] : seite
+        },
+        bearbeite: async (buchung) => {
+          if (abgebrochen) return false
+          if (begonnen - geprueftBei >= ABGESCHALTET_NEU_PRUEFEN_ALLE && !(await pruefe())) return false
+          begonnen += 1
+          return loescheMitZellen(lauf, buchung.$id, null)
+        },
+      }),
+    { geloescht: 0, gedeckelt: false, vollstaendig: false },
+  )
+
+  let einstellungWeg = false
+  if (seiten.vollstaendig && !abgebrochen) {
+    einstellungWeg = await schritt(
+      lauf,
+      'Einstellung abgeschalteter Funktion',
+      () =>
+        withLocks([`termine-cfg:${funktionId}`], async () => {
+          if (!(await nochAbgeschaltet(lauf, funktionId, grenze))) return false
+          try {
+            await deleteDocument(config.collections.termineConfig, funktionId)
+            return true
+          } catch (err) {
+            if (err?.status === 404 && !fehlendeCollection(err)) return false // schon weg
+            throw err
+          }
+        }),
+      false,
+    )
+  }
+  return { geloescht: seiten.geloescht, gedeckelt: seiten.gedeckelt, einstellungWeg }
+}
+
 /**
  * Funktionen im Zustand `disabled` seit mehr als 30 Tagen (disabledAt): alle Buchungen mit Zellen und zuletzt die Einstellung
- * loeschen. Vor der Buchungsliste, nach jeweils 50 Buchungen und vor dem Loeschen der Einstellung wird die Funktion frisch gelesen
- * (nochAbgeschaltet); gilt sie nicht mehr als abgeschaltet, endet die Loeschung fuer diese Funktion sofort (Log, kein Wurf).
- * Scheitert eine Buchung, bleibt die Einstellung bis zum naechsten Lauf. Zellen ohne Buchung raeumt danach der Tagesjob.
- * funktionen zaehlt die Funktionen, bei denen etwas geloescht wurde (Buchungen oder Einstellung).
+ * loeschen, je Funktion seitenweise mit Deckel (loescheAbgeschalteteFunktion). Endet eine Funktion am Deckel oder an einem Fehler,
+ * bleibt sie `disabled` mit altem disabledAt und der naechste Tag macht weiter; die anderen Funktionen kommen im selben Lauf dran.
+ * funktionen zaehlt die Funktionen, bei denen etwas geloescht wurde (Buchungen oder Einstellung), gedeckelt die Funktionen, die am
+ * Deckel endeten. Zellen ohne Buchung raeumt danach der Tagesjob.
  */
 async function loescheAbgeschaltete(lauf) {
-  const erg = { funktionen: 0, buchungen: 0 }
+  const erg = { funktionen: 0, buchungen: 0, gedeckelt: 0 }
   const grenze = lauf.nowMs - ABGESCHALTET_BEHALTEN_MS
   const funktionen = await listAllDocuments(config.collections.portalFeatures, [Query.equal('featureKey', 'termine'), Query.equal('state', 'disabled')])
   for (const funktion of funktionen) {
     if (!(zeitMs(funktion.disabledAt) < grenze)) continue
-    const buchungen = await schritt(lauf, 'Buchungen abgeschalteter Funktion', () => listAllDocuments(config.collections.termineBookings, [Query.equal('featureId', funktion.$id)]), null)
-    if (buchungen === null || !(await nochAbgeschaltet(lauf, funktion.$id, grenze))) continue
-
-    let geloescht = 0
-    let vollstaendig = true
-    for (const [i, buchung] of buchungen.entries()) {
-      if (i > 0 && i % ABGESCHALTET_NEU_PRUEFEN_ALLE === 0 && !(await nochAbgeschaltet(lauf, funktion.$id, grenze))) {
-        vollstaendig = false
-        break
-      }
-      const weg = await loescheMitZellen(lauf, buchung.$id, null)
-      if (weg) geloescht += 1
-      if (weg === undefined) vollstaendig = false
-    }
-    erg.buchungen += geloescht
-
-    let einstellungWeg = false
-    if (vollstaendig) {
-      einstellungWeg = await schritt(
-        lauf,
-        'Einstellung abgeschalteter Funktion',
-        () =>
-          withLocks([`termine-cfg:${funktion.$id}`], async () => {
-            if (!(await nochAbgeschaltet(lauf, funktion.$id, grenze))) return false
-            try {
-              await deleteDocument(config.collections.termineConfig, funktion.$id)
-              return true
-            } catch (err) {
-              if (err?.status === 404 && !fehlendeCollection(err)) return false // schon weg
-              throw err
-            }
-          }),
-        false,
-      )
-    }
-    if (geloescht > 0 || einstellungWeg) erg.funktionen += 1
+    const weg = await loescheAbgeschalteteFunktion(lauf, funktion.$id, grenze)
+    erg.buchungen += weg.geloescht
+    if (weg.gedeckelt) erg.gedeckelt += 1
+    if (weg.geloescht > 0 || weg.einstellungWeg) erg.funktionen += 1
   }
   return erg
 }
@@ -539,10 +575,11 @@ export function wendeLoeschfristenAn(now) {
 }
 
 /**
- * Abgeschaltete Funktionen nach 30 Tagen: Buchungen, Zellen, Einstellung loeschen. Baustein des Tagesjobs, ohne Schalter- und
- * Ueberlappungspruefung (fuer Tests).
+ * Abgeschaltete Funktionen nach 30 Tagen: Buchungen, Zellen, Einstellung loeschen, seitenweise und je Funktion bis config.termine.
+ * loeschDeckel Buchungen je Lauf. Baustein des Tagesjobs, ohne Schalter- und Ueberlappungspruefung (fuer Tests).
  * @param {Date} now
- * @returns {Promise<{ funktionen: number, buchungen: number }>}
+ * @returns {Promise<{ funktionen: number, buchungen: number, gedeckelt: number }>}
+ *   gedeckelt = Zahl der Funktionen, die am Deckel endeten
  */
 export function loescheAbgeschalteteFunktionen(now) {
   return loescheAbgeschaltete(einzelLauf('abgeschalteteFunktionen', now))
@@ -558,11 +595,15 @@ export async function taeglicherJob(now) {
   return fuehreAus('taeglicherJob', now, async (lauf) => {
     const festgefahren = await schritt(lauf, 'Festgefahrene Mails', () => beendeFestgefahrene(now), 0)
     const { gedeckelt: loeschfristenGedeckelt, ...loeschung } = await loeschfristen(lauf, now)
-    const abgeschaltet = await schritt(lauf, 'Abgeschaltete Funktionen', () => loescheAbgeschaltete(lauf), { funktionen: 0, buchungen: 0 })
+    const { gedeckelt: abgeschaltetGedeckelt, ...abgeschaltet } = await schritt(lauf, 'Abgeschaltete Funktionen', () => loescheAbgeschaltete(lauf), {
+      funktionen: 0,
+      buchungen: 0,
+      gedeckelt: 0,
+    })
     const aufgeraeumt = await schritt(lauf, 'Warteschlange aufräumen', () => raeumeAuf(now), 0)
     const zellen = await schritt(lauf, 'Verwaiste Zellen', () => raeumeVerwaisteZellen(now), 0)
-    // gedeckelt: Schritte, die am Deckel endeten (abgeschaltet und zellen fuellen spaetere Tasks); getrennt vom Loeschzaehler, damit die Summe im Tagesbericht stimmt
-    const gedeckelt = { loeschfristen: loeschfristenGedeckelt, abgeschaltet: 0, zellen: 0 }
+    // gedeckelt: Schritte bzw. Funktionen, die am Deckel endeten (zellen fuellt ein spaeterer Task); getrennt vom Loeschzaehler, damit die Summe im Tagesbericht stimmt
+    const gedeckelt = { loeschfristen: loeschfristenGedeckelt, abgeschaltet: abgeschaltetGedeckelt, zellen: 0 }
     return { festgefahren, loeschfristen: loeschung, gedeckelt, abgeschaltet, aufgeraeumt, zellen, fehler: lauf.fehler }
   })
 }