@stamhoofd/backend 2.137.4 → 2.138.0

package/src/services/OrderService.ts

@@ -0,0 +1,215 @@
+import { I18n } from '@stamhoofd/backend-i18n';
+import type { Organization, Payment, Ticket } from '@stamhoofd/models';
+import { Order, Webshop, WebshopCounter } from '@stamhoofd/models';
+import { sendEmailTemplate } from '../helpers/EmailBuilder.js';
+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',
+            });
+        });
+    }
+}

package/src/services/OrganizationAdminService.test.ts

@@ -0,0 +1,47 @@
+import { AccessRight, PermissionLevel, PermissionRoleDetailed, Permissions } from '@stamhoofd/structures';
+import { OrganizationFactory, UserFactory } from '@stamhoofd/models';
+import { OrganizationAdminService } from './OrganizationAdminService.js';
+
+describe('Organization admin recipients', () => {
+    async function createOrganizationWithAdmins() {
+        const financeRole = PermissionRoleDetailed.create({
+            name: 'financial director',
+            accessRights: [AccessRight.OrganizationFinanceDirector],
+        });
+
+        const organization = await new OrganizationFactory({ roles: [financeRole] }).create();
+
+        const fullAdmin = await new UserFactory({
+            organization,
+            email: 'full-admin@example.com',
+            permissions: Permissions.create({ level: PermissionLevel.Full }),
+        }).create();
+
+        const financeAdmin = await new UserFactory({
+            organization,
+            email: 'finance-admin@example.com',
+            permissions: Permissions.create({
+                level: PermissionLevel.None,
+                roles: [financeRole],
+            }),
+        }).create();
+
+        return { organization, fullAdmin, financeAdmin };
+    }
+
+    test('The finance admin recipients include a financial director without full access', async () => {
+        const { organization, fullAdmin, financeAdmin } = await createOrganizationWithAdmins();
+
+        const emails = (await OrganizationAdminService.getFinanceAdminRecipients(organization)).map(r => r.email);
+
+        expect(emails).toIncludeSameMembers([fullAdmin.email, financeAdmin.email]);
+    });
+
+    test('The regular admin recipients only include full admins', async () => {
+        const { organization, fullAdmin } = await createOrganizationWithAdmins();
+
+        const emails = (await OrganizationAdminService.getAdminRecipients(organization)).map(r => r.email);
+
+        expect(emails).toIncludeSameMembers([fullAdmin.email]);
+    });
+});

package/src/services/OrganizationAdminService.ts

