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, 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 2  fuer jedes abgeschaltete Dokument mit Grund 'abo_ende' ohne aboEndeMailAt die Mail K22 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. 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.
 * - 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 K22 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; 'abo_ende_vor_einrichtung' gehoert zu E5, ordered/setup ebenfalls (sie zaehlen hier nur als geprueft).
 */

const GRUND = 'abo_ende'
const NOTIZ = 'Abgeschaltet: Wartungs-Abo beendet'

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 und der Sofortpfad E9 rufen nur ihn, nie K22 einzeln):
 * K22 an die E-Mail des Kundenkontos, danach der Marker aboEndeMailAt = now.
 * Grund 'abo_ende': 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.
 * Der Aufrufer liest `doc` frisch und haelt die Sperre feature-admin:<projectId> (diese Funktion sperrt nicht, damit der Sofortpfad
 * sie aus seiner eigenen Sperre rufen kann). Ohne Kunde oder ohne E-Mail gibt es nichts 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')
  if (doc.disabledReason !== GRUND || doc.aboEndeMailAt) return true // E5 ergaenzt abo_ende_vor_einrichtung; mit Marker ist alles gesagt
  const setzeMarker = () => updateDocument(portalFeatures(), doc.$id, { aboEndeMailAt: new Date(nowMs).toISOString() })
  let gesendet = false
  try {
    const customer = await customerOf(doc.customerId)
    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
    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: { [lage?.art === 'hosting' || lage?.art === 'wechsel_widerrufen' ? 'hosting' : 'abo_ende']: true, daten: true },
    })
    gesendet = true
    onGesendet?.()
    await setzeMarker()
    return true
  } catch (err) {
    console.error(`[termine-abo] K22 für Funktion ${doc.$id}: ${gesendet ? 'Marker nicht gesetzt' : 'nicht gesendet'}, der nächste Lauf wiederholt: ${fehlerText(err)}`)
    return false
  }
}

/**
 * Ein Dokument unter seiner Sperre: frisch lesen, frisch das Abo lesen, erst dann schreiben.
 * Dokument war in der Liste aktiv => noch aktiv und vom Kauf freigeschaltet, Abo laeuft noch nicht wieder => abschalten, dann K22.
 * Dokument war in der Liste abgeschaltet (abo_ende) => noch so und ohne Marker, Abo laeuft weiter nicht => K22 nachholen.
 */
async function bearbeiteDokument(doc, ctx) {
  const { erg, now } = ctx
  const warAktiv = doc.state === 'active'
  await withLocks([`feature-admin:${doc.projectId}`], async () => {
    const frisch = await getDocument(portalFeatures(), doc.$id)
    if (warAktiv) {
      if (frisch.state !== 'active' || frisch.unlockedByPurchase !== true) return // das Team war schneller
    } else if (frisch.state !== 'disabled' || frisch.disabledReason !== GRUND || frisch.aboEndeMailAt) {
      return
    }
    const lage = await aboLage(doc.customerId) // wirft bei Lesefehler: dann bleibt alles, wie es ist
    if (lage.laeuft) return // das Abo ist zurueck (Schritt 2 und die Wiedereinschaltung gehoeren E6)

    let zuMelden = frisch
    if (warAktiv) {
      zuMelden = await disable(frisch.$id, { reason: GRUND, adminNote: NOTIZ })
      if (zuMelden.state !== 'disabled' || zuMelden.disabledReason !== GRUND) return // jemand war zwischen Lesen und Schreiben schneller
      erg.abgeschaltet += 1
    }
    const fertig = await meldeAboEnde(zuMelden, { 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) {
    const aktiv = doc.state === 'active'
    const nachholen = doc.state === 'disabled' && doc.disabledReason === GRUND && !doc.aboEndeMailAt
    if (!aktiv && !nachholen) 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
}