Öffnungszeiten: nach Abo-Ende für 30 € behalten

Neuer Modus neben Bestellen und Einschalten (Spec 3.3): POST /api/funktionen/zeiten/behalten startet einen Checkout mit zweck 'behalten', ohne den Zustand zu ändern; der Webhook-Zweig bucht vor markPaid/adoptPaidSession unter feature-admin zum Kauf (Frist weg, stripeSessionId = Sitzung), schaltet eine abgeschaltete Funktion wieder ein (Neubau nach der Sperre), ohne neues Ticket, mit K15 im Behalten-Wortlaut. Passt die Sitzung nicht, geht T19 nach der Sperre raus. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 02:54:39 +00:00
1 parent 97e6971276
commit 53253f0451
@@ -0,0 +1,259 @@
+import { config } from '../../config.js'
+import { getDocument, updateDocument } from '../appwriteAdmin.js'
+import { featureConfig } from '../featureRegistry.js'
+import { withLocks } from '../keyedLock.js'
+import { sendCustomerMail } from '../mailer.js'
+import { bestellMail, customerOf, getFeatureDoc, invoiceOf, meldeErstattung, notizVorn, projectName, stateFields, unlockedByVon, unmatchedNotice } from '../siteFeatures.js'
+import { createFeatureCheckout, retrieveCheckoutSession } from '../stripeBilling.js'
+import { stosseNeubauAn } from './neubau.js'
+import { ladeZeiten } from './speicher.js'
+
+/**
+ * "Fuer 30 EUR behalten": nach dem Ende des Wartungs-Abos behaelt der Kunde Oeffnungszeiten live fuer einmalig 30 EUR, ohne neuen Einbau
+ * und ohne neues Ticket (Spezifikation 2026-10-04-oeffnungszeiten-live-design.md, 3.3). Eigener Modus neben Bestellen und Einschalten:
+ * markOrdered und markPaid antworten bei setup/active/disabled mit 409 bzw. als Anomalie.
+ *
+ *   starteBehalten  Stripe-Checkout mit zweck 'behalten' und behaltenSessionId am Dokument. Der Zustand bleibt unveraendert, die Leisten
+ *                   bleiben waehrend der Zahlung live. Unter der Sperre `feature-order:<kunde>:<projekt>` (wie Checkout und Einschalten).
+ *   bucheBehalten   Webhook: passt die Sitzung zu behaltenSessionId, wird das Dokument unter `feature-admin:<projekt>` zum Kauf (unlockedBy
+ *                   kauf, Frist weg) und, wenn es abgeschaltet war, wieder eingeschaltet (Neubau nach der Sperre). K15 mit Behalten-Wortlaut
+ *                   nach der Sperre. Passt sie nicht (schon behalten, Daten geloescht, vom Team abgeschaltet): nichts wird gebucht, T19
+ *                   "Erstattung faellig" geht nach der Sperre ans Team.
+ *   verwerfeBehalten  Webhook: Sitzung abgelaufen oder SEPA fehlgeschlagen => behaltenSessionId wird frei.
+ *
+ * Sperren (keyedLock) sind nicht wiederbetretbar: stosseNeubauAn, K15 und T19 laufen nie innerhalb von `feature-admin` oder `feature-order`.
+ */
+
+const KEY = 'zeiten'
+
+const konflikt = (text) => Object.assign(new Error(text), { status: 409 })
+
+const NICHT_MOEGLICH = 'Behalten ist gerade nicht möglich. Das geht nur nach dem Ende deines Wartungs-Abos, solange deine Öffnungszeiten noch nicht gelöscht sind.'
+const ZAHLUNG_LAEUFT = 'Deine Zahlung wird gerade bestätigt. Bitte schau in einigen Minuten noch einmal vorbei.'
+const STRIPE_NICHT_ERREICHBAR = 'Die Zahlungsseite ist gerade nicht erreichbar. Bitte versuch es gleich noch einmal.'
+
+/** Sind Eingaben des Kunden gespeichert (oder nur Team-Einstellungen bzw. gar nichts)? Lesefehler werden weitergereicht. */
+async function datenDa(featureId) {
+  return (await ladeZeiten(featureId))?.daten != null
+}
+
+/**
+ * Darf der Kunde die Funktion jetzt behalten? In Einrichtung oder aktiv: sobald das Ende des Abos erkannt ist (aboEndeAt). Abgeschaltet:
+ * nur nach dem Abo-Ende (disabledReason abo_ende, nicht: Team, vor der Einrichtung, Kunde geloescht) und solange die Eingaben noch da sind.
+ */
+async function behaltenMoeglich(doc) {
+  if (!doc) return false
+  if (doc.state === 'setup' || doc.state === 'active') return Boolean(doc.aboEndeAt)
+  if (doc.state === 'disabled' && doc.disabledReason === 'abo_ende') return datenDa(doc.$id)
+  return false
+}
+
+/** Die gespeicherte Behalten-Sitzung bei Stripe: offen => { url }; abgelaufen oder unbekannt => null (neue Sitzung); sonst 409 bzw. 503. */
+async function offeneSitzung(sessionId) {
+  let session
+  try {
+    session = await retrieveCheckoutSession(sessionId)
+  } catch (err) {
+    if (err?.statusCode === 404 || err?.code === 'resource_missing') return null
+    console.warn(`[zeiten] Behalten: Sitzung nicht abrufbar: ${err?.name ?? 'Fehler'} ${err?.statusCode ?? err?.status ?? ''}`.trim())
+    throw Object.assign(new Error(STRIPE_NICHT_ERREICHBAR), { status: 503 })
+  }
+  if (session.status === 'open' && session.url) return { url: session.url }
+  if (session.status === 'expired') return null
+  // abgeschlossen: Zahlung eingegangen oder (SEPA) unterwegs; der Webhook bucht oder gibt die Sitzung frei
+  throw konflikt(ZAHLUNG_LAEUFT)
+}
+
+/**
+ * Behalten-Checkout starten (Spec 3.3). Die Vorpruefungen der Route (Kundenansicht, Zustimmung, Projekt, Schalter, Unterlagen) liegen
+ * davor; hier entscheidet das Dokument. Unter der Sperre `feature-order:<kunde>:<projekt>`: zwei schnelle Klicks legen eine Sitzung an, ein
+ * zweiter Klick bekommt die offene Zahlungsseite zurueck (eine abgelaufene wird ersetzt). Reihenfolge wie im Checkout: erst die Stripe-Sitzung
+ * (der Nachweis traegt ihre ID, sie ist der Anker der Widerrufsfrist), dann der Nachweis, dann behaltenSessionId; scheitert der Nachweis,
+ * gibt es keine URL und kein behaltenSessionId (die Sitzung verfaellt nach 24 h). Der Zustand des Dokuments aendert sich nicht.
+ * @param {{ customer: { $id: string }, projectId: string, nachweis: (sessionId: string) => Promise<unknown>, now?: Date }} p
+ *   customer: Kundendokument; nachweis: speichert den Zustimmungsnachweis zur Stripe-Sitzung; now: Zeit des Klicks (Metadaten consentAt)
+ * @returns {Promise<{ url: string }>}
+ * @throws {Error} 409 (nicht moeglich, Zahlung laeuft), 503 (Stripe nicht erreichbar), sonst Fehler von Appwrite, Stripe und Nachweis
+ */
+export async function starteBehalten({ customer, projectId, nachweis, now = new Date() } = {}) {
+  if (typeof customer?.$id !== 'string' || customer.$id === '') throw new TypeError('starteBehalten: customer fehlt')
+  if (typeof projectId !== 'string' || projectId === '') throw new TypeError('starteBehalten: projectId fehlt')
+  if (typeof nachweis !== 'function') throw new TypeError('starteBehalten: nachweis fehlt')
+  const customerId = customer.$id
+
+  return withLocks([`feature-order:${customerId}:${projectId}`], async () => {
+    const doc = await getFeatureDoc(customerId, projectId, KEY)
+    if (!(await behaltenMoeglich(doc))) throw konflikt(NICHT_MOEGLICH)
+
+    // eine schon begonnene Zahlung: dieselbe Seite nochmal, nie eine zweite Sitzung daneben
+    if (doc.behaltenSessionId) {
+      const offen = await offeneSitzung(doc.behaltenSessionId)
+      if (offen) return offen
+    }
+
+    const created = await createFeatureCheckout(customer, { projectId, key: KEY, consentAt: now.toISOString(), zweck: 'behalten' })
+    await nachweis(created.id)
+    await updateDocument(config.collections.portalFeatures, doc.$id, { behaltenSessionId: created.id })
+    return { url: created.url }
+  })
+}
+
+/** Passt die bezahlte Sitzung (mit passender behaltenSessionId) noch zum Zustand? Abgeschaltet nur nach dem Abo-Ende und mit Eingaben. */
+async function passtZumZustand(doc) {
+  if (doc.state === 'setup' || doc.state === 'active') return true
+  if (doc.state === 'disabled' && doc.disabledReason === 'abo_ende') return datenDa(doc.$id)
+  return false
+}
+
+/** Zeitpunkt des Klicks aus den Metadaten der Sitzung (consentAt), sonst jetzt. */
+function bestelltAm(session) {
+  const ms = Date.parse(session.metadata?.consentAt)
+  return new Date(Number.isNaN(ms) ? Date.now() : ms).toISOString()
+}
+
+/** Das Projekt fuer den Neubau; nicht lesbar oder geloescht ergibt null (der Neubau meldet dann manuell). */
+async function ladeProjekt(projectId) {
+  try {
+    return await getDocument(config.collections.websiteProjects, projectId)
+  } catch (err) {
+    if (err?.status !== 404) console.error(`[zeiten] Behalten: Projekt ${projectId} fuer den Neubau nicht lesbar: ${err?.name ?? 'Fehler'} ${err?.status ?? ''}`.trim())
+    return null
+  }
+}
+
+/**
+ * Buchung unter `feature-admin:<projekt>`: das Dokument zum Kauf machen. Schon gebucht (stripeSessionId ist diese Sitzung, Wiederholung des
+ * Webhooks) => { schonGebucht }. Passt die Sitzung nicht => nichts gebucht; der Vermerk mit der Sitzung (einmal je Sitzung, der Schutz vor
+ * einem zweiten T19 bei Wiederholung) und das Zuruecksetzen eines frueheren Markers 'gemeldet' (sonst verschluckte meldeEinmal dieses T19)
+ * stehen in einem Schreibzugriff.
+ */
+async function buche(session, { customerId, projectId, invoice }) {
+  const feature = featureConfig(KEY)
+  return withLocks([`feature-admin:${projectId}`], async () => {
+    const doc = await getFeatureDoc(customerId, projectId, KEY)
+    if (!doc) return { fall: 'unpassend', doc: null }
+    if (doc.stripeSessionId === session.id && unlockedByVon(doc) === 'kauf') return { fall: 'behalten', doc, schonGebucht: true }
+
+    const jetzt = new Date().toISOString()
+    if (doc.behaltenSessionId !== session.id || !(await passtZumZustand(doc))) {
+      if (String(doc.adminNote || '').includes(session.id)) return { fall: 'unpassend', doc }
+      const vermerkt = await updateDocument(config.collections.portalFeatures, doc.$id, {
+        adminNote: notizVorn(doc.adminNote, `${jetzt} System: Behalten-Zahlung (Sitzung ${session.id}) passt nicht, Erstattung fällig`),
+        ...(doc.zahlungMeldung === 'gemeldet' ? { zahlungMeldung: '' } : {}),
+      })
+      return { fall: 'unpassend', doc: vermerkt }
+    }
+
+    const warAus = doc.state === 'disabled'
+    const gebucht = await updateDocument(config.collections.portalFeatures, doc.$id, {
+      // abgeschaltet: zurueck auf active, wenn die Funktion schon einmal freigeschaltet war (activatedAt, das Ticket war geschlossen), sonst
+      // setup; Grund und Marker der Abschaltung enden damit (wie activate), activatedAt bleibt. zahlungMeldung bleibt unberuehrt.
+      ...(warAus ? { ...stateFields(doc.activatedAt ? 'active' : 'setup'), disabledAt: null, disabledReason: null, aboEndeMailAt: null } : {}),
+      featureKey: KEY,
+      unlockedBy: 'kauf',
+      unlockedByPurchase: true,
+      purchaseStatus: 'paid',
+      orderedAt: bestelltAm(session),
+      aboEndeAt: null,
+      behaltenSessionId: '',
+      stripeSessionId: session.id,
+      stripeInvoiceId: invoice.invoiceId || '',
+      invoiceUrl: invoice.invoiceUrl || '',
+      adminNote: notizVorn(doc.adminNote, `${jetzt} System: Nach dem Abo-Ende für ${feature.priceLabel} behalten (Sitzung ${session.id})`),
+    })
+    return { fall: 'behalten', doc: gebucht, warAus }
+  })
+}
+
+/** Nach der Buchung, ausserhalb der Sperre: Neubau (nur wenn die Funktion abgeschaltet war), dann K15. Wirft nie: gebucht ist gebucht. */
+async function nachBuchung(doc, { warAus, invoice }) {
+  if (warAus) {
+    const einbau = await stosseNeubauAn(await ladeProjekt(doc.projectId))
+    try {
+      await updateDocument(config.collections.portalFeatures, doc.$id, { einbau })
+    } catch (err) {
+      console.error(`[zeiten] Behalten: einbau für Projekt ${doc.projectId} nicht gespeichert: ${err?.name ?? 'Fehler'} ${err?.status ?? ''}`.trim())
+    }
+  }
+  try {
+    const customer = await customerOf(doc.customerId)
+    if (!customer?.email) return
+    await sendCustomerMail(
+      customer.email,
+      bestellMail(featureConfig(KEY), { kundeName: customer.name || '', projekt: await projectName(doc.projectId), invoiceUrl: invoice.invoiceUrl, behalten: true })
+    )
+  } catch (err) {
+    console.error('[zeiten] K15 (Behalten) fehlgeschlagen:', err?.message)
+  }
+}
+
+/**
+ * Eine bezahlte Behalten-Sitzung verbuchen (Webhook-Zweig zweck 'behalten', vor markPaid und adoptPaidSession); idempotent.
+ * @param {{ id: string, invoice?: unknown, metadata?: { customerId?: string, projectId?: string, featureKey?: string, consentAt?: string } }} session
+ *   bezahlte Checkout-Sitzung (checkout.session.completed mit payment_status paid bzw. async_payment_succeeded)
+ * @returns {Promise<{ fall: 'behalten'|'unpassend' }>} behalten: gebucht (auch bei einer Wiederholung); unpassend: nichts gebucht, das Team
+ *   bekommt T19 (bzw. T16 ungeklaert, wenn es zur Sitzung gar kein Dokument gibt)
+ * @throws {Error} bei Lesefehlern und Schreibfehlern der Buchung sowie wenn T19 weder raus ist noch schon draussen war: der Webhook
+ *   antwortet 500 und Stripe wiederholt
+ */
+export async function bucheBehalten(session) {
+  const { customerId, projectId, featureKey } = session?.metadata ?? {}
+  if (typeof session?.id !== 'string' || session.id === '' || featureKey !== KEY || !customerId || !projectId) {
+    await meldeOhneDokument(session)
+    return { fall: 'unpassend' }
+  }
+  // die Rechnung vor der Sperre (Netzwerkanfrage); nicht lesbar => ohne Link
+  const invoice = await invoiceOf(session.invoice)
+
+  const ergebnis = await buche(session, { customerId, projectId, invoice })
+  if (ergebnis.schonGebucht) return { fall: 'behalten' }
+  if (ergebnis.fall === 'behalten') {
+    await nachBuchung(ergebnis.doc, { warAus: ergebnis.warAus, invoice })
+    return { fall: 'behalten' }
+  }
+
+  // unpassend, ausserhalb der Sperre: T19 an das Team
+  if (!ergebnis.doc) {
+    await meldeOhneDokument(session)
+    return { fall: 'unpassend' }
+  }
+  console.error(
+    `[funktionen] BEZAHLTE Behalten-Sitzung ${session.id} passt nicht zur Funktion zeiten (Kunde ${customerId}, Projekt ${projectId}, Zustand ${ergebnis.doc.state}) - nichts gebucht, Erstattung wird gemeldet`
+  )
+  const customer = await customerOf(customerId).catch((err) => {
+    console.error('[funktionen] Kunde für die Zahlungsmeldung nicht lesbar:', err.message)
+    return null
+  })
+  // Die Zahlung gehoert zu keinem Ticket und nicht zur Rechnung am Dokument: T19 sagt "Zahlung nach dem Abo-Ende" und nennt deren Rechnung
+  const gemeldet = await meldeErstattung(ergebnis.doc, { customer, sitzung: session.id, nachAboEnde: true, ticketOffen: false, rechnungUrl: invoice.invoiceUrl })
+  if (!gemeldet.sent && !gemeldet.schonGemeldet) throw new Error(`Meldung zur Zahlung ${session.id} (Behalten passt nicht) nicht gesendet`)
+  return { fall: 'unpassend' }
+}
+
+/** Bezahlte Sitzung ohne Dokument (oder ohne verwertbare Metadaten): T16 "ungeklaert", wie adoptPaidSession; ein Fehler dabei wird nur geloggt. */
+async function meldeOhneDokument(session) {
+  console.error(
+    `[funktionen] BEZAHLTE Behalten-Sitzung ${session?.id} ohne passende Funktion (Kunde ${session?.metadata?.customerId}, Projekt ${session?.metadata?.projectId}) - bitte von Hand pruefen`
+  )
+  try {
+    await unmatchedNotice(session)
+  } catch (err) {
+    console.error('[funktionen] Hinweis zur ungeklaerten Zahlung fehlgeschlagen:', err?.message)
+  }
+}
+
+/**
+ * Behalten-Sitzung abgelaufen oder die SEPA-Zahlung fehlgeschlagen: behaltenSessionId wird frei, wenn es diese Sitzung ist (Stripe meldet
+ * eine fehlgeschlagene Lastschrift als abgeschlossene Sitzung, der Kunde kaeme sonst nie mehr zu einer neuen). Der Zustand bleibt.
+ * @returns {Promise<boolean>} true, wenn die Sitzung freigegeben wurde
+ */
+export async function verwerfeBehalten(session) {
+  const { customerId, projectId, featureKey } = session?.metadata ?? {}
+  if (typeof session?.id !== 'string' || session.id === '' || featureKey !== KEY || !customerId || !projectId) return false
+  return withLocks([`feature-admin:${projectId}`], async () => {
+    const doc = await getFeatureDoc(customerId, projectId, KEY)
+    if (!doc || doc.behaltenSessionId !== session.id) return false
+    await updateDocument(config.collections.portalFeatures, doc.$id, { behaltenSessionId: '' })
+    return true
+  })
+}