Öffnungszeiten: Einschalten im Wartungs-Abo

POST /api/funktionen/zeiten/einschalten (Gratisweg, Spec 3.2): Abo frisch
prüfen, Zustimmung (consentFrei) und Nachweis ohne Stripe-Sitzung, Zustand
setup mit unlockedBy abo, dann Neubau, Einbau-Ticket und K24; ein zweiter
Klick holt Fehlendes nach (holeZeitenNach, eigene Sperre). GET /api/funktionen
liefert das Angebot (zeiten), features.zeiten mit unlockedBy, aboEndeAt, einbau,
loeschungAm sowie zeitenStatus und zeitenLeer je Projekt.

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

server/services/featureConsents.js

@@ -158,3 +158,47 @@ export function nachweisTexte(feature, { belehrung = null } = {}) {
   texte.push({ id: 'knopf', text: feature.consent.knopf, haken: false })
   return texte
 }
+
+// ---------------------------------------------------------------------------------------------------------------
+// Nachweis aus einer Anfrage (Checkout und Gratisweg "Einschalten"): Serverfassungen und -texte der Funktion, IP, Browser und Konto
+// aus der Anfrage. Hier statt in der Route, damit beide Wege denselben Nachweis schreiben.
+// ---------------------------------------------------------------------------------------------------------------
+
+/** Handelnde Person: bei Admin-Sitzung (adminName/adminEmail, siehe auth.js) der Admin, sonst der Kunde. */
+export const actingPerson = (session) =>
+  session.adminName || session.adminEmail
+    ? { name: session.adminName, email: session.adminEmail }
+    : { name: session.name, email: session.email }
+
+/** "Name <E-Mail>" der handelnden Person (oder was davon da ist); das Speichern kuerzt auf die Feldgroesse. */
+const kontoLabel = (person) => (person?.name && person?.email ? `${person.name} <${person.email}>` : person?.name || person?.email || '')
+
+/**
+ * Zustimmungsnachweis aus einer Anfrage speichern: die Serverfassungen und -texte der Funktion (nie Texte aus dem Client), dazu
+ * (falls der Haken `belehrung` der Funktion einen Text liefert) die Belehrung und die Zeit des Klicks. Jeder Fehler hier ist ein
+ * Serverfehler: die Route antwortet mit dem allgemeinen Text (auch bei Pruefungen des Nachweises wie "Texte zu lang"), der Rohtext
+ * steht nur im Log. Ohne sessionId (Gratisweg) traegt der Nachweis keine Stripe-Sitzung.
+ * @param {object} req Express-Anfrage (ip, User-Agent, Sitzung)
+ * @param {{ feature: object, haken?: object, customerId: string, projectId: string, sessionId?: string, klickAt: string }} p
+ *   feature: Registereintrag, beim Gratisweg freiweg(feature) (Zustimmung consentFrei)
+ */
+export async function speichereNachweisAusAnfrage(req, { feature, haken = {}, customerId, projectId, sessionId, klickAt }) {
+  const belehrung = (await haken.belehrung?.()) ?? null
+  const texte = nachweisTexte(feature, { belehrung })
+  try {
+    await speichereZustimmung({
+      customerId,
+      projectId,
+      featureKey: feature.key,
+      stripeSessionId: sessionId,
+      fassungen: zustimmungsfassungen(feature),
+      texte,
+      ip: req.ip,
+      userAgent: req.get('user-agent'),
+      konto: kontoLabel(actingPerson(req.session)),
+      at: klickAt,
+    })
+  } catch (err) {
+    throw Object.assign(new Error(`Zustimmungsnachweis nicht gespeichert: ${err?.message}`), { status: 500, cause: err })
+  }
+}

server/services/featureOrder.js

@@ -1,6 +1,6 @@
 import { config } from '../config.js'
