Webklar-Kundenbereich/server/services/termine/aboAbgleich.js

import { config } from '../../config.js'
import { aboLage, aboMemo } from '../aboStatus.js'
import { Query, getDocument, listAllDocuments, updateDocument } from '../appwriteAdmin.js'
import { withLocks } from '../keyedLock.js'
import { sendCustomerMail } from '../mailer.js'
import { customerOf, disable, meldeErstattung, projectName } from '../siteFeatures.js'
import { loeschzeit } from './frist.js'
import { pruefeNow, zeitMs } from './util.js'
import { datumKurz } from './zeit.js'

/**
 * Abo-Abgleich des Terminplaners (Terminplaner TP2, Block E): der Terminplaner gehoert zum Wartungs-Abo und endet mit ihm.
 * gleicheAboAb(now) ist der Baustein fuer den Tagesjob (angeschlossen in E7); er kennt weder Schalter noch Ueberlappungssperre.
 *
 *   Schritt 1  aktive, bezahlte Terminplaner (state active, unlockedByPurchase true) ohne laufendes Wartungs-Abo => abschalten
 *              (disabledReason 'abo_ende'; ab disabledAt laeuft die 30-Tage-Frist bis zur Loeschung, jobs.js)
 *   Schritt 1b Einrichtungen, die das Abo-Ende erreicht (state ordered oder setup) => abschalten (disabledReason
 *              'abo_ende_vor_einrichtung'); eine bezahlte Einrichtung wird dem Team als Erstattung gemeldet (T19), der Kunde bekommt K22
 *              mit dem Block vor_einrichtung. Die offene Stripe-Sitzung wird nicht storniert, das Ticket nicht angefasst.
 *   Schritt 2  fuer jedes abgeschaltete Dokument mit Grund 'abo_ende' oder (bezahlt) 'abo_ende_vor_einrichtung' ohne aboEndeMailAt
 *              die Meldung nachholen (auch fuer die eben abgeschalteten); der Marker aboEndeMailAt wird erst nach erfolgreichem
 *              Versand gesetzt
 *
 * Regeln (Block E):
 * - Eine Listenabfrage fuer alle Kunden (Entwuerfe `off` bleiben ungelesen), ein aboMemo() je Lauf: die Abo-Lage jedes Kunden wird
 *   fuer die Vorauswahl nur einmal gelesen. Aktive Dokumente, die nicht vom Kauf freigeschaltet wurden (Pilot, Kulanz:
 *   unlockedByPurchase nicht true), fasst der Abgleich nie an; sie zaehlen in `ausgenommen` und kosten keine Abo-Abfrage.
 * - Geschrieben wird nur unter der Sperre feature-admin:<projectId> (wie die Team-Route) und nach frischem Lesen von Dokument UND
 *   Abo (aboLage direkt, nie der Memo): zwischen Vorauswahl und Sperre kann das Abo zurueckkommen oder das Team abschalten.
 *   Die Mails (T19, K22) und die Marker folgen NACH der Sperre (meldeAboEnde), denn T19 laeuft ueber meldeErstattung mit eigener
 *   Sperre feature-meldung:<docId> und darf nie innerhalb einer feature-admin- oder feature-paid-Sperre gerufen werden.
 * - Fail-closed: ist etwas nicht lesbar (Liste, Abo, Ereignisse, Dokument), wird nichts abgeschaltet. Kunde bzw. Dokument werden
 *   uebersprungen, `fehler` zaehlt, der naechste Lauf versucht es wieder. Das Log nennt weder Namen noch Adressen.
 * - disabledAt aendert dieser Abgleich nie nach dem Abschalten: schlaegt eine Mail fehl, wiederholt der naechste Tag den Versand mit
 *   denselben Daten (Enddatum, Loeschdatum), die Loeschfrist waechst nicht.
 * - Nur die Gruende aus siteFeatures.DISABLED_REASONS gelten. 'team', 'kunde_geloescht' und Altbestand ohne Grund fasst der
 *   Abgleich nie an.
 */

const GRUND = 'abo_ende'
const NOTIZ = 'Abgeschaltet: Wartungs-Abo beendet'
const GRUND_VOR = 'abo_ende_vor_einrichtung'
const NOTIZ_VOR = 'Abgeschaltet: Wartungs-Abo endete vor der Einrichtung'

