Merge remote-tracking branch 'origin/main' into feature/oeffnungszeiten

Zusammenführung von TP2-Abschluss und Webshop (origin/main cab9c33) mit Öffnungszeiten live. Beide
Funktionen bleiben vollständig: jeder Konflikt ist als Vereinigung gelöst, Reihenfolge der Funktionsschlüssel
überall news, termine, shop, zeiten.

Konfliktdateien (28): public/app.js, dashboard.html, funktionen.js, widerrufen.html; scripts/stripe-products.mjs;
server/config.js, index.js, middleware/kundenansichtGuard.js, routes/abo.js, routes/admin/funktionenAdmin.js,
routes/funktionen.js, services/customerAdmin.js, customerViewLog.js, featureRegistry.js, retention.js,
siteFeatures.js, stripeBilling.js; test/customerViewLog, featureFreischaltung, featureRegistry, funktionenRoutes,
funktionenTermine, kundenansichtGuard, mailTemplates, publicForms, siteFeatures, stripeProductsScript (je
.test.js) und test/support/schema.js.

Entscheidungen: Mailvorlagen G01–G15, K01–K30, T01–T21 lückenlos (K24–K26 Webshop, K27–K30 Öffnungszeiten);
Stripe-Katalog mit shopSetup und zeitenSetup; Widerruf kennt shop und zeiten; ABO_FUNKTIONEN bleibt analyse
und termine (kein zeiten); activate() schreibt die Zeiten-Felder nur über extra; kein Halter von
feature-activate:<id> ruft disable() auf; die Aufbewahrungs-Löschung löscht Zeiten-Daten vor dem Abschalten und
hält den Kunden bei einem Fehler (held); die Admin-Antwort trägt ersatzTicket und warnung; Hash-Routen webshop
und zeiten, Ansichten view-webshop und view-zeiten; assertOwnProject behält die Meldung von main.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

scripts/build-legal-html.mjs

@@ -5,8 +5,10 @@
 //
 //   node scripts/build-legal-html.mjs termine            schreibt die drei Seiten des Terminplaners
 //   node scripts/build-legal-html.mjs termine --check    vergleicht mit den eingecheckten Seiten (Exit 1 bei Abweichung, schreibt nichts)
+//   node scripts/build-legal-html.mjs shop [--check]     dasselbe für Leistungsbeschreibung und AVV des Webshops (die Widerrufsbelehrung der
+//                                                        Funktionen gehört zum Satz termine und wird von shop nicht angefasst)
 //
-// Fassung = config.termine.avvVersion. Die Ausgabe enthält keine Datumsangabe außer der Fassung und hängt nur vom Markdown und
+// Fassung = config.termine.avvVersion (Satz termine) bzw. config.shop.fassung (Satz shop). Die Ausgabe enthält keine Datumsangabe außer der Fassung und hängt nur vom Markdown und
 // von der Fassung ab (zweimal erzeugen ergibt dieselben Bytes). Unterstützte Teilmenge von Markdown: Überschriften # bis ###
 // (# nur als erste Zeile), Absätze, Listen mit "- ", **fett**, `code` und Tabellen (Kopfzeile, Trennzeile |---|---|, Zeilen).
 // Jede andere Syntax (Codeblöcke, Zitate, Bilder, Links, rohes HTML, nummerierte Listen, Einrückungen, Trennlinien) bricht laut ab,
@@ -176,9 +178,9 @@ const STYLE = (seitenkopf) => `    :root { color-scheme: light; }
     }
 `
 
