domma-cms 1.6.33 → 1.6.34

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);

package/plugins/shopping-cart/plugin.js

@@ -28,7 +28,7 @@ import {formatMoney} from './public/lib/money.js';
 import {publicProduct, byShelf} from './public/lib/products.js';
 import {cartRegistry} from './lib/extensions.js';
 import {SAMPLES} from './lib/samples.js';
-import {cleanLines, priceBasket} from './lib/pricing.js';
+import {cleanCharges, cleanCustomLines, cleanLines, priceBasket} from './lib/pricing.js';
 import {badge, summarise} from './lib/summary.js';
 import * as pay from './lib/payments.js';
 import {
@@ -58,7 +58,7 @@ const receiptPath = (s, order) => `${s.shopPath}/order/${order.id}?t=${order.dat
 const fail = (reply, status, error, extra = {}) => reply.code(status).send({error, ...extra});
 
 /** The quote, from a request body, at today's prices. */
-async function quoteFor(body, settings, {allowUnlisted = false} = {}) {
+async function quoteFor(body, settings, {allowUnlisted = false, custom = [], charges = null} = {}) {
     const lines = cleanLines(body?.lines);
     const ids = new Set(lines.map(l => l.productId));
     const products = new Map();
@@ -73,7 +73,8 @@ async function quoteFor(body, settings, {allowUnlisted = false} = {}) {
         email: String(body?.customer?.email || '').slice(0, 200),
         allowUnlisted
     };
-    const quote = await priceBasket({lines, products, settings, input, handlers: cartRegistry().handlers()});
+    const quote = await priceBasket({lines, products, settings, input, handlers: cartRegistry().handlers(),
+        custom: cleanCustomLines(custom), charges: cleanCharges(charges)});
     return {quote, input};
 }
 
@@ -326,32 +327,37 @@ export default async function shoppingCart(fastify, options) {
      * through them first; only when they say yes is the order marked refunded.
      * An offline order is marked only - the money goes back the way it came.
      */
-    fastify.post('/orders/:id/refund', can('manage'), async (request, reply) => {
-        const o = await getOrder(request.params.id);
-        if (!o) return fail(reply, 404, 'No such order.');
+    /** Refund an order in full (see above). Throws {status, message}. */
+    async function refundOrder(id, {restock = false, note = '', viaProvider = true, by = 'admin'} = {}) {
+        const bad = (status, message) => Object.assign(new Error(message), {status});
+        const o = await getOrder(id);
+        if (!o) throw bad(404, 'No such order.');
         const d = o.data;
-        if (!['paid', 'fulfilled'].includes(d.status)) return fail(reply, 409, 'Only a paid order can be refunded.');
+        if (!['paid', 'fulfilled'].includes(d.status)) throw bad(409, 'Only a paid order can be refunded.');
         const s = await liveSettings();
-        const {restock = false, note = '', viaProvider = true} = request.body || {};
         let how = 'marked refunded';
         try {
             if (viaProvider && d.provider === 'stripe' && d.paymentRef) {
-                if (!s.stripeSecretKey) return fail(reply, 409, 'Stripe is not set up any more - refund it in Stripe, then mark it refunded here.');
+                if (!s.stripeSecretKey) throw bad(409, 'Stripe is not set up any more - refund it in Stripe, then mark it refunded here.');
                 await pay.stripeRefund({secretKey: s.stripeSecretKey, paymentIntent: d.paymentRef});
                 how = 'refunded through Stripe';
             } else if (viaProvider && d.provider === 'paypal' && d.paymentRef) {
-                if (!s.paypalClientId || !s.paypalSecret) return fail(reply, 409, 'PayPal is not set up any more - refund it in PayPal, then mark it refunded here.');
+                if (!s.paypalClientId || !s.paypalSecret) throw bad(409, 'PayPal is not set up any more - refund it in PayPal, then mark it refunded here.');
                 await pay.paypalRefund({creds: {clientId: s.paypalClientId, secret: s.paypalSecret, mode: s.paypalMode}, captureId: d.paymentRef});
                 how = 'refunded through PayPal';
             }
         } catch (err) {
-            return fail(reply, err.status || 502, `Not refunded: ${err.message}`);
+            throw bad(err.status || 502, err.status === 409 ? err.message : `Not refunded: ${err.message}`);
         }
+        const {order, from} = await moveOrder(o.id, 'refunded', {by, note: [how, String(note || '')].filter(Boolean).join(' - '), restock: Boolean(restock)});
+        announceMove(order, from, 'refunded');
+        return {order, how};
+    }
+
+    fastify.post('/orders/:id/refund', can('manage'), async (request, reply) => {
+        const {restock = false, note = '', viaProvider = true} = request.body || {};
         try {
-            const {order, from} = await moveOrder(o.id, 'refunded', {by: request.user?.name || request.user?.email || 'admin',
-                note: [how, String(note || '')].filter(Boolean).join(' - '), restock: Boolean(restock)});
-            announceMove(order, from, 'refunded');
-            return {order, how};
+            return await refundOrder(request.params.id, {restock, note, viaProvider, by: request.user?.name || request.user?.email || 'admin'});
         } catch (err) {
             return fail(reply, err.status || 500, err.message);
         }
@@ -546,28 +552,39 @@ export default async function shoppingCart(fastify, options) {
      * (it comes back in on.paid) and its own page to come back to. Throws {status, message}.
      *
      * @param {object} p
-     * @param {{productId: string, qty: number}[]} p.lines
-     * @param {{name: string, email: string}} p.customer
+     * @param {{productId: string, qty: number}[]} [p.lines]
+     * @param {object[]} [p.custom]   - lines the extension priced (pricing.js cleanCustomLines): Takeaway's dishes
+     * @param {object[]} [p.charges]  - [{label, amount}] standing in for delivery (Takeaway's delivery fee)
+     * @param {'none'|'collect'|'deliver'} [p.delivery] - 'deliver' needs `address`; neither is ever posted
+     * @param {object} [p.address]
+     * @param {string} [p.note]
+     * @param {string} [p.code]      - a discount code (Shopping Cart Pro)
+     * @param {boolean} [p.ownEmails] - the extension writes to the shopper itself: other extensions' shopper emails stay quiet
+     * @param {string} [p.payNote]    - offline only: what the receipt says about paying, instead of the shop's offline instructions
+     * @param {{name: string, email: string, phone?: string}} p.customer
      * @param {string} [p.provider] - one of the Shop's methods; the first when left out
      * @param {string} [p.ref]      - the extension's reference, 64 characters at most
      * @param {string} [p.returnTo] - a path on this site ('/admin/#/...'), where the shopper comes back to
      * @param {string} [p.base]     - this site's origin, from the extension's request
      */
-    async function startCheckout({lines, customer, provider = '', ref = '', returnTo = '', base = ''} = {}) {
+    async function startCheckout({lines = [], custom = [], charges = null, delivery = 'none', address = null, note = '', code = '',
+        customer, provider = '', ref = '', returnTo = '', base = '', ownEmails = false, payNote = ''} = {}) {
         const bad = (status, message) => Object.assign(new Error(message), {status});
         const s = await liveSettings();
-        const {quote} = await quoteFor({lines, customer}, s, {allowUnlisted: true});
+        const {quote} = await quoteFor({lines, customer, code, address}, s, {allowUnlisted: true, custom, charges});
         if (!quote.lines.length) throw bad(400, 'Nothing to buy.');
         if (quote.problems.length) throw bad(409, quote.problems.map(p => p.message).join(' '));
         if (quote.requiresShipping) throw bad(400, 'This checkout is only for things that are not posted.');
-        const checkout = cleanCheckout({customer}, {needsAddress: false});
+        const deliver = delivery === 'deliver';
+        const checkout = cleanCheckout({customer, address, note}, {needsAddress: deliver, countries: s.countries});
         if (Object.keys(checkout.errors).length) throw bad(400, Object.values(checkout.errors)[0]);
         const methods = methodsOf(s).map(m => m.id);
         const via = quote.total === 0 ? 'free' : (provider || methods[0] || '');
         if (via !== 'free' && !methods.includes(via)) throw bad(409, 'The Shop has no way to take payment set up yet.');
         const origin = /^https?:\/\/[^/\s]+$/i.test(base) ? base.replace(/\/+$/, '') : siteBase(null);
         const back = /^\/(?!\/)/.test(String(returnTo)) ? `${origin}${returnTo}` : '';
-        const order = await createOrder({quote, checkout, provider: via, delivery: 'none', ref, returnTo: back});
+        const order = await createOrder({quote, checkout, provider: via, delivery: deliver ? 'ship' : delivery === 'collect' ? 'collect' : 'none',
+            code: String(code || '').slice(0, 60), ref, returnTo: back, ownEmails: ownEmails === true, payNote});
         registry.emit('checkout', order);
         const opened = await openPayment(order, s, via, origin);
         if (!opened) throw bad(400, 'Choose how to pay.');
@@ -581,6 +598,14 @@ export default async function shoppingCart(fastify, options) {
     }
 
     registry.services.startCheckout = startCheckout;
+    /** What startCheckout would charge, without ordering: a basket page's totals. Same arguments. */
+    registry.services.quote = async ({lines = [], custom = [], charges = null, code = '', customer = {}, address = null} = {}) => {
+        const s = await liveSettings();
+        const {quote} = await quoteFor({lines, customer, code, address}, s, {allowUnlisted: true, custom, charges});
+        return shopperQuote(quote, s);
+    };
+    /** Refund an order in full, through its provider first (Takeaway's Reject). Throws {status, message}. */
+    registry.services.refund = (id, opts = {}) => refundOrder(id, {by: 'shop', ...opts});
     registry.services.checkOrder = checkOrder;
     registry.services.paymentMethods = async () => methodsOf(await liveSettings()).map(m => ({id: m.id, label: m.label}));
     // An extension looks after its own (unlisted) products: made, changed and removed through these.

package/plugins/shopping-cart/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "shopping-cart",
   "displayName": "Shopping Cart",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "tier": "free",
   "description": "Sell from your site: products with options, stock and pictures, a storefront and a cart that follows shoppers from page to page, and checkout with Stripe, PayPal or payment offline. Orders to fulfil in the sidebar, refunds from the order.",
   "author": "Domma CMS",
@@ -45,7 +45,7 @@
     ],
     "views": {
       "plugin-shopping-cart": {
-        "entry": "shopping-cart/admin/views/shop.js?v=1.2.0",
+        "entry": "shopping-cart/admin/views/shop.js?v=1.3.0",
         "exportName": "shopView"
       }
     }

package/plugins/shopping-cart/tests/api.test.js

@@ -239,3 +239,55 @@ test('an extension keeps its own part of a product, and moves its orders on', as
         reg.unregister('test-dl');
     }
 });
+
+test('an extension checks out lines it priced, with a delivery fee and address; refunds through the Cart', async () => {
+    const {cartRegistry} = await import('../lib/extensions.js');
+    const reg = cartRegistry();
+    const paid = [];
+    reg.register('test-takeaway', {on: {paid: (o) => paid.push(o)}});
+    try {
+        await call('PUT', '/settings', {offlineEnabled: true, countries: ['GB'], taxRate: 0, shippingFlat: 395});
+        const dishes = [{name: 'Vindaloo', optionName: 'Protein', variantName: 'Chicken', unitPrice: 950, qty: 2, detail: ['+ Extra chilli £0.50'], ref: 'dish:vin'},
+            {name: 'Pilau rice', unitPrice: 300, qty: 1, ref: 'dish:rice'}];
+        const charges = [{label: 'Delivery (YO10)', amount: 250}];
+        const q = await reg.services.quote({custom: dishes, charges});
+        assert.equal(q.total, 1900 + 300 + 250);
+        assert.equal(q.requiresShipping, false);
+
+        // Delivering needs an address; collecting does not.
+        await assert.rejects(reg.services.startCheckout({custom: dishes, charges, delivery: 'deliver', customer: {name: 'Ann', email: 'ann@x.test'}, provider: 'offline'}), /address/i);
+        const out = await reg.services.startCheckout({custom: dishes, charges, delivery: 'deliver', note: 'Ring the bell',
+            address: {line1: '1 High St', city: 'York', postcode: 'yo10 5dd', country: 'GB'},
+            customer: {name: 'Ann', email: 'ann@x.test', phone: '07700 900000'}, provider: 'offline', ref: 'takeaway:t1', base: 'https://site.test'});
+        assert.equal(out.total, 2450);
+        let order = await reg.services.checkOrder(out.orderId);
+        assert.equal(order.data.delivery, 'ship');
+        assert.equal(order.data.address.postcode, 'YO10 5DD');
+        assert.equal(order.data.note, 'Ring the bell');
+        assert.equal(order.data.customer.phone, '07700 900000');
+        const vin = order.data.lines.find(l => l.ref === 'dish:vin');
+        assert.deepEqual([vin.custom, vin.variantName, vin.detail], [true, 'Chicken', ['+ Extra chilli £0.50']]);
+        assert.deepEqual((await call('GET', `/order/${order.id}?t=${order.data.token}`)).body.lines[0].detail, ['+ Extra chilli £0.50']);
+
+        // Paid: no stock to take, the extension hears; then refunded through the Cart.
+        const r = await call('PUT', `/orders/${order.id}/status`, {status: 'paid'});
+        assert.equal(r.status, 200, JSON.stringify(r.body));
+        await new Promise(res => setTimeout(res, 20));
+        assert.equal(paid.at(-1)?.data?.ref, 'takeaway:t1');
+        const refunded = await reg.services.refund(order.id, {note: 'Kitchen closed early'});
+        assert.equal(refunded.order.data.status, 'refunded');
+        assert.match(refunded.order.data.history.at(-1).note, /Kitchen closed early/);
+        await assert.rejects(reg.services.refund(order.id), /Only a paid order/);
+
+        // Collecting: no address asked, no delivery.
+        const c = await reg.services.startCheckout({custom: dishes, delivery: 'collect', customer: {name: 'Bo', email: 'bo@x.test'}, provider: 'offline'});
+        order = await reg.services.checkOrder(c.orderId);
+        assert.equal(order.data.delivery, 'collect');
+        assert.equal(order.data.total, 2200);
+        // The storefront's own checkout never takes priced lines.
+        const s = await call('POST', '/checkout', {custom: dishes, provider: 'offline', customer: {name: 'Cy', email: 'cy@x.test'}});
+        assert.equal(s.status, 400);
+    } finally {
+        reg.unregister('test-takeaway');
+    }
+});

package/plugins/shopping-cart/tests/pure.test.js

@@ -4,7 +4,7 @@ import {createHmac} from 'node:crypto';
 import {formatMoney, fromMinor, includedTax, percentOf, toMinor} from '../public/lib/money.js';
 import {available, cleanProduct, priceRange, publicProduct, slugify, unitPrice} from '../public/lib/products.js';
 import {canMove, cleanCheckout} from '../public/lib/orders.js';
-import {cleanLines, priceBasket} from '../lib/pricing.js';
+import {cleanCharges, cleanCustomLines, cleanLines, priceBasket} from '../lib/pricing.js';
 import {paypalPaid, stripeForm, stripeLineItems, stripeSessionPaid, stripeVerify} from '../lib/payments.js';
 import {badge, summarise} from '../lib/summary.js';
 import {cartRegistry} from '../lib/extensions.js';
@@ -77,6 +77,35 @@ test('pricing: stock caps quantities, archived products drop out', async () => {
     assert.equal(q.problems.length, 2);
 });
 
+test('pricing: lines an extension priced, and its charges standing in for delivery', async () => {
+    const custom = cleanCustomLines([
+        {name: 'Vindaloo', optionName: 'Protein', variantName: 'Chicken', unitPrice: 950, qty: 2, taxClass: 'standard',
+            detail: ['+ Extra chilli £0.50', '  No onions  ', ''], category: 'Mains', ref: 'dish:vin'},
+        {name: 'Junk', unitPrice: -5, qty: 1}, {name: '', unitPrice: 100, qty: 1}, {name: 'Naan', unitPrice: 300, qty: 0}, {name: 'Rice', unitPrice: 1.5, qty: 1}
+    ]);
+    assert.equal(custom.length, 1, 'no name, a negative or fractional price, or no quantity: dropped');
+    assert.deepEqual(custom[0].detail, ['+ Extra chilli £0.50', 'No onions']);
+    assert.equal(cleanCharges(undefined), null, 'no charges: the shipping stage runs as usual');
+    assert.deepEqual(cleanCharges([{label: 'Delivery (YO10)', amount: 250}, {amount: 'x'}]), [{label: 'Delivery (YO10)', amount: 250}]);
+
+    const settings = {...S, shippingFlat: 395, taxRate: 20, pricesIncludeTax: true, taxShipping: true};
+    let q = await priceBasket({lines: cleanLines([{productId: 'p1', qty: 1}]), products: catalogue, settings, custom, charges: cleanCharges([{label: 'Delivery', amount: 250}])});
+    assert.equal(q.lines.length, 2);
+    const dish = q.lines.find(l => l.custom);
+    assert.equal(dish.lineTotal, 1900);
+    assert.equal(dish.productId, '');
+    assert.equal(dish.shippable, false);
+    assert.equal(q.requiresShipping, true, 'the product still needs posting');
+    assert.deepEqual(q.adjustments.filter(a => a.stage === 'shipping').map(a => a.amount), [250], 'the charge, not the flat rate');
+    assert.equal(q.total, 1000 + 1900 + 250);
+    assert.equal(q.adjustments.find(a => a.stage === 'tax').amount, Math.round((1000 + 1900 + 250) / 6), 'taxed as delivery is');
+    // Only the extension's lines: nothing to post, and no charges means no delivery at all.
+    q = await priceBasket({lines: [], products: catalogue, settings, custom});
+    assert.equal(q.requiresShipping, false);
+    assert.equal(q.adjustments.filter(a => a.stage === 'shipping').length, 0);
+    assert.equal(q.subtotal, 1900);
+});
+
 test('pricing: flat delivery, free over a threshold, collection, nothing to ship', async () => {
     const s = {...S, shippingFlat: 395, freeShippingOver: 2500, allowCollection: true};
     let q = await priceBasket({lines: [{productId: 'p1', variantId: '', qty: 1}], products: catalogue, settings: s});