@@ -0,0 +1,139 @@
+import type { Organization } from '@stamhoofd/models';
+import { Platform, Token, User } from '@stamhoofd/models';
+import type { EmailInterfaceRecipient } from '@stamhoofd/email';
+import type { OrganizationEmail } from '@stamhoofd/structures';
+import { AccessRight, Recipient } from '@stamhoofd/structures';
+import { Sorter } from '@stamhoofd/utility';
+
+/**
+ * Resolves which administrators of an organization should receive a given kind of email.
+ */
+export class OrganizationAdminService {
+    /**
+     * E-mail address when we receive replies for organization@stamhoofd.email.
+     * Note that this sould be private because it can contain personal e-mail addresses if the organization is not configured correctly
+     */
+    static async getReplyEmails(organization: Organization): Promise<EmailInterfaceRecipient[]> {
+        const sender: OrganizationEmail | undefined = organization.privateMeta.emails.find(e => e.default) ?? organization.privateMeta.emails[0];
+
+        if (sender) {
+            return [
+                {
+                    name: sender.name,
+                    email: sender.email,
+                },
+            ];
+        }
+
+        return await this.getAdminToEmails(organization);
+    }
+
+    static async getAdmins(organization: Organization) {
+        return await User.getAdmins(organization.id, { verified: true });
+    }
+
+    /**
+     * These email addresess are private
+     */
+    static async getFullAdmins(organization: Organization) {
+        const admins = await this.getAdmins(organization);
+        const platform = await Platform.getSharedStruct();
+
+        // Only full access
+        return admins.filter(a => a.permissions && a.permissions.forOrganization(organization, platform, { inheritFromPlatform: false })?.hasFullAccess());
+    }
+
+    /**
+     * These email addresess are private
+     */
+    static async getFinanceAdmins(organization: Organization) {
+        const admins = await this.getAdmins(organization);
+        const platform = await Platform.getSharedStruct();
+        const filtered = admins.filter(a => a.permissions && (a.permissions.forOrganization(organization, platform, { inheritFromPlatform: false })?.hasFullAccess() || a.permissions.forOrganization(organization, platform, { inheritFromPlatform: false })?.hasAccessRight(AccessRight.OrganizationFinanceDirector)));
+
+        // Only full access
+        return filtered;
+    }
+
+    /**
+     * These email addresess are private
+     */
+    static async getAdminToEmails(organization: Organization): Promise<EmailInterfaceRecipient[]> {
+        const filtered = await this.getFullAdmins(organization);
+
+        if (STAMHOOFD.environment === 'production') {
+            if (filtered.length > 1) {
+                // remove stamhoofd email addresses
+                const f = filtered.flatMap(f => f.getEmailTo()).filter(e => !e.email.endsWith('@stamhoofd.be') && !e.email.endsWith('@stamhoofd.nl'));
+                if (f.length > 0) {
+                    return f;
+                }
+            }
+        }
+
+        return filtered.flatMap(f => f.getEmailTo());
+    }
+
+    static adminsToRecipients(admins: User[]) {
+        return admins.flatMap((f) => {
+            return Recipient.create({
+                firstName: f.firstName,
+                lastName: f.lastName,
+                email: f.email,
+                replacements: [],
+            });
+        });
+    }
+
+    /**
+     * These email addresess are private
+     */
+    static async getAdminRecipients(organization: Organization): Promise<Recipient[]> {
+        const filtered = await this.getFullAdmins(organization);
+        return this.adminsToRecipients(filtered);
+    }
+
+    /**
+     * These email addresess are private
+     */
+    static async getFinanceAdminRecipients(organization: Organization): Promise<Recipient[]> {
+        const filtered = await this.getFinanceAdmins(organization);
+        return this.adminsToRecipients(filtered);
+    }
+
+    /**
+     * Returns one email for invoices. since in ubl we can only add one address.
+     * We choose the oldest user that was active in the last 3 months (otherwise the oldest user if noone was active)
+     */
+    static async getInvoicingToEmail(organization: Organization): Promise<string | undefined> {
+        const admins = await this.getAdmins(organization);
+
+        const tokens = await Token.select().where('userId', admins.map(a => a.id)).fetch();
+
+        // Sort by admins that were active in the last 3 months, then creation date
+        const cutoffDate = new Date(Date.now() - 1000 * 60 * 60 * 24 * 31 * 3);
+        admins.sort((a, b) => {
+            const aTokens = tokens.filter(t => t.userId === a.id);
+            const bTokens = tokens.filter(t => t.userId === b.id);
+            const aActive = !!aTokens.find(t => t.updatedAt > cutoffDate);
+            const bActive = !!bTokens.find(t => t.updatedAt > cutoffDate);
+            return Sorter.stack(
+                Sorter.byBooleanValue(aActive, bActive),
+                Sorter.byDateValue(b.createdAt, a.createdAt),
+            );
+        });
+
+        const platform = await Platform.getSharedStruct();
+        const filtered = admins.filter(a => a.verified && a.permissions && !a.email.endsWith('@stamhoofd.be') && (a.permissions.forOrganization(organization, platform, { inheritFromPlatform: false })?.hasFullAccess() || a.permissions.forOrganization(organization, platform, { inheritFromPlatform: false })?.hasAccessRight(AccessRight.OrganizationFinanceDirector)));
+
+        if (filtered.length > 0) {
+            return filtered.map(f => f.email)[0];
+        }
+        const filtered2 = admins.filter(a => a.verified && a.permissions && (a.permissions.forOrganization(organization, platform, { inheritFromPlatform: false })?.hasFullAccess() || a.permissions.forOrganization(organization, platform, { inheritFromPlatform: false })?.hasAccessRight(AccessRight.OrganizationFinanceDirector)));
+
+        if (filtered2.length > 0) {
+            return filtered2.map(f => f.email)[0];
+        }
+        return undefined;
+    }
+}