-/** Adresse eines Links der Navigation: relativ zur Wurzel ("/…", nicht "//") oder https. */
+/** Adresse eines Links der Navigation: relativ zur Wurzel ("/…", nicht "//") oder https; kein Rückwärtsschrägstrich (Browser lesen ihn wie "/"). */
 function pruefeHref(href) {
-  if (typeof href !== 'string' || !(/^\/(?!\/)/.test(href) || /^https:\/\/[^\s"'<>]+$/.test(href)) || /[\s"'<>]/.test(href)) {
+  if (typeof href !== 'string' || !(/^\/(?!\/)/.test(href) || /^https:\/\/[^\s"'<>]+$/.test(href)) || /[\s"'<>\\]/.test(href)) {
     throw new Error(`render: ungültige Adresse in der Navigation: ${String(href).slice(0, 60)}`)
   }
   return href
@@ -257,50 +259,74 @@ ${STYLE(meta.seitenkopf)}  </style>
 
 // ---------------------------------------------------------------------------------------------------------- Dokumentsätze
 
-/** Namen je Dokument des Terminplaners (Schlüssel wie in legalPaths: lb, avv, widerruf). */
+/** Namen je Dokument (Schlüssel wie in legalPaths: lb, avv, widerruf): Seitentitel und Kopfzeile des Drucks. */
 const TERMINE_NAMEN = {
   lb: { titel: 'Leistungsbeschreibung Terminplaner', seitenkopf: 'Leistungsbeschreibung Terminplaner' },
   avv: { titel: 'Auftragsverarbeitungsvertrag Terminplaner', seitenkopf: 'AVV Terminplaner' },
   widerruf: { titel: 'Widerrufsbelehrung und Muster-Widerrufsformular (Funktionen)', seitenkopf: 'Widerrufsbelehrung Funktionen' },
 }
-const NAV_NAMEN = { lb: 'Leistungsbeschreibung Terminplaner', avv: 'AVV Terminplaner', widerruf: 'Widerrufsbelehrung Funktionen' }
+const SHOP_NAMEN = {
+  lb: { titel: 'Leistungsbeschreibung Webshop', seitenkopf: 'Leistungsbeschreibung Webshop' },
+  avv: { titel: 'Auftragsverarbeitungsvertrag Webshop', seitenkopf: 'AVV Webshop' },
+}
+const NAV_NAMEN = {
+  termine: { lb: 'Leistungsbeschreibung Terminplaner', avv: 'AVV Terminplaner', widerruf: 'Widerrufsbelehrung Funktionen' },
+  shop: { lb: 'Leistungsbeschreibung Webshop', avv: 'AVV Webshop', widerruf: 'Widerrufsbelehrung Funktionen' },
+}
 
 /**
- * Die drei Dokumente des Terminplaners in der Fassung: { doc, md, html, meta } mit Pfaden relativ zur Wurzel des Projekts.
+ * Dokumente eines Satzes in der Fassung: { doc, md, html, meta } mit Pfaden relativ zur Wurzel des Projekts.
+ * namen = die Dokumente, die dieser Satz erzeugt (Schlüssel von legalPaths); die Navigation verlinkt alle Dokumente des Satzes.
  * Quelle docs/rechtliches/<slug>.md, Ziel public/rechtliches/<slug>-<Fassung>.html (Slugs und Adressen aus legalDocs.js).
  */
-export function termineDokumente(fassung = config.termine.avvVersion) {
-  const adressen = legalPaths('termine', fassung)
+function dokumenteDesSatzes(satz, fassung, namen) {
+  const adressen = legalPaths(satz, fassung)
   const nav = [
     { href: '/dashboard.html', text: '← Kundenportal' },
     { href: '/abo-bedingungen.html', text: 'Abo-Bedingungen' },
-    ...Object.keys(adressen).map((doc) => ({ href: adressen[doc], text: NAV_NAMEN[doc] })),
+    ...Object.keys(adressen).map((doc) => ({ href: adressen[doc], text: NAV_NAMEN[satz][doc] })),
     { href: '/datenschutz.html', text: 'Datenschutzerklärung' },
     { href: 'https://webklar.com/impressum', text: 'Impressum' },
   ]
-  return Object.entries(adressen).map(([doc, adresse]) => ({
+  return Object.keys(namen).map((doc) => ({
     doc,
-    md: `docs/rechtliches/${basename(adresse, `-${fassung}.html`)}.md`,
-    html: `public${adresse}`,
-    meta: { fassung, ...TERMINE_NAMEN[doc], nav },
+    md: `docs/rechtliches/${basename(adressen[doc], `-${fassung}.html`)}.md`,
+    html: `public${adressen[doc]}`,
+    meta: { fassung, ...namen[doc], nav },
   }))
 }
 
+/** Die drei Dokumente des Terminplaners (lb, avv, widerruf) in der Fassung config.termine.avvVersion. */
+export function termineDokumente(fassung = config.termine.avvVersion) {
+  return dokumenteDesSatzes('termine', fassung, TERMINE_NAMEN)
+}
+
+/**
+ * Die Dokumente des Webshops in der Fassung config.shop.fassung: lb und avv. Die Widerrufsbelehrung der Funktionen (dritte Adresse
+ * des Satzes shop) ist dieselbe Datei wie die des Terminplaners und wird nur vom Satz termine erzeugt; die Navigation verlinkt sie.
+ */
+export function shopDokumente(fassung = config.shop.fassung) {
+  return dokumenteDesSatzes('shop', fassung, SHOP_NAMEN)
+}
+
+/** Sätze der Kommandozeile: Name => Dokumente. */
+const SAETZE = { termine: termineDokumente, shop: shopDokumente }
+
 // ---------------------------------------------------------------------------------------------------------- Aufruf
 
 /**
- * Kommandozeile: `termine [--check]`. root = Wurzel des Projekts (Tests übergeben ein Verzeichnis mit Kopien).
+ * Kommandozeile: `termine|shop [--check]`. root = Wurzel des Projekts (Tests übergeben ein Verzeichnis mit Kopien).
  * => Exit-Code: 0 ok, 1 mindestens eine Seite weicht ab (nur --check), 2 falscher Aufruf
  */
 export function lauf(argv, { root = ROOT, log = console.log, fehler = console.error } = {}) {
   const [satz, ...optionen] = argv
   const pruefen = optionen.includes('--check')
-  if (satz !== 'termine' || optionen.some((o) => o !== '--check')) {
-    fehler('Aufruf: node scripts/build-legal-html.mjs termine [--check]')
+  if (!Object.hasOwn(SAETZE, satz ?? '') || optionen.some((o) => o !== '--check')) {
+    fehler('Aufruf: node scripts/build-legal-html.mjs termine|shop [--check]')
     return 2
   }
   let abweichungen = 0
-  for (const d of termineDokumente()) {
+  for (const d of SAETZE[satz]()) {
     const html = render(readFileSync(join(root, d.md), 'utf8'), d.meta)
     const ziel = join(root, d.html)
     if (pruefen) {

scripts/build-legal-pdfs.sh

@@ -1,13 +1,17 @@
 #!/usr/bin/env bash
 # Erzeugt die Druck-/PDF-Fassungen der Vertragsunterlagen aus den HTML-Quellen.
 # Laeuft auf dem Host (braucht Chrome/Chromium), die PDFs werden eingecheckt.
-# Usage: CHROME=/pfad/zu/chrome scripts/build-legal-pdfs.sh [all|analyse|termine|datenschutz]
+# Usage: CHROME=/pfad/zu/chrome scripts/build-legal-pdfs.sh [all|analyse|termine|shop|datenschutz]
 #   analyse = nur AVV und Leistungsbeschreibung der Website-Analyse (Fassung ANALYSE_VERSION), andere PDFs bleiben unveraendert
 #   termine = Leistungsbeschreibung, AVV und Widerrufsbelehrung des Terminplaners (Fassung TERMINE_VERSION, Standard: config.termine.avvVersion);
 #             die HTML-Seiten kommen vorher aus `node scripts/build-legal-html.mjs termine`. Neben jedem PDF liegt <PDF>.sha256 mit der
 #             SHA-256 der HTML-Seite, aus der es gedruckt wurde (test/buildLegalHtml.test.js prueft, dass beide zusammenpassen). Ein PDF,
 #             dessen Pruefsumme noch stimmt, wird nicht neu gedruckt (FORCE=1 druckt alle neu).
-#   datenschutz = nur die Datenschutzerklaerung (docs/WEBklar-Datenschutzerklaerung.pdf)
+#   shop    = Leistungsbeschreibung und AVV des Webshops (Fassung SHOP_VERSION, Standard: config.shop.fassung); die HTML-Seiten kommen vorher
+#             aus `node scripts/build-legal-html.mjs shop`, Pruefsumme und Neudruck wie bei termine. Die Widerrufsbelehrung der Funktionen
+#             gehoert zu termine (dieselbe Datei) und wird hier nicht gedruckt. `all` druckt auch diese beiden PDFs.
+#   datenschutz = nur die Datenschutzerklaerung (docs/WEBklar-Datenschutzerklaerung.pdf); daneben liegt <PDF>.sha256 mit der SHA-256 von
+#             public/datenschutz.html (test/legalTexts.test.js prueft sie); ein PDF mit passender Pruefsumme wird nicht neu gedruckt (FORCE=1 druckt neu)
 # Vorher `free -m` pruefen und mit `nice` aufrufen; jeder Chrome-Aufruf laeuft hoechstens 120 Sekunden (timeout), die PDFs nacheinander.
 set -euo pipefail
 cd "$(dirname "$0")/.."
@@ -33,6 +37,34 @@ termine_version() {
   echo "$v"
 }
 
+# Fassung des Webshops: SHOP_VERSION, sonst die Konstante des Servers
+shop_version() {
+  local v="${SHOP_VERSION:-}"
+  if [ -z "$v" ]; then
+    v="$(timeout 60 node --max-old-space-size=256 --input-type=module -e "const { config } = await import('./server/config.js'); console.log(config.shop.fassung)")"
+  fi
+  [[ "$v" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}$ ]] || { echo "Ungueltige Fassung: $v" >&2; exit 1; }
+  echo "$v"
+}
+
+# Leistungsbeschreibung und AVV des Webshops drucken (je PDF nur, wenn die Pruefsumme der HTML-Seite nicht mehr passt)
+shop_pdfs() {
+  local fassung slug quelle ziel summe
+  fassung="$(shop_version)"
+  for slug in leistungsbeschreibung-webshop avv-webshop; do
+    [ -f "public/rechtliches/$slug-$fassung.html" ] || { echo "HTML fehlt: public/rechtliches/$slug-$fassung.html (zuerst node scripts/build-legal-html.mjs shop)"; exit 1; }
+    quelle="public/rechtliches/$slug-$fassung.html"
+    ziel="public/rechtliches/$slug-$fassung.pdf"
+    summe="$(sha256sum "$quelle" | cut -d' ' -f1)"
+    if [ -z "${FORCE:-}" ] && [ -f "$ziel" ] && [ "$(cat "$ziel.sha256" 2>/dev/null)" = "$summe" ]; then
+      echo "= $ziel (unveraendert)"
+    else
+      pdf "$quelle" "$ziel"
+      echo "$summe" > "$ziel.sha256"
+    fi
+  done
+}
+
 case "$MODE" in
 analyse)
   pdf "public/rechtliches/avv-website-analyse-$ANALYSE_VERSION.html" "public/rechtliches/avv-website-analyse-$ANALYSE_VERSION.pdf"
@@ -53,16 +85,28 @@ termine)
     fi
   done
   ;;
+shop)
+  shop_pdfs
+  ;;
 datenschutz)
-  pdf public/datenschutz.html docs/WEBklar-Datenschutzerklaerung.pdf
+  quelle="public/datenschutz.html"
+  ziel="docs/WEBklar-Datenschutzerklaerung.pdf"
+  summe="$(sha256sum "$quelle" | cut -d' ' -f1)"
+  if [ -z "${FORCE:-}" ] && [ -f "$ziel" ] && [ "$(cat "$ziel.sha256" 2>/dev/null)" = "$summe" ]; then
+    echo "= $ziel (unveraendert)"
+  else
+    pdf public/datenschutz.html docs/WEBklar-Datenschutzerklaerung.pdf
+    echo "$summe" > "$ziel.sha256"
+  fi
   ;;
 all)
   pdf docs/leitfaden-empfehlungsgeber.html docs/WEBklar-Leitfaden-Empfehlungsgeber.pdf
   # Fassung 3 (public/WEBklar-Wartungs-Abo-Vertragsunterlagen.pdf, Archiv unter public/vertragsunterlagen/v3/) wird nicht neu erzeugt
   pdf public/abo-bedingungen.html public/WEBklar-Abo-Vertragsunterlagen.pdf
   pdf public/datenschutz.html docs/WEBklar-Datenschutzerklaerung.pdf
+  shop_pdfs
   ;;
 *)
-  echo "Usage: $0 [all|analyse|termine|datenschutz]"; exit 1
+  echo "Usage: $0 [all|analyse|termine|shop|datenschutz]"; exit 1
   ;;
 esac

scripts/feature-consent-felder-leeren.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * Einmalig (TP2 Abschlusspruefung): IP und Browser der Bestellung von den Funktionsdokumenten (portalFeatures.consentIp,
+ * consentUserAgent) leeren. Neue Bestellungen speichern sie dort nicht mehr; der Nachweis (featureConsents) traegt sie und hat die
+ * Loeschfrist der Datenschutzerklaerung Abschnitt 7 (drei Jahre nach Ablauf des Jahres, in dem das letzte Abo endet). Altbestand am
+ * Funktionsdokument hatte keine Loeschung.
+ *
+ * Geleert wird nur dort, wo der Nachweis die Angabe wirklich traegt: ein featureConsents-Eintrag zur Stripe-Sitzung des Dokuments, dessen
+ * ip bzw. userAgent gesetzt ist, wo das Dokument sie hat. Ohne solchen Nachweis (Bestellung vor dem Nachweis, keine Sitzung) ist die Angabe
+ * am Dokument der einzige Beleg; sie bleibt stehen und wird im Bericht genannt (die Loeschfrist im Aufbewahrungslauf, services/retention.js,
+ * leert sie spaeter). consentText und consentAt bleiben: sie sind kein Personenbezug, der Aufbewahrungslauf leert sie mit.
+ *
+ * Standard ist der Probelauf: zaehlt und listet, schreibt nichts.
+ *   node scripts/feature-consent-felder-leeren.mjs               (= --dry-run)
+ *   node scripts/feature-consent-felder-leeren.mjs --dry-run
+ *   node scripts/feature-consent-felder-leeren.mjs --apply       (leert consentIp und consentUserAgent; danach Bericht)
+ * Im Container als Datei: docker exec -w /app <container> node scripts/feature-consent-felder-leeren.mjs
+ * NICHT gegen Produktion ausfuehren, ohne dass der Probelauf geprueft und die Freigabe da ist.
+ */
+import 'dotenv/config'
+import { pathToFileURL } from 'node:url'
+import { config } from '../server/config.js'
+import { listAllDocuments, updateDocument } from '../server/services/appwriteAdmin.js'
+import { zustimmungFuerSitzung } from '../server/services/featureConsents.js'
+
+/** Aufrufargumente: keine oder --dry-run => Probelauf, --apply => schreiben; alles andere (auch beide zusammen) ist ein Fehler. */
+export function parseArgs(argv = []) {
+  const flags = new Set(argv)
+  const unknown = argv.filter((a) => a !== '--apply' && a !== '--dry-run')
+  if (unknown.length) throw new Error(`Unbekanntes Argument: ${unknown.join(' ')} (erlaubt: --dry-run, --apply)`)
+  if (flags.has('--apply') && flags.has('--dry-run')) throw new Error('--apply und --dry-run schliessen sich aus')
+  return { apply: flags.has('--apply') }
+}
+
+/** Traegt der Nachweis jede Angabe, die am Funktionsdokument steht? */
+const nachweisTraegt = (doc, nachweis) => (!doc.consentIp || Boolean(nachweis.ip)) && (!doc.consentUserAgent || Boolean(nachweis.userAgent))
+
+/**
+ * @param {{ apply?: boolean, log?: (line: string) => void }} [options]
+ * @returns {Promise<{ applied: boolean, total: number, withData: number, clearable: string[], kept: string[], unreadable: string[],
+ *   cleared: number, failed: { id: string, reason: string }[] }>}
+ */
+export async function run({ apply = false, log = console.log } = {}) {
+  const docs = await listAllDocuments(config.collections.portalFeatures)
+  const withData = docs.filter((d) => d.consentIp || d.consentUserAgent)
+  const clearable = []
+  const kept = []
+  const unreadable = []
+  for (const doc of withData) {
+    try {
+      const nachweis = await zustimmungFuerSitzung(doc.stripeSessionId)
+      if (nachweis && nachweisTraegt(doc, nachweis)) clearable.push(doc.$id)
+      else kept.push(doc.$id)
+    } catch (err) {
+      unreadable.push(doc.$id)
+      log(`Nachweis zu Dokument ${doc.$id} nicht lesbar: ${err.message}`)
+    }
+  }
+  log(`Funktionsdokumente: ${docs.length}, davon mit IP/Browser der Bestellung: ${withData.length}`)
+  log(`  zu leeren (der Nachweis in featureConsents traegt die Angabe): ${clearable.length}`)
+  log(`  bleiben (kein tragender Nachweis, die Angabe am Dokument ist der einzige Beleg): ${kept.length}${kept.length ? ` (${kept.join(', ')})` : ''}`)
+  if (unreadable.length) log(`  nicht geprueft (Nachweis nicht lesbar, bleiben): ${unreadable.length} (${unreadable.join(', ')})`)
+
+  const failed = []
+  let cleared = 0
+  if (!apply) {
+    log('Probelauf (--dry-run): es wird nichts geschrieben. Mit --apply werden die oben genannten Dokumente geleert.')
+    return { applied: false, total: docs.length, withData: withData.length, clearable, kept, unreadable, cleared, failed }
+  }
+  for (const id of clearable) {
+    try {
+      await updateDocument(config.collections.portalFeatures, id, { consentIp: '', consentUserAgent: '' })
+      cleared += 1
+    } catch (err) {
+      failed.push({ id, reason: err.message })
+      log(`Dokument ${id} nicht geleert: ${err.message}`)
+    }
+  }
+  log(`Geleert: ${cleared} von ${clearable.length}${failed.length ? `, fehlgeschlagen: ${failed.length} (Skript erneut ausfuehren)` : ''}`)
+  return { applied: true, total: docs.length, withData: withData.length, clearable, kept, unreadable, cleared, failed }
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] || '').href) {
+  try {
+    const { apply } = parseArgs(process.argv.slice(2))
+    const result = await run({ apply })
+    if (result.failed.length || result.unreadable.length) process.exitCode = 1
+  } catch (err) {
+    console.error('Fehler:', err.message)
+    process.exit(1)
+  }
+}

scripts/feature-setup.mjs

@@ -53,6 +53,8 @@ export const FEATURE_CONSENT_ATTRIBUTES = [
 export const FEATURE_CONSENT_INDEXES = [
   { key: 'idx_session', type: 'key', attributes: ['stripeSessionId'] },
   { key: 'idx_project_feature', type: 'key', attributes: ['projectId', 'featureKey', 'acceptedAt'] },
+  // Loeschfristen (services/retention.js): alle Nachweise eines Kunden, drei Jahre nach Ablauf des Jahres, in dem sein letztes Abo endet
+  { key: 'idx_customer', type: 'key', attributes: ['customerId'] },
 ]
 
 /** true, wenn das Ergebnis von main() Luecken meldet (Exit-Code 1 im Pruefmodus) */

scripts/shop-setup.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * Webshop: legt die fuenf Collections shopConfig, shopProducts, shopOrders, shopWiderrufe und shopRechtstexteArchiv mit
+ * Attributen und Indizes in Appwrite an (nur Server-Key, keine Client-Rechte). Das Schema steht in
+ * server/services/shop/schema.js. Idempotent: Vorhandenes wird uebersprungen, fehlende Attribute und Indizes
+ * auch in schon vorhandenen Collections nachgezogen. Vor dem Einschalten (SHOP_ENABLED) ausfuehren.
+ * Usage:
+ *   node scripts/shop-setup.mjs --check   (nur melden, nichts anlegen; Exit 1 bei Fehlendem)
+ *   node scripts/shop-setup.mjs           (Fehlendes anlegen)
+ */
+import { pathToFileURL } from 'node:url'
+import { config } from '../server/config.js'
+import { SHOP_COLLECTIONS } from '../server/services/shop/schema.js'
+import { createAppwriteClient } from './analyse-setup.mjs'
+
+export async function main({ check = false, client, log = console.log } = {}) {
+  const api = client || createAppwriteClient()
+  const missing = []
+  const missingCollections = []
+  const missingIndexes = []
+  const plan = []
+
+  // Erst alles pruefen, dann (ohne --check) anlegen, damit --check garantiert nichts veraendert
+  for (const [name, { attributes, indexes }] of Object.entries(SHOP_COLLECTIONS)) {
+    const id = config.collections[name]
+    const exists = await api.collectionExists(id)
+    const haveAttributes = exists ? new Set((await api.listAttributes(id)).map((a) => a.key)) : new Set()
+    const haveIndexes = exists ? new Set((await api.listIndexes(id)).map((i) => i.key)) : new Set()
+    const absentAttributes = attributes.filter((a) => !haveAttributes.has(a.key))
+    const absentIndexes = indexes.filter((i) => !haveIndexes.has(i.key))
+
+    if (!exists) {
+      log(`${check ? '-' : '+'} Collection ${id}${check ? ' FEHLT' : ''}`)
+      missingCollections.push(id)
+    } else {
+      log(`= ${id}: ${haveAttributes.size} Attribute, ${haveIndexes.size} Indizes vorhanden`)
+    }
+    if (check) {
+      absentAttributes.forEach((a) => log(`- ${id}.${a.key} FEHLT`))
+      absentIndexes.forEach((i) => log(`- Index ${id}.${i.key} FEHLT`))
+    }
+    absentAttributes.forEach((a) => missing.push({ ...a, collection: id }))
+    absentIndexes.forEach((i) => missingIndexes.push({ ...i, collection: id }))
+    plan.push({ id, exists, absentAttributes, absentIndexes })
+  }
+
+  const result = { missing, missingCollections, missingIndexes }
+  if (check) {
+    const open = missing.length + missingCollections.length + missingIndexes.length
+    log(open ? `${open} Eintrag/Eintraege fehlen.` : 'Alles vorhanden.')
+    return result
+  }
+
+  for (const { id, exists, absentAttributes } of plan) {
+    if (!exists) await api.ensureCollection(id, id)
+    for (const attr of absentAttributes) {
+      await api.createAttribute(id, attr)
+      log(`+ Attribut ${id}.${attr.key}`)
+    }
+  }
+  // Indizes brauchen verfuegbare Attribute: erst warten, dann anlegen
+  for (const { id, absentAttributes } of plan) {
+    for (const attr of absentAttributes) await api.waitForAttribute(id, attr.key)
+  }
+  for (const { id, absentIndexes } of plan) {
+    for (const index of absentIndexes) {
+      await api.createIndex(id, index)
+      log(`+ Index ${id}.${index.key}`)
+    }
+  }
+  log('Fertig.')
+  return result
+}
+
+const invokedDirectly = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href
+if (invokedDirectly) {
+  const check = process.argv.includes('--check')
+  main({ check })
+    .then(({ missing, missingCollections, missingIndexes }) =>
+      process.exit(check && (missing.length || missingCollections.length || missingIndexes.length) ? 1 : 0))
+    .catch((e) => {
+      console.error(e.message)
+      process.exit(1)
+    })
+}

scripts/stripe-products.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Stripe-Preise je Produkt (Wartungs-Abo, Hosting-Abo, E-Mail-Zusatzspeicher, News-, Terminplaner- und Oeffnungszeiten-Einrichtung als Einmalpreise): legt fehlende
+ * Stripe-Preise je Produkt (Wartungs-Abo, Hosting-Abo, E-Mail-Zusatzspeicher, News-, Terminplaner-, Webshop- und Oeffnungszeiten-Einrichtung als Einmalpreise): legt fehlende
  * Preise an (ensurePrice), haelt die Wartungs-Produktbeschreibung bei Stripe auf dem Katalogtext
  * (server/config.js) und passt die Kundenportal-Konfiguration an ("WEBklar – Abo verwalten").
  * Idempotent: vorhandene Preise werden ueber lookup_key gefunden, nicht neu angelegt.
@@ -17,7 +17,7 @@ import { config } from '../server/config.js'
 import { ensurePortalConfiguration, ensurePrice, getStripe, PORTAL_HEADLINE } from '../server/services/stripeBilling.js'
 import { PRODUCT_KEYS } from '../server/services/products.js'
 
-export const KEYS = [...PRODUCT_KEYS, 'mailStorage', 'newsSetup', 'termineSetup', 'zeitenSetup'] // ['wartung', 'hosting', 'mailStorage', 'newsSetup', 'termineSetup', 'zeitenSetup']
+export const KEYS = [...PRODUCT_KEYS, 'mailStorage', 'newsSetup', 'termineSetup', 'shopSetup', 'zeitenSetup'] // ['wartung', 'hosting', 'mailStorage', 'newsSetup', 'termineSetup', 'shopSetup', 'zeitenSetup']
 const USAGE = 'Usage: node scripts/stripe-products.mjs --pruefen | --anlegen'
 
 export function parseArgs(argv) {
@@ -31,6 +31,7 @@ export function catalogEntry(key) {
   if (key === 'mailStorage') return config.mailStorage
   if (key === 'newsSetup') return config.newsSetup
   if (key === 'termineSetup') return config.termineSetup
+  if (key === 'shopSetup') return config.shopSetup
   if (key === 'zeitenSetup') return config.zeitenSetup
   return config.products[key]
 }

scripts/termine-texte-archiv.mjs

@@ -91,7 +91,7 @@ export function baueArchiv() {
       'Die Haken stehen immer in der Sie-Form, auch bei Betrieben, die ihre Gäste duzen.',
       '### Vorzeitiger Beginn (Pflicht bei einer Leistung mit Preis für Verbraucher, wenn der Termin vor Ablauf der Widerrufsfrist beginnt, bei Terminanfragen immer)',
       zitat(ZUSTIMMUNG_VORZEITIG(PLATZHALTER_BETRIEB.name)),
-      '### Stornobedingungen (Pflicht, wenn der Betrieb Stornobedingungen hat; der Text der Bedingungen steht beim Betrieb und trägt eine eigene Version)',
+      '### Stornobedingungen (Pflicht bei einer Leistung mit Preis, wenn der Betrieb Stornobedingungen hat; bei kostenlosen Leistungen fragt der Terminplaner nicht danach; der Text der Bedingungen steht beim Betrieb und trägt eine eigene Version)',
       zitat(ZUSTIMMUNG_STORNO),
       '### Erinnerung (freiwillig, nie vorangekreuzt, nur wenn der Betrieb Erinnerungen anbietet)',
       zitat(ZUSTIMMUNG_ERINNERUNG(PLATZHALTER_STUNDEN)),