435 lines
26 KiB
JavaScript
435 lines
26 KiB
JavaScript
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 { activate, customerOf, disable, listCustomerFeatureDocs, meldeErstattung, projectName } from '../siteFeatures.js'
|
|
import { loeschzeit } from './frist.js'
|
|
import { ladeEinstellung } from './kontext.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
|
|
* Schritt 2b Erstattung nachholen, unabhaengig vom Abo (R107, E5b): fuer jedes BEZAHLTE (unlockedByPurchase true), abgeschaltete
|
|
* Dokument mit Grund 'abo_ende_vor_einrichtung' und zahlungMeldung !== 'gemeldet' geht T19 an das Team, ob das Wartungs-
|
|
* Abo inzwischen wieder laeuft oder nicht lesbar ist (die Erstattung bleibt nach D3 voll geschuldet, die Rueckkehr nach
|
|
* Schritt 3 gilt dafuer nicht). Der Nachlauf liest das Abo nie. Danach, in dieser Reihenfolge und nur nach erfolgreichem
|
|
* T19: K22 (Block vor_einrichtung), falls aboEndeMailAt noch leer ist, und der Marker. Ein unbezahltes Dokument bekommt nichts.
|
|
* Schritt 3 Rueckkehr: ein abgeschaltetes Dokument mit Grund 'abo_ende', dessen Wartungs-Abo wieder laeuft, wird wieder eingeschaltet
|
|
* (activate: Daten und Einstellungen bleiben, Grund, Marker und disabledAt enden), solange die Einstellung noch da ist, auch
|
|
* nach Tag 30 (der Abgleich laeuft im Tagesjob vor der Loeschung; sonst blockierten sich Loeschung und Rueckkehr).
|
|
* K23 geht nur an Kunden, die K22 bekommen haben (Marker aboEndeMailAt, vor dem activate gelesen). Nach der Loeschung ist
|
|
* das Dokument `off` und wird nie automatisch aktiv. Nicht automatisch: 'abo_ende_vor_einrichtung' (die Erstattung laeuft,
|
|
* das Team entscheidet per WOMS), 'team', 'kunde_geloescht' und Altbestand ohne Grund.
|
|
*
|
|
* Sofortpfad (E9): endeTermineFuerKunde(customerId) beendet die Terminplaner eines Kunden sofort, wenn dessen Wechsel ins Wartungs-
|
|
* Abo in der Frist widerrufen wird (routes/abo.js, withdrawOrder). Dieselben Aktionen wie Schritt 1 und 1b, aber OHNE Abo-Pruefung
|
|
* (der Spiegel steht noch auf Wartung, das Team setzt ihn von Hand zurueck); die Meldung (meldeAboEnde) ist dieselbe wie im
|
|
* Tagesabgleich. Danach laesst der Tagesabgleich diese Dokumente in Ruhe (aboLage kennt die Wechsel-Regel: kein Flattern).
|
|
*
|
|
* 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.
|
|
* - Ausnahme von "nach frischem Lesen des Abos": der Nachlauf der Erstattung (Schritt 2b) liest nur das Dokument frisch (unter
|
|
* feature-admin:<projectId>), nie das Abo - er schaltet nichts ab und nichts ein, er meldet nur, was geschuldet ist.
|
|
* - 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 NOTIZ_WIEDER = 'Wieder eingeschaltet: Wartungs-Abo läuft wieder'
|
|
const NOTIZ_WECHSEL = 'Abgeschaltet: Wechsel widerrufen'
|
|
// Lage fuer den Sofortpfad: das Abo bleibt (oder wird wieder) ein Hosting-Abo, K22 nimmt den Block hosting
|
|
const LAGE_WECHSEL_WIDERRUFEN = { laeuft: false, art: 'wechsel_widerrufen', endedAt: null }
|
|
|
|
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'))
|
|
|
|
/**
|
|
* Schritt 2b: bezahlte, wegen des Abo-Endes vor der Einrichtung abgeschaltete Einrichtung, deren Erstattung (T19) noch nicht beim Team ist.
|
|
* Das Abo spielt keine Rolle: die Erstattung bleibt geschuldet, auch wenn es zurueckkommt.
|
|
*/
|
|
export const istErstattungOffen = (doc) =>
|
|
doc.state === 'disabled' && doc.disabledReason === GRUND_VOR && doc.unlockedByPurchase === true && doc.zahlungMeldung !== 'gemeldet'
|
|
|
|
/** Schritt 3: abgeschaltet wegen des Abo-Endes (nur 'abo_ende', nicht 'abo_ende_vor_einrichtung'). */
|
|
const istRueckkehr = (doc) => doc.state === 'disabled' && doc.disabledReason === GRUND
|
|
|
|
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 des Abo-Endes (lage.endedAt), sonst von disabledAt;
|
|
* loeschdatum = 30 Tage nach disabledAt.
|
|
* - 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 Marker aboEndeMailAt gilt nur fuer K22: steht er schon, aber T19 ist
|
|
* noch nicht gemeldet (R107), geht nur T19 und K22 nicht noch einmal. `lage` braucht dieser Grund nicht (nur 'abo_ende' fuer
|
|
* den Block hosting).
|
|
* 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 } | null, 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 = null, now, onGesendet = null }) {
|
|
const nowMs = pruefeNow(now, 'meldeAboEnde')
|
|
const vorEinrichtung = doc.disabledReason === GRUND_VOR
|
|
if (doc.disabledReason !== GRUND && !vorEinrichtung) return true
|
|
if (vorEinrichtung && doc.unlockedByPurchase !== true) return true // nichts zu erstatten, nichts zu sagen: die Zahlung kommt eventuell noch
|
|
const erstattungOffen = vorEinrichtung && doc.zahlungMeldung !== 'gemeldet'
|
|
if (doc.aboEndeMailAt && !erstattungOffen) return true // 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 (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 (doc.aboEndeMailAt) return true // K22 ging schon, hier fehlte nur T19
|
|
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
|
|
// enddatum ist der Tag des Abo-Endes (lage.endedAt: endedAt || canceledAt des Abos), wenn bekannt - das Abschalten kann Tage danach liegen;
|
|
// sonst (Sofortpfad, Nachlauf ohne Abo-Lesen, kein lesbares Datum) der Tag des Abschaltens. loeschdatum bleibt 30 Tage nach dem Abschalten.
|
|
// Nur bei art 'beendet' ist lage.endedAt das Ende des Wartungs-Abos; bei 'hosting' gehoert es zum Hosting-Abo (etwa eine vorgemerkte Kuendigung).
|
|
const aboEnde = lage?.art === 'beendet' ? zeitMs(lage.endedAt) : NaN
|
|
const ende = Number.isFinite(aboEnde) ? new Date(aboEnde) : beginn
|
|
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(ende),
|
|
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: nichts mehr abzuschalten oder nachzuholen (die Rueckkehr ist Schritt 3, schalteWiederEin)
|
|
|
|
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
|
|
}
|
|
|
|
/**
|
|
* Schritt 2b, ein Dokument (R107): in der Liste bezahlt, abgeschaltet mit Grund 'abo_ende_vor_einrichtung' und T19 nicht gemeldet.
|
|
* Unter der Sperre feature-admin:<projectId> frisch lesen (das Team kann inzwischen aktiviert haben, der Webhook T19 gemeldet), das
|
|
* Abo wird NICHT gelesen. Die Meldung (T19, danach K22 und Marker, meldeAboEnde) folgt nach der Sperre. Wirft nie.
|
|
* @returns {Promise<boolean>} true = erledigt oder gescheitert (fehler gezaehlt, der naechste Tag wiederholt): das Dokument ist fuer
|
|
* diesen Lauf versorgt; false = nichts zu tun (die frische Fassung ist nicht mehr offen): der Abo-Pfad darf es noch bewerten
|
|
*/
|
|
async function holeErstattungNach(doc, ctx) {
|
|
const { erg, now } = ctx
|
|
try {
|
|
const frisch = await withLocks([`feature-admin:${doc.projectId}`], () => getDocument(portalFeatures(), doc.$id))
|
|
if (!istErstattungOffen(frisch)) return false
|
|
const fertig = await meldeAboEnde(frisch, { now, onGesendet: () => (erg.mails += 1) })
|
|
if (!fertig) erg.fehler += 1
|
|
} catch (err) {
|
|
erg.fehler += 1
|
|
console.error(`[termine-abo] Erstattung für Funktion ${doc.$id} nicht gemeldet, der nächste Lauf wiederholt: ${fehlerText(err)}`)
|
|
}
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* Sofortpfad, ein Dokument: unter der Sperre feature-admin:<projectId> frisch lesen (das Team kann inzwischen aktiviert oder
|
|
* abgeschaltet, der Webhook die Zahlung gebucht haben) und nach dem FRISCHEN Zustand abschalten: aktiv und vom Kauf freigeschaltet =>
|
|
* 'abo_ende', ordered/setup => 'abo_ende_vor_einrichtung' (aktionFuer, wie im Tagesabgleich). Das Abo wird nicht gelesen.
|
|
* @returns {Promise<object|null>} das abgeschaltete Dokument (mit Kauf- und Zahlungsfeldern fuer meldeAboEnde) oder null, wenn nichts zu tun war
|
|
*/
|
|
async function beendeSofort(doc) {
|
|
return withLocks([`feature-admin:${doc.projectId}`], async () => {
|
|
const frisch = await getDocument(portalFeatures(), doc.$id)
|
|
const aktion = aktionFuer(frisch)
|
|
const grund = aktion === 'abschalten' ? GRUND : aktion === 'einrichtung' ? GRUND_VOR : null
|
|
if (!grund) return null
|
|
const abgeschaltet = await disable(frisch.$id, { reason: grund, adminNote: NOTIZ_WECHSEL })
|
|
return abgeschaltet.state === 'disabled' && abgeschaltet.disabledReason === grund ? abgeschaltet : null // sonst war jemand schneller
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Sofortpfad beim Widerruf des Wechsels ins Wartungs-Abo (E9): alle Terminplaner des Kunden, die der Wechsel getragen hat, werden
|
|
* sofort abgeschaltet, ohne Abo-Pruefung (der Spiegel ist veraltet). Aktiv und vom Kauf freigeschaltet => 'abo_ende'; ordered/setup =>
|
|
* 'abo_ende_vor_einrichtung'. Aktive Dokumente ohne Kauf (Pilot, Kulanz), News, 'off' und schon Abgeschaltete bleiben unberuehrt.
|
|
* Danach je Dokument NACH der Sperre meldeAboEnde: K22 (Block hosting bzw. vor_einrichtung); eine bezahlte Einrichtung meldet zuerst
|
|
* T19 (genau einmal), ein unbezahltes ordered bekommt weder T19 noch K22 noch Marker. Scheitert eine Meldung, holt der Tagesabgleich
|
|
* sie nach. Ein Fehler bei einem Dokument (Lesen, Abschalten) stoppt die anderen nicht; Fehler stehen im Log (ohne Namen und Adressen).
|
|
* Wirft nie, wie endAnalyseForCustomer.
|
|
* @param {string} customerId
|
|
* @param {{ now?: Date }} [options] Zeitpunkt des Widerrufs (Marker aboEndeMailAt)
|
|
* @returns {Promise<{ beendet: string[] }>} die IDs der abgeschalteten Funktionsdokumente
|
|
*/
|
|
export async function endeTermineFuerKunde(customerId, { now = new Date() } = {}) {
|
|
const beendet = []
|
|
if (!customerId) return { beendet }
|
|
try {
|
|
const kandidaten = (await listCustomerFeatureDocs(customerId)).filter(
|
|
(doc) => doc.featureKey === 'termine' && doc.projectId && ['abschalten', 'einrichtung'].includes(aktionFuer(doc))
|
|
)
|
|
for (const doc of kandidaten) {
|
|
try {
|
|
const abgeschaltet = await beendeSofort(doc)
|
|
if (!abgeschaltet) continue
|
|
beendet.push(abgeschaltet.$id)
|
|
await meldeAboEnde(abgeschaltet, { lage: LAGE_WECHSEL_WIDERRUFEN, now }) // nach der Sperre; bei Misserfolg wiederholt der Tagesabgleich
|
|
} catch (err) {
|
|
console.error(`[termine-abo] Sofortpfad: Funktion ${doc.$id} nicht vollständig beendet, der Tagesabgleich holt nach: ${fehlerText(err)}`)
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error(`[termine-abo] Sofortpfad: Funktionen eines Kunden nicht lesbar, nichts beendet: ${fehlerText(err)}`)
|
|
}
|
|
return { beendet }
|
|
}
|
|
|
|
/**
|
|
* K23 an die E-Mail des Kundenkontos. Nur nach geschriebenem `active` gerufen, nie innerhalb einer Sperre. Scheitert der Versand,
|
|
* bleibt die Reaktivierung bestehen: das Log (ohne Adresse) und `fehler` halten es fest; der Marker aboEndeMailAt ist mit dem
|
|
* Aktivieren geleert, es gibt also keine Wiederholung am naechsten Tag (K23 geht hoechstens einmal je Rueckkehr). Ohne Kunde oder
|
|
* ohne E-Mail-Adresse entfaellt die Mail (Hinweis im Log, kein Fehler). Wirft nie.
|
|
*/
|
|
async function sendeWiederEin(doc, ctx) {
|
|
const { erg } = ctx
|
|
try {
|
|
const customer = await customerOf(doc.customerId)
|
|
if (!customer?.email) {
|
|
console.warn('[termine-abo] K23 entfällt: Kunde nicht mehr vorhanden oder ohne E-Mail-Adresse')
|
|
return
|
|
}
|
|
await sendCustomerMail(customer.email, {
|
|
template: 'K23',
|
|
values: {
|
|
kunde_name: customer.name || '',
|
|
projekt: (await projectName(doc.projectId)) || 'Dein Projekt',
|
|
portal_url: `${config.publicBaseUrl}/dashboard.html#termine`,
|
|
},
|
|
})
|
|
erg.mails += 1
|
|
} catch (err) {
|
|
erg.fehler += 1
|
|
console.error(`[termine-abo] K23 für Funktion ${doc.$id} nicht gesendet, der Terminplaner bleibt eingeschaltet: ${fehlerText(err)}`)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Schritt 3, ein Dokument: in der Liste abgeschaltet mit Grund 'abo_ende' und das Abo laeuft. Unter der Sperre feature-admin:<projectId>
|
|
* frisch lesen (noch disabled/abo_ende: das Team kann inzwischen aktiviert oder mit anderem Grund abgeschaltet haben), frisch das
|
|
* Abo lesen (laeuft es wieder nicht, bleibt alles), die Einstellung lesen (fehlt sie, ist sie geloescht oder nie gespeichert worden:
|
|
* nie automatisch aktiv), dann activate. Ob K22 ging, zeigt der Marker aboEndeMailAt, der VOR dem activate gelesen wird (activate
|
|
* leert ihn). K23 folgt nach der Sperre und nur, wenn K22 ging; wer nie von dem Ende erfuhr, hoert auch nicht von der Rueckkehr.
|
|
* Lesefehler werfen (der Aufrufer zaehlt fehler): dann bleibt das Dokument abgeschaltet.
|
|
*/
|
|
async function schalteWiederEin(doc, ctx) {
|
|
const { erg } = ctx
|
|
const eingeschaltet = await withLocks([`feature-admin:${doc.projectId}`], async () => {
|
|
const frisch = await getDocument(portalFeatures(), doc.$id)
|
|
if (!istRueckkehr(frisch)) return null
|
|
const lage = await aboLage(doc.customerId)
|
|
if (!lage.laeuft) return null // das Abo endete zwischen Vorauswahl und Sperre wieder
|
|
if ((await ladeEinstellung(frisch.$id)) === null) return null // Daten geloescht oder nie da: Rueckkehr nur, solange sie existieren
|
|
const k22Ging = Boolean(frisch.aboEndeMailAt)
|
|
await activate(frisch.$id, { adminNote: NOTIZ_WIEDER })
|
|
erg.wiederEin += 1
|
|
return { k22Ging }
|
|
})
|
|
if (eingeschaltet?.k22Ging) await sendeWiederEin(doc, ctx)
|
|
}
|
|
|
|
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
|
|
|
|
// Schritt 2b (R107) VOR dem Abo: die Erstattung haengt nicht davon ab, ob das Abo lesbar ist oder wieder laeuft
|
|
const versorgt = new Set()
|
|
for (const doc of bewertet.filter(istErstattungOffen)) {
|
|
if (await holeErstattungNach(doc, ctx)) versorgt.add(doc)
|
|
}
|
|
erg.geprueft += versorgt.size
|
|
const uebrige = bewertet.filter((doc) => !versorgt.has(doc))
|
|
if (uebrige.length === 0) return // alles versorgt: 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, ${uebrige.length} Funktion(en) übersprungen: ${fehlerText(err)}`)
|
|
return
|
|
}
|
|
erg.geprueft += uebrige.length
|
|
|
|
for (const doc of uebrige) {
|
|
// laeuft das Abo, gibt es nur die Rueckkehr (Schritt 3); sonst abschalten, einrichten, nachholen (Schritte 1, 1b, 2)
|
|
const bearbeite = lage.laeuft ? istRueckkehr(doc) && schalteWiederEin : aktionFuer(doc) && bearbeiteDokument
|
|
if (!bearbeite) continue
|
|
try {
|
|
await bearbeite(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; der Nachlauf der Erstattung, Schritt 2b, braucht das Abo nicht und zaehlt immer), abgeschaltet = in diesem Lauf abgeschaltet, wiederEin = in diesem Lauf wieder eingeschaltet (Schritt 3), mails =
|
|
* versendete Kundenmails K22 und K23 (T19 geht ans Team und zaehlt nicht), ausgenommen = aktive Dokumente ohne Kauf (Pilot, Kulanz),
|
|
* fehler = Kunden und Dokumente, die nicht bearbeitet werden konnten, sowie ein gescheiterter K23-Versand (das Dokument ist dann
|
|
* trotzdem wieder aktiv)
|
|
*/
|
|
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
|
|
}
|