package/src/services/OrganizationDNSService.test.ts

@@ -0,0 +1,177 @@
+import { EmailMocker } from '@stamhoofd/email';
+import type { Organization } from '@stamhoofd/models';
+import { EmailTemplateFactory, OrganizationFactory, UserFactory } from '@stamhoofd/models';
+import { EmailTemplateType, PermissionLevel, Permissions } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { OrganizationDNSService } from './OrganizationDNSService.js';
+
+const validateDNSRecordsMock = vi.hoisted(() => vi.fn());
+
+vi.mock('@stamhoofd/models/helpers/DNSValidator.js', () => ({
+    validateDNSRecords: validateDNSRecordsMock,
+}));
+
+const templateTypes = [
+    EmailTemplateType.OrganizationStableDNS,
+    EmailTemplateType.OrganizationUnstableDNS,
+    EmailTemplateType.OrganizationValidDNS,
+    EmailTemplateType.OrganizationInvalidDNS,
+    EmailTemplateType.OrganizationDNSSetupComplete,
+];
+
+async function createTemplates() {
+    for (const type of templateTypes) {
+        await new EmailTemplateFactory({
+            type,
+            subject: type,
+            html: '<p>{{organizationName}} - {{mailDomain}}</p>',
+            text: '{{organizationName}} - {{mailDomain}}',
+        }).create();
+    }
+}
+
+async function createOrganizationWithAdmin(): Promise<Organization> {
+    const organization = await new OrganizationFactory({}).create();
+    await new UserFactory({
+        organization,
+        email: 'admin@example.com',
+        firstName: 'Ad',
+        lastName: 'Min',
+        permissions: Permissions.create({ level: PermissionLevel.Full }),
+    }).create();
+    return organization;
+}
+
+function daysAgo(days: number) {
+    return new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+}
+
+function setupEnvironment() {
+    TestUtils.setEnvironment('userMode', 'organization');
+
+    // The notification emails localize the marketing domain, which the shared test environment does not set
+    TestUtils.setEnvironment('domains', {
+        ...STAMHOOFD.domains,
+        marketing: { '': 'stamhoofd.dev', BE: 'be.stamhoofd.dev', NL: 'nl.stamhoofd.dev' },
+    });
+}
+
+describe('OrganizationDNSService.updateDNSRecords notifications', () => {
+    beforeAll(async () => {
+        await createTemplates();
+    });
+
+    beforeEach(() => {
+        setupEnvironment();
+        validateDNSRecordsMock.mockReset();
+    });
+
+    test('Sends the setup complete email the first time the mail domain becomes valid', async () => {
+        validateDNSRecordsMock.mockResolvedValue({ allValid: true, hasAllNonTXT: true });
+
+        const organization = await createOrganizationWithAdmin();
+        organization.privateMeta.pendingMailDomain = 'mail.example.com';
+        organization.privateMeta.mailDomainActive = false;
+        organization.serverMeta.didSendDomainSetupMail = false;
+        await organization.save();
+
+        await OrganizationDNSService.updateDNSRecords(organization);
+
+        const emails = await EmailMocker.transactional.getSucceededEmails();
+        expect(emails).toHaveLength(1);
+        expect(emails[0].subject).toBe(EmailTemplateType.OrganizationDNSSetupComplete);
+        expect(emails[0].to).toContain('admin@example.com');
+        expect(emails[0].html).toContain('mail.example.com');
+        expect(emails[0].html).toContain(organization.name);
+        expect(emails[0].bcc).toBeUndefined();
+
+        expect(organization.privateMeta.mailDomain).toBe('mail.example.com');
+        expect(organization.privateMeta.pendingMailDomain).toBe(null);
+        expect(organization.privateMeta.mailDomainActive).toBe(true);
+        expect(organization.serverMeta.didSendDomainSetupMail).toBe(true);
+    });
+
+    test('Sends the valid DNS email instead of the setup complete email once the setup email was sent before', async () => {
+        validateDNSRecordsMock.mockResolvedValue({ allValid: true, hasAllNonTXT: true });
+
+        const organization = await createOrganizationWithAdmin();
+        organization.privateMeta.pendingMailDomain = 'mail.example.com';
+        organization.privateMeta.mailDomainActive = false;
+        organization.serverMeta.didSendDomainSetupMail = true;
+        organization.serverMeta.DNSRecordWarningCount = 1;
+        await organization.save();
+
+        await OrganizationDNSService.updateDNSRecords(organization);
+
+        const emails = await EmailMocker.transactional.getSucceededEmails();
+        expect(emails).toHaveLength(1);
+        expect(emails[0].subject).toBe(EmailTemplateType.OrganizationValidDNS);
+        expect(emails[0].bcc).toBeUndefined();
+        expect(organization.serverMeta.DNSRecordWarningCount).toBe(0);
+    });
+
+    test('Sends the stable DNS email with a bcc when the DNS settings become stable again', async () => {
+        validateDNSRecordsMock.mockResolvedValue({ allValid: true, hasAllNonTXT: true });
+
+        const organization = await createOrganizationWithAdmin();
+        organization.serverMeta.isDNSUnstable = true;
+        organization.serverMeta.lastInvalidDNSDates = [];
+        await organization.save();
+
+        await OrganizationDNSService.updateDNSRecords(organization);
+
+        const emails = await EmailMocker.transactional.getSucceededEmails();
+        expect(emails).toHaveLength(1);
+        expect(emails[0].subject).toBe(EmailTemplateType.OrganizationStableDNS);
+        expect(emails[0].bcc).toContain('simon@stamhoofd.be');
+        expect(organization.serverMeta.isDNSUnstable).toBe(false);
+    });
+
+    test('Sends the unstable DNS email with a bcc when the DNS settings become unstable', async () => {
+        validateDNSRecordsMock.mockResolvedValue({ allValid: false, hasAllNonTXT: false });
+
+        const organization = await createOrganizationWithAdmin();
+        organization.privateMeta.mailDomain = 'mail.example.com';
+        organization.privateMeta.mailDomainActive = true;
+        organization.serverMeta.isDNSUnstable = false;
+        organization.serverMeta.firstInvalidDNSRecords = undefined;
+
+        // 4 earlier failures + the one of this run makes the DNS unstable
+        organization.serverMeta.lastInvalidDNSDates = [daysAgo(1), daysAgo(2), daysAgo(3), daysAgo(4)];
+        await organization.save();
+
+        await OrganizationDNSService.updateDNSRecords(organization);
+
+        const emails = await EmailMocker.transactional.getSucceededEmails();
+        expect(emails).toHaveLength(1);
+        expect(emails[0].subject).toBe(EmailTemplateType.OrganizationUnstableDNS);
+        expect(emails[0].bcc).toContain('simon@stamhoofd.be');
+
+        expect(organization.serverMeta.isDNSUnstable).toBe(true);
+        expect(organization.privateMeta.mailDomain).toBe(null);
+        expect(organization.privateMeta.pendingMailDomain).toBe('mail.example.com');
+        expect(organization.privateMeta.mailDomainActive).toBe(false);
+    });
+
+    test('Sends the invalid DNS email once when the DNS settings break without becoming unstable', async () => {
+        validateDNSRecordsMock.mockResolvedValue({ allValid: false, hasAllNonTXT: false });
+
+        const organization = await createOrganizationWithAdmin();
+        organization.privateMeta.mailDomain = 'mail.example.com';
+        organization.privateMeta.mailDomainActive = true;
+        organization.serverMeta.didSendDomainSetupMail = true;
+        organization.serverMeta.DNSRecordWarningCount = 0;
+        await organization.save();
+
+        await OrganizationDNSService.updateDNSRecords(organization);
+
+        const emails = await EmailMocker.transactional.getSucceededEmails();
+        expect(emails).toHaveLength(1);
+        expect(emails[0].subject).toBe(EmailTemplateType.OrganizationInvalidDNS);
+        expect(emails[0].bcc).toBeUndefined();
+        expect(organization.serverMeta.DNSRecordWarningCount).toBe(1);
+
+        await OrganizationDNSService.updateDNSRecords(organization);
+        expect(await EmailMocker.transactional.getSucceededEmails()).toHaveLength(1);
+    });
+});