-import { aboMemo } from './aboStatus.js'
-import { oeffentlicheAnsicht } from './featureRegistry.js'
+import { aboMemo, bestellbar } from './aboStatus.js'
+import { featureConfig } from './featureRegistry.js'
 import { istObjekt } from './termine/ablauf.js'
 import { holeOderNull, ladeEinstellung } from './termine/kontext.js'
 
@@ -31,6 +31,16 @@ const ZUSTIMMUNG_FEHLT = 'Bitte stimme der Erklärung zu, um zu bestellen.'
 const FASSUNG_VERALTET = 'Die Erklärungen wurden inzwischen geändert. Bitte lies sie noch einmal und stimme neu zu.'
 const MAX_HAKEN = 50
 
+/**
+ * Sicht der Zustimmung fuer den Browser (Bestellseite, Antwort bei veralteter Fassung): Fassung, Knopf und alle Texte; ob ein Punkt
+ * einen Haken braucht, steht je Punkt. Fuer feature.consent und, beim Gratisweg, freiweg(feature).consent.
+ */
+export const oeffentlicheConsent = (consent) => ({
+  version: consent.version,
+  knopf: consent.knopf,
+  items: consent.items.map((item) => ({ id: item.id, text: item.text, haken: Boolean(item.haken) })),
+})
+
 const fehlt = () => bestellFehler(400, ZUSTIMMUNG_FEHLT, 'zustimmung_fehlt')
 const hatWert = (wert) => wert !== undefined && wert !== null
 
@@ -63,7 +73,8 @@ export function pruefeZustimmung(feature, eingabe) {
   const { version, haken } = eingabe.zustimmung
   if (typeof version !== 'string' || !Array.isArray(haken) || haken.length > MAX_HAKEN) throw fehlt()
   if (version !== feature.consent.version) {
-    throw bestellFehler(409, FASSUNG_VERALTET, 'fassung_veraltet', { consent: oeffentlicheAnsicht(feature.key).consent })
+    // die Fassung des geprueften Eintrags (beim Gratisweg die Gratis-Zustimmung), nicht die des Registers
+    throw bestellFehler(409, FASSUNG_VERALTET, 'fassung_veraltet', { consent: oeffentlicheConsent(feature.consent) })
   }
   if (!haken.every((id) => typeof id === 'string' && ids.includes(id))) throw fehlt()
   const gesetzt = new Set(haken)
@@ -132,3 +143,33 @@ export async function pruefeAbo(feature, customerId) {
   if (!Object.hasOwn(ABO_TEXTE, grund) || grund === 'unbekannt') throw new Error('Abo-Prüfung ohne gültiges Ergebnis')
   throw bestellFehler(409, aboMeldung(feature, grund), grund, { grund })
 }
+
+const GRATIS_ABO_TEXT = {
+  kein_abo_gekuendigt: (name, preis) => `Ohne laufendes Wartungs-Abo kannst Du ${name} für einmalig ${preis} bestellen.`,
+  nicht_aktiv: () => 'Einschaltbar, sobald Dein Abo aktiv ist.',
+}
+const GERADE_NICHT_PRUEFBAR = 'Gerade nicht prüfbar – bitte versuch es gleich noch einmal.'
+
+/**
+ * Abo-Pruefung des Gratisweges "Einschalten" von Oeffnungszeiten live (Spec 3.2 Schritt 1): immer frisch gelesen (bestellbar direkt,
+ * nie aboMemo), gedacht fuer den Aufruf unter der Sperre feature-order. Laeuft das Wartungs-Abo und ist es aktiv, geschieht nichts.
+ * kein_abo und gekuendigt: 409 (code und body.grund wie der Grund) mit dem Hinweis auf den 30-Euro-Weg; nicht_aktiv: 409 "Einschaltbar,
+ * sobald Dein Abo aktiv ist." Ein Lesefehler ist 503 (fail-closed, nie stillschweigend erlaubt); im Log stehen nur Art und Status.
+ */
+export async function pruefeAboFuerEinschalten(customerId) {
+  const feature = featureConfig('zeiten')
+  let ergebnis
+  try {
+    ergebnis = await bestellbar(customerId)
+  } catch (err) {
+    console.error(`[funktionen] Abo für das Einschalten nicht lesbar: ${err?.name ?? 'Fehler'} ${err?.status ?? ''}`.trim())
+    throw Object.assign(new Error(GERADE_NICHT_PRUEFBAR), { status: 503 })
+  }
+  if (ergebnis?.ok === true) return
+  const grund = ergebnis?.grund
+  if (grund === 'nicht_aktiv') throw bestellFehler(409, GRATIS_ABO_TEXT.nicht_aktiv(), grund, { grund })
+  if (grund === 'kein_abo' || grund === 'gekuendigt') {
+    throw bestellFehler(409, GRATIS_ABO_TEXT.kein_abo_gekuendigt(feature.label.name, feature.priceLabel), grund, { grund })
+  }
+  throw new Error('Abo-Prüfung ohne gültiges Ergebnis')
+}

server/services/siteFeatures.js

@@ -71,7 +71,11 @@ export async function getFeatureDoc(customerId, projectId, key) {
   }
 }
 
