@stamhoofd/backend 2.137.3 → 2.137.5

package/src/services/OrderService.test.ts

@@ -0,0 +1,308 @@
+import { I18n } from '@stamhoofd/backend-i18n';
+import { EmailMocker } from '@stamhoofd/email';
+import type { Organization } from '@stamhoofd/models';
+import { EmailTemplateFactory, Order, OrganizationFactory, Payment, Webshop, WebshopCounter, WebshopFactory } from '@stamhoofd/models';
+import { Cart, CartItem, Customer, EmailContent, EmailTemplateType, OrderData, OrderStatus, PaymentMethod, PaymentStatus, Product, ProductPrice, ProductType, WebshopMetaData, WebshopStatus, WebshopTicketType } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Country } from '@stamhoofd/types/Country';
+import { Language } from '@stamhoofd/types/Language';
+import { OrderService } from './OrderService.js';
+
+/**
+ * The order emails are rendered in the language the customer ordered in. The status name below is
+ * rendered through $t inside the order recipient replacements, and is hardcoded on purpose so we
+ * don't verify $t with the same $t machinery we're testing.
+ * (translations of OrderStatus.Created in shared/locales/dist/locales/digit/{nl,fr}-BE.json)
+ */
+const orderStatusName = {
+    [Language.Dutch]: 'Nieuw',
+    [Language.French]: 'Nouveau',
+};
+
+function createCustomer() {
+    return Customer.create({
+        firstName: 'John',
+        lastName: 'Doe',
+        email: 'john@example.com',
+    });
+}
+
+async function createOrder(webshop: Webshop, options: { consumerLanguage?: Language; valid?: boolean; cart?: Cart; paymentMethod?: PaymentMethod } = {}) {
+    const order = new Order();
+    order.organizationId = webshop.organizationId;
+    order.webshopId = webshop.id;
+    order.status = OrderStatus.Created;
+    order.consumerLanguage = options.consumerLanguage ?? Language.Dutch;
+    order.data = OrderData.create({
+        paymentMethod: options.paymentMethod ?? PaymentMethod.Transfer,
+        customer: createCustomer(),
+        cart: options.cart ?? Cart.create({}),
+    });
+
+    if (options.valid ?? true) {
+        order.validAt = new Date();
+        order.number = await WebshopCounter.getNextNumber(webshop);
+    }
+
+    await order.save();
+    return order;
+}
+
+function loadRelations(order: Order, webshop: Webshop, organization: Organization) {
+    return order.setRelation(Order.webshop, webshop.setRelation(Webshop.organization, organization));
+}
+
+async function createTransferPayment(organization: Organization) {
+    const payment = new Payment();
+    payment.organizationId = organization.id;
+    payment.method = PaymentMethod.Transfer;
+    payment.status = PaymentStatus.Succeeded;
+    payment.price = 1000;
+    payment.paidAt = new Date();
+    await payment.save();
+    return payment;
+}
+
+describe('OrderService', () => {
+    describe('sendEmailTemplate', () => {
+        test('renders the email in the language the customer ordered in, not the ambient language', async () => {
+            // Make French a valid locale so its real translations (loaded from disk) are actually used.
+            TestUtils.setEnvironment('locales', { [Country.Belgium]: [Language.Dutch, Language.French] });
+
+            const organization = await new OrganizationFactory({}).create();
+            const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+            await new EmailTemplateFactory({
+                organization,
+                webshopId: webshop.id,
+                type: EmailTemplateType.OrderConfirmationOnline,
+                subject: 'Bevestiging',
+                html: '<p>{{orderStatus}}</p>',
+                text: '{{orderStatus}}',
+            }).create();
+
+            const order = await createOrder(webshop, { consumerLanguage: Language.French });
+            const loadedOrder = loadRelations(order, webshop, organization);
+
+            // The ambient language is Dutch while the customer ordered in French
+            await I18n.runWithLocale(new I18n(Language.Dutch, Country.Belgium), async () => {
+                await OrderService.sendEmailTemplate(loadedOrder, {
+                    type: EmailTemplateType.OrderConfirmationOnline,
+                });
+            });
+
+            const emails = await EmailMocker.transactional.getSucceededEmails();
+            expect(emails).toHaveLength(1);
+            expect(emails[0].html).toContain(orderStatusName[Language.French]);
+            expect(emails[0].html).not.toContain(orderStatusName[Language.Dutch]);
+        });
+
+        test('does not send anything for an archived webshop', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const webshop = await new WebshopFactory({
+                organizationId: organization.id,
+                meta: WebshopMetaData.patch({ status: WebshopStatus.Archived }),
+            }).create();
+
+            await new EmailTemplateFactory({
+                organization,
+                webshopId: webshop.id,
+                type: EmailTemplateType.OrderConfirmationOnline,
+                subject: 'Bevestiging',
+                html: '<p>Bevestiging</p>',
+                text: 'Bevestiging',
+            }).create();
+
+            const order = await createOrder(webshop);
+            const loadedOrder = loadRelations(order, webshop, organization);
+
+            await OrderService.sendEmailTemplate(loadedOrder, {
+                type: EmailTemplateType.OrderConfirmationOnline,
+            });
+
+            expect(await EmailMocker.transactional.getSucceededEmails()).toHaveLength(0);
+        });
+    });
+
+    describe('markValid', () => {
+        test('sends the notification email without the customer name and in the webshop language', async () => {
+            TestUtils.setEnvironment('locales', { [Country.Belgium]: [Language.Dutch, Language.French] });
+
+            const organization = await new OrganizationFactory({}).create();
+            const webshop = await new WebshopFactory({
+                organizationId: organization.id,
+                meta: WebshopMetaData.patch({ defaultLanguage: Language.French }),
+            }).create();
+            webshop.privateMeta.notificationEmails = ['admin@example.com'];
+            await webshop.save();
+
+            await new EmailTemplateFactory({
+                organization,
+                webshopId: webshop.id,
+                type: EmailTemplateType.OrderConfirmationOnline,
+                subject: 'Bevestiging',
+                html: '<p>Bevestiging</p>',
+                text: 'Bevestiging',
+            }).create();
+
+            // Default (Dutch) content + a French translation, so we can tell which language was selected
+            await new EmailTemplateFactory({
+                organization,
+                webshopId: webshop.id,
+                type: EmailTemplateType.OrderNotification,
+                subject: 'Nederlandse melding',
+                html: '<p>NL [{{firstName}}][{{lastName}}] {{orderUrl}}</p>',
+                text: 'Nederlandse melding',
+                language: Language.Dutch,
+                translations: new Map([
+                    [Language.French, EmailContent.create({
+                        subject: 'Franse melding',
+                        html: '<p>FR [{{firstName}}][{{lastName}}] {{orderUrl}}</p>',
+                        text: 'Franse melding',
+                    })],
+                ]),
+            }).create();
+
+            // The customer ordered in Dutch, the webshop default language is French
+            const order = await createOrder(webshop, { consumerLanguage: Language.Dutch, valid: false });
+            const loadedOrder = loadRelations(order, webshop, organization);
+
+            await OrderService.markValid(loadedOrder, null, []);
+
+            const emails = await EmailMocker.transactional.getSucceededEmails();
+            expect(emails).toHaveLength(2);
+
+            const customerEmail = emails.find(e => e.to.includes('john@example.com'));
+            const notification = emails.find(e => e.to.includes('admin@example.com'));
+            expect(customerEmail).toBeDefined();
+            expect(notification).toBeDefined();
+
+            // The customer name is cleared, so the notification is not addressed to the customer
+            expect(notification!.to).toBe('admin@example.com');
+
+            // The firstName/lastName replacements are dropped, so the customer name doesn't leak
+            expect(notification!.html).toContain('[][]');
+            expect(notification!.html).not.toContain('John');
+            expect(notification!.html).not.toContain('Doe');
+
+            // The language falls back to the webshop default (French), not the customer's (Dutch)
+            expect(notification!.subject).toBe('Franse melding');
+            expect(notification!.html).toContain('FR ');
+
+            // The orderUrl of the notification points at the dashboard, not at the webshop order page
+            expect(notification!.html).toContain('/webshops/');
+
+            // The customer still receives their own confirmation
+            expect(customerEmail!.subject).toBe('Bevestiging');
+        });
+    });
+
+    describe('markPaid', () => {
+        test('sends the tickets email when tickets were created', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const productPrice = ProductPrice.create({ name: 'Standaard', price: 0 });
+            const ticketProduct = Product.create({
+                name: 'Ticket',
+                type: ProductType.Ticket,
+                prices: [productPrice],
+            });
+
+            const webshop = await new WebshopFactory({
+                organizationId: organization.id,
+                meta: WebshopMetaData.patch({ ticketType: WebshopTicketType.Tickets }),
+                products: [ticketProduct],
+            }).create();
+
+            await new EmailTemplateFactory({
+                organization,
+                webshopId: webshop.id,
+                type: EmailTemplateType.TicketsReceivedTransfer,
+                subject: 'Tickets ontvangen',
+                html: '<p>Tickets ontvangen</p>',
+                text: 'Tickets ontvangen',
+            }).create();
+
+            await new EmailTemplateFactory({
+                organization,
+                webshopId: webshop.id,
+                type: EmailTemplateType.OrderReceivedTransfer,
+                subject: 'Betaling ontvangen',
+                html: '<p>Betaling ontvangen</p>',
+                text: 'Betaling ontvangen',
+            }).create();
+
+            const order = await createOrder(webshop, {
+                cart: Cart.create({
+                    items: [CartItem.create({ product: ticketProduct, productPrice, amount: 1 })],
+                }),
+            });
+
+            const payment = await createTransferPayment(organization);
+            await OrderService.markPaid(order, payment, organization, webshop);
+
+            const emails = await EmailMocker.transactional.getSucceededEmails();
+            expect(emails).toHaveLength(1);
+            expect(emails[0].subject).toBe('Tickets ontvangen');
+        });
+
+        test('sends the paid email for a transfer payment when no tickets were created', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+            await new EmailTemplateFactory({
+                organization,
+                webshopId: webshop.id,
+                type: EmailTemplateType.TicketsReceivedTransfer,
+                subject: 'Tickets ontvangen',
+                html: '<p>Tickets ontvangen</p>',
+                text: 'Tickets ontvangen',
+            }).create();
+
+            await new EmailTemplateFactory({
+                organization,
+                webshopId: webshop.id,
+                type: EmailTemplateType.OrderReceivedTransfer,
+                subject: 'Betaling ontvangen',
+                html: '<p>Betaling ontvangen</p>',
+                text: 'Betaling ontvangen',
+            }).create();
+
+            const order = await createOrder(webshop);
+            const payment = await createTransferPayment(organization);
+
+            await OrderService.markPaid(order, payment, organization, webshop);
+
+            const emails = await EmailMocker.transactional.getSucceededEmails();
+            expect(emails).toHaveLength(1);
+            expect(emails[0].subject).toBe('Betaling ontvangen');
+        });
+
+        test('does not send the paid email for a non-transfer payment when no tickets were created', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+            await new EmailTemplateFactory({
+                organization,
+                webshopId: webshop.id,
+                type: EmailTemplateType.OrderReceivedTransfer,
+                subject: 'Betaling ontvangen',
+                html: '<p>Betaling ontvangen</p>',
+                text: 'Betaling ontvangen',
+            }).create();
+
+            const order = await createOrder(webshop, { paymentMethod: PaymentMethod.PointOfSale });
+
+            const payment = new Payment();
+            payment.organizationId = organization.id;
+            payment.method = PaymentMethod.PointOfSale;
+            payment.status = PaymentStatus.Succeeded;
+            payment.price = 1000;
+            payment.paidAt = new Date();
+            await payment.save();
+
+            await OrderService.markPaid(order, payment, organization, webshop);
+
+            expect(await EmailMocker.transactional.getSucceededEmails()).toHaveLength(0);
+        });
+    });
+});