const ADRESSE = /[^\s<>"',;()]+@[^\s<>"',;()]+/g

/** Fehlertext fuers Log: Name und gekuerzte Meldung, E-Mail-Adressen (SMTP-Antworten nennen sie) unkenntlich. */
const fehlerText = (err) => `${err?.name ?? 'Fehler'} ${String(err?.message ?? '').replace(ADRESSE, '[Adresse]').slice(0, 200)}`

const istAusgenommen = (doc) => doc.state === 'active' && doc.unlockedByPurchase !== true
const istBewertet = (doc) =>
  (doc.state === 'active' && doc.unlockedByPurchase === true) ||
  doc.state === 'ordered' ||
  doc.state === 'setup' ||
  (doc.state === 'disabled' && typeof doc.disabledReason === 'string' && doc.disabledReason.startsWith('abo_ende'))

const portalFeatures = () => config.collections.portalFeatures

/**
 * Der gemeinsame Melder fuer das Ende des Terminplaners (Schritt 2, Schritt 1b und der Sofortpfad E9 rufen nur ihn, nie T19 oder
 * K22 einzeln). Reihenfolge: (T19,) K22 an die E-Mail des Kundenkontos, danach der Marker aboEndeMailAt = now.
 * - Grund 'abo_ende': K22 mit Block `abo_ende` (Wartungs-Abo beendet) bzw. `hosting` (lage.art 'hosting' oder 'wechsel_widerrufen':
 *   das Abo ist ein Hosting-Abo), dazu der Kasten `daten`. enddatum = Berliner Tag von disabledAt, loeschdatum = 30 Tage danach.
 * - Grund 'abo_ende_vor_einrichtung': ein unbezahltes Dokument (unlockedByPurchase nicht true, die Bestellung wartet noch auf die
 *   Zahlung) hat nichts zu erstatten: weder T19 noch K22 noch Marker, kein Schreibzugriff (kommt die Zahlung spaeter, meldet
 *   siteFeatures das als T19 und der Abgleich sendet dann K22). Ein bezahltes Dokument meldet ZUERST die Erstattung an das Team
 *   (meldeErstattung, T19, genau einmal je Dokument, auch ohne erreichbaren Kunden), dann K22 mit Block `vor_einrichtung` (ohne
 *   `daten`: es gibt nichts zu loeschen). Scheitert T19 (weder gesendet noch schon gemeldet), folgen weder K22 noch Marker: der
 *   naechste Tag wiederholt beides in dieser Reihenfolge.
 * Der Aufrufer liest `doc` frisch und haelt KEINE feature-admin- und keine feature-paid-Sperre (meldeErstattung sperrt selbst
 * feature-meldung:<docId>). Ohne Kunde oder ohne E-Mail gibt es keine K22 zu senden: der Marker wird gesetzt, damit es kein
 * Wiederholen gibt. Wirft nie.
 * @param {object} doc portalFeatures-Dokument (disabled)
 * @param {{ lage: { art: string }, now: Date, onGesendet?: () => void }} options onGesendet wird nach jedem versendeten K22 gerufen
 * @returns {Promise<boolean>} true = nichts mehr offen (Marker gesetzt oder nichts zu melden), false = Versand oder Marker
 *   gescheitert (der naechste Tag wiederholt)
 */
export async function meldeAboEnde(doc, { lage, now, onGesendet = null }) {
  const nowMs = pruefeNow(now, 'meldeAboEnde')
  const vorEinrichtung = doc.disabledReason === GRUND_VOR
  if ((doc.disabledReason !== GRUND && !vorEinrichtung) || doc.aboEndeMailAt) return true // mit Marker ist alles gesagt
  if (vorEinrichtung && doc.unlockedByPurchase !== true) return true // nichts zu erstatten, nichts zu sagen: die Zahlung kommt eventuell noch
  const setzeMarker = () => updateDocument(portalFeatures(), doc.$id, { aboEndeMailAt: new Date(nowMs).toISOString() })
  let gesendet = false
  try {
    const customer = await customerOf(doc.customerId)
    if (vorEinrichtung) {
      const erstattung = await meldeErstattung(doc, { customer, nachAboEnde: false })
      if (!erstattung.sent && !erstattung.schonGemeldet) {
        console.error(`[termine-abo] T19 für Funktion ${doc.$id} nicht gesendet, der nächste Lauf wiederholt (K22 folgt danach)`)
        return false
      }
    }
    if (!customer?.email) {
      console.warn('[termine-abo] K22 entfällt: Kunde nicht mehr vorhanden oder ohne E-Mail-Adresse, Marker wird gesetzt')
      await setzeMarker()
      return true
    }
    const projekt = (await projectName(doc.projectId)) || 'Dein Projekt'
    const beginn = new Date(Number.isFinite(zeitMs(doc.disabledAt)) ? zeitMs(doc.disabledAt) : nowMs) // disabledAt fehlt nie, ausser bei Altdaten
    const grundBlock = vorEinrichtung
      ? { vor_einrichtung: true }
      : { [lage?.art === 'hosting' || lage?.art === 'wechsel_widerrufen' ? 'hosting' : 'abo_ende']: true, daten: true }
    await sendCustomerMail(customer.email, {
      template: 'K22',
      values: {
        kunde_name: customer.name || '',
        projekt,
        enddatum: datumKurz(beginn),
        loeschdatum: datumKurz(loeschzeit(beginn)),
        preis: config.features.termine.priceLabel,
        portal_url: `${config.publicBaseUrl}/dashboard.html#termine`,
      },
      blocks: grundBlock,
    })
    gesendet = true
    onGesendet?.()
    await setzeMarker()
    return true
  } catch (err) {
    console.error(`[termine-abo] Meldung für Funktion ${doc.$id}: ${gesendet ? 'Marker nicht gesetzt' : 'nicht gesendet'}, der nächste Lauf wiederholt: ${fehlerText(err)}`)
    return false
  }
}

/**
 * Was der Abgleich mit einem Dokument tut, das er aus der Liste bekommt (null = nichts):
 * 'abschalten' aktiv und vom Kauf freigeschaltet (Grund abo_ende), 'einrichtung' ordered/setup (Grund abo_ende_vor_einrichtung),
 * 'nachholen' abgeschaltet mit dem Grund abo_ende oder (bezahlt) abo_ende_vor_einrichtung ohne Marker. Ein unbezahltes,
 * abgeschaltetes abo_ende_vor_einrichtung-Dokument hat nichts nachzuholen.
 */
function aktionFuer(doc) {
  if (doc.state === 'active') return doc.unlockedByPurchase === true ? 'abschalten' : null
  if (doc.state === 'ordered' || doc.state === 'setup') return 'einrichtung'
  if (doc.state !== 'disabled' || doc.aboEndeMailAt) return null
  if (doc.disabledReason === GRUND) return 'nachholen'
  return doc.disabledReason === GRUND_VOR && doc.unlockedByPurchase === true ? 'nachholen' : null
}

/**
 * Ein Dokument: unter der Sperre feature-admin:<projectId> frisch lesen, frisch das Abo lesen, erst dann schreiben; die Meldung
 * (meldeAboEnde) folgt nach der Sperre.
 * 'abschalten': in der Liste aktiv => noch aktiv und vom Kauf freigeschaltet, Abo laeuft noch nicht wieder => abschalten.
 * 'einrichtung': in der Liste ordered/setup => noch ordered/setup (das Team kann inzwischen aktiviert haben), Abo laeuft nicht
 *   => abschalten (abo_ende_vor_einrichtung). Eine bezahlte Bestellung, die zwischen Liste und Sperre vom Webhook auf setup
 *   gestellt wurde, liefert disable() bereits als bezahlt zurueck.
 * 'nachholen': in der Liste abgeschaltet mit Grund und ohne Marker => noch so und ohne Marker, Abo laeuft weiter nicht.
 */
async function bearbeiteDokument(doc, ctx) {
  const { erg, now } = ctx
  const aktion = aktionFuer(doc)
  const grund = aktion === 'einrichtung' ? GRUND_VOR : GRUND
  const gefunden = await withLocks([`feature-admin:${doc.projectId}`], async () => {
    const frisch = await getDocument(portalFeatures(), doc.$id)
    if (aktion === 'abschalten') {
      if (frisch.state !== 'active' || frisch.unlockedByPurchase !== true) return null // das Team war schneller
    } else if (aktion === 'einrichtung') {
      if (frisch.state !== 'ordered' && frisch.state !== 'setup') return null // aktiviert oder abgeschaltet
    } else if (frisch.state !== 'disabled' || frisch.disabledReason !== doc.disabledReason || frisch.aboEndeMailAt) {
      return null
    }
    const lage = await aboLage(doc.customerId) // wirft bei Lesefehler: dann bleibt alles, wie es ist
    if (lage.laeuft) return null // das Abo ist zurueck (Schritt 2 und die Wiedereinschaltung gehoeren E6)

    let zuMelden = frisch
    if (aktion !== 'nachholen') {
      zuMelden = await disable(frisch.$id, { reason: grund, adminNote: grund === GRUND_VOR ? NOTIZ_VOR : NOTIZ })
      if (zuMelden.state !== 'disabled' || zuMelden.disabledReason !== grund) return null // jemand war zwischen Lesen und Schreiben schneller
      erg.abgeschaltet += 1
    }
    return { zuMelden, lage }
  })
  if (!gefunden) return
  const fertig = await meldeAboEnde(gefunden.zuMelden, { lage: gefunden.lage, now, onGesendet: () => (erg.mails += 1) })
  if (!fertig) erg.fehler += 1
}

async function bearbeiteKunde(customerId, dokumente, ctx) {
  const { erg } = ctx
  erg.ausgenommen += dokumente.filter(istAusgenommen).length
  const bewertet = dokumente.filter(istBewertet)
  if (bewertet.length === 0) return // nichts zu bewerten: das Abo wird nicht gelesen

  let lage
  try {
    lage = await ctx.memo.lage(customerId)
  } catch (err) {
    erg.fehler += 1
    console.error(`[termine-abo] Abo-Lage eines Kunden nicht lesbar, ${bewertet.length} Funktion(en) übersprungen: ${fehlerText(err)}`)
    return
  }
  erg.geprueft += bewertet.length
  if (lage.laeuft) return // laeuft weiter (E6 schaltet abgeschaltete wieder ein)

  for (const doc of bewertet) {
    if (!aktionFuer(doc)) continue
    try {
      await bearbeiteDokument(doc, ctx)
    } catch (err) {
      erg.fehler += 1
      console.error(`[termine-abo] Funktion ${doc.$id} nicht bearbeitet: ${fehlerText(err)}`)
    }
  }
}

/**
 * Taeglicher Abgleich des Terminplaners mit dem Wartungs-Abo (siehe Kopf der Datei). Wirft nie (ausser bei fehlendem `now`, wie
 * alle Termine-Jobs); jedes Problem steht im Log und in `fehler`.
 * @param {Date} now
 * @returns {Promise<{ geprueft: number, abgeschaltet: number, wiederEin: number, mails: number, ausgenommen: number, fehler: number }>}
 *   geprueft = bewertete Dokumente (aktiv mit unlockedByPurchase true, ordered/setup, disabled mit Grund abo_ende*, deren Kunde
 *   lesbar war), abgeschaltet = in diesem Lauf abgeschaltet, wiederEin = wieder eingeschaltet (E6; hier immer 0), mails = versendete
 *   K22, ausgenommen = aktive Dokumente ohne Kauf (Pilot, Kulanz), fehler = Kunden und Dokumente, die nicht bearbeitet werden konnten
 */
export async function gleicheAboAb(now) {
  pruefeNow(now, 'gleicheAboAb')
  const erg = { geprueft: 0, abgeschaltet: 0, wiederEin: 0, mails: 0, ausgenommen: 0, fehler: 0 }
  try {
    let dokumente
    try {
      dokumente = await listAllDocuments(portalFeatures(), [Query.equal('featureKey', 'termine'), Query.notEqual('state', 'off')])
    } catch (err) {
      erg.fehler += 1
      console.error(`[termine-abo] Funktionen nicht lesbar, der Abgleich entfällt: ${fehlerText(err)}`)
      return erg
    }
    const nachKunde = new Map()
    for (const doc of dokumente) {
      if (!doc.customerId || !doc.projectId) {
        // ohne Kunde gaelte "kein Abo": nie abschalten, was sich nicht zuordnen laesst
        erg.fehler += 1
        console.error(`[termine-abo] Funktion ${doc.$id} ohne Kunde oder Projekt übersprungen`)
        continue
      }
      if (!nachKunde.has(doc.customerId)) nachKunde.set(doc.customerId, [])
      nachKunde.get(doc.customerId).push(doc)
    }
    const ctx = { erg, now, memo: aboMemo() }
    for (const [customerId, liste] of nachKunde) {
      try {
        await bearbeiteKunde(customerId, liste, ctx)
      } catch (err) {
        erg.fehler += 1
        console.error(`[termine-abo] Kunde nicht bearbeitet: ${fehlerText(err)}`)
      }
    }
  } catch (err) {
    erg.fehler += 1
    console.error(`[termine-abo] Abgleich abgebrochen: ${fehlerText(err)}`)
  }
  return erg
}