domma-cms 1.6.33 → 1.6.35

package/plugins/shopping-cart/lib/extensions.js

@@ -17,6 +17,7 @@
  *       panels: [{key, label, icon, module, help, on}], // a section in the product editor or an order (on: 'product' | 'order')
  *       product: {clean(input, {had, copy, product, variantMap})}, // checks what a product panel saves (product.ext[owner])
  *       receipt(order, {settings}),                 // HTML for the shopper's receipt page (escape it yourself)
+ *       account(order, {settings}),                 // HTML beside an order on a customer's account page (Reorder)
  *       checkout: {codes: true}                     // storefront features to show
  *   });
  *
@@ -55,6 +56,7 @@ export function cartRegistry() {
                 panels: Array.isArray(ext.panels) ? ext.panels : [],
                 product: ext.product || {},
                 receipt: typeof ext.receipt === 'function' ? ext.receipt : null,
+                account: typeof ext.account === 'function' ? ext.account : null,
                 checkout: ext.checkout || {},
                 order: Number(ext.order) || 0
             });
@@ -128,17 +130,23 @@ export function cartRegistry() {
          * What extensions add to a shopper's receipt: [{owner, html}]. Each has
          * a few seconds; one that fails or dawdles is left out, never the page.
          */
-        async receiptParts(order, ctx = {}) {
-            const parts = await Promise.all(reg.list().filter(e => e.receipt).map(async (e) => {
+        receiptParts(order, ctx = {}) { return reg.parts('receipt', order, ctx); },
+
+        /** What extensions put beside an order on a customer's account page: [{owner, html}]. */
+        accountParts(order, ctx = {}) { return reg.parts('account', order, ctx); },
+
+        /** One HTML part per extension that has a `kind` handler; each has a few seconds. */
+        async parts(kind, order, ctx = {}) {
+            const parts = await Promise.all(reg.list().filter(e => e[kind]).map(async (e) => {
                 let timer;
                 try {
                     const html = await Promise.race([
-                        Promise.resolve().then(() => e.receipt(order, ctx)),
+                        Promise.resolve().then(() => e[kind](order, ctx)),
                         new Promise((_, no) => { timer = setTimeout(() => no(new Error('took too long')), RECEIPT_WAIT); })
                     ]);
                     return typeof html === 'string' && html.trim() ? {owner: e.owner, html} : null;
                 } catch (err) {
-                    console.warn(`[shopping-cart] ${e.owner} failed on the receipt: ${err?.message || err}`);
+                    console.warn(`[shopping-cart] ${e.owner} failed on the ${kind}: ${err?.message || err}`);
                     return null;
                 } finally {
                     clearTimeout(timer);

package/plugins/shopping-cart/lib/pricing.js

@@ -14,11 +14,16 @@
  * `{label, amount}` in minor units, negative for a discount; `included: true`
  * for tax already inside the prices (shown, not added).
  *
+ * An extension's own checkout (services.startCheckout - Takeaway's dishes) may
+ * add lines it priced itself (`custom`, never from a browser) and fixed
+ * `charges` (its delivery fee), which stand in for the shipping stage - so tax
+ * treats them as it treats delivery.
+ *
  * @module shopping-cart/lib/pricing
  */
 
 import {includedTax, percentOf} from '../public/lib/money.js';
-import {available, unitPrice, variantOf} from '../public/lib/products.js';
+import {TAX_CLASSES, available, safeImage, unitPrice, variantOf} from '../public/lib/products.js';
 
 export const STAGES = ['discount', 'shipping', 'tax'];
 export const MAX_LINES = 100;
@@ -46,6 +51,38 @@ export function cleanLines(raw) {
     return [...out.values()];
 }
 
+const text = (v, max) => String(v ?? '').replace(/[\u0000-\u001f\u007f]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
+const minor = (v) => { const n = Number(v); return Number.isInteger(n) && n >= 0 && n <= 1e9 ? n : null; };
+
+/**
+ * Lines an extension priced itself (server code only - never a browser's):
+ * `[{name, optionName, variantName, unitPrice, qty, taxClass, detail[], image, category, ref}]`.
+ * Junk dropped; `detail` is what was chosen with it ("+ Extra cheese £1.00").
+ */
+export function cleanCustomLines(raw) {
+    const out = [];
+    for (const l of Array.isArray(raw) ? raw : []) {
+        const name = text(l?.name, 140);
+        const unit = minor(l?.unitPrice);
+        const qty = Math.floor(Number(l?.qty));
+        if (!name || unit === null || !(qty > 0)) continue;
+        out.push({
+            name, optionName: text(l.optionName, 40), variantName: text(l.variantName, 80), unitPrice: unit, qty: Math.min(MAX_QTY, qty),
+            taxClass: TAX_CLASSES.includes(l.taxClass) ? l.taxClass : 'standard',
+            detail: (Array.isArray(l.detail) ? l.detail : []).map(d => text(d, 120)).filter(Boolean).slice(0, 20),
+            image: safeImage(l.image) || '', category: text(l.category, 60), ref: text(l.ref, 64)
+        });
+        if (out.length >= MAX_LINES) break;
+    }
+    return out;
+}
+
+/** Fixed charges (a delivery fee): `[{label, amount}]`, or null when there are none to stand in for shipping. */
+export function cleanCharges(raw) {
+    if (!Array.isArray(raw)) return null;
+    return raw.map(c => ({label: text(c?.label, 120) || 'Delivery', amount: minor(c?.amount)})).filter(c => c.amount !== null).slice(0, 5);
+}
+
 // ---- The built-in handlers -------------------------------------------------
 
 /** No discounts in the free Cart: Pro's codes replace this. */
@@ -111,9 +148,11 @@ function cleanAdjustments(result, stage) {
  * @param {object} args.settings                      - the Cart's live settings
  * @param {object} [args.input]                       - {code, country, region, postcode, delivery}
  * @param {Object<string, Function>} [args.handlers]  - stage -> handler; missing = built in
+ * @param {object[]} [args.custom]                    - cleanCustomLines(): lines an extension priced
+ * @param {object[]|null} [args.charges]              - cleanCharges(): stand in for the shipping stage
  * @returns {Promise<object>} the quote
  */
-export async function priceBasket({lines, products, settings, input = {}, handlers = {}}) {
+export async function priceBasket({lines, products, settings, input = {}, handlers = {}, custom = [], charges = null}) {
     const currency = settings.currency || 'GBP';
     const out = [];
     const problems = [];
@@ -162,6 +201,14 @@ export async function priceBasket({lines, products, settings, input = {}, handle
         });
     }
 
+    for (const c of custom) {
+        out.push({
+            productId: '', variantId: '', name: c.name, variantName: c.variantName, optionName: c.optionName, slug: '', image: c.image,
+            sku: '', unitPrice: c.unitPrice, qty: c.qty, lineTotal: c.unitPrice * c.qty, available: null, shippable: false, weight: null,
+            taxClass: c.taxClass, category: c.category, custom: true, detail: c.detail, ref: c.ref
+        });
+    }
+
     const subtotal = out.reduce((s, l) => s + l.lineTotal, 0);
     const requiresShipping = out.some(l => l.shippable);
     const weight = out.reduce((s, l) => s + (l.weight || 0) * l.qty, 0);
@@ -173,17 +220,22 @@ export async function priceBasket({lines, products, settings, input = {}, handle
     for (const stage of STAGES) {
         const handler = typeof handlers[stage] === 'function' ? handlers[stage] : BUILT_IN[stage];
         let result;
-        try {
-            result = await handler({
-                stage, lines: out, subtotal, runningTotal, currency, settings, input,
-                adjustments: [...adjustments], requiresShipping, weight
-            });
-        } catch (err) {
-            // An extension that throws must not take checkout down with it:
-            // fall back to the built-in rule for this stage and say so.
-            result = await BUILT_IN[stage]({stage, lines: out, subtotal, runningTotal, currency, settings, input,
-                adjustments: [...adjustments], requiresShipping, weight});
-            notes.push({stage, message: `The ${stage} rules failed (${err?.message || err}); the standard ${stage} was used.`, internal: true});
+        // An extension's fixed charges are the delivery: no shipping rules asked.
+        if (stage === 'shipping' && charges) {
+            result = charges;
+        } else {
+            try {
+                result = await handler({
+                    stage, lines: out, subtotal, runningTotal, currency, settings, input,
+                    adjustments: [...adjustments], requiresShipping, weight
+                });
+            } catch (err) {
+                // An extension that throws must not take checkout down with it:
+                // fall back to the built-in rule for this stage and say so.
+                result = await BUILT_IN[stage]({stage, lines: out, subtotal, runningTotal, currency, settings, input,
+                    adjustments: [...adjustments], requiresShipping, weight});
+                notes.push({stage, message: `The ${stage} rules failed (${err?.message || err}); the standard ${stage} was used.`, internal: true});
+            }
         }
         let adds = cleanAdjustments(result, stage);
         // A discount can take the basket to nothing, never below it.

package/plugins/shopping-cart/lib/render.js

@@ -110,6 +110,7 @@ export function storefrontHtml({entries, settings, base, category = '', query =
     const intro = settings.shopIntro ? `<p class="shop-intro">${esc(settings.shopIntro)}</p>` : '';
     return `<header class="shop-hero">
   <h1>${esc(settings.shopTitle || 'Shop')}</h1>${intro}
+  ${settings.accounts ? `<a class="shop-linkbtn shop-acc-link" href="${esc(base)}/account">Your account</a>` : ''}
 </header>
 ${chips || search || sort ? `<div class="shop-toolbar">${chips}<div class="shop-tools">${search}${sort}</div></div>` : ''}
 ${entries.length
@@ -181,7 +182,7 @@ ${related.length ? `<section class="shop-related"><h2>You may also like</h2>${gr
 /** The basket and checkout, one page. The script fills it from the basket in the browser. */
 export function cartHtml({settings, base}) {
     const countries = (settings.countries || ['GB']).map(c => `<option value="${esc(c)}">${esc(COUNTRIES[c] || c)}</option>`).join('');
-    return `<nav class="shop-crumbs" aria-label="Breadcrumb"><a href="${esc(base)}">${ICON.back}Keep shopping</a></nav>
+    return `<nav class="shop-crumbs" aria-label="Breadcrumb"><a href="${esc(base)}">${ICON.back}Keep shopping</a>${settings.accounts ? ` <a class="shop-acc-link" href="${esc(base)}/account" data-acc-link>Sign in for faster checkout</a>` : ''}</nav>
 <h1 class="shop-co-title">Your basket</h1>
 <div class="shop-checkout" data-shop-checkout>
   <div class="shop-co-main">
@@ -233,6 +234,16 @@ export function cartHtml({settings, base}) {
 </div>`;
 }
 
+/** The account page's frame; public/account.js fills it (signed in or not is the browser's to know). */
+export function accountHtml({settings, view = 'account'}) {
+    const title = view === 'reset' ? 'Set a new password' : view === 'confirm' ? 'Confirming your account…' : 'Your account';
+    return `<div class="shop-account" data-shop-account="${esc(view)}">
+  <h1>${esc(title)}</h1>
+  <div data-acc-body><noscript>Your account needs JavaScript switched on.</noscript></div>
+  <p class="shop-muted"><a class="shop-linkbtn" href="${esc(settings.shopPath)}">Back to the shop</a></p>
+</div>`;
+}
+
 /**
  * A shopper's receipt. `parts` are extensions' sections ([{owner, html}],
  * their own HTML, escaped by them) - Shopping Cart Pro's downloads.
@@ -249,7 +260,7 @@ export function receiptHtml({order, settings, base, problem = '', parts = []}) {
     const closed = status === 'cancelled' || status === 'refunded';
     const lines = order.lines.map(l => `<li class="shop-r-line">
   ${l.image ? `<img src="${esc(safeImage(l.image))}" alt="" loading="lazy">` : `<span class="shop-r-noimg">${ICON.bag}</span>`}
-  <span class="shop-r-name">${esc(l.name)}${l.variantName ? `<small>${esc(l.optionName || 'Option')}: ${esc(l.variantName)}</small>` : ''}</span>
+  <span class="shop-r-name">${esc(l.name)}${l.variantName ? `<small>${esc(l.optionName || 'Option')}: ${esc(l.variantName)}</small>` : ''}${(l.detail || []).map(d => `<small>${esc(d)}</small>`).join('')}</span>
   <span class="shop-r-qty">× ${l.qty}</span>
   <span class="shop-r-amt">${esc(formatMoney(l.lineTotal, cur))}</span></li>`).join('');
     const totals = `<dl class="shop-totals">
@@ -266,12 +277,13 @@ export function receiptHtml({order, settings, base, problem = '', parts = []}) {
       <p class="shop-muted">Order #${esc(order.number)}</p>
       <h1>${closed ? esc(STATUS_PUBLIC[status]) : waiting ? 'Confirming your payment…' : `Thank you${order.customer?.name ? `, ${esc(order.customer.name.split(' ')[0])}` : ''}!`}</h1>
       <p>${waiting ? 'This takes a moment. You can keep this page open.'
-        : status === 'awaiting' ? 'Your order is in. It is sent as soon as your payment arrives.'
+        : status === 'awaiting' ? (order.payNote ? 'Your order is in.' : 'Your order is in. It is sent as soon as your payment arrives.')
         : closed ? '' : `A record of your order is below${order.email ? ` - we will write to <strong>${esc(order.email)}</strong> if anything changes` : ''}.`}</p>
     </div>
   </div>
   ${problem === 'paypal' && waiting ? '<p class="shop-co-error">PayPal did not confirm the payment. Nothing has been taken - <a href="' + esc(base) + '/cart">try again from your basket</a>.</p>' : ''}
-  ${status === 'awaiting' && settings.offlineInstructions ? `<div class="shop-r-note"><strong>${esc(settings.offlineLabel || 'How to pay')}</strong><p>${esc(settings.offlineInstructions)}</p><p>Please quote <strong>#${esc(order.number)}</strong> with your payment - ${esc(formatMoney(order.total, cur))}.</p></div>` : ''}
+  ${status === 'awaiting' && order.payNote ? `<div class="shop-r-note"><strong>Payment</strong><p>${esc(order.payNote)}</p><p>${esc(formatMoney(order.total, cur))} to pay.</p></div>` : ''}
+  ${status === 'awaiting' && !order.payNote && settings.offlineInstructions ? `<div class="shop-r-note"><strong>${esc(settings.offlineLabel || 'How to pay')}</strong><p>${esc(settings.offlineInstructions)}</p><p>Please quote <strong>#${esc(order.number)}</strong> with your payment - ${esc(formatMoney(order.total, cur))}.</p></div>` : ''}
   ${closed ? '' : `<ol class="shop-r-steps">${steps.map(s => `<li class="${s.done ? 'is-done' : ''}"><span></span>${esc(s.label)}</li>`).join('')}</ol>`}
   ${t ? `<div class="shop-r-note">${ICON.truck} <strong>${esc(t.carrier || 'Tracking')}</strong> ${esc(t.number || '')} ${t.url ? `<a href="${esc(t.url)}" target="_blank" rel="noopener">Track it</a>` : ''}</div>` : ''}
   ${parts.map(p => `<div class="shop-r-ext" data-ext="${esc(p.owner)}">${p.html}</div>`).join('')}
@@ -281,6 +293,7 @@ export function receiptHtml({order, settings, base, problem = '', parts = []}) {
       ${addr.length ? `<h2>${order.delivery === 'collect' ? 'Collection' : 'Delivering to'}</h2><address>${addr.map(esc).join('<br>')}</address>` : order.delivery === 'collect' ? `<h2>Collection</h2><p>${esc(settings.collectionLabel || 'Collect in person')}</p>` : ''}
       <h2>Placed</h2><p>${esc(fmtDateTime(order.placedAt))}</p>
       <p><a class="shop-linkbtn" href="${esc(base)}">Continue shopping</a> · <button type="button" class="shop-linkbtn" data-shop-print>Print</button></p>
+      ${settings.accounts && !waiting && !closed ? `<div class="shop-r-join" data-shop-join data-email="${esc(order.email || '')}" data-name="${esc(order.customer?.name || '')}" hidden></div>` : ''}
     </section>
   </div>
 </div>`;

package/plugins/shopping-cart/lib/sales.js

@@ -0,0 +1,193 @@
+/**
+ * The Sales report. PURE: orders in, figures out - for the Sales tab and its CSV.
+ *
+ * A sale is an order that took money (paid, fulfilled - or refunded later), dated by when it was PAID, in the
+ * shop's time zone. A refund is dated by when it was refunded, so a period's net is what really stayed.
+ *
+ * Every line is put to a SOURCE, from what the order already says about itself:
+ *   takeaway  - an order Takeaway placed (`ref: 'takeaway:…'`)
+ *   downloads - a line for a product Shopping Cart Pro gave a download link or licence key for
+ *   addons    - an order another extension placed (any other `ref` - Cards Pro's credits, …)
+ *   shop      - everything else: the Shop's own products
+ *
+ * Platform commission (lib/commission.js) is the figure each order was given when it was paid; it counts on the day it
+ * was paid and comes back on the day of a refund.
+ *
+ * Amounts are minor units. Line amounts are before discounts; the order-level figures (discount, delivery, tax)
+ * are reported beside them, not shared out across sources.
+ *
+ * @module shopping-cart/lib/sales
+ */
+
+export const SOURCES = {shop: 'Shop', downloads: 'Downloads & keys', takeaway: 'Takeaway', addons: 'Other add-ons'};
+const PROVIDERS = {stripe: 'Card (Stripe)', paypal: 'PayPal', offline: 'Paid offline', free: 'Free'};
+const TOOK = new Set(['paid', 'fulfilled', 'refunded']);
+const DAY = 86400000;
+
+const parts = new Map();
+/** The shop's calendar date of an instant: 'YYYY-MM-DD'. */
+export function dateIn(t, tz = 'Europe/London') {
+    if (!parts.has(tz)) {
+        try { parts.set(tz, new Intl.DateTimeFormat('en-CA', {timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit'})); }
+        catch { parts.set(tz, new Intl.DateTimeFormat('en-CA', {timeZone: 'Europe/London', year: 'numeric', month: '2-digit', day: '2-digit'})); }
+    }
+    return parts.get(tz).format(new Date(t));
+}
+
+const addDays = (date, n) => { const [y, m, d] = date.split('-').map(Number); return new Date(Date.UTC(y, m - 1, d + n)).toISOString().slice(0, 10); };
+const weekday = (date) => { const [y, m, d] = date.split('-').map(Number); return new Date(Date.UTC(y, m - 1, d)).getUTCDay(); };
+
+/** The period a date falls in: the day, the Monday of its week, or the 1st of its month. */
+export function periodOf(date, by) {
+    if (by === 'month') return `${date.slice(0, 7)}-01`;
+    if (by === 'week') return addDays(date, -((weekday(date) + 6) % 7));
+    return date;
+}
+
+/** Every period from `from` to `to`, in order, so empty ones show as empty. */
+export function periodsBetween(from, to, by) {
+    const out = [];
+    let p = periodOf(from, by);
+    const last = periodOf(to, by);
+    for (let i = 0; p <= last && i < 800; i++) {
+        out.push(p);
+        if (by === 'month') { const [y, m] = p.split('-').map(Number); p = new Date(Date.UTC(y, m, 1)).toISOString().slice(0, 10); }
+        else p = addDays(p, by === 'week' ? 7 : 1);
+    }
+    return out;
+}
+
+/** Which source an order line belongs to. */
+export function sourceOf(order, line) {
+    const ref = String(order.data?.ref || '');
+    if (ref.startsWith('takeaway:')) return 'takeaway';
+    if (ref) return 'addons';
+    const pro = order.data?.ext?.['shopping-cart-pro'];
+    const digital = new Set([...(pro?.downloads || []), ...(pro?.keys || [])].map(x => x.productId));
+    if (line.productId && digital.has(line.productId)) return 'downloads';
+    return 'shop';
+}
+
+/** One order's money, split the way the report shows it. */
+export function orderFigures(o) {
+    const d = o.data;
+    const adj = d.adjustments || [];
+    const sum = (f) => adj.filter(f).reduce((n, a) => n + a.amount, 0);
+    return {
+        subtotal: d.subtotal || 0,
+        discount: -sum(a => a.stage === 'discount'),
+        delivery: sum(a => a.stage === 'shipping'),
+        taxAdded: sum(a => a.stage === 'tax' && !a.included),
+        taxIncluded: sum(a => a.stage === 'tax' && a.included),
+        total: d.total || 0
+    };
+}
+
+/**
+ * The report for `from`..`to` (dates, both included), in periods of `by`.
+ *
+ * @param {{id, data, meta}[]} orders
+ * @param {{from: string, to: string, by?: 'day'|'week'|'month', timeZone?: string}} opts
+ */
+export function salesReport(orders, {from, to, by = 'day', timeZone = 'Europe/London'}) {
+    const inRange = (date) => date >= from && date <= to;
+    const periods = new Map(periodsBetween(from, to, by).map(p => [p, {period: p, orders: 0, takings: 0, refunds: 0, commission: 0}]));
+    const totals = {orders: 0, items: 0, subtotal: 0, discount: 0, delivery: 0, taxAdded: 0, taxIncluded: 0, takings: 0, refunds: 0, refundCount: 0,
+        commission: 0, commissionBack: 0};
+    const sources = Object.fromEntries(Object.keys(SOURCES).map(k => [k, {key: k, label: SOURCES[k], orders: 0, amount: 0}]));
+    const methods = new Map();
+    const takeaway = {collect: 0, deliver: 0};
+
+    for (const o of orders) {
+        const d = o.data || {};
+        if (!TOOK.has(d.status)) continue;
+        const paidDate = dateIn(d.paidAt || o.meta?.createdAt, timeZone);
+        if (inRange(paidDate)) {
+            const f = orderFigures(o);
+            totals.orders++;
+            for (const k of ['subtotal', 'discount', 'delivery', 'taxAdded', 'taxIncluded']) totals[k] += f[k];
+            totals.takings += f.total;
+            const seen = new Set();
+            for (const l of d.lines || []) {
+                const s = sourceOf(o, l);
+                sources[s].amount += l.lineTotal || 0;
+                totals.items += l.qty || 0;
+                if (!seen.has(s)) { sources[s].orders++; seen.add(s); }
+            }
+            if (String(d.ref || '').startsWith('takeaway:')) takeaway[d.delivery === 'ship' ? 'deliver' : 'collect']++;
+            const m = methods.get(d.provider) || {key: d.provider, label: PROVIDERS[d.provider] || d.provider || 'Other', orders: 0, takings: 0};
+            m.orders++; m.takings += f.total;
+            methods.set(d.provider, m);
+            const c = d.commission?.amount || 0;
+            totals.commission += c;
+            const p = periods.get(periodOf(paidDate, by));
+            if (p) { p.orders++; p.takings += f.total; p.commission += c; }
+        }
+        if (d.status === 'refunded') {
+            const refDate = dateIn(d.refundedAt || d.paidAt || o.meta?.createdAt, timeZone);
+            if (inRange(refDate)) {
+                totals.refunds += d.total || 0;
+                totals.refundCount++;
+                const p = periods.get(periodOf(refDate, by));
+                if (p) p.refunds += d.total || 0;
+            }
+        }
+        if (d.commission?.reversed) {
+            const backDate = dateIn(d.commission.reversedAt || d.refundedAt || o.meta?.createdAt, timeZone);
+            if (inRange(backDate)) {
+                totals.commissionBack += d.commission.amount || 0;
+                const p = periods.get(periodOf(backDate, by));
+                if (p) p.commission -= d.commission.amount || 0;
+            }
+        }
+    }
+    return {
+        from, to, by,
+        totals: {...totals, net: totals.takings - totals.refunds, average: totals.orders ? Math.round(totals.takings / totals.orders) : 0,
+            commissionNet: totals.commission - totals.commissionBack, afterCommission: totals.takings - totals.refunds - (totals.commission - totals.commissionBack)},
+        periods: [...periods.values()].map(p => ({...p, net: p.takings - p.refunds})),
+        sources: Object.values(sources).filter(s => s.orders || s.key === 'shop'),
+        methods: [...methods.values()].sort((a, b) => b.takings - a.takings),
+        takeaway
+    };
+}
+
+/** The named ranges the Sales tab offers, as {from, to} dates for `today`. */
+export function rangeFor(name, today) {
+    const [y, m] = today.split('-').map(Number);
+    const monthStart = (yy, mm) => new Date(Date.UTC(yy, mm - 1, 1)).toISOString().slice(0, 10);
+    switch (name) {
+        case 'today': return {from: today, to: today};
+        case 'week': return {from: periodOf(today, 'week'), to: today};
+        case 'last7': return {from: addDays(today, -6), to: today};
+        case 'month': return {from: monthStart(y, m), to: today};
+        case 'lastmonth': return {from: monthStart(y, m - 1), to: addDays(monthStart(y, m), -1)};
+        case 'last30': return {from: addDays(today, -29), to: today};
+        case 'year': return {from: `${y}-01-01`, to: today};
+        default: return {from: addDays(today, -29), to: today};
+    }
+}
+
+const csvCell = (v) => { const s = String(v ?? ''); return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s; };
+const pounds = (n) => ((n || 0) / 100).toFixed(2);
+
+/** One row per order sold or refunded in the range - for the accountant. */
+export function salesCsv(orders, {from, to, timeZone = 'Europe/London'}) {
+    const rows = [['Order', 'Paid', 'Status', 'Refunded', 'Sources', 'Payment', 'Customer', 'Subtotal', 'Discount', 'Delivery', 'Tax added', 'Tax included', 'Total', 'Commission', 'Commission rate']];
+    const list = orders.filter(o => TOOK.has(o.data?.status)).filter(o => {
+        const paid = dateIn(o.data.paidAt || o.meta?.createdAt, timeZone);
+        const refunded = o.data.refundedAt ? dateIn(o.data.refundedAt, timeZone) : '';
+        return (paid >= from && paid <= to) || (refunded && refunded >= from && refunded <= to);
+    }).sort((a, b) => String(a.data.paidAt || a.meta?.createdAt).localeCompare(String(b.data.paidAt || b.meta?.createdAt)));
+    for (const o of list) {
+        const d = o.data;
+        const f = orderFigures(o);
+        rows.push([`#${d.number}`, dateIn(d.paidAt || o.meta?.createdAt, timeZone), d.status, d.refundedAt ? dateIn(d.refundedAt, timeZone) : '',
+            [...new Set((d.lines || []).map(l => SOURCES[sourceOf(o, l)]))].join('; '), PROVIDERS[d.provider] || d.provider, d.customer?.name || d.email || '',
+            pounds(f.subtotal), pounds(f.discount), pounds(f.delivery), pounds(f.taxAdded), pounds(f.taxIncluded), pounds(f.total),
+            d.commission ? pounds(d.commission.reversed ? 0 : d.commission.amount) : '', d.commission ? `${d.commission.percent}% + ${pounds(d.commission.fixed)}` : '']);
+    }
+    return rows.map(r => r.map(csvCell).join(',')).join('\r\n') + '\r\n';
+}
+
+export {DAY};

package/plugins/shopping-cart/lib/shop.js

@@ -18,6 +18,14 @@ import {cleanProduct} from '../public/lib/products.js';
 import {NEXT, SOLD, canMove} from '../public/lib/orders.js';
 import {currencyOf} from '../public/lib/money.js';
 import {cartRegistry} from './extensions.js';
+import {commissionFor, currentCommission} from './commission.js';
+
+/** The platform's commission on a sale being paid now - kept if it already has one. */
+function commissionOn(d, at) {
+    if (d.commission) return {};
+    const c = commissionFor({data: d}, currentCommission().rates, at);
+    return c ? {commission: c} : {};
+}
 import defaults from '../config.js';
 
 export const NAME = 'shopping-cart';
@@ -98,6 +106,7 @@ export function cleanSettings(input, current) {
     out.lowStockAt = Math.max(0, Math.min(1000, Math.round(Number(input.lowStockAt ?? current.lowStockAt) || 0)));
     out.showStockLeft = bool('showStockLeft');
     out.termsUrl = str('termsUrl', 300);
+    out.accounts = bool('accounts');
     if (out.termsUrl && !/^(\/(?!\/)|https?:\/\/)/.test(out.termsUrl)) errors.termsUrl = 'A page on this site (/terms) or a full https:// address.';
 
     const countries = Array.isArray(input.countries) ? input.countries : (current.countries || ['GB']);
@@ -254,7 +263,7 @@ async function nextNumber() {
  *
  * @returns {Promise<{id, data}>}
  */
-export function createOrder({quote, checkout, provider, delivery, code = '', ref = '', returnTo = ''}) {
+export function createOrder({quote, checkout, provider, delivery, code = '', ref = '', returnTo = '', ownEmails = false, payNote = ''}) {
     return withLock(async () => {
         const now = new Date().toISOString();
         const data = {
@@ -265,7 +274,9 @@ export function createOrder({quote, checkout, provider, delivery, code = '', ref
             lines: quote.lines.map(l => ({
                 productId: l.productId, variantId: l.variantId, name: l.name, variantName: l.variantName,
                 optionName: l.optionName, slug: l.slug, image: l.image, sku: l.sku, unitPrice: l.unitPrice,
-                qty: l.qty, lineTotal: l.lineTotal, shippable: l.shippable, weight: l.weight, taxClass: l.taxClass, category: l.category || ''
+                qty: l.qty, lineTotal: l.lineTotal, shippable: l.shippable, weight: l.weight, taxClass: l.taxClass, category: l.category || '',
+                // A line an extension priced (Takeaway's dish): no product behind it, and what was chosen with it.
+                ...(l.custom ? {custom: true, detail: l.detail || [], ref: l.ref || ''} : {})
             })),
             subtotal: quote.subtotal,
             adjustments: quote.adjustments,
@@ -285,6 +296,10 @@ export function createOrder({quote, checkout, provider, delivery, code = '', ref
             ref: String(ref || '').slice(0, 64),
             // Where an extension's shopper goes back to after paying, instead of the Shop's receipt.
             returnTo: String(returnTo || '').slice(0, 500),
+            // The extension behind it writes to the shopper itself (Takeaway): other shopper emails stay quiet.
+            ...(ownEmails ? {ownEmails: true} : {}),
+            // An extension's own word on paying offline ("Pay when you collect"), shown instead of the shop's instructions.
+            ...(payNote ? {payNote: String(payNote).replace(/[\u0000-\u001f]/g, ' ').trim().slice(0, 300)} : {}),
             provider,
             providerRef: '',
             paymentRef: '',
@@ -309,6 +324,7 @@ export const setProviderRef = (id, providerRef) => withLock(() => patchOrder(id,
 async function moveStock(order, sign) {
     const byProduct = new Map();
     for (const l of order.lines || []) {
+        if (!l.productId) continue; // an extension's own line has no stock here
         if (!byProduct.has(l.productId)) byProduct.set(l.productId, []);
         byProduct.get(l.productId).push(l);
     }
@@ -353,6 +369,7 @@ export function markPaid(id, info = {}) {
             stockTaken: true,
             ...(info.ref ? {providerRef: info.ref} : {}),
             ...(info.payment ? {paymentRef: info.payment} : {}),
+            ...commissionOn(d, now),
             history: [...(d.history || []), {at: now, status: 'paid', by: info.by || d.provider, note: info.note || ''}]
         });
         return {order, changed: true, from: d.status};
@@ -377,6 +394,9 @@ export function moveOrder(id, to, {by = 'admin', note = '', restock = false, tra
         const patch = {status: to, history: [...(d.history || []), {at: now, status: to, by, note: String(note || '').slice(0, 500)}]};
         if (to === 'paid' && !d.stockTaken) { await moveStock(d, -1); patch.stockTaken = true; }
         if (to === 'paid' && !d.paidAt) patch.paidAt = now;
+        if (to === 'paid') Object.assign(patch, commissionOn(d, now));
+        // A refund gives the platform's commission back too (statements net it off in the month of the refund).
+        if (to === 'refunded' && d.commission && !d.commission.reversed) patch.commission = {...d.commission, reversed: true, reversedAt: now};
         if (to === 'fulfilled') {
             patch.fulfilledAt = now;
             if (tracking) patch.tracking = tracking;
@@ -437,7 +457,7 @@ export function publicOrder(entry) {
         status: d.status,
         currency: d.currency,
         lines: d.lines.map(l => ({productId: l.productId, variantId: l.variantId || '', name: l.name, variantName: l.variantName, optionName: l.optionName, qty: l.qty,
-            unitPrice: l.unitPrice, lineTotal: l.lineTotal, image: l.image, slug: l.slug})),
+            unitPrice: l.unitPrice, lineTotal: l.lineTotal, image: l.image, slug: l.slug, detail: l.detail || []})),
         subtotal: d.subtotal,
         adjustments: (d.adjustments || []).map(a => ({stage: a.stage, label: a.label, amount: a.amount, included: Boolean(a.included)})),
         total: d.total,
@@ -447,6 +467,7 @@ export function publicOrder(entry) {
         delivery: d.delivery,
         provider: d.provider,
         tracking: d.tracking || null,
+        payNote: d.payNote || '',
         placedAt: entry.meta?.createdAt,
         paidAt: d.paidAt || null,
         fulfilledAt: d.fulfilledAt || null

package/plugins/shopping-cart/lib/summary.js

@@ -56,10 +56,12 @@ export function summarise(orders, products, settings, now = Date.now()) {
     const units = new Map();
     for (const o of d30) {
         for (const l of o.data.lines || []) {
-            const had = units.get(l.productId) || {productId: l.productId, name: l.name, qty: 0, revenue: 0};
+            // An extension's own line (a Takeaway dish) has no product: counted by its own ref, else its name.
+            const key = l.productId || `ref:${l.ref || l.name}`;
+            const had = units.get(key) || {productId: l.productId, name: l.name, qty: 0, revenue: 0};
             had.qty += l.qty;
             had.revenue += l.lineTotal;
-            units.set(l.productId, had);
+            units.set(key, had);
         }
     }
     const topProducts = [...units.values()].sort((a, b) => b.revenue - a.revenue).slice(0, 5);