Terminplaner: Kunden-Schnittstelle
/api/termine: Einstellungen (Vorlage, PATCH mit Version, Feed-Link), Buchungen (Liste, Zeiten, von Hand, Sperre, Aktionen), CSV-Export, Protokoll der Kundenansicht. Pflichtangaben fuer Gaeste (Telefon immer, Anschrift bei Widerrufsbelehrung) in normalisiereEinstellung, Entwurf aus Vorlagen, kontextPerSiteKey ohne Pflichtangaben nicht buchbar; speichereEinstellung nimmt eine Funktion unter der Sperre. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
ClaudeandClaude Sonnet 5.5 committed
1 parent
9e8fd33713
commit
e3e198fb1a
10 files changed
+1766
-40
No files matched your search
@@ -16,6 +16,7 @@ import customerDataRoutes from './routes/customerData.js'
|
||||
import chatRoutes from './routes/chat.js'
|
||||
import aboRoutes from './routes/abo.js'
|
||||
import funktionenRoutes from './routes/funktionen.js'
|
||||
import termineRoutes from './routes/termine.js'
|
||||
import takeoverCreditRoutes from './routes/takeoverCredits.js'
|
||||
import { purgeExpiredUploads } from './services/takeoverCredits.js'
|
||||
import { purgePendingChatUploads } from './services/chatAttachments.js'
|
||||
@@ -77,6 +78,7 @@ app.use('/api/chat', chatRoutes)
|
||||
app.use('/api/abo/takeover-credits', takeoverCreditRoutes)
|
||||
app.use('/api/abo', aboRoutes)
|
||||
app.use('/api/funktionen', funktionenRoutes)
|
||||
app.use('/api/termine', termineRoutes)
|
||||
app.use('/api/team', teamRoutes)
|
||||
app.use('/api/admin/gitea', adminGiteaRoutes)
|
||||
app.use('/api/admin/website-projects', adminPreviewRoutes)
|
||||
|
||||
@@ -0,0 +1,474 @@
|
||||
import { Router } from 'express'
|
||||
import { config } from '../config.js'
|
||||
import { getSessionCustomerId, requireSession } from '../middleware/session.js'
|
||||
import { getDocument } from '../services/appwriteAdmin.js'
|
||||
import { analysePrivacyData } from '../services/analysePrivacy.js'
|
||||
import { isKundenansicht, logIfKundenansicht } from '../services/kundenansicht.js'
|
||||
import { assertOwnProject, getFeatureDoc } from '../services/siteFeatures.js'
|
||||
import { aktion, entsperre, manuell, sperre } from '../services/termine/ablaufBetrieb.js'
|
||||
import { imZeitraum, zaehleAnfragen, zaehleKuenftige } from '../services/termine/buchungen.js'
|
||||
import { fehlendePflichtangaben, neuerFeedToken, normalisiereEinstellung } from '../services/termine/einstellungen.js'
|
||||
import { kontextPerFeature, speichereEinstellung } from '../services/termine/kontext.js'
|
||||
import { zustellFehler } from '../services/termine/outbox.js'
|
||||
import { termineFuerKunde } from '../services/termine/schalter.js'
|
||||
import { belegungAus, freieZeiten } from '../services/termine/slots.js'
|
||||
import { buchungsNummer } from '../services/termine/token.js'
|
||||
import { VORLAGEN, ausVorlage, vorlagenListe } from '../services/termine/vorlagen.js'
|
||||
import { ausUtc, datumKurz, plusTage, uhrzeit, zuUtc } from '../services/termine/zeit.js'
|
||||
|
||||
/**
|
||||
* Kunden-Schnittstelle des Terminplaners: /api/termine (Spezifikation 2026-10-02-terminplaner-design.md, Abschnitt 9).
|
||||
*
|
||||
* Jede Route: Session, projectId (Query oder Body), eigenes Projekt, Pilot-Schalter des Kunden, Funktion `active` oder
|
||||
* `disabled`. Abgeschaltete Funktionen (`disabled`) dürfen nur gelesen werden (GET, auch der Export); jedes Schreiben ist 409.
|
||||
* Schreib-Routen zählen gegen 120 Änderungen pro Kunde und Stunde (im Speicher). Die Geschäftsregeln stehen in
|
||||
* services/termine/*; hier wird geprüft, übersetzt und protokolliert (Kundenansicht: termin_einstellungen, termin_aktion,
|
||||
* termin_manuell, nur nach Erfolg und ohne Gastdaten im Detail).
|
||||
*
|
||||
* Fehler: { error: <erster Text>, fehler?: { <feld|_>: Text }, code? }. `error` liest das Portal (wie bei allen Routen),
|
||||
* `fehler` zeigt Feldfehler am Feld (Pfade wie 'betrieb.telefon' oder 'leistungen.s_abcd1234'). Texte von Appwrite oder
|
||||
* unbekannten Fehlern verlassen den Server nie (500 "Interner Serverfehler").
|
||||
* Antworten sind nie zwischenspeicherbar (Gastdaten, Kalender-Links).
|
||||
*/
|
||||
|
||||
const router = Router()
|
||||
|
||||
const HOUR_MS = 60 * 60 * 1000
|
||||
const MAX_WRITES_PER_HOUR = 120
|
||||
const MAX_TAGE = 62
|
||||
const STATUS = ['gehalten', 'angefragt', 'bestaetigt', 'erledigt', 'nichterschienen', 'abgesagt', 'abgelehnt', 'verfallen']
|
||||
const STATUS_TEXT = {
|
||||
gehalten: 'Reserviert',
|
||||
angefragt: 'Angefragt',
|
||||
bestaetigt: 'Bestätigt',
|
||||
erledigt: 'Erledigt',
|
||||
nichterschienen: 'Nicht erschienen',
|
||||
abgesagt: 'Abgesagt',
|
||||
abgelehnt: 'Abgelehnt',
|
||||
verfallen: 'Verfallen',
|
||||
}
|
||||
const CSV_KOPF = ['Nummer', 'Status', 'Datum', 'Uhrzeit', 'Leistung', 'Person/Platz', 'Name', 'E-Mail', 'Telefon', 'Nachricht']
|
||||
const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,35}$/
|
||||
|
||||
const MELDUNG = {
|
||||
projekt: 'Bitte wähle ein Projekt.',
|
||||
fremd: 'Kein Zugriff auf dieses Projekt.',
|
||||
nichtVerfuegbar: 'Der Terminplaner ist noch nicht verfügbar.',
|
||||
nichtAktiv: 'Der Terminplaner ist für diese Website nicht aktiv.',
|
||||
abgeschaltet: 'Der Terminplaner ist für diese Website abgeschaltet. Du kannst Termine nur noch ansehen und exportieren.',
|
||||
keineEinstellung: 'Bitte richte den Terminplaner zuerst ein.',
|
||||
zuViele: 'Zu viele Änderungen in kurzer Zeit. Bitte versuch es in einer Stunde wieder.',
|
||||
vorlage: 'Bitte wähle eine Vorlage aus der Liste.',
|
||||
vorlageVorhanden: 'Es gibt schon Einstellungen. Eine Vorlage kannst du nur beim ersten Öffnen wählen.',
|
||||
version: 'Die Version der Einstellungen fehlt. Bitte lade die Seite neu.',
|
||||
art: 'Bitte wähle „Termin eintragen“ oder „Zeit sperren“.',
|
||||
zeitraum: 'Bitte gib von und bis als Datum an (JJJJ-MM-TT).',
|
||||
zeitraumLang: `Der Zeitraum darf höchstens ${MAX_TAGE} Tage umfassen.`,
|
||||
zeitraumUmgekehrt: 'Das Ende darf nicht vor dem Beginn liegen.',
|
||||
status: 'Ungültiger Status.',
|
||||
tag: 'Bitte ein Datum auswählen.',
|
||||
leistung: 'Bitte eine Leistung auswählen.',
|
||||
ressource: 'Unbekannte Person oder unbekannter Platz.',
|
||||
keineRessource: 'Diese Person oder diesen Platz gibt es nicht.',
|
||||
ungueltig: 'Ungültige Eingabe.',
|
||||
}
|
||||
|
||||
// Uhr der Schnittstelle: Tests setzen eine feste Uhr (die Dienste nehmen `now` immer als Parameter).
|
||||
let uhr = () => new Date()
|
||||
export function setzeUhrFuerTests(neueUhr) {
|
||||
uhr = typeof neueUhr === 'function' ? neueUhr : () => new Date()
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Fehler
|
||||
|
||||
const istObjekt = (wert) => wert !== null && typeof wert === 'object' && !Array.isArray(wert)
|
||||
|
||||
/** Fehler des Kunden (4xx) mit Text in `fehler`; `fail` macht daraus die Antwort. */
|
||||
const stop = (status, text, code, feld = '_') => Object.assign(new Error(text), { status, fehler: { [feld]: text }, ...(code ? { code } : {}) })
|
||||
|
||||
/** Antwort für einen Fehler: Fehler des Kunden (4xx mit `fehler`, oder EINSTELLUNG_VERALTET) wie sie sind, alles andere 500 ohne Rohtext. */
|
||||
function fail(res, err) {
|
||||
const status = Number.isInteger(err?.status) ? err.status : 500
|
||||
const texte = istObjekt(err?.fehler) ? Object.fromEntries(Object.entries(err.fehler).filter(([, t]) => typeof t === 'string')) : {}
|
||||
const eigen = Object.keys(texte).length > 0 || err?.code === 'EINSTELLUNG_VERALTET'
|
||||
if (!eigen || status < 400 || status >= 500) {
|
||||
console.error(`[termine] ${err?.name ?? 'Fehler'}: ${String(err?.message ?? '').slice(0, 200)}`)
|
||||
return res.status(500).json({ error: 'Interner Serverfehler' })
|
||||
}
|
||||
const body = { error: Object.values(texte)[0] ?? String(err.message) }
|
||||
if (Object.keys(texte).length > 0) body.fehler = texte
|
||||
if (typeof err.code === 'string') body.code = err.code
|
||||
return res.status(status).json(body)
|
||||
}
|
||||
|
||||
/** Handler mit Fehlerbehandlung (Express 4 fängt async-Fehler nicht selbst). */
|
||||
const route = (fn) => async (req, res, next) => {
|
||||
try {
|
||||
await fn(req, res, next)
|
||||
} catch (err) {
|
||||
fail(res, err)
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Schreib-Limit
|
||||
|
||||
// Schreib-Limit je Kunde und Stunde (im Speicher, wie bei den News); zählt POST/PATCH/DELETE
|
||||
const recentWrites = new Map()
|
||||
function writeRateLimited(customerId) {
|
||||
const now = uhr().getTime()
|
||||
for (const [key, times] of recentWrites) {
|
||||
const live = times.filter((t) => now - t < HOUR_MS)
|
||||
if (live.length === 0) recentWrites.delete(key)
|
||||
else if (live.length !== times.length) recentWrites.set(key, live)
|
||||
}
|
||||
const list = recentWrites.get(customerId) || []
|
||||
list.push(now)
|
||||
recentWrites.set(customerId, list)
|
||||
return list.length > MAX_WRITES_PER_HOUR
|
||||
}
|
||||
|
||||
const limitWrites = route((req, res, next) => {
|
||||
if (writeRateLimited(getSessionCustomerId(req))) return res.status(429).json({ error: MELDUNG.zuViele })
|
||||
return next()
|
||||
})
|
||||
|
||||
export function resetTermineRoutesForTests() {
|
||||
recentWrites.clear()
|
||||
uhr = () => new Date()
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Projekt und Funktion
|
||||
|
||||
const projectIdOf = (req) => {
|
||||
const raw = req.query.projectId ?? req.body?.projectId
|
||||
return typeof raw === 'string' ? raw : ''
|
||||
}
|
||||
|
||||
/**
|
||||
* Eigenes Projekt, Pilot-Schalter, Funktion active oder disabled => req.ctx (kontext.js). schreiben: nur active.
|
||||
* Reihenfolge der Prüfungen: Projekt (403), Schalter (409), Funktion (409), abgeschaltet beim Schreiben (409).
|
||||
*/
|
||||
const withTermine = ({ schreiben = false } = {}) => route(async (req, _res, next) => {
|
||||
const projectId = projectIdOf(req)
|
||||
if (!projectId) throw stop(400, MELDUNG.projekt, undefined, 'projectId')
|
||||
const customerId = getSessionCustomerId(req)
|
||||
try {
|
||||
req.project = await assertOwnProject(customerId, projectId)
|
||||
} catch (err) {
|
||||
// auch eine unbrauchbare ID (Appwrite 400) ist kein eigenes Projekt
|
||||
throw err?.status === 403 || err?.status === 400 ? stop(403, MELDUNG.fremd) : err
|
||||
}
|
||||
req.projectId = projectId
|
||||
if (!termineFuerKunde(req.session?.email)) throw stop(409, MELDUNG.nichtVerfuegbar, 'nicht_verfuegbar')
|
||||
const feature = await getFeatureDoc(customerId, projectId, 'termine')
|
||||
const ctx = feature && ['active', 'disabled'].includes(feature.state) ? await kontextPerFeature(feature.$id) : null
|
||||
if (!ctx || ctx.feature.customerId !== customerId) throw stop(409, MELDUNG.nichtAktiv, 'nicht_aktiv')
|
||||
if (schreiben && ctx.feature.state !== 'active') throw stop(409, MELDUNG.abgeschaltet, 'abgeschaltet')
|
||||
req.ctx = ctx
|
||||
return next()
|
||||
})
|
||||
|
||||
/** Wer ändert? Für updatedBy der Einstellung (Kundenansicht: der Mitarbeiter, sonst der Kunde). */
|
||||
const von = (req) => (isKundenansicht(req.session) ? `team:${req.session.appwriteUserId}` : `kunde:${getSessionCustomerId(req)}`)
|
||||
|
||||
/** Buchungen, Zeiten und Aktionen brauchen gespeicherte Einstellungen (Betriebsangaben). */
|
||||
function mitEinstellung(req) {
|
||||
if (!req.ctx.einstellung) throw stop(409, MELDUNG.keineEinstellung, 'keine_einstellung')
|
||||
return req.ctx
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Einstellungen
|
||||
|
||||
/** Einstellung für den Browser: ohne Feed-Token (die Links stehen in `feeds`, neue Token vergibt nur der Server). */
|
||||
const fuerKunde = (e) => ({ ...e, ressourcen: (e.ressourcen || []).map(({ feedToken: _geheim, ...rest }) => rest) })
|
||||
|
||||
const feedUrl = (siteKey, token) => `${config.publicBaseUrl}/api/public/termine/v1/kalender/${siteKey}/${token}.ics`
|
||||
|
||||
/** { [ressourceId]: Kalender-Link } aller Personen und Plätze. */
|
||||
function feedLinks(ctx) {
|
||||
const links = {}
|
||||
for (const r of ctx.einstellung?.ressourcen || []) {
|
||||
if (typeof r?.id === 'string' && typeof r.feedToken === 'string') links[r.id] = feedUrl(ctx.feature.siteKey, r.feedToken)
|
||||
}
|
||||
return links
|
||||
}
|
||||
|
||||
const esc = (text) => String(text).replace(/[&<>"]/g, (z) => ({ '&': '&', '<': '<', '>': '>', '"': '"' })[z])
|
||||
|
||||
/** Einbau-Code für die Website (Spezifikation Abschnitt 7): Platzhalter mit Ausweichtext, bleibt ohne JavaScript stehen. */
|
||||
function einbauSnippet(ctx) {
|
||||
const telefon = ctx.einstellung?.betrieb?.telefon
|
||||
const ausweich = telefon ? `Termine telefonisch unter ${esc(telefon)}.` : 'Termine telefonisch vereinbaren.'
|
||||
return [
|
||||
`<div data-webklar-termine="${esc(ctx.feature.siteKey)}" data-api="${esc(config.publicBaseUrl)}" data-modus="inline">`,
|
||||
` <p>${ausweich}</p>`,
|
||||
'</div>',
|
||||
`<script src="${esc(config.publicBaseUrl)}/embed/termine.js" defer></script>`,
|
||||
].join('\n')
|
||||
}
|
||||
|
||||
router.use((_req, res, next) => {
|
||||
res.set('Cache-Control', 'no-store')
|
||||
next()
|
||||
})
|
||||
|
||||
router.get('/einstellungen', requireSession, withTermine(), route(async (req, res) => {
|
||||
const { ctx } = req
|
||||
const e = ctx.einstellung
|
||||
res.json({
|
||||
state: ctx.feature.state,
|
||||
aktivSeit: ctx.feature.activatedAt || null,
|
||||
einstellung: e ? fuerKunde(e) : null,
|
||||
version: ctx.version,
|
||||
vorlagen: vorlagenListe(),
|
||||
feeds: e && ctx.feature.state === 'active' ? feedLinks(ctx) : {},
|
||||
siteKey: ctx.feature.siteKey || null,
|
||||
einbau: { snippet: einbauSnippet(ctx) },
|
||||
anfragenOffen: await zaehleAnfragen(ctx.feature.$id),
|
||||
fehlt: e ? fehlendePflichtangaben(e) : [], // Pflichtangaben für Gäste (Ruling R41): solange etwas fehlt, ist die Funktion nicht buchbar
|
||||
})
|
||||
}))
|
||||
|
||||
/** Betriebsangaben aus dem Kundenkonto für eine Vorlage: Name/Firma, Anschrift, E-Mail (analysePrivacyData) und Telefon. */
|
||||
async function betriebAusKonto(customerId) {
|
||||
let kunde = null
|
||||
try {
|
||||
kunde = await getDocument(config.collections.customers, customerId)
|
||||
} catch (err) {
|
||||
if (err?.status !== 404) throw err
|
||||
}
|
||||
const daten = analysePrivacyData(kunde)
|
||||
return { name: daten.company, adresse: daten.address, email: daten.email, telefon: typeof kunde?.phone === 'string' ? kunde.phone : '' }
|
||||
}
|
||||
|
||||
router.post('/einstellungen/vorlage', requireSession, withTermine({ schreiben: true }), limitWrites, route(async (req, res) => {
|
||||
const key = req.body?.vorlage
|
||||
if (typeof key !== 'string' || !Object.hasOwn(VORLAGEN, key)) throw stop(400, MELDUNG.vorlage, undefined, 'vorlage')
|
||||
if (req.ctx.einstellung) throw stop(409, MELDUNG.vorlageVorhanden, 'einstellung_vorhanden')
|
||||
|
||||
const betrieb = await betriebAusKonto(getSessionCustomerId(req))
|
||||
const now = uhr()
|
||||
let gespeichert
|
||||
try {
|
||||
// version 0: nur wenn noch nichts gespeichert ist, auch bei zwei gleichzeitigen Anfragen
|
||||
gespeichert = await speichereEinstellung(req.ctx.feature, () => {
|
||||
try {
|
||||
return ausVorlage(key, betrieb, now)
|
||||
} catch (err) {
|
||||
throw Object.assign(new Error(err.message), { status: 400, fehler: err.fehler ?? { _: err.message } })
|
||||
}
|
||||
}, { version: 0, by: von(req), now })
|
||||
} catch (err) {
|
||||
throw err?.code === 'EINSTELLUNG_VERALTET' ? stop(409, MELDUNG.vorlageVorhanden, 'einstellung_vorhanden') : err
|
||||
}
|
||||
await logIfKundenansicht(req, 'termin_einstellungen', `Vorlage ${key}`)
|
||||
res.status(201).json({ einstellung: fuerKunde(gespeichert.einstellung), version: gespeichert.version, fehlt: fehlendePflichtangaben(gespeichert.einstellung) })
|
||||
}))
|
||||
|
||||
router.patch('/einstellungen', requireSession, withTermine({ schreiben: true }), limitWrites, route(async (req, res) => {
|
||||
const { version, einstellung: eingabe } = req.body ?? {}
|
||||
if (!Number.isInteger(version) || version < 0) throw stop(400, MELDUNG.version, undefined, 'version')
|
||||
const now = uhr()
|
||||
const feature = req.ctx.feature
|
||||
|
||||
// Entfernen-Prüfung (künftige Termine) und Schreiben laufen unter derselben Sperre (kontext.js, Ruling R40)
|
||||
const gespeichert = await speichereEinstellung(feature, async (bisher) => {
|
||||
const kuenftigeTermine = bisher ? await zaehleKuenftige(feature.$id, now) : null
|
||||
const ergebnis = normalisiereEinstellung(eingabe, { bisher, kuenftigeTermine, now })
|
||||
if (ergebnis.fehler) {
|
||||
throw Object.assign(new Error(Object.values(ergebnis.fehler)[0]), { status: 400, fehler: ergebnis.fehler })
|
||||
}
|
||||
return ergebnis.einstellung
|
||||
}, { version, by: von(req), now })
|
||||
|
||||
await logIfKundenansicht(req, 'termin_einstellungen', 'Einstellungen gespeichert')
|
||||
res.json({ einstellung: fuerKunde(gespeichert.einstellung), version: gespeichert.version })
|
||||
}))
|
||||
|
||||
router.post('/ressourcen/:id/feed', requireSession, withTermine({ schreiben: true }), limitWrites, route(async (req, res) => {
|
||||
const ressourceId = String(req.params.id)
|
||||
const now = uhr()
|
||||
// Baut auf dem aktuellen Stand auf (version null) und ersetzt nur das Token dieser einen Person/dieses Platzes
|
||||
const gespeichert = await speichereEinstellung(req.ctx.feature, (bisher) => {
|
||||
const ressourcen = Array.isArray(bisher?.ressourcen) ? bisher.ressourcen : []
|
||||
if (!ressourcen.some((r) => r?.id === ressourceId)) throw stop(404, MELDUNG.keineRessource, 'unbekannt')
|
||||
return { ...bisher, ressourcen: ressourcen.map((r) => (r.id === ressourceId ? { ...r, feedToken: neuerFeedToken() } : r)) }
|
||||
}, { version: null, by: von(req), now })
|
||||
|
||||
const token = gespeichert.einstellung.ressourcen.find((r) => r.id === ressourceId).feedToken
|
||||
await logIfKundenansicht(req, 'termin_einstellungen', 'Kalender-Link erneuert')
|
||||
// version: die Änderung zählt die Version hoch, die offene Einstellungsseite braucht die neue für ihr nächstes Speichern
|
||||
res.json({ url: feedUrl(req.ctx.feature.siteKey, token), version: gespeichert.version })
|
||||
}))
|
||||
|
||||
// ---------------------------------------------------------------- Buchungen lesen
|
||||
|
||||
const iso = (wert) => {
|
||||
const zeit = wert ? new Date(wert) : null
|
||||
return zeit && !Number.isNaN(zeit.getTime()) ? zeit.toISOString() : null
|
||||
}
|
||||
|
||||
/** Eine Buchung für das Portal. datum = Berliner Tag 'JJJJ-MM-TT', zeit = 'HH:MM' (Berliner Wanduhr). */
|
||||
function buchungJson(b, zustellFehlerIds) {
|
||||
const start = new Date(b.startsAt)
|
||||
const ende = new Date(b.endsAt)
|
||||
const istSperre = b.quelle === 'sperre'
|
||||
const { tag, uhrzeit: zeit } = ausUtc(start)
|
||||
const leistung = istSperre ? '' : b.leistungName || ''
|
||||
return {
|
||||
id: b.$id,
|
||||
nummer: buchungsNummer(b.$id),
|
||||
status: b.status,
|
||||
quelle: b.quelle || 'online',
|
||||
startsAt: start.toISOString(),
|
||||
endsAt: ende.toISOString(),
|
||||
datum: tag,
|
||||
zeit,
|
||||
leistungId: b.leistungId || '',
|
||||
leistung,
|
||||
dauer: Math.round((ende.getTime() - start.getTime()) / 60000),
|
||||
titel: istSperre ? b.leistungName || 'Gesperrt' : b.gastName ? `${leistung}: ${b.gastName}` : leistung,
|
||||
person: b.ressourceName || '',
|
||||
ressourceId: b.ressourceId || '',
|
||||
gastName: b.gastName || '',
|
||||
gastEmail: b.gastEmail || '',
|
||||
gastTelefon: b.gastTelefon || '',
|
||||
gastNachricht: b.gastNachricht || '',
|
||||
erinnerung: b.erinnerung === true,
|
||||
zustellFehler: zustellFehlerIds.has(b.$id),
|
||||
angenommenAt: iso(b.angenommenAt),
|
||||
widerrufenAt: iso(b.widerrufenAt),
|
||||
abgesagtVon: b.abgesagtVon || '',
|
||||
absageGrund: b.absageGrund || '',
|
||||
}
|
||||
}
|
||||
|
||||
const tagGueltig = (tag) => typeof tag === 'string' && zuUtc(tag, '12:00') !== null
|
||||
|
||||
router.get('/buchungen', requireSession, withTermine(), route(async (req, res) => {
|
||||
const ctx = req.ctx
|
||||
const { von: vonTag, bis: bisTag, status } = req.query
|
||||
if (!tagGueltig(vonTag) || !tagGueltig(bisTag)) throw stop(400, MELDUNG.zeitraum, undefined, 'von')
|
||||
if (bisTag < vonTag) throw stop(400, MELDUNG.zeitraumUmgekehrt, undefined, 'bis')
|
||||
if (bisTag > plusTage(vonTag, MAX_TAGE)) throw stop(400, MELDUNG.zeitraumLang, undefined, 'bis')
|
||||
|
||||
let gewollt = null
|
||||
if (typeof status === 'string' && status !== '') {
|
||||
gewollt = status.split(',').map((s) => s.trim()).filter(Boolean)
|
||||
if (gewollt.length === 0 || gewollt.some((s) => !STATUS.includes(s))) throw stop(400, MELDUNG.status, undefined, 'status')
|
||||
} else if (status !== undefined && typeof status !== 'string') {
|
||||
throw stop(400, MELDUNG.status, undefined, 'status')
|
||||
}
|
||||
|
||||
const anfang = zuUtc(vonTag, '00:00')
|
||||
const ende = zuUtc(bisTag, '24:00')
|
||||
const liste = (await imZeitraum(ctx.feature.$id, anfang, ende))
|
||||
.filter((b) => new Date(b.endsAt).getTime() > anfang.getTime()) // Pause nach dem Termin zählt nicht zum Zeitraum
|
||||
.filter((b) => gewollt === null || gewollt.includes(b.status))
|
||||
.sort((a, b) => new Date(a.startsAt) - new Date(b.startsAt))
|
||||
const mitMail = await zustellFehler(liste.filter((b) => b.quelle !== 'sperre').map((b) => b.$id))
|
||||
res.json({ buchungen: liste.map((b) => buchungJson(b, mitMail)) })
|
||||
}))
|
||||
|
||||
router.get('/zeiten', requireSession, withTermine(), route(async (req, res) => {
|
||||
const ctx = mitEinstellung(req)
|
||||
const { leistung, ressource = 'egal', tag, ohne } = req.query
|
||||
if (typeof leistung !== 'string' || !(ctx.einstellung.leistungen || []).some((l) => l.id === leistung && l.aktiv)) {
|
||||
throw stop(400, MELDUNG.leistung, undefined, 'leistung')
|
||||
}
|
||||
if (typeof ressource !== 'string' || (ressource !== 'egal' && !(ctx.einstellung.ressourcen || []).some((r) => r.id === ressource))) {
|
||||
throw stop(400, MELDUNG.ressource, undefined, 'ressource')
|
||||
}
|
||||
if (!tagGueltig(tag)) throw stop(400, MELDUNG.tag, undefined, 'tag')
|
||||
if (ohne !== undefined && (typeof ohne !== 'string' || !ID_RE.test(ohne))) throw stop(400, MELDUNG.ungueltig, undefined, 'ohne')
|
||||
|
||||
const now = uhr()
|
||||
const amTag = await imZeitraum(ctx.feature.$id, zuUtc(tag, '00:00'), zuUtc(tag, '24:00'))
|
||||
// ohneRegeln: der Betrieb trägt auch kurzfristig und jenseits des Buchungszeitraums ein (nie in die Vergangenheit);
|
||||
// ohne = die Buchung, die verschoben wird, belegt ihre neue Zeit nicht selbst
|
||||
const zeiten = freieZeiten({
|
||||
einstellung: ctx.einstellung,
|
||||
leistungId: leistung,
|
||||
ressourceId: ressource,
|
||||
tag,
|
||||
belegung: belegungAus(amTag, now, ohne ? { ohneBuchung: ohne } : {}),
|
||||
now,
|
||||
ohneRegeln: true,
|
||||
})
|
||||
res.json({ zeiten: zeiten.map((z) => z.uhrzeit) })
|
||||
}))
|
||||
|
||||
// ---------------------------------------------------------------- Buchungen schreiben
|
||||
|
||||
router.post('/buchungen', requireSession, withTermine({ schreiben: true }), limitWrites, route(async (req, res) => {
|
||||
const ctx = mitEinstellung(req)
|
||||
const { projectId: _projekt, art, ...roh } = req.body ?? {}
|
||||
if (art !== 'manuell' && art !== 'sperre') throw stop(400, MELDUNG.art, undefined, 'art')
|
||||
const now = uhr()
|
||||
const ergebnis = art === 'manuell' ? await manuell(ctx, roh, now) : await sperre(ctx, roh, now)
|
||||
await logIfKundenansicht(req, 'termin_manuell', art)
|
||||
res.status(201).json(ergebnis)
|
||||
}))
|
||||
|
||||
router.post('/buchungen/:id/aktion', requireSession, withTermine({ schreiben: true }), limitWrites, route(async (req, res) => {
|
||||
const ctx = mitEinstellung(req)
|
||||
const { projectId: _projekt, ...roh } = req.body ?? {}
|
||||
const id = String(req.params.id)
|
||||
const ergebnis = await aktion(ctx, id, roh, uhr())
|
||||
// ein zweiter Klick ändert nichts und steht nicht im Protokoll
|
||||
if (!ergebnis.schon) await logIfKundenansicht(req, 'termin_aktion', `${roh.aktion} ${buchungsNummer(id)}`)
|
||||
res.json(ergebnis)
|
||||
}))
|
||||
|
||||
router.delete('/buchungen/:id', requireSession, withTermine({ schreiben: true }), limitWrites, route(async (req, res) => {
|
||||
const ctx = mitEinstellung(req)
|
||||
const id = String(req.params.id)
|
||||
const ergebnis = await entsperre(ctx, id) // nur Sperren; alles andere ist 404
|
||||
await logIfKundenansicht(req, 'termin_aktion', `entsperren ${buchungsNummer(id)}`)
|
||||
res.json(ergebnis)
|
||||
}))
|
||||
|
||||
// ---------------------------------------------------------------- Export
|
||||
|
||||
/**
|
||||
* Eine Zelle der CSV-Datei: Anführungszeichen, Strichpunkt und Zeilenumbrüche werden gequotet; Zellen, die ein
|
||||
* Tabellenprogramm als Formel lesen würde (= + - @ am Anfang, auch nach Leerraum, Tab oder CR; Tab und CR am Anfang),
|
||||
* bekommen ein ' davor.
|
||||
*/
|
||||
function csvZelle(wert) {
|
||||
let zelle = String(wert ?? '')
|
||||
if (/^\s*[=+\-@]/.test(zelle) || /^[\t\r]/.test(zelle)) zelle = `'${zelle}`
|
||||
return /[;"\r\n]/.test(zelle) ? `"${zelle.replace(/"/g, '""')}"` : zelle
|
||||
}
|
||||
|
||||
router.get('/export.csv', requireSession, withTermine(), route(async (req, res) => {
|
||||
const ctx = req.ctx
|
||||
// alle Buchungen der Funktion (die Aufbewahrungsfristen halten die Menge klein); keine Sperren
|
||||
const liste = (await imZeitraum(ctx.feature.$id, new Date(0), new Date('2100-01-01T00:00:00.000Z')))
|
||||
.filter((b) => b.quelle !== 'sperre')
|
||||
.sort((a, b) => new Date(a.startsAt) - new Date(b.startsAt))
|
||||
const zeilen = [CSV_KOPF, ...liste.map((b) => {
|
||||
const start = new Date(b.startsAt)
|
||||
return [
|
||||
buchungsNummer(b.$id),
|
||||
STATUS_TEXT[b.status] ?? b.status,
|
||||
datumKurz(start),
|
||||
uhrzeit(start),
|
||||
b.leistungName,
|
||||
b.ressourceName,
|
||||
b.gastName,
|
||||
b.gastEmail,
|
||||
b.gastTelefon,
|
||||
b.gastNachricht,
|
||||
]
|
||||
})]
|
||||
const csv = `${zeilen.map((zeile) => zeile.map(csvZelle).join(';')).join('\r\n')}\r\n`
|
||||
res.set({
|
||||
'Content-Type': 'text/csv; charset=utf-8',
|
||||
'Content-Disposition': 'attachment; filename="termine.csv"',
|
||||
'X-Content-Type-Options': 'nosniff',
|
||||
})
|
||||
res.send(csv)
|
||||
}))
|
||||
|
||||
export default router
|
||||
@@ -475,9 +475,12 @@ const MELDUNG_RESSOURCE = (r, n) => (r.typ === 'platz'
|
||||
* Prueft und normalisiert eine Einstellung (Eingabe vom Client oder aus einer Vorlage).
|
||||
* bisher = zuletzt gespeicherte Einstellung (Feed-Token, Storno-Fassung, Entfernen-Pruefung);
|
||||
* kuenftigeTermine = { leistungen: { [id]: Anzahl }, ressourcen: { [id]: Anzahl } } kuenftiger belegender Termine.
|
||||
* Pflichtangaben fuer Gaeste (fehlendePflichtangaben): Telefon immer, Anschrift bei Widerrufsbelehrung. entwurf: true
|
||||
* laesst nur diese beiden Pruefungen aus (Entwurf aus einer Vorlage, Kunde ohne Telefon/Anschrift im Konto); als
|
||||
* oeffentlich buchbar gilt eine solche Einstellung erst, wenn die Angaben da sind (kontextPerSiteKey).
|
||||
* => { einstellung } oder { fehler: { [pfad]: text } }.
|
||||
*/
|
||||
export function normalisiereEinstellung(eingabe, { bisher = null, kuenftigeTermine = null, now } = {}) {
|
||||
export function normalisiereEinstellung(eingabe, { bisher = null, kuenftigeTermine = null, entwurf = false, now } = {}) {
|
||||
if (!(now instanceof Date) || Number.isNaN(now.getTime())) throw new TypeError('normalisiereEinstellung: now fehlt')
|
||||
const fehler = {}
|
||||
const fehl = (pfad, meldung) => { if (!Object.hasOwn(fehler, pfad)) fehler[pfad] = meldung }
|
||||
@@ -534,6 +537,10 @@ export function normalisiereEinstellung(eingabe, { bisher = null, kuenftigeTermi
|
||||
aufbewahrungTage: zahl(fehl, 'aufbewahrungTage', eingabe.aufbewahrungTage, { vorgabe: 90, min: 14, max: 365, meldung: 'Die Aufbewahrung muss zwischen 14 und 365 Tagen liegen.' }),
|
||||
}
|
||||
|
||||
if (!entwurf) {
|
||||
for (const pfad of fehlendePflichtangaben(einstellung)) fehl(pfad, MELDUNG_PFLICHT[pfad])
|
||||
}
|
||||
|
||||
if (Object.keys(fehler).length === 0 && JSON.stringify(einstellung).length > GRENZEN.json) {
|
||||
fehl('_', 'Die Einstellungen sind zu umfangreich. Bitte entferne Zeitfenster oder Einträge.')
|
||||
}
|
||||
@@ -550,6 +557,40 @@ function farbe(fehl, wert) {
|
||||
return s
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Pflichtangaben und Widerruf
|
||||
|
||||
const MELDUNG_PFLICHT = {
|
||||
'betrieb.telefon': 'Bitte gib die Telefonnummer deines Betriebs an. Gäste sehen sie als Ausweichweg und in ihren Mails.',
|
||||
'betrieb.adresse': 'Bitte gib die Anschrift deines Betriebs an. Sie steht in der Widerrufsbelehrung, die Gäste vor der Buchung sehen.',
|
||||
}
|
||||
|
||||
/** Leistungen, die Gaeste sehen: aktiv und mit mindestens einer aktiven Ressource (wie in oeffentlicheEinstellung). */
|
||||
function sichtbareLeistungen(einstellung) {
|
||||
const aktiveIds = new Set((einstellung?.ressourcen || []).filter((r) => r?.aktiv).map((r) => r.id))
|
||||
return (einstellung?.leistungen || []).filter((l) => l?.aktiv && (l.ressourcen || []).some((id) => aktiveIds.has(id)))
|
||||
}
|
||||
|
||||
/**
|
||||
* Zeigt die oeffentliche Sicht eine Widerrufsbelehrung (oeffentlicheEinstellung.widerruf)? Verbraucher-Gaeste und
|
||||
* mindestens eine sichtbare Leistung, die sofort gebucht wird.
|
||||
*/
|
||||
export function zeigtWiderruf(einstellung) {
|
||||
return istVerbraucher(einstellung) && sichtbareLeistungen(einstellung).some((l) => l.buchungsart === 'sofort')
|
||||
}
|
||||
|
||||
/**
|
||||
* Pflichtangaben des Betriebs, die in einer Einstellung fehlen: 'betrieb.telefon' (immer noetig) und 'betrieb.adresse'
|
||||
* (noetig, sobald die Widerrufsbelehrung erscheint, zeigtWiderruf). Reihenfolge Telefon, Anschrift; [] = vollstaendig.
|
||||
* Ohne diese Angaben ist der Terminplaner fuer Gaeste nicht buchbar.
|
||||
*/
|
||||
export function fehlendePflichtangaben(einstellung) {
|
||||
const betrieb = einstellung?.betrieb || {}
|
||||
const fehlt = []
|
||||
if (typeof betrieb.telefon !== 'string' || betrieb.telefon.trim() === '') fehlt.push('betrieb.telefon')
|
||||
if (zeigtWiderruf(einstellung) && (typeof betrieb.adresse !== 'string' || betrieb.adresse.trim() === '')) fehlt.push('betrieb.adresse')
|
||||
return fehlt
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Texte und Regeln
|
||||
|
||||
/** Hat die Leistung einen Preis (fest/ab und mehr als 0)? */
|
||||
@@ -652,7 +693,7 @@ export function oeffentlicheEinstellung(einstellung, now) {
|
||||
zahlung: { modus: 'vorort', text: zahlungText(e) },
|
||||
preisHinweis: preisHinweis(e),
|
||||
storno: e.storno?.text ? { text: e.storno.text, version: e.storno.version } : null,
|
||||
widerruf: verbraucher && leistungen.some((l) => l.buchungsart === 'sofort'),
|
||||
widerruf: zeigtWiderruf(e),
|
||||
erinnerung: { anbieten: e.erinnerung.anbieten, stundenVorher: e.erinnerung.stundenVorher },
|
||||
gastFelder: structuredClone(e.gastFelder),
|
||||
}
|
||||
|
||||
@@ -3,6 +3,7 @@ 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 { termineAus } from './schalter.js'
|
||||
import { pruefeNow, pruefeText } from './util.js'
|
||||
|
||||
@@ -18,7 +19,8 @@ import { pruefeNow, pruefeText } from './util.js'
|
||||
* 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; Modus off => null ohne jede Abfrage. Treffer und Fehlschlaege werden 30 Sekunden je siteKey im Speicher
|
||||
* 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),
|
||||
@@ -98,7 +100,7 @@ export async function kontextPerSiteKey(siteKey, now = new Date()) {
|
||||
const stand = generation
|
||||
const feature = await findActiveBySiteKey(siteKey, FUNKTION)
|
||||
let ctx = feature ? await baueKontext(feature) : null
|
||||
if (ctx && !ctx.einstellung) ctx = null
|
||||
if (ctx && (!ctx.einstellung || fehlendePflichtangaben(ctx.einstellung).length > 0)) ctx = null
|
||||
if (stand === generation) merke(siteKey, ctx, nowMs)
|
||||
return ctx
|
||||
}
|
||||
@@ -135,22 +137,32 @@ const veraltet = () =>
|
||||
* 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.
|
||||
* @param {{ $id: string, customerId: string, projectId: string }} feature portalFeatures-Dokument
|
||||
* @param {object} einstellung
|
||||
* @param {{ version: number, by?: string, now?: Date }} optionen
|
||||
* @param {object|((bisher: object|null) => object|Promise<object>)} einstellungOderFn
|
||||
* @param {{ version: number|null, by?: string, now?: Date }} optionen
|
||||
* @returns {Promise<{ einstellung: object, version: number }>} wie gespeichert, mit der neuen Version
|
||||
*/
|
||||
export async function speichereEinstellung(feature, einstellung, { version, by = '', now = new Date() } = {}) {
|
||||
export async function speichereEinstellung(feature, einstellungOderFn, { version, by = '', now = new Date() } = {}) {
|
||||
pruefeText(feature?.$id, 'feature.$id')
|
||||
if (!istObjekt(einstellung)) throw new TypeError('einstellung fehlt')
|
||||
const alsFunktion = typeof einstellungOderFn === 'function'
|
||||
if (!alsFunktion && !istObjekt(einstellungOderFn)) throw new TypeError('einstellung fehlt')
|
||||
const nowMs = pruefeNow(now, 'speichereEinstellung')
|
||||
const json = JSON.stringify(einstellung)
|
||||
|
||||
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 !== aktuell) throw veraltet()
|
||||
if (version !== null && version !== aktuell) throw veraltet()
|
||||
|
||||
const einstellung = alsFunktion ? await einstellungOderFn(vorhanden ? (liesEinstellung(vorhanden)?.einstellung ?? null) : null) : einstellungOderFn
|
||||
if (!istObjekt(einstellung)) throw new TypeError('einstellung fehlt')
|
||||
const json = JSON.stringify(einstellung)
|
||||
|
||||
const felder = {
|
||||
customerId: feature.customerId,
|
||||
|
||||
@@ -175,9 +175,11 @@ export function vorlagenListe() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Gueltige Einstellung aus einer Vorlage + den Betriebsangaben (name, email, telefon, adresse, kleinunternehmer,
|
||||
* Einstellung (Entwurf) aus einer Vorlage + den Betriebsangaben (name, email, telefon, adresse, kleinunternehmer,
|
||||
* impressumUrl, datenschutzUrl, agbUrl, websiteUrl, optional bundesland). Neue IDs und Feed-Token bei jedem Aufruf.
|
||||
* Unbekannte Vorlage oder unbrauchbare Betriebsangaben (kein Name/keine E-Mail) werfen; err.fehler enthaelt dann die Feldfehler.
|
||||
* Telefon und Anschrift duerfen fehlen (normalisiereEinstellung mit entwurf); fehlendePflichtangaben(einstellung) nennt,
|
||||
* was vor dem oeffentlichen Betrieb noch gebraucht wird. Unbekannte Vorlage oder unbrauchbare Betriebsangaben (kein
|
||||
* Name/keine E-Mail) werfen; err.fehler enthaelt dann die Feldfehler.
|
||||
*/
|
||||
export function ausVorlage(key, betrieb, now) {
|
||||
if (typeof key !== 'string' || !Object.hasOwn(VORLAGEN, key)) throw new Error(`Unbekannte Vorlage: ${String(key).slice(0, 40)}`)
|
||||
@@ -208,7 +210,8 @@ export function ausVorlage(key, betrieb, now) {
|
||||
recht: { ...v.recht },
|
||||
zahlung: { modus: 'vorort', vorOrtArten: [...ZAHLARTEN] },
|
||||
}
|
||||
const ergebnis = normalisiereEinstellung(eingabe, { now })
|
||||
// Entwurf: ein Kunde ohne Telefon/Anschrift im Konto kann trotzdem starten; die Angaben holt das Portal nach (fehlendePflichtangaben)
|
||||
const ergebnis = normalisiereEinstellung(eingabe, { now, entwurf: true })
|
||||
if (ergebnis.fehler) {
|
||||
const err = new Error('Die Vorlage ergibt mit diesen Betriebsangaben keine gültige Einstellung.')
|
||||
err.fehler = ergebnis.fehler
|
||||
|
||||
Reference in new issue
Block a user