677 lines
34 KiB
JavaScript
677 lines
34 KiB
JavaScript
import express, { Router } from 'express'
|
||
import { getSessionCustomerId, requireSession } from '../middleware/session.js'
|
||
import { assertOwnProject, getFeatureDoc } from '../services/siteFeatures.js'
|
||
import { countDocuments, getDocument, listAllDocuments, Query, updateDocument } from '../services/appwriteAdmin.js'
|
||
import { config } from '../config.js'
|
||
import { withLocks } from '../services/keyedLock.js'
|
||
import { isKundenansicht, logIfKundenansicht } from '../services/kundenansicht.js'
|
||
import { createWriteLimiter } from '../services/writeLimiter.js'
|
||
import { anfrageAnsicht, ensureShopConfig, leseShopConfig, stelleAnfrage, zieheZurueck } from '../services/shop/anfrage.js'
|
||
import { shopFuerKunde } from '../services/shop/schalter.js'
|
||
import { kundenartWirksam } from '../services/kundenart.js'
|
||
import { neueAnsicht } from '../services/kundenansicht/schalter.js'
|
||
import { kontoAnlegen, kontoStatus, onboardingLink, statusAusKonto } from '../services/shop/connect.js'
|
||
import { bestellungKunde, bestellungLesen, csv as bestellungenCsv, erstatte, listeBestellungen, setzeStatus } from '../services/shop/bestellungen.js'
|
||
import { listeWiderrufe, markiereBearbeitet } from '../services/shop/widerrufe.js'
|
||
import { uploadSlot } from './chat.js'
|
||
import { istVollstaendig, speichereEinstellungen } from '../services/shop/einstellungen.js'
|
||
import { bereitschaft, istGeoeffnet, ladeShop, leereCache } from '../services/shop/kontext.js'
|
||
import {
|
||
bildIdsInGebrauch, holeProdukt, leseBestandGeladen, listeProdukte, loescheProdukt, normalisiereProdukt, parseProdukt, sortiere, speichereProdukt,
|
||
} from '../services/shop/produkte.js'
|
||
import { archiviereRechtstexte } from '../services/shop/archiv.js'
|
||
import {
|
||
BESTAETIGUNG_TEXT, GEWAEHRLEISTUNG_BILD, gewaehrleistungsHinweis, musterAgb, musterWiderrufsbelehrung, musterWiderrufsformular,
|
||
normalisiereRechtstexte, pruefeBestaetigbar, rechtstexteHash, versandUndZahlung, vollstaendig,
|
||
} from '../services/shop/rechtstexte.js'
|
||
import {
|
||
BILD_MAX_BYTES, beanspruche, bildLimitErreicht, bildMeta, bildPfad, loescheBild, setzeBildLimitZurueck, speichereBild,
|
||
} from '../services/shop/bilder.js'
|
||
|
||
/**
|
||
* Kunden-Schnittstelle des Webshops: /api/shop (Spezifikation 2026-10-05-webshop-design.md). Stand: Anfrage (B1) und
|
||
* Verwaltung (C7): Status, Einstellungen, Artikel, Rechtstexte, Oeffnen, Bilder. Stripe-Konto (D2) und Bestellungen (E) kommen dazu.
|
||
*
|
||
* Jede Route: Session, projectId (Query oder Body), eigenes Projekt. Die Verwaltungs-Routen laufen ueber mitShop: Schalter
|
||
* (409 nicht verfuegbar), Funktion im Zustand setup|active (lesend auch disabled), shopConfig vorhanden (setup|active legt es an).
|
||
* Kundenansicht: Artikel, Einstellungen, Rechtstexte (nur Entwurf speichern) und Bilder darf das Team mit ausfuellen und werden
|
||
* protokolliert (kundenansichtGuard); Anfrage, Oeffnen und Bestaetigen der Rechtstexte bleiben dem Kunden vorbehalten (hier 403).
|
||
* Schreib-Routen zaehlen gegen 300 Aufrufe je Kunde und Stunde (Anfrage-Routen gegen 20), Bilder zusaetzlich gegen 40 je Stunde.
|
||
* Fehler: { error: <Text>, fehler?: { <feld>: Text }, code? }; Texte von Appwrite oder unbekannten Fehlern verlassen den Server nie.
|
||
*/
|
||
|
||
const router = Router()
|
||
|
||
const MAX_ANFRAGE_WRITES_PER_HOUR = 20
|
||
const MAX_WRITES_PER_HOUR = 300
|
||
const MAX_CSV_PER_HOUR = 30
|
||
const PRODUKT_DOC_MAX_JSON = 100000
|
||
const BILD_DATEI_RE = /^([a-z0-9-]{1,64})-(l|s)\.webp$/
|
||
const MELDUNG = {
|
||
projekt: 'Bitte wähle ein Projekt.',
|
||
fremd: 'Kein Zugriff auf dieses Projekt.',
|
||
kundenansicht: 'In der Kundenansicht kann das nicht geändert werden.',
|
||
zuViele: 'Zu viele Änderungen in kurzer Zeit. Bitte versuch es in einer Stunde wieder.',
|
||
nichtVerfuegbar: 'Der Webshop ist noch nicht verfügbar.',
|
||
nichtEingerichtet: 'Der Webshop ist für dieses Projekt noch nicht eingerichtet.',
|
||
zuVieleBilder: 'Zu viele Bilder in kurzer Zeit. Bitte versuch es später wieder.',
|
||
bildFehlt: 'Bild nicht gefunden.',
|
||
eingabe: 'Die Eingabe fehlt oder ist unlesbar.',
|
||
stripeKundenansicht: 'In der Kundenansicht kann das Stripe-Konto nicht eingerichtet werden.',
|
||
stripeFern: 'Stripe ist gerade nicht erreichbar. Bitte versuch es gleich noch einmal.',
|
||
plattform: 'Die Stripe-Anbindung ist bei WEBklar noch nicht fertig eingerichtet. Wir kümmern uns darum – schreib uns gern im Chat.',
|
||
keinKonto: 'Es ist noch kein Stripe-Konto angelegt.',
|
||
}
|
||
|
||
/** Fehler des Kunden (4xx/503 ohne Appwrite-Typ) wie sie sind, alles andere 500 ohne Rohtext. */
|
||
function fail(res, err) {
|
||
const own = ((err?.status >= 400 && err.status < 500) || err?.status === 502 || err?.status === 503) && !err.type
|
||
if (!own) {
|
||
console.error(`[shop] ${err?.name ?? 'Fehler'} ${err?.status ?? ''} ${String(err?.message ?? '').slice(0, 200)}`.trim())
|
||
return res.status(500).json({ error: 'Interner Serverfehler' })
|
||
}
|
||
const body = { ...err.body, error: err.message }
|
||
if (err.fehler && typeof err.fehler === 'object') {
|
||
body.fehler = err.fehler
|
||
const erster = Object.values(err.fehler).find((t) => typeof t === 'string')
|
||
if (erster) body.error = erster
|
||
}
|
||
if (typeof err.code === 'string' && /^[A-Za-z0-9_]{1,40}$/.test(err.code) && body.code === undefined) body.code = err.code
|
||
return res.status(err.status).json(body)
|
||
}
|
||
|
||
const route = (fn) => async (req, res, next) => {
|
||
try {
|
||
await fn(req, res, next)
|
||
} catch (err) {
|
||
fail(res, err)
|
||
}
|
||
}
|
||
|
||
const anfrageLimiter = createWriteLimiter({ max: MAX_ANFRAGE_WRITES_PER_HOUR })
|
||
const limitAnfrage = anfrageLimiter.middleware((req) => getSessionCustomerId(req), MELDUNG.zuViele)
|
||
const schreibLimiter = createWriteLimiter({ max: MAX_WRITES_PER_HOUR })
|
||
const csvLimiter = createWriteLimiter({ max: MAX_CSV_PER_HOUR })
|
||
const limitCsv = csvLimiter.middleware((req) => getSessionCustomerId(req), MELDUNG.zuViele)
|
||
const limitWrites = schreibLimiter.middleware((req) => getSessionCustomerId(req), MELDUNG.zuViele)
|
||
|
||
export function resetShopRoutesForTests() {
|
||
anfrageLimiter.reset()
|
||
schreibLimiter.reset()
|
||
csvLimiter.reset()
|
||
setzeBildLimitZurueck()
|
||
}
|
||
|
||
const nurKunde = (req, res, next) => {
|
||
if (isKundenansicht(req.session) || req.session?.viewAs) return res.status(403).json({ error: MELDUNG.kundenansicht })
|
||
return next()
|
||
}
|
||
|
||
const person = (req) => ({ name: req.session?.name || '', email: req.session?.email || '' })
|
||
const projectIdOf = (req) => {
|
||
const raw = req.params?.projectId ?? req.query.projectId ?? req.body?.projectId
|
||
return typeof raw === 'string' ? raw : ''
|
||
}
|
||
|
||
router.use((_req, res, next) => {
|
||
res.set('Cache-Control', 'no-store')
|
||
next()
|
||
})
|
||
|
||
const STRIPE_FELDER = ['charges_enabled', 'payouts_enabled', 'details_submitted', 'currently_due', 'past_due', 'disabled_reason', 'geprueftAt']
|
||
const BEZAHLT = ['bezahlt', 'versendet', 'abholbereit', 'abgeschlossen']
|
||
|
||
/** Stripe-Status fuer den Browser: nur bekannte Felder, nie Konto-ID oder Schluessel. */
|
||
function stripeAnsicht(shop) {
|
||
const roh = shop?.stripeStatus
|
||
const status = roh ? Object.fromEntries(STRIPE_FELDER.filter((k) => Object.hasOwn(roh, k)).map((k) => [k, roh[k]])) : null
|
||
return { verbunden: Boolean(shop?.stripeAccountId), status }
|
||
}
|
||
|
||
/** Kennzahlen der Uebersicht (nur Anzeige): Artikel und, best effort, Bestellungen. Ein Lesefehler bei den Bestellungen zaehlt als 0. */
|
||
async function kennzahlen(shopId, produkte, now = new Date()) {
|
||
const zahlen = {
|
||
artikel: produkte.length,
|
||
aktiveArtikel: produkte.filter((d) => d.aktiv !== false).length,
|
||
offeneBestellungen: 0,
|
||
bestellungen30: 0,
|
||
umsatz30Cent: 0,
|
||
}
|
||
try {
|
||
zahlen.offeneBestellungen = await countDocuments(config.collections.shopOrders, [Query.equal('shopId', shopId), Query.equal('status', 'bezahlt')])
|
||
const seit = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000)
|
||
const neu = await listAllDocuments(config.collections.shopOrders, [Query.equal('shopId', shopId), Query.greaterThanEqual('erstelltAt', seit.toISOString())])
|
||
for (const o of neu) {
|
||
if (!BEZAHLT.includes(o.status)) continue
|
||
zahlen.bestellungen30 += 1
|
||
if (Number.isInteger(o.summeCent)) zahlen.umsatz30Cent += o.summeCent
|
||
}
|
||
} catch (err) {
|
||
console.warn(`[shop] Kennzahlen der Bestellungen nicht lesbar: ${String(err?.message ?? '').slice(0, 120)}`)
|
||
}
|
||
return zahlen
|
||
}
|
||
|
||
const einbauSnippet = (siteKey) => `<div data-webklar-shop="${siteKey}"></div>\n<script src="${config.publicBaseUrl}/embed/shop.js" defer></script>`
|
||
const vorschauUrl = (siteKey) => `${config.publicBaseUrl}/shop/${siteKey}`
|
||
const widerrufUrl = (siteKey) => `${config.publicBaseUrl}/shop/${siteKey}/widerruf`
|
||
|
||
async function ticketWoid(ticketId) {
|
||
if (!ticketId) return null
|
||
try {
|
||
return (await getDocument(config.collections.workorders, ticketId))?.woid || null
|
||
} catch {
|
||
return null
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Stand des Webshops fuer ein Projekt. verfuegbar = Schalter fuer diesen Kunden; state = Zustand der Funktion (off ohne Dokument);
|
||
* anfrage = anfrageAnsicht oder null; mit shopConfig dazu: ticketWoid, bereitschaft ({ bereit, punkte }), geoeffnet (verkauft der Shop
|
||
* gerade), schalter (Schalter des Kunden), siteKey, snippet, vorschauUrl, stripe ({ verbunden, status }), zahlen. Legt nichts an.
|
||
*/
|
||
router.get('/status', requireSession, route(async (req, res) => {
|
||
const projectId = projectIdOf(req)
|
||
if (!projectId) throw Object.assign(new Error(MELDUNG.projekt), { status: 400 })
|
||
const customerId = getSessionCustomerId(req)
|
||
try {
|
||
await assertOwnProject(customerId, projectId)
|
||
} catch (err) {
|
||
throw err?.status === 403 || err?.status === 400 ? Object.assign(new Error(MELDUNG.fremd), { status: 403 }) : err
|
||
}
|
||
const verfuegbar = shopFuerKunde(req.session?.email)
|
||
const feature = await getFeatureDoc(customerId, projectId, 'shop')
|
||
const shopDoc = feature ? await leseShopConfig(feature.$id) : null
|
||
const antwort = {
|
||
verfuegbar,
|
||
state: feature?.state || 'off',
|
||
ticketWoid: null,
|
||
anfrage: shopDoc ? anfrageAnsicht(shopDoc) : null,
|
||
bereitschaft: null,
|
||
geoeffnet: false,
|
||
schalter: false,
|
||
siteKey: feature?.siteKey || null,
|
||
snippet: null,
|
||
vorschauUrl: null,
|
||
stripe: { verbunden: false, status: null },
|
||
zahlen: null,
|
||
}
|
||
if (feature && shopDoc) {
|
||
const shop = ladeShop(shopDoc)
|
||
const produkte = await listeProdukte(shop.id)
|
||
const ctx = { doc: feature, shop, project: null }
|
||
antwort.ticketWoid = await ticketWoid(feature.ticketId)
|
||
antwort.bereitschaft = await bereitschaft(ctx, { produkte })
|
||
antwort.geoeffnet = await istGeoeffnet(ctx, { produkte })
|
||
antwort.schalter = shop.geoeffnet
|
||
antwort.snippet = einbauSnippet(shop.siteKey || feature.siteKey)
|
||
antwort.vorschauUrl = vorschauUrl(shop.siteKey || feature.siteKey)
|
||
antwort.stripe = stripeAnsicht(shop)
|
||
antwort.zahlen = await kennzahlen(shop.id, produkte)
|
||
}
|
||
res.json(antwort)
|
||
}))
|
||
|
||
/** Kundenart des Kundendokuments (leer oder unbekannt = privat) - nur der Server entscheidet, nie der Client; ein unbekannter Kunde ist privat. */
|
||
async function kundenartDesKunden(customerId) {
|
||
try {
|
||
return kundenartWirksam(await getDocument(config.collections.customers, customerId))
|
||
} catch (err) {
|
||
if (err?.status === 404) return 'privat'
|
||
throw err
|
||
}
|
||
}
|
||
|
||
router.post('/anfrage', requireSession, nurKunde, limitAnfrage, route(async (req, res) => {
|
||
const customerId = getSessionCustomerId(req)
|
||
const anfrage = await stelleAnfrage({
|
||
customerId,
|
||
projectId: projectIdOf(req),
|
||
eingabe: req.body?.anfrage,
|
||
person: person(req),
|
||
// Abo-Modell (neue Ansicht): Unternehmer aus der Kundenart, privat nur_betrieb; sonst unveraendert (undefined)
|
||
kundenart: neueAnsicht(req) ? await kundenartDesKunden(customerId) : undefined,
|
||
})
|
||
res.json({ anfrage })
|
||
}))
|
||
|
||
router.post('/anfrage/zurueckziehen', requireSession, nurKunde, limitAnfrage, route(async (req, res) => {
|
||
const anfrage = await zieheZurueck({ customerId: getSessionCustomerId(req), projectId: projectIdOf(req), person: person(req) })
|
||
res.json({ anfrage })
|
||
}))
|
||
|
||
// ---------------------------------------------------------------- Verwaltung (C7)
|
||
|
||
const stop = (status, text, code, fehlerFelder) =>
|
||
Object.assign(new Error(text), { status, ...(code ? { body: { code } } : {}), ...(fehlerFelder ? { fehler: fehlerFelder } : {}) })
|
||
const eingabeFehler = (fehlerFelder) => stop(400, Object.values(fehlerFelder)[0], undefined, fehlerFelder)
|
||
const personLabel = (p) => (p.name ? `${p.name}${p.email ? ` <${p.email}>` : ''}` : p.email || 'Kunde')
|
||
|
||
/**
|
||
* Gemeinsame Pruefung der Verwaltungs-Routen: projectId, eigenes Projekt (403; archiviert nur lesend), Schalter (409
|
||
* nicht_verfuegbar), Funktion im Zustand zustaende (Vorgabe: schreibend setup|active, lesend setup|active|disabled; sonst 409
|
||
* nicht_eingerichtet) und shopConfig (fehlt es und der Zustand ist setup|active, wird es angelegt).
|
||
* @returns {Promise<{ customerId: string, projectId: string, project: object, doc: object, shopDoc: object, shop: object }>}
|
||
*/
|
||
async function mitShop(req, { schreiben = false, zustaende } = {}) {
|
||
const projectId = projectIdOf(req)
|
||
if (!projectId) throw stop(400, MELDUNG.projekt)
|
||
const customerId = getSessionCustomerId(req)
|
||
let project
|
||
try {
|
||
project = await assertOwnProject(customerId, projectId, { forNewOrder: schreiben })
|
||
} catch (err) {
|
||
throw err?.status === 403 || err?.status === 400 ? stop(403, MELDUNG.fremd) : err
|
||
}
|
||
if (!shopFuerKunde(req.session?.email)) throw stop(409, MELDUNG.nichtVerfuegbar, 'nicht_verfuegbar')
|
||
const erlaubt = zustaende || (schreiben ? ['setup', 'active'] : ['setup', 'active', 'disabled'])
|
||
const doc = await getFeatureDoc(customerId, projectId, 'shop')
|
||
if (!doc || !erlaubt.includes(doc.state)) throw stop(409, MELDUNG.nichtEingerichtet, 'nicht_eingerichtet')
|
||
let shopDoc = await leseShopConfig(doc.$id)
|
||
if (!shopDoc && ['setup', 'active'].includes(doc.state)) shopDoc = await ensureShopConfig(doc)
|
||
if (!shopDoc) throw stop(409, MELDUNG.nichtEingerichtet, 'nicht_eingerichtet')
|
||
return { customerId, projectId, project, doc, shopDoc, shop: ladeShop(shopDoc) }
|
||
}
|
||
|
||
/** Middleware: mitShop vor dem Einlesen eines Uploads; Ergebnis in req.shopCtx. */
|
||
const mitShopSchreibend = route(async (req, _res, next) => {
|
||
req.shopCtx = await mitShop(req, { schreiben: true })
|
||
next()
|
||
})
|
||
|
||
const protokoll = (req, text) => logIfKundenansicht(req, 'shop_aenderung', text)
|
||
|
||
// ---- Einstellungen
|
||
|
||
const einstellungenAntwort = (shop) => ({ einstellungen: shop.einstellungen, version: shop.version, vollstaendig: istVollstaendig(shop.einstellungen) })
|
||
|
||
router.get('/einstellungen', requireSession, route(async (req, res) => {
|
||
const { shop } = await mitShop(req)
|
||
res.json(einstellungenAntwort(shop))
|
||
}))
|
||
|
||
router.put('/einstellungen', requireSession, limitWrites, route(async (req, res) => {
|
||
const { shop } = await mitShop(req, { schreiben: true })
|
||
const gespeichert = await speichereEinstellungen(shop.id, req.body?.einstellungen, { erwarteteVersion: Number.isInteger(req.body?.version) ? req.body.version : undefined })
|
||
await protokoll(req, 'Einstellungen gespeichert')
|
||
res.json({ einstellungen: gespeichert.einstellungen, version: gespeichert.version, vollstaendig: istVollstaendig(gespeichert.einstellungen) })
|
||
}))
|
||
|
||
// ---- Artikel
|
||
|
||
/** Artikel fuer den Haendler: alle gespeicherten Felder, dazu id, aktiv, sort und Vorschau-Adressen der Bilder. */
|
||
function produktAnsicht(doc, projectId) {
|
||
const p = parseProdukt(doc) || {}
|
||
const bilder = Array.isArray(p.bilder) ? p.bilder.filter((b) => typeof b === 'string') : []
|
||
return {
|
||
...p,
|
||
id: doc.$id,
|
||
name: typeof p.name === 'string' ? p.name : doc.name || '',
|
||
aktiv: doc.aktiv !== false,
|
||
sort: Number.isInteger(doc.sort) ? doc.sort : 0,
|
||
bilder,
|
||
bildUrls: bilder.map((id) => ({
|
||
id,
|
||
klein: `/api/shop/bild/${encodeURIComponent(projectId)}/${id}-s.webp`,
|
||
gross: `/api/shop/bild/${encodeURIComponent(projectId)}/${id}-l.webp`,
|
||
})),
|
||
}
|
||
}
|
||
|
||
const bildIdsVon = (produkt) => (Array.isArray(produkt?.bilder) ? produkt.bilder.filter((b) => typeof b === 'string') : [])
|
||
|
||
/** Bilder, die nach einer Aenderung kein Artikel des Shops mehr verwendet, loeschen. */
|
||
async function raeumeBilderAuf(shop, kandidaten) {
|
||
if (kandidaten.length === 0) return
|
||
const inGebrauch = await bildIdsInGebrauch(shop.id)
|
||
for (const id of kandidaten) if (!inGebrauch.has(id)) await loescheBild(shop.siteKey, id)
|
||
}
|
||
|
||
router.get('/produkte', requireSession, route(async (req, res) => {
|
||
const { shop, projectId } = await mitShop(req)
|
||
const docs = await listeProdukte(shop.id)
|
||
res.json({ produkte: docs.map((d) => produktAnsicht(d, projectId)), maxArtikel: config.shop.maxArtikel, maxBilder: config.shop.maxBilder })
|
||
}))
|
||
|
||
/** Artikel anlegen (id null) oder aendern: normalisieren, Bilder pruefen und beanspruchen, entfernte Bilder aufraeumen. */
|
||
async function speichereArtikel(req, res, id) {
|
||
const { shop, customerId, projectId } = await mitShop(req, { schreiben: true })
|
||
const { produkt, fehler } = normalisiereProdukt(req.body?.produkt, { einstellungen: shop.einstellungen })
|
||
if (fehler) throw eingabeFehler(fehler)
|
||
const neueBilder = bildIdsVon(produkt)
|
||
const doc = await withLocks([`shop-bilder:${shop.id}`], async () => {
|
||
let vorher = []
|
||
if (id) {
|
||
const alt = await holeProdukt(shop.id, id)
|
||
if (!alt) throw stop(404, 'Diesen Artikel gibt es nicht (mehr).')
|
||
vorher = bildIdsVon(parseProdukt(alt))
|
||
}
|
||
for (const bildId of neueBilder) {
|
||
const meta = await bildMeta(shop.siteKey, bildId)
|
||
if (!meta || meta.shopId !== shop.id) throw eingabeFehler({ bilder: 'Eines der Bilder gibt es nicht (mehr). Bitte lade es neu hoch.' })
|
||
}
|
||
const gespeichert = await speichereProdukt({ shopId: shop.id, customerId }, id, produkt, { geladen: leseBestandGeladen(req.body?.produkt) })
|
||
await beanspruche(shop.siteKey, neueBilder)
|
||
await raeumeBilderAuf(shop, vorher.filter((b) => !neueBilder.includes(b)))
|
||
return gespeichert
|
||
})
|
||
await protokoll(req, `Artikel ${id ? 'geändert' : 'angelegt'}: ${produkt.name}`)
|
||
res.status(id ? 200 : 201).json({ produkt: produktAnsicht(doc, projectId) })
|
||
}
|
||
|
||
router.post('/produkte', requireSession, limitWrites, route((req, res) => speichereArtikel(req, res, null)))
|
||
|
||
router.post('/produkte/sortierung', requireSession, limitWrites, route(async (req, res) => {
|
||
const { shop, projectId } = await mitShop(req, { schreiben: true })
|
||
const docs = await sortiere(shop.id, req.body?.ids)
|
||
await protokoll(req, 'Artikel sortiert')
|
||
res.json({ produkte: docs.map((d) => produktAnsicht(d, projectId)) })
|
||
}))
|
||
|
||
router.put('/produkte/:id', requireSession, limitWrites, route((req, res) => speichereArtikel(req, res, req.params.id)))
|
||
|
||
router.delete('/produkte/:id', requireSession, limitWrites, route(async (req, res) => {
|
||
const { shop } = await mitShop(req, { schreiben: true })
|
||
const name = await withLocks([`shop-bilder:${shop.id}`], async () => {
|
||
const alt = await holeProdukt(shop.id, req.params.id)
|
||
if (!alt) throw stop(404, 'Diesen Artikel gibt es nicht (mehr).')
|
||
await loescheProdukt(shop.id, req.params.id)
|
||
await raeumeBilderAuf(shop, bildIdsVon(parseProdukt(alt)))
|
||
return alt.name || ''
|
||
})
|
||
await protokoll(req, `Artikel gelöscht: ${name}`)
|
||
res.json({ ok: true })
|
||
}))
|
||
|
||
// ---- Rechtstexte
|
||
|
||
/** Antwort der Rechtstexte: Entwurf, zuletzt bestaetigte Fassung, Muster zum Zuruecksetzen, erzeugte Texte und Hash des Entwurfs. */
|
||
function rechtstexteAntwort(shop) {
|
||
const e = shop.einstellungen
|
||
const { entwurf, bestaetigt } = shop.rechtstexte
|
||
const hash = rechtstexteHash(entwurf, e)
|
||
return {
|
||
entwurf,
|
||
bestaetigt: bestaetigt ? { texte: bestaetigt.texte, at: bestaetigt.at, von: bestaetigt.von, aktuell: bestaetigt.hash === hash } : null,
|
||
muster: {
|
||
agb: musterAgb(e),
|
||
widerrufsbelehrung: musterWiderrufsbelehrung(e, { widerrufUrl: widerrufUrl(shop.siteKey) }),
|
||
widerrufsformular: musterWiderrufsformular(e),
|
||
},
|
||
versandUndZahlung: versandUndZahlung(e),
|
||
gewaehrleistung: { bild: GEWAEHRLEISTUNG_BILD, text: gewaehrleistungsHinweis() },
|
||
hash,
|
||
bestaetigungText: BESTAETIGUNG_TEXT,
|
||
vollstaendig: vollstaendig(entwurf),
|
||
// Was das Bestaetigen des gespeicherten Entwurfs derzeit verhindert (Platzhalter, Musterkopf, fehlende Adresse der Widerrufsfunktion)
|
||
probleme: pruefeBestaetigbar(entwurf, { widerrufUrl: widerrufUrl(shop.siteKey) }),
|
||
}
|
||
}
|
||
|
||
/** shopConfig frisch lesen (unter der Sperre) und als geparsten Shop liefern. */
|
||
async function frischerShop(shopId) {
|
||
return ladeShop(await getDocument(config.collections.shopConfig, shopId))
|
||
}
|
||
|
||
router.get('/rechtstexte', requireSession, route(async (req, res) => {
|
||
const { shop } = await mitShop(req)
|
||
res.json(rechtstexteAntwort(shop))
|
||
}))
|
||
|
||
router.put('/rechtstexte', requireSession, limitWrites, route(async (req, res) => {
|
||
const { shop } = await mitShop(req, { schreiben: true })
|
||
const { rechtstexte, fehler } = normalisiereRechtstexte(req.body?.rechtstexte)
|
||
if (fehler) throw eingabeFehler(fehler)
|
||
const neu = await withLocks([`shop-rt:${shop.id}`], async () => {
|
||
const aktuell = await frischerShop(shop.id)
|
||
const json = JSON.stringify({ entwurf: rechtstexte, bestaetigt: aktuell.rechtstexte.bestaetigt })
|
||
if (json.length > PRODUKT_DOC_MAX_JSON) throw stop(400, 'Die Rechtstexte sind zu umfangreich. Bitte kürze die Texte.')
|
||
await updateDocument(config.collections.shopConfig, shop.id, { rechtstexte: json })
|
||
return { ...aktuell, rechtstexte: { entwurf: rechtstexte, bestaetigt: aktuell.rechtstexte.bestaetigt } }
|
||
})
|
||
leereCache(shop.siteKey)
|
||
await protokoll(req, 'Rechtstexte-Entwurf gespeichert')
|
||
res.json(rechtstexteAntwort(neu))
|
||
}))
|
||
|
||
router.post('/rechtstexte/bestaetigen', requireSession, nurKunde, limitWrites, route(async (req, res) => {
|
||
const { shop } = await mitShop(req, { schreiben: true })
|
||
const hash = typeof req.body?.hash === 'string' ? req.body.hash : ''
|
||
const von = personLabel(person(req))
|
||
const neu = await withLocks([`shop-rt:${shop.id}`], async () => {
|
||
const aktuell = await frischerShop(shop.id)
|
||
const { entwurf } = aktuell.rechtstexte
|
||
if (hash === '' || hash !== rechtstexteHash(entwurf, aktuell.einstellungen)) {
|
||
throw stop(409, 'Die Texte wurden inzwischen geändert. Bitte lies sie noch einmal durch und bestätige dann erneut.', 'texte_geaendert')
|
||
}
|
||
if (!vollstaendig(entwurf)) throw stop(400, 'Bitte fülle AGB, Widerrufsbelehrung, Widerrufsformular, Impressum und Datenschutz aus, bevor du bestätigst.')
|
||
const probleme = pruefeBestaetigbar(entwurf, { widerrufUrl: widerrufUrl(aktuell.siteKey) })
|
||
if (probleme.length) {
|
||
throw Object.assign(stop(400, 'Die Texte können noch nicht bestätigt werden. Bitte behebe zuerst die genannten Punkte.', 'nicht_bestaetigbar'), { body: { code: 'nicht_bestaetigbar', probleme } })
|
||
}
|
||
const at = new Date().toISOString()
|
||
const bestaetigt = { texte: { ...entwurf }, hash, at, von }
|
||
// Fassung ins Archiv (G09 zeigt dem Kaeufer die Fassung seiner Bestellung); scheitert das, wird nichts bestaetigt
|
||
await archiviereRechtstexte({
|
||
shopId: shop.id,
|
||
customerId: shop.customerId,
|
||
hash,
|
||
texte: { ...entwurf, versandUndZahlung: versandUndZahlung(aktuell.einstellungen), gewaehrleistung: gewaehrleistungsHinweis() },
|
||
at,
|
||
von,
|
||
})
|
||
const json = JSON.stringify({ entwurf, bestaetigt })
|
||
if (json.length > PRODUKT_DOC_MAX_JSON) throw stop(400, 'Die Rechtstexte sind zu umfangreich. Bitte kürze die Texte.')
|
||
await updateDocument(config.collections.shopConfig, shop.id, {
|
||
rechtstexte: json,
|
||
rechtstexteBestaetigtAt: at,
|
||
rechtstexteBestaetigtVon: von,
|
||
rechtstexteHash: hash,
|
||
})
|
||
return { ...aktuell, rechtstexte: { entwurf, bestaetigt } }
|
||
})
|
||
leereCache(shop.siteKey)
|
||
res.json(rechtstexteAntwort(neu))
|
||
}))
|
||
|
||
// ---- Shop oeffnen und schliessen
|
||
|
||
router.post('/oeffnen', requireSession, nurKunde, limitWrites, route(async (req, res) => {
|
||
if (typeof req.body?.offen !== 'boolean') throw stop(400, 'Bitte wähle, ob der Shop geöffnet oder geschlossen sein soll.')
|
||
const { shop, doc } = await mitShop(req, { schreiben: true })
|
||
const produkte = await listeProdukte(shop.id)
|
||
const ctx = { doc, shop, project: null }
|
||
if (req.body.offen) {
|
||
const stand = await bereitschaft(ctx, { produkte })
|
||
if (!stand.bereit) throw Object.assign(stop(409, 'Der Shop kann noch nicht geöffnet werden. Bitte erledige zuerst die offenen Punkte.', 'nicht_bereit'), { body: { code: 'nicht_bereit', punkte: stand.punkte } })
|
||
}
|
||
await updateDocument(config.collections.shopConfig, shop.id, { geoeffnet: req.body.offen, geoeffnetAt: new Date().toISOString() })
|
||
leereCache(shop.siteKey)
|
||
const neu = { ...shop, geoeffnet: req.body.offen }
|
||
res.json({ schalter: req.body.offen, geoeffnet: await istGeoeffnet({ doc, shop: neu, project: null }, { produkte }), bereitschaft: await bereitschaft({ doc, shop: neu, project: null }, { produkte }) })
|
||
}))
|
||
|
||
// ---- Stripe-Konto (D2)
|
||
|
||
/** Nur der Kunde selbst richtet sein Stripe-Konto ein (weder Kundenansicht noch "Ansehen als"). */
|
||
const nurKundeStripe = (req, res, next) => {
|
||
if (isKundenansicht(req.session) || req.session?.viewAs) return res.status(403).json({ error: MELDUNG.stripeKundenansicht })
|
||
return next()
|
||
}
|
||
|
||
/** Stripe-Aufruf: jeder Fehler von Stripe wird zu 502 mit festem Text (Stripe-Texte verlassen den Server nie, geloggt wird nur Typ und Code). */
|
||
// Connect im WEBklar-Konto nicht fertig (Plattformprofil fehlt oder Connect nicht aktiviert): das kann nur WEBklar beheben
|
||
const PLATTFORM_FEHLT = /platform profile|signed up for Connect/i
|
||
|
||
async function ueberStripe(fn) {
|
||
try {
|
||
return await fn()
|
||
} catch (err) {
|
||
if (err?.status >= 400 && err.status < 500 && !err.type) throw err
|
||
if (err?.type === 'StripeInvalidRequestError' && PLATTFORM_FEHLT.test(String(err.message || ''))) {
|
||
console.error('[shop] Stripe Connect: Plattformprofil fehlt (Stripe-Dashboard → Connect → Fragebogen ausfüllen)')
|
||
throw stop(503, MELDUNG.plattform, 'plattform_nicht_bereit')
|
||
}
|
||
console.error(`[shop] Stripe ${String(err?.type ?? err?.name ?? 'Fehler').slice(0, 60)} ${String(err?.code ?? '').slice(0, 60)}`.trim())
|
||
throw stop(502, MELDUNG.stripeFern)
|
||
}
|
||
}
|
||
|
||
const speichereStripe = async (shop, felder) => {
|
||
await updateDocument(config.collections.shopConfig, shop.id, felder)
|
||
leereCache(shop.siteKey)
|
||
}
|
||
|
||
const stripeRueckUrl = (projectId, was) => `${config.publicBaseUrl}/dashboard.html#webshop?stripe=${was}&projekt=${encodeURIComponent(projectId)}`
|
||
const onboardingFuer = (accountId, projectId) =>
|
||
ueberStripe(() => onboardingLink(accountId, { returnUrl: stripeRueckUrl(projectId, 'zurueck'), refreshUrl: stripeRueckUrl(projectId, 'neu') }))
|
||
|
||
// Konto anlegen (einmalig, unter Sperre) und Onboarding-Link liefern
|
||
router.post('/stripe/einrichten', requireSession, nurKundeStripe, limitWrites, route(async (req, res) => {
|
||
const { shop, customerId, projectId, project } = await mitShop(req, { schreiben: true, zustaende: ['setup', 'active'] })
|
||
const accountId = await withLocks([`shop-stripe:${shop.id}`], async () => {
|
||
const frisch = await frischerShop(shop.id)
|
||
if (frisch.stripeAccountId) return frisch.stripeAccountId
|
||
const customer = await getDocument(config.collections.customers, customerId).catch(() => null)
|
||
const neu = await ueberStripe(() => kontoAnlegen({ customer: customer || { $id: customerId, email: req.session?.email }, project }))
|
||
let status
|
||
try {
|
||
status = await ueberStripe(() => kontoStatus(neu))
|
||
} catch {
|
||
status = statusAusKonto({})
|
||
}
|
||
await speichereStripe(shop, { stripeAccountId: neu, stripeStatus: JSON.stringify(status) })
|
||
return neu
|
||
})
|
||
res.json({ url: await onboardingFuer(accountId, projectId) })
|
||
}))
|
||
|
||
// Neuer Onboarding-Link (der alte laeuft nach wenigen Minuten ab)
|
||
router.post('/stripe/link', requireSession, nurKundeStripe, limitWrites, route(async (req, res) => {
|
||
const { shop, projectId } = await mitShop(req, { schreiben: true, zustaende: ['setup', 'active'] })
|
||
if (!shop.stripeAccountId) throw stop(409, MELDUNG.keinKonto, 'kein_konto')
|
||
res.json({ url: await onboardingFuer(shop.stripeAccountId, projectId) })
|
||
}))
|
||
|
||
// Status bei Stripe neu lesen und speichern
|
||
router.post('/stripe/aktualisieren', requireSession, nurKundeStripe, limitWrites, route(async (req, res) => {
|
||
const { shop } = await mitShop(req, { schreiben: true, zustaende: ['setup', 'active'] })
|
||
if (!shop.stripeAccountId) throw stop(409, MELDUNG.keinKonto, 'kein_konto')
|
||
const status = await ueberStripe(() => kontoStatus(shop.stripeAccountId))
|
||
const alt = shop.stripeStatus
|
||
const zahlungsarten = Array.isArray(shop.einstellungen?.zahlungsarten) ? shop.einstellungen.zahlungsarten : ['card']
|
||
const behalteHinweis = typeof alt?.hinweis === 'string' && alt.hinweis !== '' && status.charges_enabled === true && zahlungsarten.some((z) => z === 'klarna' || z === 'sepa')
|
||
const neu = behalteHinweis ? { ...status, hinweis: alt.hinweis } : status
|
||
await speichereStripe(shop, { stripeStatus: JSON.stringify(neu) })
|
||
res.json({ stripe: stripeAnsicht({ ...shop, stripeStatus: neu }) })
|
||
}))
|
||
|
||
// ---- Bestellungen und Widerrufe (E3)
|
||
|
||
const seiteVon = (wert) => {
|
||
const nr = Number.parseInt(wert, 10)
|
||
return Number.isInteger(nr) && nr >= 1 ? nr : 1
|
||
}
|
||
const textParam = (wert) => (typeof wert === 'string' ? wert : undefined)
|
||
/** Status aendern verschickt Mails an Kaeufer und erstattet Geld: nie in der Kundenansicht oder "Ansehen als". */
|
||
const nurHaendler = nurKunde
|
||
/** Bestellungen bearbeiten, erstatten und Widerrufe abhaken muss auch bei deaktivierter Funktion gehen (Widerruf, Erstattung bleiben Pflicht). */
|
||
const ZUSTAENDE_ABWICKLUNG = ['setup', 'active', 'disabled']
|
||
|
||
// Liste (Lesen auch in der Kundenansicht und bei deaktiviertem Shop)
|
||
router.get('/bestellungen', requireSession, route(async (req, res) => {
|
||
const { shop } = await mitShop(req)
|
||
res.json(await listeBestellungen(shop.id, { status: textParam(req.query.status), suche: textParam(req.query.suche), seite: seiteVon(req.query.seite) }))
|
||
}))
|
||
|
||
// CSV fuer die Buchhaltung (vor /bestellungen/:id, damit der Pfad eindeutig bleibt)
|
||
router.get('/bestellungen.csv', requireSession, limitCsv, route(async (req, res) => {
|
||
const { shop } = await mitShop(req)
|
||
const erg = await bestellungenCsv(shop.id, { von: textParam(req.query.von), bis: textParam(req.query.bis) })
|
||
res.set({
|
||
'Content-Type': 'text/csv; charset=utf-8',
|
||
'Content-Disposition': `attachment; filename="${erg.dateiname}"`,
|
||
'X-Content-Type-Options': 'nosniff',
|
||
})
|
||
res.send(erg.csv)
|
||
}))
|
||
|
||
router.get('/bestellungen/:id', requireSession, route(async (req, res) => {
|
||
const { shop } = await mitShop(req)
|
||
const order = await bestellungLesen(req.params.id)
|
||
if (!order || order.shopId !== shop.id) throw stop(404, 'Diese Bestellung gibt es nicht.')
|
||
res.json({ bestellung: bestellungKunde(order) })
|
||
}))
|
||
|
||
router.post('/bestellungen/:id/aktion', requireSession, nurHaendler, limitWrites, route(async (req, res) => {
|
||
const { shop, doc, project } = await mitShop(req, { schreiben: true, zustaende: ZUSTAENDE_ABWICKLUNG })
|
||
const aktion = typeof req.body?.aktion === 'string' ? req.body.aktion : ''
|
||
const { order, mailOk } = await setzeStatus({ doc, shop, project }, req.params.id, aktion, {
|
||
versanddienst: req.body?.versanddienst,
|
||
sendungsnummer: req.body?.sendungsnummer,
|
||
})
|
||
res.json({ bestellung: bestellungKunde(order), mailOk })
|
||
}))
|
||
|
||
router.post('/bestellungen/:id/erstatten', requireSession, nurHaendler, limitWrites, route(async (req, res) => {
|
||
const { shop, doc, project } = await mitShop(req, { schreiben: true, zustaende: ZUSTAENDE_ABWICKLUNG })
|
||
const { order, erstattung, voll, mailOk } = await erstatte({ doc, shop, project }, req.params.id, {
|
||
betragCent: req.body?.betragCent,
|
||
grund: req.body?.grund,
|
||
})
|
||
res.json({ bestellung: bestellungKunde(order), erstattung, voll, mailOk })
|
||
}))
|
||
|
||
router.get('/widerrufe', requireSession, route(async (req, res) => {
|
||
const { shop } = await mitShop(req)
|
||
res.json(await listeWiderrufe(shop.id, { seite: seiteVon(req.query.seite) }))
|
||
}))
|
||
|
||
router.post('/widerrufe/:id/erledigt', requireSession, nurHaendler, limitWrites, route(async (req, res) => {
|
||
const { shop } = await mitShop(req, { schreiben: true, zustaende: ZUSTAENDE_ABWICKLUNG })
|
||
res.json({ widerruf: await markiereBearbeitet(shop.id, req.params.id) })
|
||
}))
|
||
|
||
// ---- Bilder
|
||
|
||
// Bild als rohe Bytes (application/octet-stream), hoechstens 8 MB; die Pruefung des Shops laeuft vor dem Einlesen
|
||
router.post(
|
||
'/bild',
|
||
requireSession,
|
||
limitWrites,
|
||
mitShopSchreibend,
|
||
(req, res, next) => {
|
||
if (bildLimitErreicht(getSessionCustomerId(req))) return res.status(429).json({ error: MELDUNG.zuVieleBilder })
|
||
return next()
|
||
},
|
||
uploadSlot,
|
||
express.raw({ type: 'application/octet-stream', limit: BILD_MAX_BYTES }),
|
||
route(async (req, res) => {
|
||
const { shop, customerId } = req.shopCtx
|
||
const bild = await speichereBild({ customerId, shopId: shop.id, siteKey: shop.siteKey, buffer: req.body })
|
||
await protokoll(req, 'Bild hochgeladen')
|
||
res.status(201).json({ imageId: bild.imageId, w: bild.w, h: bild.h })
|
||
})
|
||
)
|
||
|
||
// Vorschau im Portal: nur fuer den Kunden, dem das Projekt gehoert
|
||
router.get('/bild/:projectId/:datei', requireSession, route(async (req, res) => {
|
||
const { shop } = await mitShop(req)
|
||
const treffer = BILD_DATEI_RE.exec(req.params.datei)
|
||
const datei = treffer && (await bildMeta(shop.siteKey, treffer[1])) && bildPfad(shop.siteKey, treffer[1], treffer[2])
|
||
if (!datei) return res.status(404).json({ error: MELDUNG.bildFehlt })
|
||
res.set({ 'Cache-Control': 'private, max-age=3600', 'X-Content-Type-Options': 'nosniff' })
|
||
return res.sendFile(datei, (err) => {
|
||
if (err && !res.headersSent) res.status(404).json({ error: MELDUNG.bildFehlt })
|
||
})
|
||
}))
|
||
|
||
// Fehler beim Einlesen eines Uploads (zu gross, abgebrochen): verstaendlich beantworten, nie Rohtext
|
||
router.use((err, _req, res, next) => {
|
||
if (err?.type === 'entity.too.large') return res.status(413).json({ error: 'Das Bild ist größer als 8 MB.' })
|
||
if (err?.status >= 400 && err.status < 500 && res.headersSent === false) return res.status(err.status).json({ error: 'Die Anfrage ist ungültig.' })
|
||
return next(err)
|
||
})
|
||
|
||
export default router
|