diff --git a/scripts/unterkunft-setup.mjs b/scripts/unterkunft-setup.mjs new file mode 100644 index 0000000..ed0ed65 --- /dev/null +++ b/scripts/unterkunft-setup.mjs @@ -0,0 +1,85 @@ +#!/usr/bin/env node +/** + * Buchungskalender: legt die sechs Collections ukUnterkuenfte, ukPreise, ukSperren, ukAnfragen, ukRechnungen und ukEinstellungen mit + * Attributen und Indizes in Appwrite an (nur Server-Key, keine Client-Rechte). Das Schema steht in + * server/services/unterkunft/schema.js. Idempotent: Vorhandenes wird uebersprungen, fehlende Attribute und Indizes + * auch in schon vorhandenen Collections nachgezogen. Vor dem Einschalten (UNTERKUNFT_ENABLED) ausfuehren. + * Usage: + * node scripts/unterkunft-setup.mjs --check (nur melden, nichts anlegen; Exit 1 bei Fehlendem) + * node scripts/unterkunft-setup.mjs (Fehlendes anlegen) + */ +import { pathToFileURL } from 'node:url' +import { config } from '../server/config.js' +import { UNTERKUNFT_COLLECTIONS } from '../server/services/unterkunft/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(UNTERKUNFT_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) + }) +} diff --git a/server/config.js b/server/config.js index f300977..36c2fe2 100644 --- a/server/config.js +++ b/server/config.js @@ -31,6 +31,7 @@ function nonNegativeNumber(raw, fallback) { const termineEnabled = (process.env.TERMINE_ENABLED || '').trim().toLowerCase() const shopEnabled = (process.env.SHOP_ENABLED || '').trim().toLowerCase() +const unterkunftEnabled = (process.env.UNTERKUNFT_ENABLED || '').trim().toLowerCase() const zeitenEnabled = (process.env.ZEITEN_ENABLED || '').trim().toLowerCase() /** Komma-Liste aus einer Umgebungsvariablen: getrimmt, klein geschrieben, ohne Leereintraege; leer ergibt den Vorgabewert. */ @@ -137,6 +138,16 @@ const shopSetup = { priceNickname: 'Webshop-Einrichtung 299 €', } +// Buchungskalender (Funktionsschluessel 'unterkunft'): einmalige Einrichtung (Einmalpreis, kein Abo) +const unterkunftSetup = { + key: 'unterkunftSetup', + name: 'Buchungskalender (Einrichtung)', + amountCents: 19900, + lookupKey: 'webklar_unterkunft_einrichtung_19900', + oneTime: true, + priceNickname: 'Buchungskalender-Einrichtung 199 €', +} + // Oeffnungszeiten live: einmalige Einrichtung (Einmalpreis, kein Abo); im Wartungs-Abo ist die Funktion enthalten const zeitenSetup = { key: 'zeitenSetup', @@ -631,6 +642,13 @@ export const config = { shopOrders: process.env.APPWRITE_COLLECTION_SHOP_ORDERS || 'shopOrders', shopWiderrufe: process.env.APPWRITE_COLLECTION_SHOP_WIDERRUFE || 'shopWiderrufe', shopRechtstexteArchiv: process.env.APPWRITE_COLLECTION_SHOP_RECHTSTEXTE_ARCHIV || 'shopRechtstexteArchiv', + // Buchungskalender (Unterkuenfte, Preise, Sperren, Anfragen, Rechnungen, Einstellungen; scripts/unterkunft-setup.mjs) + ukUnterkuenfte: process.env.APPWRITE_COLLECTION_UK_UNTERKUENFTE || 'ukUnterkuenfte', + ukPreise: process.env.APPWRITE_COLLECTION_UK_PREISE || 'ukPreise', + ukSperren: process.env.APPWRITE_COLLECTION_UK_SPERREN || 'ukSperren', + ukAnfragen: process.env.APPWRITE_COLLECTION_UK_ANFRAGEN || 'ukAnfragen', + ukRechnungen: process.env.APPWRITE_COLLECTION_UK_RECHNUNGEN || 'ukRechnungen', + ukEinstellungen: process.env.APPWRITE_COLLECTION_UK_EINSTELLUNGEN || 'ukEinstellungen', // Oeffnungszeiten live (Einstellungen, Erinnerungsmerker; scripts/zeiten-setup.mjs) oeffnungszeiten: process.env.APPWRITE_COLLECTION_OEFFNUNGSZEITEN || 'oeffnungszeiten', zeitenErinnerungen: process.env.APPWRITE_COLLECTION_ZEITEN_ERINNERUNGEN || 'zeitenErinnerungen', @@ -651,6 +669,7 @@ export const config = { newsSetup, termineSetup, shopSetup, + unterkunftSetup, zeitenSetup, ustHinweis, // Register der kaufbaren Funktionen (siehe oben) @@ -915,6 +934,47 @@ export const config = { unbezahltLoeschTage: 30, }, + // Buchungskalender (Funktionsschluessel 'unterkunft'). Wird bei jedem Aufruf gelesen (Tests aendern die Werte zur + // Laufzeit); Schalter siehe server/services/unterkunft/schalter.js + unterkunft: { + // off (Vorgabe) | pilot (nur UNTERKUNFT_PILOT_EMAILS) | on (alle Kunden) + mode: ['pilot', 'on'].includes(unterkunftEnabled) ? unterkunftEnabled : 'off', + // Kunden-E-Mails fuer den Pilotbetrieb; '*' = alle + pilotEmails: (process.env.UNTERKUNFT_PILOT_EMAILS || '') + .split(',') + .map((s) => s.trim().toLowerCase()) + .filter(Boolean), + // Fassung der Rechtstexte: Berliner Kalendertag (JJJJ-MM-TT); eine ausgelieferte Fassung wird nie ueberschrieben + fassung: '2026-10-07', + // Mindestzeit (Sekunden) zwischen Laden und Absenden des Anfrageformulars (schneller = Bot) + formMinSekunden: nonNegativeNumber(process.env.UNTERKUNFT_FORM_MIN_SEKUNDEN, 3), + // Kuerzeste Antwortzeit (ms) der POST-Routen der oeffentlichen Schnittstelle. Tests setzen 0. + minAntwortMs: nonNegativeNumber(process.env.UNTERKUNFT_MIN_ANTWORT_MS, 300), + // iCal-Import: Abrufintervall, Groessen-/Zeitgrenzen, Fehlermail nach so vielen Stunden anhaltenden Fehlern + icalIntervallMin: 15, + icalMaxBytes: 1_000_000, + icalTimeoutMs: 10_000, + icalFehlerStunden: 6, + // Buchbar sind so viele Monate in die Zukunft + horizontMonate: 18, + maxPosten: 30, + postenTextMax: 200, + nachrichtMax: 2000, + // Anfragen je Unterkunfts-Seite und Stunde (Missbrauchsbremse) + anfragenJeSiteStunde: 30, + // IP-Hashes werden nach so vielen Tagen geloescht + ipHashTage: 30, + // Unverbindliche Anfragen werden nach so vielen Monaten anonymisiert/geloescht + unverbindlichMonate: 6, + // Offene (neue) Anfragen verfallen nach so vielen Tagen + neuVerfallTage: 60, + // Anfragen werden so viele Jahre nach Abschluss anonymisiert; Rechnungen bleiben rechnungJahre Jahre + anonymisierenJahre: 3, + rechnungJahre: 8, + // Tage nach Abschalten der Funktion bis zur Loeschung der Daten + loeschTageNachAbschalten: 90, + }, + // Oeffnungszeiten live (Funktionsschluessel 'zeiten'); Geschwister von termine (termineSchalter.test.js pinnt // config.termine). Wird bei jedem Aufruf gelesen; Schalter siehe server/services/zeiten/schalter.js zeiten: { diff --git a/server/services/unterkunft/schalter.js b/server/services/unterkunft/schalter.js new file mode 100644 index 0000000..3fac8d0 --- /dev/null +++ b/server/services/unterkunft/schalter.js @@ -0,0 +1,26 @@ +import { config } from '../../config.js' + +/** + * Buchungskalender-Schalter (Funktionsschluessel 'unterkunft'): UNTERKUNFT_ENABLED = off (Vorgabe) | pilot | on. + * Liest config.unterkunft bei jedem Aufruf. Bei off laufen keine Jobs und keine Abfragen des Moduls. + */ + +/** 'off' | 'pilot' | 'on'; alles andere (leer, unbekannt) gilt als off. */ +export function unterkunftModus() { + const mode = config.unterkunft.mode + return mode === 'pilot' || mode === 'on' ? mode : 'off' +} + +/** + * Darf dieser Kunde den Buchungskalender nutzen? pilot = nur Adressen aus UNTERKUNFT_PILOT_EMAILS ('*' = alle; eine leere + * Liste laesst niemanden durch); on = alle Kunden; off = niemand. + */ +export function unterkunftFuerKunde(email) { + const modus = unterkunftModus() + if (modus === 'off') return false + if (modus === 'on') return true + const erlaubt = config.unterkunft.pilotEmails + if (erlaubt.includes('*')) return true + const adresse = String(email || '').trim().toLowerCase() + return adresse !== '' && erlaubt.includes(adresse) +} diff --git a/server/services/unterkunft/schema.js b/server/services/unterkunft/schema.js new file mode 100644 index 0000000..55cbf10 --- /dev/null +++ b/server/services/unterkunft/schema.js @@ -0,0 +1,157 @@ +/** + * Buchungskalender: Appwrite-Schema der sechs Collections (Spezifikation 2026-10-07-buchungskalender-design.md, Abschnitt 3). + * Reine Daten, absichtlich ohne Import von server/config.js (wie shop/schema.js: test/support/schema.js liest sie vor + * useTestEnv()). Die Collection-IDs stehen in config.collections.; scripts/unterkunft-setup.mjs legt alles an. + * Kein Feld heisst data; JSON-Felder sind Text. ukEinstellungen: Dokument-ID = featureId. + * + * Attribut: { key, type: 'string' | 'integer' | 'boolean' | 'datetime', size (nur Text), required: false } + * Index: { key, type: 'key', attributes: [...] } + * Datumswerte (dt) sind UTC (toISOString()); Kalendertage (von, bis, datum) sind Text YYYY-MM-DD (Berlin). + */ + +const str = (key, size) => ({ key, type: 'string', size, required: false }) +const int = (key) => ({ key, type: 'integer', required: false }) +const bool = (key) => ({ key, type: 'boolean', required: false }) +const dt = (key) => ({ key, type: 'datetime', required: false }) +const index = (key, ...attributes) => ({ key, type: 'key', attributes }) + +export const UNTERKUNFT_COLLECTIONS = { + ukUnterkuenfte: { + attributes: [ + str('featureId', 36), + str('customerId', 36), + str('projectId', 36), + str('name', 120), + str('beschreibung', 500), + int('maxPersonen'), + int('mindestNaechte'), + str('checkIn', 5), + str('checkOut', 5), + int('sort'), + bool('aktiv'), + str('icalImporte', 4000), + str('icalExportToken', 64), + ], + indexes: [index('idx_feature', 'featureId')], + }, + ukPreise: { + attributes: [ + str('unterkunftId', 36), + str('featureId', 36), + str('staffeln', 2000), + int('reinigungCent'), + int('personenInklusive'), + int('aufpreisPersonNachtCent'), + int('direktrabattProzent'), + str('steuerart', 20), + int('ustUebernachtung'), + int('ustReinigung'), + int('fristTage'), + str('stornobedingungen', 5000), + ], + indexes: [index('idx_unterkunft', 'unterkunftId')], + }, + ukSperren: { + attributes: [ + str('unterkunftId', 36), + str('featureId', 36), + str('von', 10), + str('bis', 10), + str('quelle', 60), + str('notiz', 200), + ], + indexes: [index('idx_unterkunft', 'unterkunftId'), index('idx_unterkunft_quelle', 'unterkunftId', 'quelle')], + }, + ukAnfragen: { + attributes: [ + str('featureId', 36), + str('customerId', 36), + str('projectId', 36), + str('unterkunftId', 36), + str('nummer', 12), + str('von', 10), + str('bis', 10), + int('personen'), + str('status', 12), + str('gast', 3000), + str('rechnungsadresse', 1500), + str('posten', 8000), + str('summen', 1000), + str('nachrichtVermieter', 2000), + dt('fristAt'), + str('tokenHash', 64), + str('zahlart', 8), + str('bezahltVia', 8), + dt('bezahltAt'), + str('stripeSessionId', 100), + str('stripePaymentIntentId', 100), + int('erstattetCent'), + str('stornoGrund', 500), + str('stornobedingungenText', 5000), + str('rechtstexteFassung', 20), + str('ipHash', 16), + dt('freigegebenAt'), + dt('gebuchtAt'), + dt('abgelehntAt'), + dt('abgelaufenAt'), + dt('storniertAt'), + str('rechnungId', 36), + dt('anonymisiertAt'), + ], + indexes: [ + index('idx_feature', 'featureId'), + index('idx_unterkunft', 'unterkunftId'), + index('idx_unterkunft_status', 'unterkunftId', 'status'), + index('idx_status', 'status'), + ], + }, + ukRechnungen: { + attributes: [ + str('featureId', 36), + str('anfrageId', 36), + str('art', 8), + str('nummer', 24), + str('datum', 10), + int('bruttoCent'), + str('inhalt', 20000), + ], + indexes: [index('idx_feature', 'featureId'), index('idx_anfrage', 'anfrageId'), index('idx_feature_nummer', 'featureId', 'nummer')], + }, + ukEinstellungen: { + attributes: [ + str('featureId', 36), + str('firma', 150), + str('inhaber', 150), + str('strasse', 150), + str('plz', 10), + str('ort', 100), + str('email', 200), + str('telefon', 50), + str('steuernummer', 30), + str('ustId', 20), + str('iban', 34), + str('bic', 11), + str('bank', 100), + str('rechnungsPraefix', 8), + str('rechnungZaehler', 100), + str('akzentfarbe', 7), + str('stripeAccountId', 40), + str('stripeStatus', 4000), + bool('onlineZahlung'), + dt('rechnungAuftragAt'), + str('anfrage', 2000), + str('anfrageStatus', 16), + dt('anfrageAt'), + dt('anfrageEntschiedenAt'), + str('anfrageEntschiedenVon', 120), + str('anfrageBegruendung', 1000), + dt('icalFehlerMailAt'), + ], + indexes: [index('idx_feature', 'featureId')], + }, +} + +/** Je Collection die datetime-Attribute (der Appwrite-Nachbau der Tests normalisiert sie). */ +export const UNTERKUNFT_DATETIMES = Object.fromEntries( + Object.entries(UNTERKUNFT_COLLECTIONS).map(([name, { attributes }]) => [name, attributes.filter((a) => a.type === 'datetime').map((a) => a.key)]), +) diff --git a/test/support/schema.js b/test/support/schema.js index 7c9c06b..0c0fc3a 100644 --- a/test/support/schema.js +++ b/test/support/schema.js @@ -1,6 +1,7 @@ import { readFileSync } from 'node:fs' import { TERMINE_COLLECTIONS } from '../../server/services/termine/schema.js' import { SHOP_COLLECTIONS } from '../../server/services/shop/schema.js' +import { UNTERKUNFT_COLLECTIONS } from '../../server/services/unterkunft/schema.js' import { ZEITEN_COLLECTIONS, ZEITEN_FEATURE_ATTRIBUTES } from '../../server/services/zeiten/schema.js' import { FEATURE_CONSENT_ATTRIBUTES, PORTAL_FEATURE_ATTRIBUTES } from '../../scripts/feature-setup.mjs' @@ -13,6 +14,7 @@ const SETUP_SCRIPTS = ['setup-abo-collections.mjs', 'setup-finanzen.mjs'] * Schreibt der Code ein Feld, das das Setup-Skript nicht anlegt, scheitert der Test wie Appwrite in * Produktion. Die Termine-Collections kommen aus server/services/termine/schema.js (scripts/termine-setup.mjs), * die Shop-Collections aus server/services/shop/schema.js (scripts/shop-setup.mjs), + * die Buchungskalender-Collections aus server/services/unterkunft/schema.js (scripts/unterkunft-setup.mjs), * die Zeiten-Collections aus server/services/zeiten/schema.js (scripts/zeiten-setup.mjs); * portalFeatures bekommt zusaetzlich die Attribute aus scripts/feature-setup.mjs (PORTAL_FEATURE_ATTRIBUTES) und die * Zeiten-Felder aus server/services/zeiten/schema.js (ZEITEN_FEATURE_ATTRIBUTES, angelegt von scripts/zeiten-setup.mjs); @@ -21,6 +23,7 @@ const SETUP_SCRIPTS = ['setup-abo-collections.mjs', 'setup-finanzen.mjs'] export function schemaKeys(collection) { if (Object.hasOwn(TERMINE_COLLECTIONS, collection)) return TERMINE_COLLECTIONS[collection].attributes.map((a) => a.key) if (Object.hasOwn(SHOP_COLLECTIONS, collection)) return SHOP_COLLECTIONS[collection].attributes.map((a) => a.key) + if (Object.hasOwn(UNTERKUNFT_COLLECTIONS, collection)) return UNTERKUNFT_COLLECTIONS[collection].attributes.map((a) => a.key) if (Object.hasOwn(ZEITEN_COLLECTIONS, collection)) return ZEITEN_COLLECTIONS[collection].attributes.map((a) => a.key) if (collection === 'featureConsents') return FEATURE_CONSENT_ATTRIBUTES.map((a) => a.key) for (const script of SETUP_SCRIPTS) { diff --git a/test/unterkunftSchalter.test.js b/test/unterkunftSchalter.test.js new file mode 100644 index 0000000..20303ac --- /dev/null +++ b/test/unterkunftSchalter.test.js @@ -0,0 +1,162 @@ +import { test, beforeEach, afterEach } from 'node:test' +import assert from 'node:assert/strict' +import { config } from '../server/config.js' +import { unterkunftFuerKunde, unterkunftModus } from '../server/services/unterkunft/schalter.js' + +const UK_ENV = [ + 'UNTERKUNFT_ENABLED', + 'UNTERKUNFT_PILOT_EMAILS', + 'UNTERKUNFT_FORM_MIN_SEKUNDEN', + 'UNTERKUNFT_MIN_ANTWORT_MS', + 'APPWRITE_COLLECTION_UK_UNTERKUENFTE', + 'APPWRITE_COLLECTION_UK_PREISE', + 'APPWRITE_COLLECTION_UK_SPERREN', + 'APPWRITE_COLLECTION_UK_ANFRAGEN', + 'APPWRITE_COLLECTION_UK_RECHNUNGEN', + 'APPWRITE_COLLECTION_UK_EINSTELLUNGEN', +] + +let original +beforeEach(() => { + original = { ...config.unterkunft } +}) +afterEach(() => { + Object.assign(config.unterkunft, original) +}) + +/** Frische config.js-Instanz mit genau diesen Umgebungsvariablen (alle anderen des Moduls entfernt). */ +let freshCounter = 0 +async function freshConfig(env = {}) { + const saved = Object.fromEntries(UK_ENV.map((key) => [key, process.env[key]])) + for (const key of UK_ENV) delete process.env[key] + Object.assign(process.env, env) + try { + freshCounter += 1 + return (await import(`../server/config.js?uk-test=${freshCounter}`)).config + } finally { + for (const key of UK_ENV) { + if (saved[key] === undefined) delete process.env[key] + else process.env[key] = saved[key] + } + } +} + +test('Konfiguration: Vorgaben ohne Umgebungsvariablen', async () => { + const fresh = await freshConfig() + assert.deepEqual(fresh.unterkunft, { + mode: 'off', + pilotEmails: [], + fassung: '2026-10-07', + formMinSekunden: 3, + minAntwortMs: 300, + icalIntervallMin: 15, + icalMaxBytes: 1_000_000, + icalTimeoutMs: 10_000, + icalFehlerStunden: 6, + horizontMonate: 18, + maxPosten: 30, + postenTextMax: 200, + nachrichtMax: 2000, + anfragenJeSiteStunde: 30, + ipHashTage: 30, + unverbindlichMonate: 6, + neuVerfallTage: 60, + anonymisierenJahre: 3, + rechnungJahre: 8, + loeschTageNachAbschalten: 90, + }) + assert.equal(fresh.collections.ukUnterkuenfte, 'ukUnterkuenfte') + assert.equal(fresh.collections.ukPreise, 'ukPreise') + assert.equal(fresh.collections.ukSperren, 'ukSperren') + assert.equal(fresh.collections.ukAnfragen, 'ukAnfragen') + assert.equal(fresh.collections.ukRechnungen, 'ukRechnungen') + assert.equal(fresh.collections.ukEinstellungen, 'ukEinstellungen') +}) + +test('Konfiguration: Umgebungsvariablen werden gelesen und bereinigt', async () => { + const fresh = await freshConfig({ + UNTERKUNFT_ENABLED: ' Pilot ', + UNTERKUNFT_PILOT_EMAILS: ' Kenso.Gri@Gmail.com, ,justin@webklar.com ', + UNTERKUNFT_FORM_MIN_SEKUNDEN: '0', + UNTERKUNFT_MIN_ANTWORT_MS: '0', + APPWRITE_COLLECTION_UK_UNTERKUENFTE: 'u1', + APPWRITE_COLLECTION_UK_PREISE: 'u2', + APPWRITE_COLLECTION_UK_SPERREN: 'u3', + APPWRITE_COLLECTION_UK_ANFRAGEN: 'u4', + APPWRITE_COLLECTION_UK_RECHNUNGEN: 'u5', + APPWRITE_COLLECTION_UK_EINSTELLUNGEN: 'u6', + }) + assert.equal(fresh.unterkunft.mode, 'pilot') + assert.deepEqual(fresh.unterkunft.pilotEmails, ['kenso.gri@gmail.com', 'justin@webklar.com']) + assert.equal(fresh.unterkunft.formMinSekunden, 0) + assert.equal(fresh.unterkunft.minAntwortMs, 0) + const c = fresh.collections + assert.deepEqual([c.ukUnterkuenfte, c.ukPreise, c.ukSperren, c.ukAnfragen, c.ukRechnungen, c.ukEinstellungen], ['u1', 'u2', 'u3', 'u4', 'u5', 'u6']) +}) + +test('Konfiguration: leerer oder unbekannter Schalter ist off', async () => { + for (const value of ['', ' ', 'banane', 'true', '1', 'ON ']) { + const fresh = await freshConfig({ UNTERKUNFT_ENABLED: value }) + assert.equal(fresh.unterkunft.mode, value.trim().toLowerCase() === 'on' ? 'on' : 'off', `UNTERKUNFT_ENABLED=${JSON.stringify(value)}`) + } +}) + +test('Konfiguration: Katalogeintrag unterkunftSetup', () => { + assert.deepEqual(config.unterkunftSetup, { + key: 'unterkunftSetup', + name: 'Buchungskalender (Einrichtung)', + amountCents: 19900, + lookupKey: 'webklar_unterkunft_einrichtung_19900', + oneTime: true, + priceNickname: 'Buchungskalender-Einrichtung 199 €', + }) +}) + +test('unterkunftModus: leer und unbekannt sind off, pilot und on bleiben, Aenderung wirkt sofort', () => { + for (const value of [undefined, null, '', 'banane', 'PILOT', 'true']) { + config.unterkunft.mode = value + assert.equal(unterkunftModus(), 'off', `mode=${JSON.stringify(value)}`) + } + config.unterkunft.mode = 'pilot' + assert.equal(unterkunftModus(), 'pilot') + config.unterkunft.mode = 'on' + assert.equal(unterkunftModus(), 'on') + config.unterkunft.mode = 'off' + assert.equal(unterkunftModus(), 'off') +}) + +test('unterkunftFuerKunde: off sperrt alle, auch mit Stern in der Liste', () => { + config.unterkunft.mode = 'off' + config.unterkunft.pilotEmails = ['*', 'kenso.gri@gmail.com'] + assert.equal(unterkunftFuerKunde('kenso.gri@gmail.com'), false) + assert.equal(unterkunftFuerKunde('jemand@example.com'), false) +}) + +test('unterkunftFuerKunde: pilot erlaubt nur Adressen der Liste, Schreibweise egal', () => { + config.unterkunft.mode = 'pilot' + config.unterkunft.pilotEmails = ['kenso.gri@gmail.com'] + assert.equal(unterkunftFuerKunde('kenso.gri@gmail.com'), true) + assert.equal(unterkunftFuerKunde(' Kenso.Gri@Gmail.com '), true) + assert.equal(unterkunftFuerKunde('jemand@example.com'), false) + assert.equal(unterkunftFuerKunde(''), false) + assert.equal(unterkunftFuerKunde(undefined), false) + assert.equal(unterkunftFuerKunde(null), false) +}) + +test('unterkunftFuerKunde: pilot mit leerer Liste laesst niemanden durch, Stern alle', () => { + config.unterkunft.mode = 'pilot' + config.unterkunft.pilotEmails = [] + assert.equal(unterkunftFuerKunde('kenso.gri@gmail.com'), false) + config.unterkunft.pilotEmails = ['*'] + assert.equal(unterkunftFuerKunde('jemand@example.com'), true) + assert.equal(unterkunftFuerKunde(''), true) +}) + +test('unterkunftFuerKunde: on erlaubt alle Kunden; unbekannter Modus gilt als off', () => { + config.unterkunft.mode = 'on' + config.unterkunft.pilotEmails = [] + assert.equal(unterkunftFuerKunde('jemand@example.com'), true) + config.unterkunft.mode = 'banane' + config.unterkunft.pilotEmails = ['*'] + assert.equal(unterkunftFuerKunde('kenso.gri@gmail.com'), false) +}) diff --git a/test/unterkunftSetup.test.js b/test/unterkunftSetup.test.js new file mode 100644 index 0000000..5eed07b --- /dev/null +++ b/test/unterkunftSetup.test.js @@ -0,0 +1,235 @@ +import { test, after } from 'node:test' +import assert from 'node:assert/strict' +import { startAppwriteMock } from './support/appwriteMock.js' +import { startFakeStripe } from './support/fakeStripe.js' +import { useTestEnv } from './support/testEnv.js' +import { schemaKeys } from './support/schema.js' +import { UNTERKUNFT_COLLECTIONS, UNTERKUNFT_DATETIMES } from '../server/services/unterkunft/schema.js' + +const aw = await startAppwriteMock({ schema: { ukEinstellungen: schemaKeys('ukEinstellungen') }, datetimes: UNTERKUNFT_DATETIMES }) +const st = await startFakeStripe() +useTestEnv({ appwriteUrl: aw.url, stripeUrl: st.url }) +const { config } = await import('../server/config.js') +const { main } = await import('../scripts/unterkunft-setup.mjs') +const { createDocument, updateDocument, getDocument } = await import('../server/services/appwriteAdmin.js') +after(() => Promise.all([aw.close(), st.close()])) + +const NAMES = ['ukUnterkuenfte', 'ukPreise', 'ukSperren', 'ukAnfragen', 'ukRechnungen', 'ukEinstellungen'] +const keysOf = (name) => UNTERKUNFT_COLLECTIONS[name].attributes.map((a) => a.key) +const byKey = (name) => Object.fromEntries(UNTERKUNFT_COLLECTIONS[name].attributes.map((a) => [a.key, a])) + +/** Appwrite-Client mit Zustand (wie shopSetup.test.js): Attribute nur in vorhandenen Collections, Indizes nur auf vorhandenen Attributen. */ +function fakeClient(initial = {}) { + const state = new Map( + Object.entries(initial).map(([id, c]) => [id, { attrs: new Map((c.attrs || []).map((key) => [key, null])), indexes: new Set(c.indexes || []) }]), + ) + const calls = { collections: [], attrs: [], indexes: [] } + const need = (id) => { + if (!state.has(id)) throw Object.assign(new Error(`Collection ${id} fehlt`), { status: 404 }) + return state.get(id) + } + return { + state, + calls, + async collectionExists(id) { + return state.has(id) + }, + async ensureCollection(id, name) { + if (state.has(id)) return false + state.set(id, { attrs: new Map(), indexes: new Set() }) + calls.collections.push({ id, name }) + return true + }, + async listAttributes(id) { + return [...need(id).attrs.keys()].map((key) => ({ key })) + }, + async createAttribute(id, attr) { + const collection = need(id) + if (collection.attrs.has(attr.key)) throw new Error(`Attribut ${id}.${attr.key} existiert schon`) + collection.attrs.set(attr.key, attr) + calls.attrs.push(`${id}.${attr.key}`) + }, + async waitForAttribute(id, key) { + assert.ok(need(id).attrs.has(key), `wartet auf nie angelegtes Attribut ${id}.${key}`) + }, + async listIndexes(id) { + return [...need(id).indexes].map((key) => ({ key })) + }, + async createIndex(id, index) { + const collection = need(id) + for (const key of index.attributes) { + if (!collection.attrs.has(key)) throw new Error(`Index ${index.key}: Attribut ${key} fehlt in ${id}`) + } + collection.indexes.add(index.key) + calls.indexes.push(`${id}.${index.key}`) + }, + } +} + +const quiet = () => {} +const expectedAttrs = NAMES.flatMap((name) => keysOf(name).map((key) => `${config.collections[name]}.${key}`)) +const expectedIndexes = NAMES.flatMap((name) => UNTERKUNFT_COLLECTIONS[name].indexes.map((i) => `${config.collections[name]}.${i.key}`)) + +test('Schema: Attribute je Collection wie in der Spezifikation', () => { + assert.deepEqual(Object.keys(UNTERKUNFT_COLLECTIONS), NAMES) + assert.deepEqual(keysOf('ukUnterkuenfte'), [ + 'featureId', 'customerId', 'projectId', 'name', 'beschreibung', 'maxPersonen', 'mindestNaechte', 'checkIn', 'checkOut', + 'sort', 'aktiv', 'icalImporte', 'icalExportToken', + ]) + assert.deepEqual(keysOf('ukPreise'), [ + 'unterkunftId', 'featureId', 'staffeln', 'reinigungCent', 'personenInklusive', 'aufpreisPersonNachtCent', + 'direktrabattProzent', 'steuerart', 'ustUebernachtung', 'ustReinigung', 'fristTage', 'stornobedingungen', + ]) + assert.deepEqual(keysOf('ukSperren'), ['unterkunftId', 'featureId', 'von', 'bis', 'quelle', 'notiz']) + assert.deepEqual(keysOf('ukAnfragen'), [ + 'featureId', 'customerId', 'projectId', 'unterkunftId', 'nummer', 'von', 'bis', 'personen', 'status', 'gast', + 'rechnungsadresse', 'posten', 'summen', 'nachrichtVermieter', 'fristAt', 'tokenHash', 'zahlart', 'bezahltVia', 'bezahltAt', + 'stripeSessionId', 'stripePaymentIntentId', 'erstattetCent', 'stornoGrund', 'stornobedingungenText', 'rechtstexteFassung', + 'ipHash', 'freigegebenAt', 'gebuchtAt', 'abgelehntAt', 'abgelaufenAt', 'storniertAt', 'rechnungId', 'anonymisiertAt', + ]) + assert.deepEqual(keysOf('ukRechnungen'), ['featureId', 'anfrageId', 'art', 'nummer', 'datum', 'bruttoCent', 'inhalt']) + assert.deepEqual(keysOf('ukEinstellungen'), [ + 'featureId', 'firma', 'inhaber', 'strasse', 'plz', 'ort', 'email', 'telefon', 'steuernummer', 'ustId', 'iban', 'bic', 'bank', + 'rechnungsPraefix', 'rechnungZaehler', 'akzentfarbe', 'stripeAccountId', 'stripeStatus', 'onlineZahlung', 'rechnungAuftragAt', + 'anfrage', 'anfrageStatus', 'anfrageAt', 'anfrageEntschiedenAt', 'anfrageEntschiedenVon', 'anfrageBegruendung', 'icalFehlerMailAt', + ]) +}) + +test('Schema: Typen und Groessen', () => { + const sizes = { + ukUnterkuenfte: { featureId: 36, name: 120, beschreibung: 500, checkIn: 5, checkOut: 5, icalImporte: 4000, icalExportToken: 64 }, + ukPreise: { unterkunftId: 36, staffeln: 2000, steuerart: 20, stornobedingungen: 5000 }, + ukSperren: { von: 10, bis: 10, quelle: 60, notiz: 200 }, + ukAnfragen: { + nummer: 12, status: 12, gast: 3000, rechnungsadresse: 1500, posten: 8000, summen: 1000, nachrichtVermieter: 2000, + tokenHash: 64, zahlart: 8, bezahltVia: 8, stripeSessionId: 100, stripePaymentIntentId: 100, stornoGrund: 500, + stornobedingungenText: 5000, rechtstexteFassung: 20, ipHash: 16, rechnungId: 36, + }, + ukRechnungen: { art: 8, nummer: 24, datum: 10, inhalt: 20000 }, + ukEinstellungen: { + firma: 150, plz: 10, ort: 100, email: 200, telefon: 50, steuernummer: 30, ustId: 20, iban: 34, bic: 11, bank: 100, + rechnungsPraefix: 8, rechnungZaehler: 100, akzentfarbe: 7, stripeAccountId: 40, stripeStatus: 4000, anfrage: 2000, + anfrageStatus: 16, anfrageEntschiedenVon: 120, anfrageBegruendung: 1000, + }, + } + for (const [name, map] of Object.entries(sizes)) { + for (const [key, size] of Object.entries(map)) assert.deepEqual([byKey(name)[key].type, byKey(name)[key].size], ['string', size], `${name}.${key}`) + } + const ints = { + ukUnterkuenfte: ['maxPersonen', 'mindestNaechte', 'sort'], + ukPreise: ['reinigungCent', 'personenInklusive', 'aufpreisPersonNachtCent', 'direktrabattProzent', 'ustUebernachtung', 'ustReinigung', 'fristTage'], + ukAnfragen: ['personen', 'erstattetCent'], + ukRechnungen: ['bruttoCent'], + } + for (const [name, keys] of Object.entries(ints)) for (const key of keys) assert.equal(byKey(name)[key].type, 'integer', `${name}.${key}`) + assert.equal(byKey('ukUnterkuenfte').aktiv.type, 'boolean') + assert.equal(byKey('ukEinstellungen').onlineZahlung.type, 'boolean') +}) + +test('Schema: jedes Attribut ist optional, hat gueltige Form und Schluessel (kein Feld data)', () => { + for (const name of NAMES) { + const { attributes } = UNTERKUNFT_COLLECTIONS[name] + assert.equal(new Set(attributes.map((a) => a.key)).size, attributes.length, `${name}: doppelte Schluessel`) + for (const attr of attributes) { + assert.match(attr.key, /^[A-Za-z][A-Za-z0-9]{0,35}$/, `${name}.${attr.key}`) + assert.notEqual(attr.key, 'data', `${name}: Feld data ist verboten`) + assert.equal(attr.required, false, `${name}.${attr.key}`) + assert.ok(['string', 'integer', 'boolean', 'datetime'].includes(attr.type)) + if (attr.type === 'string') assert.ok(Number.isInteger(attr.size) && attr.size > 0, `${name}.${attr.key}: Groesse`) + else assert.equal('size' in attr, false, `${name}.${attr.key}: Groesse nur bei Text`) + } + } +}) + +test('Schema: Indizes wie in der Spezifikation und nur auf vorhandenen Attributen', () => { + const idx = (name) => UNTERKUNFT_COLLECTIONS[name].indexes.map((i) => i.attributes.join('+')) + assert.deepEqual(idx('ukUnterkuenfte'), ['featureId']) + assert.deepEqual(idx('ukPreise'), ['unterkunftId']) + assert.deepEqual(idx('ukSperren'), ['unterkunftId', 'unterkunftId+quelle']) + assert.deepEqual(idx('ukAnfragen'), ['featureId', 'unterkunftId', 'unterkunftId+status', 'status']) + assert.deepEqual(idx('ukRechnungen'), ['featureId', 'anfrageId', 'featureId+nummer']) + for (const name of NAMES) { + const keys = new Set() + for (const index of UNTERKUNFT_COLLECTIONS[name].indexes) { + assert.equal(index.type, 'key') + assert.ok(!keys.has(index.key), `${name}: doppelter Index ${index.key}`) + keys.add(index.key) + assert.ok(index.attributes.every((key) => keysOf(name).includes(key)), `${name}.${index.key}`) + } + } +}) + +test('Schema: UNTERKUNFT_DATETIMES nennt je Collection genau die datetime-Attribute', () => { + assert.deepEqual(Object.keys(UNTERKUNFT_DATETIMES), NAMES) + assert.deepEqual(UNTERKUNFT_DATETIMES.ukAnfragen, [ + 'fristAt', 'bezahltAt', 'freigegebenAt', 'gebuchtAt', 'abgelehntAt', 'abgelaufenAt', 'storniertAt', 'anonymisiertAt', + ]) + assert.deepEqual(UNTERKUNFT_DATETIMES.ukUnterkuenfte, []) + assert.deepEqual(UNTERKUNFT_DATETIMES.ukEinstellungen, ['rechnungAuftragAt', 'anfrageAt', 'anfrageEntschiedenAt', 'icalFehlerMailAt']) +}) + +test('schemaKeys kennt die Collections; bestehende Setup-Skripte funktionieren weiter', () => { + for (const name of NAMES) assert.deepEqual(schemaKeys(name), keysOf(name)) + assert.ok(schemaKeys('shopConfig').includes('einstellungen')) + assert.ok(schemaKeys('subscriptions').length > 0) + assert.throws(() => schemaKeys('gibtEsNicht'), /fehlt im Setup-Skript/) +}) + +test('Rundreise: Dokument mit Datum anlegen, aendern, lesen; unbekanntes Attribut wird abgelehnt', async () => { + const collection = config.collections.ukEinstellungen + const created = await createDocument(collection, { featureId: 'f1', firma: 'Haus Muster', onlineZahlung: false, anfrageAt: '2026-10-07T10:00:00.000Z' }, 'f1') + assert.equal(created.$id, 'f1') + await updateDocument(collection, 'f1', { onlineZahlung: true, anfrageStatus: 'offen' }) + const doc = await getDocument(collection, 'f1') + assert.equal(doc.onlineZahlung, true) + assert.equal(doc.firma, 'Haus Muster') + await assert.rejects(() => createDocument(collection, { featureId: 'f2', fremd: 'x' }, 'f2'), /Unknown attribute/) +}) + +test('Konfiguration: Collection-IDs', () => { + assert.deepEqual(NAMES.map((name) => config.collections[name]), NAMES) +}) + +test('main legt auf leerer Datenbank 6 Collections, alle Attribute und Indizes an', async () => { + const client = fakeClient() + const result = await main({ client, log: quiet }) + assert.deepEqual(client.calls.collections, NAMES.map((id) => ({ id, name: id }))) + assert.deepEqual([...client.calls.attrs].sort(), [...expectedAttrs].sort()) + assert.deepEqual([...client.calls.indexes].sort(), [...expectedIndexes].sort()) + assert.equal(result.missing.length, expectedAttrs.length) + assert.deepEqual(result.missingCollections, NAMES) + assert.equal(result.missingIndexes.length, expectedIndexes.length) + assert.deepEqual(client.state.get('ukAnfragen').attrs.get('fristAt'), { key: 'fristAt', type: 'datetime', required: false }) + assert.deepEqual(client.state.get('ukAnfragen').attrs.get('gast'), { key: 'gast', type: 'string', size: 3000, required: false }) +}) + +test('main: zweiter Lauf legt nichts mehr an', async () => { + const client = fakeClient() + await main({ client, log: quiet }) + client.calls.collections.length = client.calls.attrs.length = client.calls.indexes.length = 0 + const result = await main({ client, log: quiet }) + assert.deepEqual(client.calls, { collections: [], attrs: [], indexes: [] }) + assert.deepEqual(result, { missing: [], missingCollections: [], missingIndexes: [] }) +}) + +test('main --check legt nichts an und meldet alle sechs Collections als FEHLT', async () => { + const client = fakeClient() + const lines = [] + const result = await main({ check: true, client, log: (line) => lines.push(line) }) + assert.deepEqual(client.calls, { collections: [], attrs: [], indexes: [] }) + assert.equal(client.state.size, 0) + assert.deepEqual(result.missingCollections, NAMES) + assert.equal(result.missing.length, expectedAttrs.length) + for (const name of NAMES) assert.ok(lines.some((line) => line.includes(name) && line.includes('FEHLT')), name) +}) + +test('main --check meldet bei vollstaendigem Stand nichts und ein einzelnes Fehlendes genau', async () => { + const client = fakeClient() + await main({ client, log: quiet }) + assert.deepEqual(await main({ check: true, client, log: quiet }), { missing: [], missingCollections: [], missingIndexes: [] }) + client.state.get('ukAnfragen').attrs.delete('anonymisiertAt') + client.state.get('ukSperren').indexes.delete('idx_unterkunft_quelle') + const result = await main({ check: true, client, log: quiet }) + assert.deepEqual(result.missing.map((a) => `${a.collection}.${a.key}`), ['ukAnfragen.anonymisiertAt']) + assert.deepEqual(result.missingIndexes.map((i) => `${i.collection}.${i.key}`), ['ukSperren.idx_unterkunft_quelle']) +})