-export async function assertOwnProject(customerId, projectId) {
+/**
+ * Das eigene Projekt des Kunden (sonst 403). forNewOrder: fuer alles, was eine Funktion neu einschaltet oder bestellt; ein archiviertes
+ * Projekt ist dann 409 (Spec 11: eine laufende Funktion laeuft weiter, aber Neubestellung ist gesperrt).
+ */
+export async function assertOwnProject(customerId, projectId, { forNewOrder = false } = {}) {
   let project = null
   try {
     project = await getDocument(config.collections.websiteProjects, projectId)
@@ -79,6 +83,7 @@ export async function assertOwnProject(customerId, projectId) {
     if (err.status !== 404) throw err
   }
   if (!project || !customerId || project.customerId !== customerId) throw httpError(403, 'Kein Zugriff auf dieses Projekt')
+  if (forNewOrder && project.archived === true) throw httpError(409, 'Dieses Projekt ist archiviert. Dafür kann keine Funktion neu eingeschaltet werden.')
   return project
 }
 
@@ -109,7 +114,8 @@ export async function ensureFeatureDoc(customerId, projectId, key) {
   }
 }
 
-async function ticketWoid(ticketId) {
+/** Ticketnummer (woid) zur Ticket-ID; ein unbekanntes Ticket ergibt null. */
+export async function ticketWoid(ticketId) {
   if (!ticketId) return null
   try {
     const ticket = await getDocument(config.collections.workorders, ticketId)
@@ -120,16 +126,28 @@ async function ticketWoid(ticketId) {
   }
 }
 
+/**
+ * Wodurch die Funktion freigeschaltet wurde: 'kauf' | 'abo' | 'team'. Altbestand ohne unlockedBy: unlockedByPurchase => 'kauf', sonst
+ * 'team' (Kulanz, Pilot, Team-Aktivierung).
+ */
+export const unlockedByVon = (doc) => doc?.unlockedBy || (doc?.unlockedByPurchase ? 'kauf' : 'team')
+
 /**
  * Ansicht einer Funktion fuer Kunde und Team. Abschaltgrund (disabledReason, ohne Grund = Altbestand => null), Zeitpunkt
  * (disabledAt) und Berliner Loeschtag (loeschungAm, 30 Tage danach, termine/frist.js) gibt es nur im Zustand `disabled`;
  * in jedem anderen Zustand sind alle drei null, auch wenn am Dokument noch Reste einer frueheren Abschaltung stehen.
  * loeschungAm gibt es nur fuer den Terminplaner (R105: der 30-Tage-Loeschlauf in jobs.js loescht nur Terminplaner-Daten,
- * bei News verspraeche das Datum eine Loeschung, die nie kommt) und ist null, wenn disabledAt fehlt oder nicht lesbar ist.
+ * bei News verspraeche das Datum eine Loeschung, die nie kommt) und fuer Oeffnungszeiten live, dort nur beim Abschaltgrund
+ * abo_ende (bei einer Abschaltung durch das Team gibt es keine Loeschfrist); es ist null, wenn disabledAt fehlt oder nicht lesbar ist.
  * disabledReason und disabledAt gelten fuer jede Funktion.
+ * Funktionen mit aboInklusive (Oeffnungszeiten live) tragen zusaetzlich unlockedBy (kauf | abo | team, null solange die Funktion
+ * aus ist), aboEndeAt (Ende des Wartungs-Abos erkannt) und einbau (angestossen | manuell, Ergebnis des Neubaus).
+ * key: Funktionsschluessel (auch ohne Dokument); ohne Angabe der des Dokuments.
  */
-async function featureView(doc) {
+export async function featureView(doc, key = doc?.featureKey) {
   const abgeschaltet = doc?.state === 'disabled'
+  const mitAbo = featureConfig(key)?.aboInklusive === true
+  const loeschtag = abgeschaltet && (key === 'termine' || (mitAbo && doc.disabledReason === 'abo_ende'))
   return {
     state: doc?.state || 'off',
     siteKey: doc?.siteKey || null,
@@ -139,7 +157,14 @@ async function featureView(doc) {
     invoiceUrl: doc?.invoiceUrl || null,
     disabledReason: abgeschaltet ? doc.disabledReason || null : null,
     disabledAt: abgeschaltet ? doc.disabledAt || null : null,
-    loeschungAm: abgeschaltet && doc.featureKey === 'termine' ? loeschTag(doc.disabledAt) : null,
+    loeschungAm: loeschtag ? loeschTag(doc.disabledAt) : null,
+    ...(mitAbo
+      ? {
+          unlockedBy: doc && doc.state !== 'off' ? unlockedByVon(doc) : null,
+          aboEndeAt: doc?.aboEndeAt || null,
+          einbau: doc?.einbau || null,
+        }
+      : {}),
   }
 }
 
@@ -161,7 +186,7 @@ export async function listCustomerFeatures(customerId, { docs: geladen } = {}) {
     const features = {}
     for (const key of FEATURE_KEYS) {
       const doc = docs.find((d) => d.projectId === p.$id && d.featureKey === key)
-      features[key] = await featureView(doc)
+      features[key] = await featureView(doc, key)
     }
     result.push({
       projectId: p.$id,

server/services/zeiten/einschalten.js

@@ -0,0 +1,177 @@
+import { config } from '../../config.js'
+import { getDocument, updateDocument } from '../appwriteAdmin.js'
+import { pruefeAboFuerEinschalten } from '../featureOrder.js'
+import { featureConfig, ticketTexte } from '../featureRegistry.js'
+import { withLocks } from '../keyedLock.js'
+import { customerOf, ensureFeatureDoc, getFeatureDoc, stateFields, ticketWoid, unlockedByVon } from '../siteFeatures.js'
+import { createFeatureTicket } from '../ticketAdmin.js'
+import { k24Mail, sendeZeitenMail } from './mails.js'
+import { stosseNeubauAn } from './neubau.js'
+import { ladeZeiten } from './speicher.js'
+import { hauptplan, statusZu } from './zeitlogik.js'
+
+/**
+ * Gratisweg "Einschalten" von Oeffnungszeiten live im Wartungs-Abo (Spezifikation 2026-10-04-oeffnungszeiten-live-design.md, 3.2)
+ * und die Selbstheilung der Schritte danach. Vorbild ist activateAnalyse (analyse.js).
+ *
+ *   einschaltenZeiten  Schritte 1-4 unter der Sperre `feature-order:<kunde>:<projekt>` (dieselbe wie im Checkout, damit sich
+ *                      Bestellen und Einschalten ausschliessen): Abo frisch pruefen, Zustand pruefen (idempotent), Nachweis speichern,
+ *                      Dokument auf setup. Danach, ohne diese Sperre: holeZeitenNach (Neubau, Ticket, K24).
+ *   holeZeitenNach     Schritte 5 und 6, jeder fuer sich nur, wenn er noch fehlt: Neubau (einbau), Einbau-Ticket, K24, dann k24At.
+ *                      Eigene Sperre `zeiten-nachholen:<dokument>`: ein Doppelklick und der 5-Minuten-Job legen nie zwei Tickets an.
+ *
+ * Sperren (keyedLock) sind nicht wiederbetretbar: stosseNeubauAn nimmt seine eigene Sperre `zeiten-neubau`, darum laufen Neubau, Ticket
+ * und Mail nie innerhalb von `feature-order`. Aufrufer, die `feature-order` oder `zeiten-nachholen` halten, duerfen diese Funktionen
+ * nicht aufrufen.
+ */
+
+const KEY = 'zeiten'
+
+/** Einhaengepunkt fuer Tests: die Uhr der Projektliste (GET /api/funktionen), die den Kurzstatus der Website berechnet. */
+export const einschaltenDeps = { jetzt: () => new Date() }
+
+const NOTIZ_MAX = 300
+const NICHT_FERTIG = 'Öffnungszeiten live ist eingeschaltet, aber das Einrichten ist noch nicht fertig. Bitte versuch es in einer Minute noch einmal.'
+
+const konflikt = (text) => Object.assign(new Error(text), { status: 409 })
+
+/** Notiz am Dokument: die der Route (staff.adminNote) oder "<Zeit> <Name>: Eingeschaltet ohne Zahlung" vor der bisherigen Notiz. */
+function notizDesTeams(staff, bisherige, now) {
+  if (typeof staff?.adminNote === 'string' && staff.adminNote) return staff.adminNote.slice(0, NOTIZ_MAX)
+  if (!staff?.name) return null
+  const eintrag = `${now.toISOString()} ${staff.name}: Eingeschaltet ohne Zahlung`
+  return (bisherige ? `${eintrag} | ${bisherige}` : eintrag).slice(0, NOTIZ_MAX)
+}
+
+/**
+ * Oeffnungszeiten live fuer ein Projekt einschalten (Spec 3.2, Schritte 1 bis 6).
+ * @param {{ customerId: string, projectId: string, by?: 'kunde'|'team', staff?: { name?: string, adminNote?: string }|null,
+ *   nachweis?: (() => Promise<unknown>)|null, now?: Date }} p
+ *   by 'kunde': Abo frisch pruefen (kein_abo/gekuendigt/nicht_aktiv 409, Lesefehler 503), unlockedBy 'abo', K24 geht an den Kunden.
+ *   by 'team': keine Abo-Pruefung, unlockedBy 'team', keine K24; staff ergibt die Notiz am Dokument.
+ *   nachweis: speichert den Zustimmungsnachweis (Schritt 3, nur wenn wirklich eingeschaltet wird); wirft er, bleibt der Zustand unveraendert.
+ * @returns {Promise<{ doc: object, changed: boolean }>} doc: das Dokument nach dem Nachholen; changed: false bei idempotentem Aufruf
+ * @throws {Error} 409 (Abo, anderer Zustand), 503 (Abo nicht lesbar; oder Zustand gespeichert, aber Neubau/Ticket nicht fertig: erneut aufrufen)
+ */
+export async function einschaltenZeiten({ customerId, projectId, by = 'kunde', staff = null, nachweis = null, now = new Date() } = {}) {
+  if (by !== 'kunde' && by !== 'team') throw new TypeError(`einschaltenZeiten: by muss kunde oder team sein, nicht ${String(by)}`)
+  const feature = featureConfig(KEY)
+
+  const { doc, changed } = await withLocks([`feature-order:${customerId}:${projectId}`], async () => {
+    // 1 Abo frisch (nie aus einem Zwischenspeicher); fuer das Team entfaellt es
+    if (by === 'kunde') await pruefeAboFuerEinschalten(customerId)
+
+    // 2 Zustand: schon eingeschaltet (setup/active) ist idempotent; sonst nur aus off (der Kunde) bzw. off/ordered/disabled (das Team)
+    const bisher = await getFeatureDoc(customerId, projectId, KEY)
+    if (bisher?.state === 'setup' || bisher?.state === 'active') {
+      if (by === 'team' || unlockedByVon(bisher) === 'abo') return { doc: bisher, changed: false }
+      throw konflikt(feature.orderedConflictMessage)
+    }
+    if (by === 'kunde' && bisher?.state === 'ordered') throw konflikt(feature.orderedConflictMessage)
+    if (by === 'kunde' && bisher?.state === 'disabled') throw konflikt(feature.disabledMessage)
+
+    // 3 Zustimmung speichern (ohne Stripe-Sitzung), vor dem Zustand: scheitert sie, bleibt alles wie es war
+    if (nachweis) await nachweis()
+
+    // 4 Dokument auf setup. Reste einer frueheren Abschaltung oder eines Abo-Endes gehoeren zum alten Lauf und enden hier;
+    // einbau beginnt leer, der Neubau (holeZeitenNach) setzt es neu.
+    const vorhanden = bisher ?? (await ensureFeatureDoc(customerId, projectId, KEY))
+    const notiz = by === 'team' ? notizDesTeams(staff, vorhanden.adminNote, now) : null
+    const gespeichert = await updateDocument(config.collections.portalFeatures, vorhanden.$id, {
+      ...stateFields('setup'),
+      featureKey: KEY,
+      unlockedBy: by === 'kunde' ? 'abo' : 'team',
+      unlockedByPurchase: false,
+      einbau: '',
+      aboEndeAt: null,
+      behaltenSessionId: '',
+      disabledAt: null,
+      disabledReason: null,
+      aboEndeMailAt: null,
+      ...(notiz ? { adminNote: notiz } : {}),
+    })
+    return { doc: gespeichert, changed: true }
+  })
+
+  // 5 und 6 nach der Sperre: Neubau, Ticket, K24
+  try {
+    return { doc: await holeZeitenNach(doc, { now }), changed }
+  } catch (err) {
+    // der Zustand ist gespeichert; ein erneuter Aufruf (oder der 5-Minuten-Job) holt nach. Im Log Art und Meldung, nie beim Kunden.
+    console.error(`[zeiten] Einschalten für Projekt ${projectId}: Nachholen fehlgeschlagen: ${err?.name ?? 'Fehler'} ${err?.status ?? ''} ${err?.message ?? ''}`.trim())
+    throw Object.assign(new Error(NICHT_FERTIG), { status: 503, cause: err })
+  }
+}
+
+/**
+ * Fehlende Schritte des Einschaltens nachholen (Spec 3.2 Schritt 5/6 und Selbstheilung): fuer ein Dokument im Zustand setup, das nicht
+ * vom Kauf stammt (unlockedBy kauf bringt markPaid in Ordnung):
+ *   1. einbau leer       => Neubau anstossen (stosseNeubauAn), Ergebnis in einbau
+ *   2. ticketId leer     => Einbau-Ticket aus dem Register (Text mit dem frischen einbau), ticketId
+ *   3. unlockedBy abo und k24At leer => K24 an den Kunden, danach k24At. Gesendet wird erst nach dem Ticket (die Mail nennt es);
+ *      nicht gesendet (Fehler) laesst k24At leer, ein Kunde ohne Adresse oder ein geloeschter Kunde bekommt k24At (es gibt nichts zu senden).
+ * Jeder Schritt erst nach dem Erfolg des vorigen. Liest das Dokument unter der Sperre frisch; andere Zustaende bleiben unberuehrt.
+ * Wirft bei Lesefehlern und wenn das Ticket nicht angelegt werden kann (der Aufrufer faengt und versucht es spaeter); eine
+ * nicht gesendete K24 wirft nicht.
+ * @param {{ $id: string }} doc portalFeatures-Dokument der Zeiten (nur $id zaehlt)
+ * @param {{ now?: Date }} [options]
+ * @returns {Promise<object>} das aktuelle Dokument
+ */
+export async function holeZeitenNach(doc, { now = new Date() } = {}) {
+  if (!doc?.$id) return doc
+  return withLocks([`zeiten-nachholen:${doc.$id}`], async () => {
+    let frisch = await getDocument(config.collections.portalFeatures, doc.$id)
+    if (frisch.state !== 'setup' || unlockedByVon(frisch) === 'kauf') return frisch
+    const mitK24 = unlockedByVon(frisch) === 'abo'
+    // nichts fehlt: weder Projekt noch Kunde lesen (der 5-Minuten-Job fragt jedes Dokument in setup)
+    if (frisch.einbau && frisch.ticketId && !(mitK24 && !frisch.k24At)) return frisch
+    const feature = featureConfig(KEY)
+    // das Projekt frisch: der Neubau und der Text des Tickets brauchen den Stand nach dem Speichern des Zustands
+    const project = await getDocument(config.collections.websiteProjects, frisch.projectId)
+
+    if (!frisch.einbau) {
+      const einbau = await stosseNeubauAn(project)
+      frisch = await updateDocument(config.collections.portalFeatures, frisch.$id, { einbau })
+    }
+
+    const customer = await customerOf(frisch.customerId)
+    if (!frisch.ticketId) {
+      const texte = await ticketTexte({ feature, doc: frisch, project, customer })
+      const { ticketId } = await createFeatureTicket({ customerId: frisch.customerId, project, featureKey: KEY, siteKey: frisch.siteKey, ...texte })
+      frisch = await updateDocument(config.collections.portalFeatures, frisch.$id, { ticketId })
+    }
+
+    if (mitK24 && !frisch.k24At) {
+      const nachricht = k24Mail({
+        kunde: customer,
+        projekt: project?.projectName || project?.subdomain || '',
+        einbau: frisch.einbau,
+        wieder: false,
+        ticketNr: await ticketWoid(frisch.ticketId).catch(() => null),
+      })
+      const { sent, reason } = await sendeZeitenMail(customer, nachricht)
+      if (sent || reason === 'keine_adresse') {
+        frisch = await updateDocument(config.collections.portalFeatures, frisch.$id, { k24At: now.toISOString() })
+      }
+    }
+    return frisch
+  })
+}
+
+/**
+ * Teil der Projektliste (GET /api/funktionen) zu den Zeiten eines Projekts: { zeitenStatus, zeitenLeer }. Eine Abfrage je Projekt mit
+ * Funktionsdokument (nicht je Kachel im Browser). zeitenLeer: es sind keine Plaene gespeichert (auch ohne Dokument oder im Zustand off).
+ * zeitenStatus { offen, kurz, text } (Hauptplan, wie ihn die Website zeigt): nur in setup und active und nur mit gespeichertem
+ * Hauptplan, sonst null. Wirft bei Lesefehlern.
+ * @param {object|null|undefined} doc portalFeatures-Dokument der Zeiten
+ * @param {Date} now
+ */
+export async function zeitenProjektAnsicht(doc, now) {
+  if (!doc || doc.state === 'off') return { zeitenStatus: null, zeitenLeer: true }
+  const daten = (await ladeZeiten(doc.$id))?.daten ?? null
+  const leer = !Array.isArray(daten?.plaene) || daten.plaene.length === 0
+  const haupt = !leer && (doc.state === 'setup' || doc.state === 'active') ? hauptplan(daten) : null
+  if (!haupt) return { zeitenStatus: null, zeitenLeer: leer }
+  const { offen, kurz, text } = statusZu(daten, haupt, now)
+  return { zeitenStatus: { offen, kurz, text }, zeitenLeer: false }
+}