Webshop E5: Widerrufe (§ 356a BGB) erfassen, G12 sofort, K26 an Händler, Liste und Bearbeitet-Markierung
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
ClaudeandClaude Opus 5.5 committed
1 parent
809da80c9b
commit
9de23c7fe2
2 files changed
+539
No files matched your search
@@ -0,0 +1,219 @@
|
||||
import { config } from '../../config.js'
|
||||
import { createDocument, getDocument, listDocuments, Query, updateDocument } from '../appwriteAdmin.js'
|
||||
import { withLocks } from '../keyedLock.js'
|
||||
import { darfWiderrufsversuch, zaehle } from '../termine/limits.js'
|
||||
import { pruefeNow } from '../termine/util.js'
|
||||
import { datumKurz, uhrzeit } from '../termine/zeit.js'
|
||||
import { bestellDaten } from './bestellungen.js'
|
||||
import { anHaendler, anKaeufer, haendlerK26 } from './mails.js'
|
||||
|
||||
/**
|
||||
* Widerrufe von Kaeufern (§ 356a BGB; Spezifikation 2026-10-05-webshop-design.md Abschnitt 5.4; Plan Task E5).
|
||||
*
|
||||
* Der Kaeufer erklaert den Widerruf ueber die oeffentliche Widerrufsseite des Shops (Name, Bestellnummer als Vertragsbezeichnung,
|
||||
* E-Mail als Kontakt, optionale Nachricht). erfasseWiderruf speichert die Erklaerung (shopWiderrufe), haengt sie an die passende
|
||||
* Bestellung (gleiche Nummer und gleiche E-Mail) und bestaetigt den Eingang sofort mit G12 (Datum und Uhrzeit, Berliner Zeit, auf
|
||||
* dem dauerhaften Datentraeger E-Mail). K26 informiert den Haendler. Mailfehler lassen die Anfrage nie scheitern: dann bleibt
|
||||
* bestaetigungAt leer. Die Bestellnummer muss nicht existieren (der Widerruf ist trotzdem wirksam erklaert).
|
||||
* Gilt fuer Shops im Zustand active und disabled, auch wenn der Shop gerade geschlossen ist; die Pruefung der Funktion
|
||||
* (off/unbekannt) liegt in der Route (Task F3).
|
||||
* Fehler: Error mit status und Kaeufertext (Sie-Form) in message; 429 bei Grenzen, 404 bei fremden Widerrufen.
|
||||
*/
|
||||
|
||||
const STUNDE_MS = 60 * 60 * 1000
|
||||
const MAX_JE_SHOP_UND_STUNDE = 20
|
||||
const SEITE = 50
|
||||
const MAX_JSON = 60000
|
||||
const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,35}$/
|
||||
const NUMMER_RE = /^[A-Z0-9-]{1,32}$/
|
||||
/** Eine einzelne Adresse: kein Leerraum, keine Listen-/Namensformen. */
|
||||
const EMAIL_RE = /^[^\s@,;:<>()[\]"\\]+@[^\s@,;:<>()[\]"\\]+\.[^\s@,;:<>()[\]"\\.]{2,}$/
|
||||
|
||||
const ZU_VIELE = 'Zu viele Versuche. Bitte versuchen Sie es später noch einmal.'
|
||||
const NICHT_GEFUNDEN = 'Der Widerruf wurde nicht gefunden.'
|
||||
|
||||
const col = () => config.collections.shopWiderrufe
|
||||
|
||||
function fehler(status, text) {
|
||||
return Object.assign(new Error(text), { status })
|
||||
}
|
||||
|
||||
// eslint-disable-next-line no-control-regex
|
||||
const STEUER_ALLE = /[\u0000-\u001F\u007F-\u009F\u2028\u2029]/g
|
||||
// eslint-disable-next-line no-control-regex
|
||||
const STEUER_OHNE_UMBRUCH = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F\u2028\u2029]/g
|
||||
|
||||
/** Einzeiliger Text: Steuerzeichen raus, Leerraum zusammengefasst. */
|
||||
const einzeilig = (wert) => (typeof wert === 'string' ? wert.replace(STEUER_ALLE, ' ').replace(/\s+/g, ' ').trim() : '')
|
||||
/** Mehrzeiliger Text: Steuerzeichen (ausser Zeilenumbruch und Tab) raus. */
|
||||
const mehrzeilig = (wert) => (typeof wert === 'string' ? wert.replace(/\r\n?/g, '\n').replace(STEUER_OHNE_UMBRUCH, '').trim() : '')
|
||||
|
||||
// ---------------------------------------------------------------- Pruefung
|
||||
|
||||
/**
|
||||
* Prueft und bereinigt die Eingabe des Widerrufsformulars.
|
||||
* @param {{ name?: string, email?: string, bestellnummer?: string, nachricht?: string }} eingabe
|
||||
* @returns {{ widerruf: { name: string, email: string, bestellnummer: string, nachricht: string } } | { fehler: Record<string, string> }}
|
||||
*/
|
||||
export function normalisiereWiderruf(eingabe) {
|
||||
const roh = eingabe !== null && typeof eingabe === 'object' && !Array.isArray(eingabe) ? eingabe : {}
|
||||
const f = {}
|
||||
|
||||
const name = einzeilig(roh.name)
|
||||
if (name.length < 2) f.name = 'Bitte geben Sie Ihren Namen an.'
|
||||
else if (name.length > 200) f.name = 'Der Name darf höchstens 200 Zeichen lang sein.'
|
||||
|
||||
// Steuerzeichen werden zu Leerzeichen: Leerraum im Inneren macht die Adresse ungueltig (keine zweite Adresse einschmuggeln)
|
||||
const email = typeof roh.email === 'string' ? roh.email.replace(STEUER_ALLE, ' ').trim().toLowerCase() : ''
|
||||
if (email === '') f.email = 'Bitte geben Sie Ihre E-Mail-Adresse an.'
|
||||
else if (email.length > 254 || !EMAIL_RE.test(email)) f.email = 'Bitte geben Sie eine gültige E-Mail-Adresse an.'
|
||||
|
||||
const nummer = einzeilig(roh.bestellnummer).toUpperCase()
|
||||
if (nummer === '') f.bestellnummer = 'Bitte geben Sie die Bestellnummer an.'
|
||||
else if (!NUMMER_RE.test(nummer)) f.bestellnummer = 'Die Bestellnummer darf nur aus Buchstaben, Ziffern und Bindestrichen bestehen und höchstens 32 Zeichen lang sein.'
|
||||
|
||||
const nachricht = mehrzeilig(roh.nachricht)
|
||||
if (nachricht.length > 2000) f.nachricht = 'Die Nachricht darf höchstens 2000 Zeichen lang sein.'
|
||||
|
||||
if (Object.keys(f).length > 0) return { fehler: f }
|
||||
return { widerruf: { name, email, bestellnummer: nummer, nachricht } }
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Erfassen
|
||||
|
||||
/** "TT.MM.JJJJ, HH:MM Uhr" (Berliner Zeit). */
|
||||
export const eingangText = (zeit) => `${datumKurz(zeit)}, ${uhrzeit(zeit)} Uhr`
|
||||
|
||||
/** Die Bestellung zu Nummer und E-Mail im selben Shop (oder null). Anonymisierte Bestellungen (leere E-Mail) passen nie. */
|
||||
async function passendeBestellung(shopId, bestellnummer, email) {
|
||||
const docs = await listDocuments(config.collections.shopOrders, [
|
||||
Query.equal('shopId', shopId),
|
||||
Query.equal('bestellnummer', bestellnummer),
|
||||
Query.limit(10),
|
||||
])
|
||||
return docs.find((d) => typeof d.kaeuferEmail === 'string' && d.kaeuferEmail.trim().toLowerCase() === email) ?? null
|
||||
}
|
||||
|
||||
/** Verlauf der Bestellung um den Widerruf ergaenzen (Bestleistung: Fehler werden verschluckt). */
|
||||
async function verlaufErgaenzen(orderId, now) {
|
||||
try {
|
||||
await withLocks([`shop-order:${orderId}`], async () => {
|
||||
const frisch = await getDocument(config.collections.shopOrders, orderId)
|
||||
const daten = bestellDaten(frisch)
|
||||
const verlauf = [...(Array.isArray(daten.verlauf) ? daten.verlauf : []), { at: now.toISOString(), was: 'widerruf' }]
|
||||
const json = JSON.stringify({ ...daten, verlauf })
|
||||
if (json.length > MAX_JSON) return
|
||||
await updateDocument(config.collections.shopOrders, orderId, { bestellung: json })
|
||||
})
|
||||
} catch (err) {
|
||||
console.warn(`[shop-widerrufe] Verlauf nicht ergänzt: ${err?.name} ${String(err?.status ?? '').slice(0, 10)}`.trim())
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Nimmt einen Widerruf entgegen.
|
||||
* @param {{ doc: object, shop: object }} ctx Shop-Kontext (kontext.js); doc.state active oder disabled
|
||||
* @param {object} eingabe { name, email, bestellnummer, nachricht }
|
||||
* @param {{ now?: Date, ip?: string }} [optionen]
|
||||
* @returns {Promise<{ ok: true, eingang: string, id: string }>}
|
||||
* @throws {Error} status 429 (Grenzen) oder 400 mit fehler: { feld: Text }
|
||||
*/
|
||||
export async function erfasseWiderruf(ctx, eingabe, { now = new Date(), ip } = {}) {
|
||||
pruefeNow(now, 'erfasseWiderruf')
|
||||
const shopId = ctx?.shop?.id
|
||||
if (typeof shopId !== 'string' || shopId === '') throw new TypeError('erfasseWiderruf: ctx.shop.id fehlt')
|
||||
|
||||
if (!darfWiderrufsversuch(ip, now) || !zaehle(`shop-widerruf:${shopId}`, MAX_JE_SHOP_UND_STUNDE, STUNDE_MS, now)) {
|
||||
throw fehler(429, ZU_VIELE)
|
||||
}
|
||||
|
||||
const geprueft = normalisiereWiderruf(eingabe)
|
||||
if (geprueft.fehler) throw Object.assign(fehler(400, Object.values(geprueft.fehler)[0]), { fehler: geprueft.fehler })
|
||||
const { name, email, bestellnummer, nachricht } = geprueft.widerruf
|
||||
|
||||
const order = await passendeBestellung(shopId, bestellnummer, email)
|
||||
|
||||
const doc = await createDocument(col(), {
|
||||
shopId,
|
||||
customerId: String(ctx.shop.customerId ?? '').slice(0, 36),
|
||||
bestellnummer,
|
||||
name,
|
||||
email,
|
||||
nachricht,
|
||||
eingangAt: now.toISOString(),
|
||||
orderId: order?.$id ?? '',
|
||||
})
|
||||
if (order) await verlaufErgaenzen(order.$id, now)
|
||||
|
||||
// G12: Eingangsbestaetigung auf dauerhaftem Datentraeger, sofort; bestaetigungAt nur, wenn die Warteschlange sie angenommen hat
|
||||
try {
|
||||
const g12 = await anKaeufer('G12', ctx, order, { an: email, bookingId: doc.$id, name, bestellnummer, eingang: now, nachricht }, now)
|
||||
if (g12?.ok) await updateDocument(col(), doc.$id, { bestaetigungAt: now.toISOString() })
|
||||
} catch (err) {
|
||||
console.warn(`[shop-widerrufe] G12 nicht bestätigt: ${err?.name}`)
|
||||
}
|
||||
|
||||
try {
|
||||
const { values, blocks } = haendlerK26(ctx, { name, email, bestellnummer, nachricht, eingang: now }, now)
|
||||
await anHaendler('K26', ctx, values, blocks)
|
||||
} catch (err) {
|
||||
console.warn(`[shop-widerrufe] K26 nicht gesendet: ${err?.name}`)
|
||||
}
|
||||
|
||||
return { ok: true, eingang: eingangText(now), id: doc.$id }
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Verwalten
|
||||
|
||||
const ansicht = (d) => ({
|
||||
id: d.$id,
|
||||
bestellnummer: d.bestellnummer ?? '',
|
||||
name: d.name ?? '',
|
||||
email: d.email ?? '',
|
||||
nachricht: d.nachricht ?? '',
|
||||
eingangAt: d.eingangAt ?? '',
|
||||
bestaetigungAt: d.bestaetigungAt || null,
|
||||
bearbeitetAt: d.bearbeitetAt || null,
|
||||
orderId: d.orderId || null,
|
||||
})
|
||||
|
||||
/**
|
||||
* Widerrufe des Shops, neueste zuerst, 50 je Seite.
|
||||
* @param {string} shopId
|
||||
* @param {{ seite?: number }} [optionen] seite ab 1
|
||||
* @returns {Promise<{ widerrufe: object[], seite: number, mehr: boolean }>}
|
||||
*/
|
||||
export async function listeWiderrufe(shopId, { seite = 1 } = {}) {
|
||||
const nr = Number.isInteger(seite) && seite >= 1 ? seite : 1
|
||||
const filter = [Query.equal('shopId', shopId), Query.orderDesc('eingangAt')]
|
||||
// Der Aufruf kennt keinen Offset: Seite fuer Seite per Cursor bis zur gewuenschten
|
||||
let cursor = null
|
||||
let docs = []
|
||||
for (let i = 1; i <= nr; i += 1) {
|
||||
docs = await listDocuments(col(), [...filter, ...(cursor ? [Query.cursorAfter(cursor)] : []), Query.limit(SEITE + 1)])
|
||||
if (i < nr) {
|
||||
if (docs.length <= SEITE) return { widerrufe: [], seite: nr, mehr: false }
|
||||
cursor = docs[SEITE - 1].$id
|
||||
}
|
||||
}
|
||||
return { widerrufe: docs.slice(0, SEITE).map(ansicht), seite: nr, mehr: docs.length > SEITE }
|
||||
}
|
||||
|
||||
/**
|
||||
* Markiert einen Widerruf als bearbeitet (nur im eigenen Shop, sonst 404). Ein zweiter Aufruf aendert den Zeitpunkt nicht.
|
||||
* @returns {Promise<object>} der Widerruf
|
||||
*/
|
||||
export async function markiereBearbeitet(shopId, id, { now = new Date() } = {}) {
|
||||
pruefeNow(now, 'markiereBearbeitet')
|
||||
if (typeof id !== 'string' || !ID_RE.test(id)) throw fehler(404, NICHT_GEFUNDEN)
|
||||
let doc
|
||||
try {
|
||||
doc = await getDocument(col(), id)
|
||||
} catch (err) {
|
||||
if (err?.status === 404 && err.type !== 'collection_not_found' && err.type !== 'database_not_found') throw fehler(404, NICHT_GEFUNDEN)
|
||||
throw err
|
||||
}
|
||||
if (doc.shopId !== shopId) throw fehler(404, NICHT_GEFUNDEN)
|
||||
if (doc.bearbeitetAt) return ansicht(doc)
|
||||
return ansicht(await updateDocument(col(), id, { bearbeitetAt: now.toISOString() }))
|
||||
}
|
||||
@@ -0,0 +1,320 @@
|
||||
import { test, after, beforeEach, afterEach, mock } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
import { startAppwriteMock } from './support/appwriteMock.js'
|
||||
import { mailSink } from './support/mailSink.js'
|
||||
import { schemaKeys } from './support/schema.js'
|
||||
import { useTestEnv } from './support/testEnv.js'
|
||||
import { TERMINE_DATETIMES } from '../server/services/termine/schema.js'
|
||||
import { SHOP_DATETIMES } from '../server/services/shop/schema.js'
|
||||
|
||||
// Webshop E5: Widerrufe (§ 356a BGB, services/shop/widerrufe.js). Mails landen in der Warteschlange (termineOutbox) bzw. der
|
||||
// Mailsenke; nichts verlässt den Prozess.
|
||||
const aw = await startAppwriteMock({
|
||||
schema: {
|
||||
termineOutbox: schemaKeys('termineOutbox'),
|
||||
shopOrders: schemaKeys('shopOrders'),
|
||||
shopWiderrufe: schemaKeys('shopWiderrufe'),
|
||||
},
|
||||
datetimes: { ...TERMINE_DATETIMES, ...SHOP_DATETIMES },
|
||||
defaultLimit: 25,
|
||||
})
|
||||
after(() => aw.close())
|
||||
useTestEnv({ appwriteUrl: aw.url, stripeUrl: 'http://127.0.0.1:1' })
|
||||
|
||||
const { config } = await import('../server/config.js')
|
||||
const { deleteDocument } = await import('../server/services/appwriteAdmin.js')
|
||||
const { setMailTransportForTests } = await import('../server/services/mailer.js')
|
||||
const { resetOutboxForTests, warteAufVersand } = await import('../server/services/termine/outbox.js')
|
||||
const { resetTermineLimitsForTests } = await import('../server/services/termine/limits.js')
|
||||
const { STANDARD_EINSTELLUNGEN } = await import('../server/services/shop/einstellungen.js')
|
||||
const W = await import('../server/services/shop/widerrufe.js')
|
||||
const { normalisiereWiderruf, erfasseWiderruf, listeWiderrufe, markiereBearbeitet } = W
|
||||
after(() => setMailTransportForTests(null))
|
||||
|
||||
const JETZT = new Date('2026-10-05T12:03:00.000Z') // 14:03 Berlin (MESZ)
|
||||
const nach = (ms) => new Date(JETZT.getTime() + ms)
|
||||
const SITE_KEY = 'abcdefghijklmnop'
|
||||
const BASIS_VORHER = config.publicBaseUrl
|
||||
const ABSENDER_VORHER = config.smtp.from
|
||||
|
||||
const ctxMit = (state = 'active', id = 'f_shop01') => ({
|
||||
doc: { $id: id, customerId: 'c1', projectId: 'p1', featureKey: 'shop', siteKey: SITE_KEY, state },
|
||||
shop: {
|
||||
id,
|
||||
customerId: 'c1',
|
||||
projectId: 'p1',
|
||||
siteKey: SITE_KEY,
|
||||
geoeffnet: false,
|
||||
einstellungen: {
|
||||
...JSON.parse(JSON.stringify(STANDARD_EINSTELLUNGEN)),
|
||||
shopname: 'Töpferei Muster',
|
||||
anbieter: { name: 'Erika Muster', strasse: 'Hauptstr. 1', plz: '67722', ort: 'Winnweiler', land: 'DE', email: 'info@toepferei.example', telefon: '', ustId: '' },
|
||||
},
|
||||
rechtstexte: { entwurf: {}, bestaetigt: { texte: { agb: 'AGB', widerrufsbelehrung: 'Belehrung', widerrufsformular: 'Formular', impressumUrl: '', datenschutzUrl: '' }, hash: 'h1', at: JETZT.toISOString(), von: 'c1' } },
|
||||
},
|
||||
})
|
||||
|
||||
const EINGABE = { name: 'Max Mustermann', email: 'Max@Example.com', bestellnummer: '26-k7qm2x', nachricht: 'Ich widerrufe den Vertrag über die Tasse.' }
|
||||
|
||||
const bestellung = (over = {}) => ({
|
||||
$id: 'o_bestellung01',
|
||||
shopId: 'f_shop01',
|
||||
customerId: 'c1',
|
||||
bestellnummer: '26-K7QM2X',
|
||||
status: 'bezahlt',
|
||||
kaeuferEmail: 'max@example.com',
|
||||
summeCent: 1200,
|
||||
erstelltAt: JETZT.toISOString(),
|
||||
bezahltAt: JETZT.toISOString(),
|
||||
bestellung: JSON.stringify({ positionen: [{ name: 'Tasse', menge: 1, summeCent: 1200, widerruf: 'gesetzlich' }], verlauf: [{ at: JETZT.toISOString(), was: 'angelegt' }] }),
|
||||
...over,
|
||||
})
|
||||
|
||||
let sink
|
||||
let log
|
||||
beforeEach(async () => {
|
||||
for (const sammlung of ['termineOutbox', 'customers', 'shopOrders', 'shopWiderrufe']) {
|
||||
for (const id of aw.docs(sammlung).keys()) await deleteDocument(config.collections[sammlung], id)
|
||||
}
|
||||
resetOutboxForTests()
|
||||
resetTermineLimitsForTests()
|
||||
config.smtp.from = 'noreply@webklar.com'
|
||||
config.publicBaseUrl = 'https://project.webklar.com'
|
||||
sink = mailSink()
|
||||
setMailTransportForTests(sink)
|
||||
log = { error: mock.method(console, 'error', () => {}), warn: mock.method(console, 'warn', () => {}) }
|
||||
aw.seed('customers', { $id: 'c1', name: 'Erika Muster', email: 'erika@toepferei.example' })
|
||||
})
|
||||
afterEach(async () => {
|
||||
await warteAufVersand()
|
||||
mock.restoreAll()
|
||||
config.smtp.from = ABSENDER_VORHER
|
||||
config.publicBaseUrl = BASIS_VORHER
|
||||
})
|
||||
|
||||
const widerrufe = () => [...aw.docs('shopWiderrufe').values()]
|
||||
const outbox = () => [...aw.docs('termineOutbox').values()]
|
||||
const fehlerVon = async (promise) => {
|
||||
try {
|
||||
await promise
|
||||
} catch (err) {
|
||||
return err
|
||||
}
|
||||
assert.fail('hätte werfen müssen')
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- Prüfung
|
||||
|
||||
test('normalisiereWiderruf: gültige Eingabe wird bereinigt (E-Mail klein, Bestellnummer groß, Steuerzeichen raus)', () => {
|
||||
const erg = normalisiereWiderruf({ name: ' Max \u0000 Mustermann\n', email: ' Max@Example.com ', bestellnummer: ' 26-k7qm2x ', nachricht: 'Zeile 1\r\nZeile\u0007 2\u0000 ' })
|
||||
assert.deepEqual(erg, { widerruf: { name: 'Max Mustermann', email: 'max@example.com', bestellnummer: '26-K7QM2X', nachricht: 'Zeile 1\nZeile 2' } })
|
||||
assert.equal(normalisiereWiderruf({ name: 'Ab', email: 'a@b.de', bestellnummer: 'X' }).widerruf.nachricht, '', 'Nachricht ist freiwillig')
|
||||
})
|
||||
|
||||
test('normalisiereWiderruf: Fehler je Feld in Sie-Form', () => {
|
||||
const grenzen = normalisiereWiderruf({ name: 'M', email: 'keine-adresse', bestellnummer: '', nachricht: 'x'.repeat(2001) })
|
||||
assert.deepEqual(Object.keys(grenzen.fehler).sort(), ['bestellnummer', 'email', 'nachricht', 'name'])
|
||||
for (const text of Object.values(grenzen.fehler)) assert.match(text, /Bitte|darf/)
|
||||
assert.equal(normalisiereWiderruf({ name: 'x'.repeat(201), email: 'a@b.de', bestellnummer: '1' }).fehler.name.includes('200'), true)
|
||||
assert.ok(normalisiereWiderruf({ name: 'Ab', email: 'a@b.de', bestellnummer: 'x'.repeat(33) }).fehler.bestellnummer)
|
||||
assert.ok(normalisiereWiderruf({ name: 'Ab', email: 'a@b.de', bestellnummer: '26_K7 QM' }).fehler.bestellnummer, 'nur Buchstaben, Ziffern, Bindestrich')
|
||||
assert.ok(normalisiereWiderruf({ name: 'Ab', email: `${'a'.repeat(250)}@b.de`, bestellnummer: '1' }).fehler.email, 'über 254 Zeichen')
|
||||
assert.equal(normalisiereWiderruf({ name: 'Ab', email: 'a@b.de', bestellnummer: '1', nachricht: 'x'.repeat(2000) }).fehler, undefined)
|
||||
// mehrere Adressen / Namensform / eingeschmuggelter Zeilenumbruch
|
||||
for (const email of ['a@b.de, c@d.de', 'a@b.de;c@d.de', 'Max <a@b.de>', 'a@b.de\nc@d.de', 'a b@c.de', 'a@b']) {
|
||||
assert.ok(normalisiereWiderruf({ name: 'Ab', email, bestellnummer: '1' }).fehler?.email, email)
|
||||
}
|
||||
assert.deepEqual(Object.keys(normalisiereWiderruf(null).fehler).sort(), ['bestellnummer', 'email', 'name'])
|
||||
assert.ok(normalisiereWiderruf({ name: 5, email: {}, bestellnummer: [] }).fehler.name, 'falsche Typen sind leer')
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------- Erfassen
|
||||
|
||||
test('passende Bestellung: orderId gesetzt, Verlauf ergänzt, G12 in der Warteschlange mit Datum und Uhrzeit, K26 an den Händler', async () => {
|
||||
aw.seed('shopOrders', bestellung())
|
||||
const erg = await erfasseWiderruf(ctxMit(), EINGABE, { now: JETZT, ip: '203.0.113.5' })
|
||||
await warteAufVersand()
|
||||
|
||||
assert.equal(erg.ok, true)
|
||||
assert.equal(erg.eingang, '05.10.2026, 14:03 Uhr')
|
||||
const [doc] = widerrufe()
|
||||
assert.equal(erg.id, doc.$id)
|
||||
assert.deepEqual(
|
||||
{ shopId: doc.shopId, customerId: doc.customerId, bestellnummer: doc.bestellnummer, name: doc.name, email: doc.email, orderId: doc.orderId },
|
||||
{ shopId: 'f_shop01', customerId: 'c1', bestellnummer: '26-K7QM2X', name: 'Max Mustermann', email: 'max@example.com', orderId: 'o_bestellung01' },
|
||||
)
|
||||
assert.equal(doc.nachricht, EINGABE.nachricht)
|
||||
assert.equal(new Date(doc.eingangAt).getTime(), JETZT.getTime())
|
||||
assert.equal(new Date(doc.bestaetigungAt).getTime(), JETZT.getTime(), 'Warteschlange hat G12 angenommen')
|
||||
|
||||
const verlauf = JSON.parse(aw.docs('shopOrders').get('o_bestellung01').bestellung).verlauf
|
||||
assert.deepEqual(verlauf.map((v) => v.was), ['angelegt', 'widerruf'])
|
||||
assert.equal(verlauf[1].at, JETZT.toISOString())
|
||||
|
||||
// G12 an den Käufer (Warteschlange): bookingId = Bestell-ID (mails.js bevorzugt sie vor der Widerruf-ID), Absender Shopname, Antwort an den Händler
|
||||
const [g12] = outbox()
|
||||
assert.equal(g12.art, 'G12')
|
||||
assert.equal(g12.featureId, 'f_shop01')
|
||||
assert.equal(g12.bookingId, 'o_bestellung01')
|
||||
assert.equal(g12.fromName, 'Töpferei Muster')
|
||||
assert.equal(g12.replyTo, 'info@toepferei.example')
|
||||
const kaeufer = sink.sent.find((m) => m.to.some((t) => t.address === 'max@example.com'))
|
||||
assert.ok(kaeufer, 'G12 versandt')
|
||||
for (const teil of ['26-K7QM2X', 'Max Mustermann', '05.10.2026, 14:03 Uhr', 'Ich widerrufe den Vertrag über die Tasse.']) assert.ok(kaeufer.text.includes(teil), teil)
|
||||
|
||||
// K26 an den Händler, ohne BCC
|
||||
const haendler = sink.sent.find((m) => m.to.some((t) => t.address === 'erika@toepferei.example'))
|
||||
assert.ok(haendler, 'K26 versandt')
|
||||
assert.ok(!haendler.bcc)
|
||||
for (const teil of ['Max Mustermann', 'max@example.com', '26-K7QM2X', '05.10.2026, 14:03 Uhr']) assert.ok(haendler.text.includes(teil), teil)
|
||||
assert.equal(sink.sent.length, 2)
|
||||
})
|
||||
|
||||
test('keine passende Bestellung (falsche Nummer, fremde E-Mail, anderer Shop): trotzdem gespeichert und bestätigt, ohne orderId und ohne Verlauf', async () => {
|
||||
aw.seed('shopOrders', bestellung())
|
||||
aw.seed('shopOrders', bestellung({ $id: 'o_fremd', shopId: 'f_anderer', bestellnummer: '26-FREMD1', kaeuferEmail: 'max@example.com' }))
|
||||
const faelle = [
|
||||
{ bestellnummer: '26-ZZZZZZ' },
|
||||
{ email: 'jemand@example.com' },
|
||||
{ bestellnummer: '26-FREMD1' }, // existiert nur in einem anderen Shop
|
||||
]
|
||||
for (const [i, abweichung] of faelle.entries()) {
|
||||
const erg = await erfasseWiderruf(ctxMit(), { ...EINGABE, ...abweichung }, { now: nach(i * 1000), ip: `203.0.113.${i + 10}` })
|
||||
assert.equal(erg.ok, true)
|
||||
assert.equal(widerrufe().find((d) => d.$id === erg.id).orderId, '')
|
||||
}
|
||||
await warteAufVersand()
|
||||
assert.equal(JSON.parse(aw.docs('shopOrders').get('o_bestellung01').bestellung).verlauf.length, 1)
|
||||
assert.equal(JSON.parse(aw.docs('shopOrders').get('o_fremd').bestellung).verlauf.length, 1)
|
||||
assert.equal(outbox().length, 3)
|
||||
assert.ok(outbox().every((e) => e.art === 'G12'))
|
||||
assert.deepEqual(outbox().map((e) => e.bookingId).sort(), widerrufe().map((d) => d.$id).sort(), 'ohne Bestellung gilt die Widerruf-ID')
|
||||
assert.equal(widerrufe().every((d) => d.bestaetigungAt), true, 'Bestätigung auch ohne passende Bestellung')
|
||||
})
|
||||
|
||||
test('E-Mail-Vergleich ohne Beachtung der Groß-/Kleinschreibung; anonymisierte Bestellung (leere E-Mail) passt nie', async () => {
|
||||
aw.seed('shopOrders', bestellung({ kaeuferEmail: 'MAX@Example.COM' }))
|
||||
const erg = await erfasseWiderruf(ctxMit(), EINGABE, { now: JETZT, ip: '203.0.113.5' })
|
||||
assert.equal(widerrufe().find((d) => d.$id === erg.id).orderId, 'o_bestellung01')
|
||||
|
||||
await deleteDocument(config.collections.shopOrders, 'o_bestellung01')
|
||||
aw.seed('shopOrders', bestellung({ kaeuferEmail: '' }))
|
||||
const erg2 = await erfasseWiderruf(ctxMit(), { ...EINGABE, email: 'x@example.com' }, { now: nach(1000), ip: '203.0.113.5' })
|
||||
assert.equal(widerrufe().find((d) => d.$id === erg2.id).orderId, '')
|
||||
})
|
||||
|
||||
test('ungültige Eingabe: Fehler 400 mit Feldtexten, nichts gespeichert, keine Mail', async () => {
|
||||
const err = await fehlerVon(erfasseWiderruf(ctxMit(), { ...EINGABE, name: '' }, { now: JETZT, ip: '203.0.113.5' }))
|
||||
assert.equal(err.status, 400)
|
||||
assert.ok(err.fehler.name)
|
||||
assert.equal(widerrufe().length, 0)
|
||||
assert.equal(outbox().length, 0)
|
||||
})
|
||||
|
||||
test('Grenzen: 10 je IP und Stunde ⇒ 429, danach wieder frei; 20 je Shop und Stunde; andere Shops unberührt', async () => {
|
||||
const ip = '203.0.113.7'
|
||||
for (let i = 0; i < 10; i += 1) await erfasseWiderruf(ctxMit(), EINGABE, { now: nach(i * 1000), ip })
|
||||
const err = await fehlerVon(erfasseWiderruf(ctxMit(), EINGABE, { now: nach(11000), ip }))
|
||||
assert.equal(err.status, 429)
|
||||
assert.equal(err.message, 'Zu viele Versuche. Bitte versuchen Sie es später noch einmal.')
|
||||
assert.equal(widerrufe().length, 10)
|
||||
// eine andere IP geht noch
|
||||
await erfasseWiderruf(ctxMit(), EINGABE, { now: nach(12000), ip: '203.0.113.8' })
|
||||
// nach einer Stunde ist die IP wieder frei
|
||||
await erfasseWiderruf(ctxMit(), EINGABE, { now: nach(61 * 60 * 1000), ip })
|
||||
|
||||
// 20 je Shop: bisher 12 Versuche in der ersten Stunde (11 + 1 in der zweiten) ⇒ in der zweiten Stunde weiter mit wechselnden IPs
|
||||
resetTermineLimitsForTests()
|
||||
const t = nach(3 * 60 * 60 * 1000)
|
||||
for (let i = 0; i < 20; i += 1) await erfasseWiderruf(ctxMit(), EINGABE, { now: t, ip: `198.51.100.${i + 1}` })
|
||||
const shopErr = await fehlerVon(erfasseWiderruf(ctxMit(), EINGABE, { now: t, ip: '198.51.100.99' }))
|
||||
assert.equal(shopErr.status, 429)
|
||||
await erfasseWiderruf(ctxMit('active', 'f_shop02'), EINGABE, { now: t, ip: '198.51.100.99' })
|
||||
})
|
||||
|
||||
test('ein ungültiger Versuch zählt gegen die Grenze (kein Raten ohne Limit)', async () => {
|
||||
const ip = '203.0.113.9'
|
||||
for (let i = 0; i < 10; i += 1) await fehlerVon(erfasseWiderruf(ctxMit(), { ...EINGABE, email: 'x' }, { now: JETZT, ip }))
|
||||
assert.equal((await fehlerVon(erfasseWiderruf(ctxMit(), EINGABE, { now: JETZT, ip }))).status, 429)
|
||||
})
|
||||
|
||||
test('Mailfehler kippen die Anfrage nicht: Warteschlange verweigert G12 ⇒ ok, bestaetigungAt leer; K26-Versand scheitert ⇒ ok', async () => {
|
||||
// G12: die Warteschlange verweigert den Eintrag (fehlende featureId)
|
||||
const ohneFeature = ctxMit()
|
||||
ohneFeature.doc.$id = ''
|
||||
const erg = await erfasseWiderruf(ohneFeature, EINGABE, { now: JETZT, ip: '203.0.113.5' })
|
||||
assert.equal(erg.ok, true)
|
||||
assert.equal(erg.eingang, '05.10.2026, 14:03 Uhr')
|
||||
const doc = widerrufe().find((d) => d.$id === erg.id)
|
||||
assert.equal(doc.bestaetigungAt ?? '', '', 'nicht bestätigt, weil nichts eingereiht wurde')
|
||||
assert.equal(outbox().length, 0)
|
||||
await warteAufVersand()
|
||||
|
||||
// K26: SMTP wirft
|
||||
setMailTransportForTests({ sendMail: async () => Promise.reject(Object.assign(new Error('smtp: max@example.com abgelehnt'), { code: 'ECONNECTION' })) })
|
||||
const erg2 = await erfasseWiderruf(ctxMit(), EINGABE, { now: nach(1000), ip: '203.0.113.5' })
|
||||
assert.equal(erg2.ok, true)
|
||||
await warteAufVersand()
|
||||
assert.ok(widerrufe().find((d) => d.$id === erg2.id).bestaetigungAt, 'G12 war eingereiht')
|
||||
assert.ok(!log.warn.mock.calls.some((a) => a.arguments.map(String).join(' ').includes('max@example.com')), 'keine Adresse im Log')
|
||||
})
|
||||
|
||||
test('K26 ohne Kunden-E-Mail scheitert still, Widerruf und G12 bleiben', async () => {
|
||||
for (const id of aw.docs('customers').keys()) await deleteDocument(config.collections.customers, id)
|
||||
const erg = await erfasseWiderruf(ctxMit(), EINGABE, { now: JETZT, ip: '203.0.113.5' })
|
||||
assert.equal(erg.ok, true)
|
||||
await warteAufVersand()
|
||||
assert.equal(outbox().length, 1)
|
||||
})
|
||||
|
||||
test('geschlossener oder deaktivierter Shop: Widerruf wird trotzdem angenommen', async () => {
|
||||
for (const [i, state] of ['active', 'disabled'].entries()) {
|
||||
const ctx = ctxMit(state)
|
||||
ctx.shop.geoeffnet = false
|
||||
const erg = await erfasseWiderruf(ctx, EINGABE, { now: nach(i * 1000), ip: `203.0.113.${20 + i}` })
|
||||
assert.equal(erg.ok, true, state)
|
||||
}
|
||||
await warteAufVersand()
|
||||
assert.equal(widerrufe().length, 2)
|
||||
assert.equal(outbox().length, 2)
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------- Verwalten
|
||||
|
||||
test('listeWiderrufe: neueste zuerst, 50 je Seite, nur der eigene Shop', async () => {
|
||||
for (let i = 0; i < 53; i += 1) {
|
||||
aw.seed('shopWiderrufe', { $id: `w_${String(i).padStart(3, '0')}`, shopId: 'f_shop01', customerId: 'c1', bestellnummer: `26-N${i}`, name: 'Max', email: 'max@example.com', nachricht: '', eingangAt: nach(i * 60000).toISOString() })
|
||||
}
|
||||
aw.seed('shopWiderrufe', { $id: 'w_fremd', shopId: 'f_shop02', customerId: 'c2', bestellnummer: '26-X', name: 'Fremd', email: 'f@example.com', nachricht: '', eingangAt: nach(999 * 60000).toISOString() })
|
||||
|
||||
const s1 = await listeWiderrufe('f_shop01')
|
||||
assert.equal(s1.widerrufe.length, 50)
|
||||
assert.equal(s1.mehr, true)
|
||||
assert.equal(s1.seite, 1)
|
||||
assert.equal(s1.widerrufe[0].id, 'w_052')
|
||||
assert.equal(s1.widerrufe[49].id, 'w_003')
|
||||
assert.ok(!s1.widerrufe.some((w) => w.id === 'w_fremd'))
|
||||
|
||||
const s2 = await listeWiderrufe('f_shop01', { seite: 2 })
|
||||
assert.deepEqual(s2.widerrufe.map((w) => w.id), ['w_002', 'w_001', 'w_000'])
|
||||
assert.equal(s2.mehr, false)
|
||||
assert.deepEqual((await listeWiderrufe('f_shop01', { seite: 3 })).widerrufe, [])
|
||||
assert.deepEqual((await listeWiderrufe('f_leer')).widerrufe, [])
|
||||
})
|
||||
|
||||
test('markiereBearbeitet: setzt bearbeitetAt einmal; fremder Shop oder unbekannte ID ⇒ 404 und keine Änderung', async () => {
|
||||
aw.seed('shopWiderrufe', { $id: 'w_eigen', shopId: 'f_shop01', customerId: 'c1', bestellnummer: '26-A', name: 'Max', email: 'max@example.com', nachricht: '', eingangAt: JETZT.toISOString() })
|
||||
aw.seed('shopWiderrufe', { $id: 'w_fremd', shopId: 'f_shop02', customerId: 'c2', bestellnummer: '26-B', name: 'Fremd', email: 'f@example.com', nachricht: '', eingangAt: JETZT.toISOString() })
|
||||
|
||||
const fremd = await fehlerVon(markiereBearbeitet('f_shop01', 'w_fremd', { now: nach(1000) }))
|
||||
assert.equal(fremd.status, 404)
|
||||
assert.ok(!aw.docs('shopWiderrufe').get('w_fremd').bearbeitetAt)
|
||||
for (const id of ['w_gibtsnicht', '../x', '', null]) assert.equal((await fehlerVon(markiereBearbeitet('f_shop01', id, { now: nach(1000) }))).status, 404, String(id))
|
||||
|
||||
const erg = await markiereBearbeitet('f_shop01', 'w_eigen', { now: nach(2000) })
|
||||
assert.equal(erg.id, 'w_eigen')
|
||||
assert.equal(new Date(erg.bearbeitetAt).getTime(), nach(2000).getTime())
|
||||
const nochmal = await markiereBearbeitet('f_shop01', 'w_eigen', { now: nach(9000) })
|
||||
assert.equal(new Date(nochmal.bearbeitetAt).getTime(), nach(2000).getTime(), 'zweiter Aufruf ändert nichts')
|
||||
assert.equal((await listeWiderrufe('f_shop01')).widerrufe[0].bearbeitetAt, erg.bearbeitetAt)
|
||||
})
|
||||
Reference in new issue
Block a user