package/src/services/OrderService.ts

@@ -0,0 +1,214 @@
+import { I18n } from '@stamhoofd/backend-i18n';
+import type { Organization, Payment, Ticket } from '@stamhoofd/models';
+import { Order, sendEmailTemplate, Webshop, WebshopCounter } from '@stamhoofd/models';
+import { EmailTemplateType, OrderStatus, PaymentMethod, Recipient, Replacement, WebshopPreview, WebshopStatus, WebshopTicketType } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+
+/**
+ * An order with its webshop, and the organization of that webshop, loaded.
+ */
+export type OrderWithWebshop = Order & { webshop: Webshop & { organization: Organization } };
+
+/**
+ * The lifecycle transitions of an order (valid / paid) and the customer emails they send.
+ */
+export class OrderService {
+    /**
+     * Only call this once! Make sure you use the queues correctly
+     */
+    static async markPaid(order: Order, payment: Payment | null, organization: Organization, knownWebshop?: Webshop) {
+        if (!order.id) {
+            await order.save();
+        }
+        console.log('Marking order ' + order.id + ' as paid');
+
+        const webshop = (knownWebshop ?? (await Webshop.getByID(order.webshopId)))?.setRelation(Webshop.organization, organization);
+        if (!webshop) {
+            console.error('Missing webshop for order ' + order.id);
+            return;
+        }
+
+        if (order.status === OrderStatus.Deleted) {
+            await order.undoPaymentFailed(payment, organization);
+        }
+
+        const loadedOrder = order.setRelation(Order.webshop, webshop);
+        const { tickets, didCreateTickets } = await loadedOrder.updateTickets({ hasPaidPayment: true });
+
+        // Needs to happen before validation, because we can include the tickets in the validation that way
+        if (order.validAt === null) {
+            await this.markValid(loadedOrder, payment, tickets);
+        } else {
+            order.markUpdated();
+            await order.save();
+
+            if (!order.data.shouldSendPaymentUpdates) {
+                console.log('Skip sending paid email for order ' + order.id);
+                return;
+            }
+            if (order.data.customer.email.length > 0) {
+                if (didCreateTickets) {
+                    await this.sendTickets(loadedOrder);
+                } else {
+                    if (payment && payment.method === PaymentMethod.Transfer) {
+                        await this.sendPaidMail(loadedOrder);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * WARNING: this should always run inside a queue so it only runs once for the same order
+     * Include any tickets that are generated and should be included in the e-mail
+     */
+    static async markValid(order: OrderWithWebshop, payment: Payment | null, tickets: Ticket[]) {
+        const webshop = order.webshop;
+        const organization = webshop.organization;
+
+        console.log('Marking as valid: order ' + order.id);
+        const wasValid = order.validAt !== null;
+
+        if (wasValid) {
+            console.warn('Warning: already validated an order');
+            return;
+        }
+        order.validAt = new Date(); // will get flattened AFTER calculations
+        order.validAt.setMilliseconds(0);
+        order.number = await WebshopCounter.getNextNumber(webshop);
+
+        if (payment && !Order.payment.isLoaded(order)) {
+            order.setRelation(Order.payment, payment);
+        }
+
+        // Now we have a number, update the payment
+        if (payment && payment.method === PaymentMethod.Transfer) {
+            // Only now we can update the transfer description, since we need the order number as a reference
+            payment.transferSettings = order.getTransferSettings({ shouldThrowIfNoIban: true });
+            payment.generateDescription(organization, order.number.toString(), order.getTransferReplacements());
+            await payment.save();
+        }
+
+        await order.save();
+
+        if (order.data.customer.email.length > 0) {
+            if (tickets.length > 0) {
+                // Also send a copy
+                if (payment && payment.method === PaymentMethod.PointOfSale) {
+                    await this.sendEmailTemplate(order, {
+                        type: EmailTemplateType.TicketsConfirmationPOS,
+                    });
+                } else {
+                    await this.sendEmailTemplate(order, {
+                        type: EmailTemplateType.TicketsConfirmation,
+                    });
+                }
+            } else {
+                if (webshop.meta.ticketType === WebshopTicketType.None) {
+                    if (payment && payment.method === PaymentMethod.Transfer) {
+                        // Also send a copy
+                        await this.sendEmailTemplate(order, {
+                            type: EmailTemplateType.OrderConfirmationTransfer,
+                        });
+                    } else if (payment && payment.method === PaymentMethod.PointOfSale) {
+                        await this.sendEmailTemplate(order, {
+                            type: EmailTemplateType.OrderConfirmationPOS,
+                        });
+                    } else {
+                        // Also send a copy
+                        await this.sendEmailTemplate(order, {
+                            type: EmailTemplateType.OrderConfirmationOnline,
+                        });
+                    }
+                } else {
+                    if (payment && payment.method === PaymentMethod.Transfer) {
+                        await this.sendEmailTemplate(order, {
+                            type: EmailTemplateType.TicketsConfirmationTransfer,
+                        });
+                    } else {
+                        console.error('Unexpected missing tickets for order where tickets are expected');
+                    }
+                }
+            }
+        }
+
+        if (webshop.privateMeta.notificationEmails) {
+            const i18n = organization.i18n;
+
+            const webshopDashboardUrl = 'https://' + (STAMHOOFD.domains.dashboard ?? 'stamhoofd.app') + '/' + i18n.locale + '/webshops/' + Formatter.slug(webshop.meta.name) + '/orders';
+
+            // Send an email to all these notification emails
+            for (const email of webshop.privateMeta.notificationEmails) {
+                await this.sendEmailTemplate(order, {
+                    type: EmailTemplateType.OrderNotification,
+                    to: Recipient.create({
+                        email,
+                        replacements: [
+                            Replacement.create({
+                                token: 'orderUrl',
+                                value: webshopDashboardUrl,
+                            }),
+                        ],
+                    }),
+                });
+            }
+        }
+    }
+
+    static async sendPaidMail(order: OrderWithWebshop) {
+        // For a tickets webshop, where the order was marked as paid / non-paid, we should still send the tickets email
+        // - because the normal email is not editable
+        const hasTickets = order.webshop.meta.hasTickets;
+
+        await this.sendEmailTemplate(order, {
+            type: hasTickets ? EmailTemplateType.TicketsReceivedTransfer : EmailTemplateType.OrderReceivedTransfer,
+        });
+    }
+
+    static async sendTickets(order: OrderWithWebshop) {
+        await this.sendEmailTemplate(order, {
+            type: EmailTemplateType.TicketsReceivedTransfer,
+        });
+    }
+
+    static async sendEmailTemplate(order: OrderWithWebshop, data: {
+        type: EmailTemplateType;
+        to?: Recipient;
+    }) {
+        // Never send an email for archived webshops
+        if (order.webshop.meta.status === WebshopStatus.Archived) {
+            return;
+        }
+
+        // Render all $t's (recipient replacements, order tables, template...) in the language
+        // the customer used while placing the order, instead of the current request language.
+        const i18n = new I18n(order.consumerLanguage, order.webshop.organization.address.country);
+
+        await I18n.runWithLocale(i18n, async () => {
+            let recipient = (await order.getStructure()).getRecipient(
+                order.webshop.organization.getBaseStructure(),
+                WebshopPreview.create(order.webshop),
+            );
+
+            if (data.to) {
+                // Clear first and last name
+                recipient.firstName = null;
+                recipient.lastName = null;
+                recipient.language = order.webshop.meta.defaultLanguage;
+                recipient.replacements = recipient.replacements.filter(r => !['firstName', 'lastName'].includes(r.token));
+                data.to.merge(recipient);
+                recipient = data.to;
+            }
+
+            // Create e-mail builder
+            await sendEmailTemplate(order.webshop.organization, {
+                recipients: [recipient],
+                template: {
+                    type: data.type,
+                    webshop: order.webshop,
+                },
+                type: 'transactional',
+            });
+        });
+    }
+}