381 lines
20 KiB
JavaScript
381 lines
20 KiB
JavaScript
import { config } from '../../config.js'
|
|
import { createDocument, getDocument, updateDocument } from '../appwriteAdmin.js'
|
|
import { analyseHosts } from '../analyse.js'
|
|
import { withLocks } from '../keyedLock.js'
|
|
import { findActiveBySiteKey } from '../siteFeatures.js'
|
|
import { fehlendePflichtangaben } from './einstellungen.js'
|
|
import { leerFragebogen, normalisiereFragebogen } from './fragebogen.js'
|
|
import { termineAus } from './schalter.js'
|
|
import { pruefeNow, pruefeText } from './util.js'
|
|
|
|
/**
|
|
* Kontext einer Terminplaner-Funktion (Spezifikation 2026-10-02-terminplaner-design.md, Abschnitte 2 und 8) und
|
|
* Speicher der Betriebs-Einstellung (termineConfig, Dokument-ID = ID des portalFeatures-Dokuments).
|
|
*
|
|
* ctx = { feature, project, einstellung, version, fragebogen }
|
|
* feature portalFeatures-Dokument (featureKey 'termine')
|
|
* project websiteProjects-Dokument oder null (Projekt fehlt)
|
|
* einstellung gespeicherte Einstellung (Objekt) oder null (noch nie gespeichert / unlesbar)
|
|
* version Zaehler fuer die optimistische Sperre (0 = noch nie gespeichert; bei unlesbarem JSON die Version des Dokuments)
|
|
* fragebogen Bestell-Fragebogen (TP2), immer normalisiert; fehlt er oder ist er unlesbar (Logzeile), der leere (leerFragebogen)
|
|
* Ein ctx ist nur zum Lesen: kontextPerSiteKey gibt innerhalb von 30 Sekunden dasselbe Objekt zurueck.
|
|
*
|
|
* - kontextPerSiteKey (oeffentliche Schnittstelle): nur Funktionen im Zustand active und nur mit gespeicherter
|
|
* Einstellung, in der die Pflichtangaben fuer Gaeste stehen (fehlendePflichtangaben, Ruling R41: ein Entwurf aus einer
|
|
* Vorlage ist noch nicht buchbar); Modus off => null ohne jede Abfrage. Treffer und Fehlschlaege werden 30 Sekunden je siteKey im Speicher
|
|
* gehalten (Zustandswechsel der Funktion wirken so mit hoechstens 30 Sekunden Verzoegerung); speichereEinstellung
|
|
* leert den Speicher. Eine Abfrage, die waehrend eines Speicherns lief, landet nie im Speicher (generation).
|
|
* - kontextPerFeature (Portal, Gaesteseiten per Token): active und disabled (Gaeste duerfen weiter absagen und widerrufen),
|
|
* ohne Speicher; liefert auch ohne gespeicherte Einstellung einen ctx (einstellung null, version 0).
|
|
* - kontextFuerPortal (Portal, Entwurf und Bestellung): das uebergebene portalFeatures-Dokument in jedem Zustand (off, ordered,
|
|
* setup, active, disabled) ohne Modus- und Zustandspruefung (die macht der Aufrufer), ohne Speicher.
|
|
* Der Fragebogen steht im selben Dokument wie die Einstellung (termineConfig.fragebogen, JSON-Text) und gehoert nur dem
|
|
* Entwurf: speichereFragebogen aendert ihn ohne die Version der Einstellung anzufassen (der Fragebogen-Editor und der
|
|
* Einstellungs-Editor stoeren sich so nicht), beide Schreibwege laufen unter derselben Sperre termine-cfg:<featureId>.
|
|
* Fehlt eine Collection (404 collection_not_found), wird der Fehler weitergereicht und nicht als "nicht gefunden" gelesen.
|
|
*/
|
|
|
|
const FUNKTION = 'termine'
|
|
const SITE_KEY_RE = /^[a-z2-7]{16}$/
|
|
const CACHE_MS = 30 * 1000
|
|
const CACHE_MAX = 10000
|
|
|
|
const cache = new Map()
|
|
/** Wird mit jedem Speichern erhoeht: eine Abfrage, die davor begann, darf ihr Ergebnis nicht mehr merken. */
|
|
let generation = 0
|
|
|
|
const istObjekt = (wert) => wert !== null && typeof wert === 'object' && !Array.isArray(wert)
|
|
|
|
/** 404 "Dokument fehlt" (nicht: Collection oder Datenbank fehlt). */
|
|
const dokumentFehlt = (err) => err?.status === 404 && err.type !== 'collection_not_found' && err.type !== 'database_not_found'
|
|
|
|
/** Dokument lesen; fehlt es (404 "Dokument fehlt"), ist das Ergebnis null. Fehlt Collection oder Datenbank, wird der Fehler weitergereicht. */
|
|
export async function holeOderNull(collectionId, id) {
|
|
try {
|
|
return await getDocument(collectionId, id)
|
|
} catch (err) {
|
|
if (dokumentFehlt(err)) return null
|
|
throw err
|
|
}
|
|
}
|
|
|
|
/**
|
|
* { einstellung, version } aus einem termineConfig-Dokument. Unlesbares JSON (mit Log) ergibt einstellung null, die Version
|
|
* des Dokuments bleibt: wer die kaputte Einstellung ueberschreiben will, speichert mit genau dieser Version.
|
|
*/
|
|
function liesDokument(doc) {
|
|
const version = Number.isInteger(doc.version) ? doc.version : 0
|
|
try {
|
|
const einstellung = JSON.parse(doc.einstellung)
|
|
if (!istObjekt(einstellung)) throw new Error('kein Objekt')
|
|
return { einstellung, version }
|
|
} catch (err) {
|
|
console.error(`[termine-kontext] Einstellung ${doc.$id} ist unlesbar: ${err.message}`)
|
|
return { einstellung: null, version }
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Der Fragebogen aus einem termineConfig-Dokument, normalisiert. Fehlt das Attribut (Altbestand, noch nie gespeichert), ist es
|
|
* der leere Fragebogen ohne Meldung; kaputtes JSON oder ein Inhalt, den die Normalisierung ablehnt, ergibt ebenfalls den leeren
|
|
* mit genau einer Logzeile (Dokument-ID und Grund) und wirft nie: der Fragebogen darf Einstellung und Kontext nicht blockieren.
|
|
*/
|
|
function fragebogenAus(doc) {
|
|
const roh = doc.fragebogen
|
|
if (roh === undefined || roh === null || roh === '') return leerFragebogen()
|
|
try {
|
|
const erg = normalisiereFragebogen(JSON.parse(roh))
|
|
if (erg.fehler) throw new Error(`ungueltige Angaben (${Object.keys(erg.fehler).join(', ')})`)
|
|
return erg.fragebogen
|
|
} catch (err) {
|
|
console.error(`[termine-kontext] Fragebogen ${doc.$id} ist unlesbar: ${err.message}`)
|
|
return leerFragebogen()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Die gespeicherte Einstellung einer Funktion samt Fragebogen.
|
|
* @param {string} featureId ID des portalFeatures-Dokuments
|
|
* @returns {Promise<{ einstellung: object, version: number, fragebogen: object }|null>} null, wenn es noch keine (lesbare)
|
|
* Einstellung gibt; fragebogen ist immer normalisiert (leer, wenn nichts oder nichts Lesbares gespeichert ist)
|
|
*/
|
|
export async function ladeEinstellung(featureId) {
|
|
pruefeText(featureId, 'featureId')
|
|
const doc = await holeOderNull(config.collections.termineConfig, featureId)
|
|
const gelesen = doc ? liesDokument(doc) : null
|
|
return gelesen?.einstellung ? { ...gelesen, fragebogen: fragebogenAus(doc) } : null
|
|
}
|
|
|
|
/**
|
|
* Der Fragebogen aus einem termineConfig-Dokument, so wie er gespeichert ist (geparstes Objekt) oder null. Anders als fragebogenAus kein
|
|
* leerer Fragebogen als Ersatz: fehlt das Attribut, ist es leer oder kein JSON-Objekt, ist das Ergebnis null (kaputtes JSON mit einer Logzeile).
|
|
*/
|
|
function fragebogenRoh(doc) {
|
|
const roh = doc.fragebogen
|
|
if (roh === undefined || roh === null || roh === '') return null
|
|
try {
|
|
const fragebogen = JSON.parse(roh)
|
|
if (!istObjekt(fragebogen)) throw new Error('kein Objekt')
|
|
return fragebogen
|
|
} catch (err) {
|
|
console.error(`[termine-kontext] Fragebogen ${doc.$id} ist unlesbar: ${err.message}`)
|
|
return null
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Der gespeicherte Stand einer Funktion fuer das Einrichtungs-Ticket und die Anleitung (TP2 D4): Einstellung, Version, Zeitpunkt der letzten
|
|
* Aenderung und Fragebogen, ohne Modus- und Zustandspruefung. Anders als ladeEinstellung unterscheidet er "noch nie gespeichert" von "unlesbar":
|
|
* null nur ohne termineConfig-Dokument; unlesbares JSON macht nur das jeweilige Feld null (die Version des Dokuments bleibt). Fehlt Collection
|
|
* oder Datenbank, wird der Fehler weitergereicht.
|
|
* @param {string} featureId ID des portalFeatures-Dokuments
|
|
* @returns {Promise<{ einstellung: object|null, version: number, updatedAt: string|null, fragebogen: object|null }|null>}
|
|
*/
|
|
export async function ladeStand(featureId) {
|
|
pruefeText(featureId, 'featureId')
|
|
const doc = await holeOderNull(config.collections.termineConfig, featureId)
|
|
if (!doc) return null
|
|
const { einstellung, version } = liesDokument(doc)
|
|
return {
|
|
einstellung,
|
|
version,
|
|
updatedAt: typeof doc.updatedAt === 'string' && doc.updatedAt !== '' ? doc.updatedAt : null,
|
|
fragebogen: fragebogenRoh(doc),
|
|
}
|
|
}
|
|
|
|
async function baueKontext(feature) {
|
|
const [project, doc] = await Promise.all([
|
|
feature.projectId ? holeOderNull(config.collections.websiteProjects, feature.projectId) : null,
|
|
holeOderNull(config.collections.termineConfig, feature.$id),
|
|
])
|
|
const gelesen = doc ? liesDokument(doc) : null
|
|
return {
|
|
feature,
|
|
project,
|
|
einstellung: gelesen?.einstellung ?? null,
|
|
version: gelesen?.version ?? 0,
|
|
fragebogen: doc ? fragebogenAus(doc) : leerFragebogen(),
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Kontext fuer die oeffentliche Schnittstelle: aktive Funktion 'termine' mit diesem siteKey und gespeicherter Einstellung.
|
|
* @param {string} siteKey
|
|
* @param {Date} [now] Zeitpunkt fuer den 30-Sekunden-Speicher
|
|
* @returns {Promise<object|null>} null bei Modus off, ungueltigem oder unbekanntem siteKey, anderem Zustand als active
|
|
* und fehlender Einstellung
|
|
*/
|
|
export async function kontextPerSiteKey(siteKey, now = new Date()) {
|
|
if (termineAus()) return null
|
|
if (typeof siteKey !== 'string' || !SITE_KEY_RE.test(siteKey)) return null
|
|
const nowMs = pruefeNow(now, 'kontextPerSiteKey')
|
|
const gemerkt = cache.get(siteKey)
|
|
if (gemerkt && gemerkt.bis > nowMs) return gemerkt.ctx
|
|
|
|
const stand = generation
|
|
const feature = await findActiveBySiteKey(siteKey, FUNKTION)
|
|
let ctx = feature ? await baueKontext(feature) : null
|
|
if (ctx && (!ctx.einstellung || fehlendePflichtangaben(ctx.einstellung).length > 0)) ctx = null
|
|
if (stand === generation) merke(siteKey, ctx, nowMs)
|
|
return ctx
|
|
}
|
|
|
|
function merke(siteKey, ctx, nowMs) {
|
|
if (cache.size >= CACHE_MAX) {
|
|
for (const [key, eintrag] of cache) if (eintrag.bis <= nowMs) cache.delete(key)
|
|
if (cache.size >= CACHE_MAX) cache.delete(cache.keys().next().value)
|
|
}
|
|
cache.set(siteKey, { bis: nowMs + CACHE_MS, ctx })
|
|
}
|
|
|
|
/**
|
|
* Kontext fuer Portal und Gaesteseiten (Token): Funktion 'termine' im Zustand active oder disabled, ohne Speicher.
|
|
* @param {string} featureId ID des portalFeatures-Dokuments
|
|
* @returns {Promise<object|null>} null bei Modus off, unbekannter ID, anderer Funktion oder anderem Zustand
|
|
*/
|
|
export async function kontextPerFeature(featureId) {
|
|
if (termineAus()) return null
|
|
if (typeof featureId !== 'string' || featureId === '') return null
|
|
const feature = await holeOderNull(config.collections.portalFeatures, featureId)
|
|
if (!feature || feature.featureKey !== FUNKTION || !['active', 'disabled'].includes(feature.state)) return null
|
|
return baueKontext(feature)
|
|
}
|
|
|
|
/**
|
|
* Kontext fuer das Portal (Entwurf, Bestellung, Einbau): das uebergebene portalFeatures-Dokument in jedem Zustand, ohne Speicher.
|
|
* Es gibt keine Modus- und keine Zustandspruefung und keinen Abgleich mit der Datenbank: das Dokument ist das, das der Aufrufer
|
|
* schon (frisch) gelesen und geprueft hat. Oeffentlich ist dieser Kontext nie, dafuer gibt es kontextPerSiteKey.
|
|
* @param {{ $id: string, projectId?: string }} feature portalFeatures-Dokument
|
|
* @returns {Promise<object>} ctx; ohne termineConfig-Dokument einstellung null, version 0, leerer Fragebogen
|
|
*/
|
|
export async function kontextFuerPortal(feature) {
|
|
pruefeText(feature?.$id, 'feature.$id')
|
|
return baueKontext(feature)
|
|
}
|
|
|
|
const veraltet = () =>
|
|
Object.assign(new Error('Die Einstellungen wurden inzwischen geändert. Bitte neu laden.'), {
|
|
status: 409,
|
|
code: 'EINSTELLUNG_VERALTET',
|
|
})
|
|
|
|
const keineEinstellung = () =>
|
|
Object.assign(new Error('Es gibt noch keinen Entwurf für den Terminplaner. Bitte wähle zuerst eine Branche.'), {
|
|
status: 409,
|
|
code: 'keine_einstellung',
|
|
})
|
|
|
|
/** Eingabe normalisieren und als JSON-Text fuer termineConfig.fragebogen bereitstellen; ungueltig => 400 mit err.fehler. */
|
|
function pruefeFragebogen(eingabe) {
|
|
const erg = normalisiereFragebogen(eingabe)
|
|
if (erg.fehler) throw Object.assign(new Error('Der Fragebogen ist ungültig.'), { status: 400, fehler: erg.fehler })
|
|
return { fragebogen: erg.fragebogen, json: JSON.stringify(erg.fragebogen) }
|
|
}
|
|
|
|
/**
|
|
* Speichert die (bereits geprueften) Einstellungen. Optimistisch gesperrt: version ist die Version, auf der die
|
|
* Aenderung beruht (0 = noch nie gespeichert); weicht sie von der gespeicherten ab, passiert nichts und es folgt
|
|
* { status: 409, code: 'EINSTELLUNG_VERALTET' }. Lesen, Pruefen und Schreiben laufen unter der Sperre
|
|
* termine-cfg:<featureId>. Danach ist der Speicher von kontextPerSiteKey leer.
|
|
* Statt der Einstellung darf eine Funktion `async (bisher) => einstellung` uebergeben werden (Ruling R40): sie laeuft
|
|
* INNERHALB der Sperre nach der Versionspruefung, bekommt die gespeicherte Einstellung (Objekt) oder null und liefert die
|
|
* zu speichernde; sie darf werfen (der Fehler geht unveraendert durch, es wird nichts geschrieben). So laufen Pruefungen,
|
|
* die den gespeicherten Stand und die Buchungen brauchen (Entfernen mit kuenftigen Terminen), unter derselben Sperre wie
|
|
* das Schreiben. version null ueberspringt die Versionspruefung (nur fuer Aenderungen, die auf dem aktuellen Stand
|
|
* aufbauen, z. B. neuer Kalender-Link); die Version zaehlt trotzdem hoch.
|
|
* Mit der Option `fragebogen` (TP2: Neuanlage mit Branche, "Vorlage ersetzen" mit zurueckgesetzten Bestaetigungen) schreibt
|
|
* derselbe Vorgang unter derselben Sperre auch den Fragebogen: entweder die Eingabe (Objekt, wird normalisiert) oder eine
|
|
* Funktion `(bisher) => Eingabe` (bisher = gespeicherter Fragebogen, leer wenn keiner da ist), die wie die Einstellungs-Funktion
|
|
* nach der Versionspruefung laeuft, sodass ein Einbau-Wunsch, der zwischendurch gespeichert wurde, nicht verloren geht. Ist sie
|
|
* ungueltig, gibt es { status: 400, fehler } und es wird nichts geschrieben (weder Einstellung noch Version noch Dokument).
|
|
* Ohne die Option bleibt der gespeicherte Fragebogen unberuehrt.
|
|
* @param {{ $id: string, customerId: string, projectId: string }} feature portalFeatures-Dokument
|
|
* @param {object|((bisher: object|null) => object|Promise<object>)} einstellungOderFn
|
|
* @param {{ version: number|null, by?: string, now?: Date, fragebogen?: object|((bisher: object) => object|Promise<object>) }} optionen
|
|
* @returns {Promise<{ einstellung: object, version: number, fragebogen?: object }>} wie gespeichert, mit der neuen Version;
|
|
* fragebogen (normalisiert) nur, wenn die Option gesetzt war
|
|
*/
|
|
export async function speichereEinstellung(feature, einstellungOderFn, { version, by = '', now = new Date(), fragebogen } = {}) {
|
|
pruefeText(feature?.$id, 'feature.$id')
|
|
const alsFunktion = typeof einstellungOderFn === 'function'
|
|
if (!alsFunktion && !istObjekt(einstellungOderFn)) throw new TypeError('einstellung fehlt')
|
|
const nowMs = pruefeNow(now, 'speichereEinstellung')
|
|
|
|
return withLocks([`termine-cfg:${feature.$id}`], async () => {
|
|
const col = config.collections.termineConfig
|
|
const vorhanden = await holeOderNull(col, feature.$id)
|
|
const aktuell = vorhanden && Number.isInteger(vorhanden.version) ? vorhanden.version : 0
|
|
if (version !== null && version !== aktuell) throw veraltet()
|
|
|
|
const einstellung = alsFunktion ? await einstellungOderFn(vorhanden ? liesDokument(vorhanden).einstellung : null) : einstellungOderFn
|
|
if (!istObjekt(einstellung)) throw new TypeError('einstellung fehlt')
|
|
const json = JSON.stringify(einstellung)
|
|
|
|
// der Fragebogen wird vor dem ersten Schreibzugriff geprueft: ein ungueltiger laesst auch die Einstellung ungespeichert
|
|
let neuerFragebogen
|
|
if (fragebogen !== undefined) {
|
|
const eingabe = typeof fragebogen === 'function' ? await fragebogen(vorhanden ? fragebogenAus(vorhanden) : leerFragebogen()) : fragebogen
|
|
neuerFragebogen = pruefeFragebogen(eingabe)
|
|
}
|
|
|
|
const felder = {
|
|
customerId: feature.customerId,
|
|
projectId: feature.projectId,
|
|
einstellung: json,
|
|
version: aktuell + 1,
|
|
updatedAt: new Date(nowMs).toISOString(),
|
|
updatedBy: String(by ?? '').slice(0, 100),
|
|
...(neuerFragebogen ? { fragebogen: neuerFragebogen.json } : {}),
|
|
}
|
|
try {
|
|
if (vorhanden) await updateDocument(col, feature.$id, felder)
|
|
else await createDocument(col, felder, feature.$id)
|
|
} finally {
|
|
// auch bei einem Fehler: unklar, was in der Datenbank steht
|
|
generation += 1
|
|
cache.clear()
|
|
}
|
|
return { einstellung: JSON.parse(json), version: aktuell + 1, ...(neuerFragebogen ? { fragebogen: neuerFragebogen.fragebogen } : {}) }
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Speichert den Fragebogen einer Funktion (die Eingaben des Kunden im Bestell-Fragebogen). Gleiche Sperre wie
|
|
* speichereEinstellung (termine-cfg:<featureId>); `aendere(bisher)` laeuft darin, bekommt den gespeicherten Fragebogen
|
|
* (leer, wenn keiner gespeichert oder lesbar ist) und liefert die zu speichernde Eingabe, die normalisiert wird. Sie darf werfen
|
|
* (der Fehler geht unveraendert durch, es wird nichts geschrieben). Eine ungueltige Eingabe wirft { status: 400, fehler }.
|
|
* Geschrieben werden nur fragebogen, updatedAt und updatedBy: `version` und `einstellung` bleiben unberuehrt, ein offener
|
|
* Einstellungs-Editor mit der gelesenen Version kann also weiter speichern. Gibt es noch kein termineConfig-Dokument, wird keins
|
|
* angelegt, sondern { status: 409, code: 'keine_einstellung' } geworfen. Danach ist der Speicher von kontextPerSiteKey leer.
|
|
* @param {{ $id: string }} feature portalFeatures-Dokument
|
|
* @param {(bisher: object) => object|Promise<object>} aendere
|
|
* @param {{ by?: string, now?: Date }} optionen
|
|
* @returns {Promise<{ fragebogen: object }>} der gespeicherte, normalisierte Fragebogen
|
|
*/
|
|
export async function speichereFragebogen(feature, aendere, { by = '', now = new Date() } = {}) {
|
|
pruefeText(feature?.$id, 'feature.$id')
|
|
if (typeof aendere !== 'function') throw new TypeError('aendere fehlt')
|
|
const nowMs = pruefeNow(now, 'speichereFragebogen')
|
|
|
|
return withLocks([`termine-cfg:${feature.$id}`], async () => {
|
|
const col = config.collections.termineConfig
|
|
const vorhanden = await holeOderNull(col, feature.$id)
|
|
if (!vorhanden) throw keineEinstellung()
|
|
|
|
const { fragebogen, json } = pruefeFragebogen(await aendere(fragebogenAus(vorhanden)))
|
|
try {
|
|
await updateDocument(col, feature.$id, {
|
|
fragebogen: json,
|
|
updatedAt: new Date(nowMs).toISOString(),
|
|
updatedBy: String(by ?? '').slice(0, 100),
|
|
})
|
|
} finally {
|
|
// auch bei einem Fehler: unklar, was in der Datenbank steht
|
|
generation += 1
|
|
cache.clear()
|
|
}
|
|
return { fragebogen }
|
|
})
|
|
}
|
|
|
|
/** Vorschau-Host des Projekts (<subdomain>.project.webklar.com, klein) oder null; gleiche Schreibweise wie in analyseHosts. */
|
|
function vorschauHost(project) {
|
|
return project.subdomain ? `${String(project.subdomain).trim().toLowerCase()}.project.webklar.com` : null
|
|
}
|
|
|
|
/**
|
|
* Host der echten (Live-)Website eines Projekts: nur wenn project.liveDomain gesetzt ist, der erste gueltige Host aus
|
|
* analyseHosts(project), der nicht die Vorschau-Adresse <subdomain>.project.webklar.com ist; sonst undefined.
|
|
* Einzige Quelle fuer websiteUrl() und den Betriebsvorschlag des Fragebogens (routes/termine.js).
|
|
*/
|
|
export function liveHost(project) {
|
|
if (!project?.liveDomain) return undefined
|
|
const vorschau = vorschauHost(project)
|
|
return analyseHosts(project).find((host) => host !== vorschau)
|
|
}
|
|
|
|
/**
|
|
* Adresse der Website des Betriebs (Link auf Gaesteseiten und im Mailfuss), immer die echte Seite statt der Vorschau:
|
|
* betrieb.websiteUrl; sonst https:// + Live-Domain des Projekts (liveHost); sonst https:// + <subdomain>.project.webklar.com;
|
|
* sonst die Portal-Adresse (config.publicBaseUrl).
|
|
*/
|
|
export function websiteUrl(ctx) {
|
|
const eigene = ctx?.einstellung?.betrieb?.websiteUrl
|
|
if (typeof eigene === 'string' && eigene !== '') return eigene
|
|
const project = ctx?.project
|
|
if (project) {
|
|
// analyseHosts: [<subdomain>.project.webklar.com, Live-Domain], ungueltige und doppelte Hosts fehlen
|
|
const vorschau = vorschauHost(project)
|
|
const host = liveHost(project) ?? analyseHosts(project).find((h) => h === vorschau)
|
|
if (host) return `https://${host}`
|
|
}
|
|
return config.publicBaseUrl
|
|
}
|
|
|
|
/** Leert den Speicher von kontextPerSiteKey (Tests). */
|
|
export function resetKontextForTests() {
|
|
generation += 1
|
|
cache.clear()
|
|
}
|