@stamhoofd/models 2.78.4 → 2.79.0

package/src/models/Order.ts

@@ -253,29 +253,6 @@ export class Order extends QueryableModel {
             if (webshop) {
                 await this.setRelation(Order.webshop, webshop).updateTickets();
             }
-
-            // Send an email if the payment failed after 15 minutes being pending
-            // const difference = new Date().getTime() - this.createdAt.getTime()
-            // if (difference > 1000 * 60 * 30 && difference < 1000 * 60 * 60 * 24) {
-            //    if (payment && payment.method !== PaymentMethod.Transfer && payment.method !== PaymentMethod.PointOfSale) {
-            //        console.log('Marked order '+this.id+' as payment failed after ' + (difference / 1000 / 60).toFixed(1) + ' mins. Sending email.')
-            //        const webshop = await Webshop.getByID(this.webshopId)
-            //        if (!webshop) {
-            //            console.error("Missing organization or webshop for order "+this.id)
-            //            return
-            //        }
-            //        const { from, replyTo } = organization.getEmail(webshop.privateMeta.defaultEmailId, true)
-            //        await this.setRelation(Order.webshop, webshop.setRelation(Order.organization, organization)).sendEmailTemplate({
-            //            type: EmailTemplateType.OrderOnlinePaymentFailed,
-            //            from,
-            //            replyTo
-            //        })
-            //    } else {
-            //        console.log('Marked order '+this.id+' as payment failed after ' + (difference / 1000 / 60).toFixed(1) + ' mins. Payment method not matching.')
-            //    }
-            // } else {
-            //     console.log('Marked order '+this.id+' as payment failed after ' + (difference / 1000 / 60).toFixed(1) + ' mins. Not sending email.')
-            // }
         }
         else {
             this.markUpdated();
@@ -763,28 +740,18 @@ export class Order extends QueryableModel {
     }
 
     async sendPaidMail(this: Order & { webshop: Webshop & { organization: Organization } }) {
-        const organization = this.webshop.organization;
-        const { from, replyTo } = organization.getEmail(this.webshop.privateMeta.defaultEmailId, true);
-
         // 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 = this.webshop.meta.hasTickets;
 
         await this.sendEmailTemplate({
             type: hasTickets ? EmailTemplateType.TicketsReceivedTransfer : EmailTemplateType.OrderReceivedTransfer,
-            from,
-            replyTo,
         });
     }
 
     async sendTickets(this: Order & { webshop: Webshop & { organization: Organization } }) {
-        const organization = this.webshop.organization;
-        const { from, replyTo } = organization.getEmail(this.webshop.privateMeta.defaultEmailId, true);
-
         await this.sendEmailTemplate({
             type: EmailTemplateType.TicketsReceivedTransfer,
-            from,
-            replyTo,
         });
     }
 
@@ -894,8 +861,6 @@ export class Order extends QueryableModel {
 
     async sendEmailTemplate(this: Order & { webshop: Webshop & { organization: Organization } }, data: {
         type: EmailTemplateType;
-        from: string;
-        replyTo?: string;
         to?: Recipient;
     }) {
         // Never send an email for archived webshops
@@ -970,25 +935,16 @@ export class Order extends QueryableModel {
         await this.save();
 
         if (this.data.customer.email.length > 0) {
-            const webshop = this.webshop;
-            const organization = webshop.organization;
-
-            const { from, replyTo } = organization.getEmail(webshop.privateMeta.defaultEmailId, true);
-
             if (tickets.length > 0) {
                 // Also send a copy
                 if (payment && payment.method === PaymentMethod.PointOfSale) {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.TicketsConfirmationPOS,
-                        from,
-                        replyTo,
                     });
                 }
                 else {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.TicketsConfirmation,
-                        from,
-                        replyTo,
                     });
                 }
             }
@@ -998,31 +954,23 @@ export class Order extends QueryableModel {
                         // Also send a copy
                         await this.sendEmailTemplate({
                             type: EmailTemplateType.OrderConfirmationTransfer,
-                            from,
-                            replyTo,
                         });
                     }
                     else if (payment && payment.method === PaymentMethod.PointOfSale) {
                         await this.sendEmailTemplate({
                             type: EmailTemplateType.OrderConfirmationPOS,
-                            from,
-                            replyTo,
                         });
                     }
                     else {
                         // Also send a copy
                         await this.sendEmailTemplate({
                             type: EmailTemplateType.OrderConfirmationOnline,
-                            from,
-                            replyTo,
                         });
                     }
                 }
                 else {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.TicketsConfirmationTransfer,
-                        from,
-                        replyTo,
                     });
                 }
             }
@@ -1031,7 +979,6 @@ export class Order extends QueryableModel {
         if (this.webshop.privateMeta.notificationEmails) {
             const webshop = this.webshop;
             const organization = webshop.organization;
-            const { from, replyTo } = organization.getEmail(webshop.privateMeta.defaultEmailId, true);
             const i18n = organization.i18n;
 
             const webshopDashboardUrl = 'https://' + (STAMHOOFD.domains.dashboard ?? 'stamhoofd.app') + '/' + i18n.locale + '/webshops/' + Formatter.slug(webshop.meta.name) + '/orders';
@@ -1040,8 +987,6 @@ export class Order extends QueryableModel {
             for (const email of this.webshop.privateMeta.notificationEmails) {
                 await this.sendEmailTemplate({
                     type: EmailTemplateType.OrderNotification,
-                    from,
-                    replyTo,
                     to: Recipient.create({
                         email,
                         replacements: [

package/src/models/Organization.ts

@@ -1,5 +1,4 @@
 import { column, Database } from '@simonbackx/simple-database';
-import { DecodedRequest } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { I18n } from '@stamhoofd/backend-i18n';
 import { Email, EmailInterfaceRecipient } from '@stamhoofd/email';
@@ -12,7 +11,7 @@ import { v4 as uuidv4 } from 'uuid';
 
 import { QueueHandler } from '@stamhoofd/queues';
 import { validateDNSRecords } from '../helpers/DNSValidator';
-import { getEmailBuilderForTemplate } from '../helpers/EmailBuilder';
+import { sendEmailTemplate } from '../helpers/EmailBuilder';
 import { OrganizationServerMetaData } from '../structures/OrganizationServerMetaData';
 import { OrganizationRegistrationPeriod, StripeAccount } from './';
 
@@ -420,7 +419,6 @@ export class Organization extends QueryableModel {
     async sendEmailTemplate(data: {
         type: EmailTemplateType;
         personal?: boolean;
-        replyTo?: string;
         bcc?: boolean;
     }) {
         const recipients = await this.getAdminRecipients();
@@ -443,15 +441,13 @@ export class Organization extends QueryableModel {
         ];
 
         // Create e-mail builder
-        const builder = await getEmailBuilderForTemplate(this, {
+        await sendEmailTemplate(null, {
             replaceAll,
             recipients,
             template: {
                 type: data.type,
             },
-            from: Email.getInternalEmailFor(this.i18n),
-            singleBcc: data.bcc ? 'simon@stamhoofd.be' : undefined,
-            replyTo: data.replyTo,
+            singleBcc: data.bcc ? { email: 'simon@stamhoofd.be' } : undefined,
             type: 'transactional',
             defaultReplacements: [
                 Replacement.create({
@@ -462,10 +458,6 @@ export class Organization extends QueryableModel {
             unsubscribeType: 'marketing',
             fromStamhoofd: true,
         });
-
-        if (builder) {
-            Email.schedule(builder);
-        }
     }
 
     async deleteAWSMailIdenitity(mailDomain: string) {
@@ -855,99 +847,12 @@ export class Organization extends QueryableModel {
     /**
      * Return default e-mail address if no email addresses are set.
      */
-    getDefaultFrom(i18n: I18n, withName = true, type: 'transactional' | 'broadcast' = 'broadcast') {
+    getDefaultFrom(i18n: I18n, type: 'transactional' | 'broadcast' = 'broadcast'): EmailInterfaceRecipient {
         const domain = type === 'transactional' ? i18n.localizedDomains.defaultTransactionalEmail() : i18n.localizedDomains.defaultBroadcastEmail();
 
-        if (!withName) {
-            return ('noreply-' + this.uri + '@' + domain);
-        }
-        return '"' + this.name.replaceAll('"', '\\"') + '" <' + ('noreply-' + this.uri + '@' + domain) + '>';
-    }
-
-    /**
-     * @deprecated Switch to EmailBuilder.sendEmailTemplate
-     */
-    getEmail(id: string | null, strongDefault = false): { from: string; replyTo: string | undefined } {
-        if (id === null) {
-            return this.getDefaultEmail(strongDefault);
-        }
-
-        // Send confirmation e-mail
-        let from = this.getDefaultFrom(this.i18n, false, strongDefault ? 'transactional' : 'broadcast');
-        const sender: OrganizationEmail | undefined = this.privateMeta.emails.find(e => e.id === id);
-        let replyTo: string | undefined = undefined;
-
-        if (sender) {
-            replyTo = sender.email;
-
-            // Can we send from this e-mail or reply-to?
-            if (replyTo && this.privateMeta.mailDomain && this.privateMeta.mailDomainActive && sender.email.endsWith('@' + this.privateMeta.mailDomain)) {
-                from = sender.email;
-                replyTo = undefined;
-            }
-
-            // Include name in form field
-            if (sender.name) {
-                from = '"' + sender.name.replaceAll('"', '\\"') + '" <' + from + '>';
-            }
-            else {
-                from = '"' + this.name.replaceAll('"', '\\"') + '" <' + from + '>';
-            }
-
-            if (replyTo) {
-                if (sender.name) {
-                    replyTo = '"' + sender.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
-                }
-                else {
-                    replyTo = '"' + this.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
-                }
-            }
-            return { from, replyTo };
-        }
-        return this.getDefaultEmail(strongDefault);
-    }
-
-    /**
-     * @deprecated Switch to EmailBuilder.sendEmailTemplate
-     */
-    getDefaultEmail(strongDefault = false): { from: string; replyTo: string | undefined } {
-        // Send confirmation e-mail
-        let from = strongDefault ? this.getDefaultFrom(this.i18n, false) : this.uri + '@stamhoofd.email';
-        const sender: OrganizationEmail | undefined = this.privateMeta.emails.find(e => e.default) ?? this.privateMeta.emails[0];
-        let replyTo: string | undefined = undefined;
-
-        if (sender) {
-            replyTo = sender.email;
-
-            // Can we send from this e-mail or reply-to?
-            if (replyTo && this.privateMeta.mailDomain && this.privateMeta.mailDomainActive && sender.email.endsWith('@' + this.privateMeta.mailDomain)) {
-                from = sender.email;
-                replyTo = undefined;
-            }
-
-            // Include name in form field
-            if (sender.name) {
-                from = '"' + sender.name.replaceAll('"', '\\"') + '" <' + from + '>';
-            }
-            else {
-                from = '"' + this.name.replaceAll('"', '\\"') + '" <' + from + '>';
-            }
-
-            if (replyTo) {
-                if (sender.name) {
-                    replyTo = '"' + sender.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
-                }
-                else {
-                    replyTo = '"' + this.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
-                }
-            }
-        }
-        else {
-            from = '"' + this.name.replaceAll('"', '\\"') + '" <' + from + '>';
-        }
-
         return {
-            from, replyTo,
+            name: this.name,
+            email: ('noreply-' + this.uri + '@' + domain),
         };
     }
 

package/src/models/Platform.test.ts

@@ -0,0 +1,107 @@
+import { PlatformConfig, PlatformMembershipType } from '@stamhoofd/structures';
+import { Platform } from './Platform';
+import { Database } from '@simonbackx/simple-database';
+
+describe('Model.Platform', () => {
+    describe('Shared caches', () => {
+        beforeEach(async () => {
+            const platform = await Platform.getByID('1');
+            platform!.config = PlatformConfig.create({});
+            await platform!.save();
+        });
+
+        test('Editable model changes do not propagate', async () => {
+            const editable = await Platform.getForEditing();
+            editable.config.membershipTypes = [
+                PlatformMembershipType.create({ id: '1', name: 'Test' }),
+            ];
+
+            const shared = (await Platform.getShared()) as any;
+            expect(shared.config.membershipTypes).toHaveLength(0);
+        });
+
+        test('Shared model is immutable', async () => {
+            const editable = await Platform.getForEditing();
+            editable.config.membershipTypes = [
+                PlatformMembershipType.create({ id: '1', name: 'Test' }),
+            ];
+            await editable.save();
+
+            const shared = (await Platform.getShared()) as any;
+            expect(() => {
+                shared.privateConfig.roles = [];
+            }).toThrow();
+
+            expect(() => {
+                shared.membershipOrganizationId = '2';
+            }).toThrow();
+
+            expect(shared.config.membershipTypes).toHaveLength(1);
+
+            expect(() => {
+                shared.concat.membershipTypes[0].name = 'Test2';
+            }).toThrow();
+        });
+
+        test('Saving changes propagates to all shared states', async () => {
+            const structBefore = await Platform.getSharedStruct();
+            const privateStructBefore = await Platform.getSharedPrivateStruct();
+            const sharedModelBefore = await Platform.getShared();
+
+            const editable = await Platform.getForEditing();
+            editable.config.membershipTypes = [
+                PlatformMembershipType.create({ id: '1', name: 'Hey there' }),
+            ];
+            await editable.save();
+
+            const structAfter = await Platform.getSharedStruct();
+            const privateStructAfter = await Platform.getSharedPrivateStruct();
+            const sharedModelAfter = await Platform.getShared();
+
+            expect(structAfter.config.membershipTypes[0].name).toEqual('Hey there');
+            expect(privateStructAfter.config.membershipTypes[0].name).toEqual('Hey there');
+            expect(sharedModelAfter.config.membershipTypes[0].name).toEqual('Hey there');
+
+            // Test before state not altered
+            expect(structBefore.config.membershipTypes).toHaveLength(0);
+            expect(privateStructBefore.config.membershipTypes).toHaveLength(0);
+            expect(sharedModelBefore.config.membershipTypes).toHaveLength(0);
+        });
+    });
+
+    describe('Creating fresh platform', () => {
+        beforeEach(async () => {
+            await Database.delete('DELETE FROM platform');
+            await Platform.clearCacheWithoutRefresh();
+            if (await Platform.getByID('1')) {
+                throw new Error('Platform 1 should not exist');
+            }
+        });
+
+        test('when requesting getForEditing', async () => {
+            const editable = await Platform.getForEditing();
+            expect(editable.id).toBe('1');
+
+            expect(await Platform.getByID('1')).toEqual(editable);
+        });
+
+        test('when requesting getShared', async () => {
+            const shared = await Platform.getShared();
+            expect(shared.id).toBe('1');
+
+            expect(await Platform.getByID('1')).toMatchObject(shared);
+        });
+
+        test('when requesting getSharedPrivateStruct', async () => {
+            const editable = await Platform.getSharedPrivateStruct();
+            expect(editable).toBeDefined();
+            expect(await Platform.getByID('1')).toBeDefined();
+        });
+
+        test('when requesting getSharedStruct', async () => {
+            const editable = await Platform.getSharedStruct();
+            expect(editable).toBeDefined();
+            expect(await Platform.getByID('1')).toBeDefined();
+        });
+    });
+});

package/src/models/Platform.ts

@@ -2,6 +2,7 @@ import { column } from '@simonbackx/simple-database';
 import { QueueHandler } from '@stamhoofd/queues';
 import { QueryableModel } from '@stamhoofd/sql';
 import { PlatformConfig, PlatformPrivateConfig, PlatformServerConfig, Platform as PlatformStruct } from '@stamhoofd/structures';
+import { deepFreeze } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from 'uuid';
 import { RegistrationPeriod } from './RegistrationPeriod';
 
@@ -36,15 +37,20 @@ export class Platform extends QueryableModel {
     @column({ type: 'json', decoder: PlatformServerConfig })
     serverConfig: PlatformServerConfig = PlatformServerConfig.create({});
 
-    static sharedStruct: PlatformStruct | null = null;
+    private static shared: Platform | null = null;
+    private static sharedPrivateStruct: PlatformStruct & { privateConfig: PlatformPrivateConfig } | null = null;
+    private static sharedStruct: PlatformStruct | null = null;
 
     static async getSharedStruct(): Promise<PlatformStruct> {
-        const struct: PlatformStruct = await this.getSharedPrivateStruct();
-        const clone = struct.clone();
-        clone.privateConfig = null;
-        clone.setShared();
+        if (!this.sharedStruct) {
+            await this.loadCaches();
+        }
 
-        return clone;
+        if (!this.sharedStruct || !!this.sharedStruct.privateConfig) {
+            throw new Error('[Platform] Failed to load platform shared struct');
+        }
+
+        return this.sharedStruct;
     }
 
     async setPreviousPeriodId() {
@@ -53,28 +59,24 @@ export class Platform extends QueryableModel {
     }
 
     static async getSharedPrivateStruct(): Promise<PlatformStruct & { privateConfig: PlatformPrivateConfig }> {
-        if (this.sharedStruct && this.sharedStruct.privateConfig) {
-            return this.sharedStruct as any;
+        if (!this.sharedPrivateStruct) {
+            await this.loadCaches();
         }
 
-        return await QueueHandler.schedule('Platform.getSharedStruct', async () => {
-            const model = await this.getShared();
-            const period = await RegistrationPeriod.getByID(model.periodId);
-            const struct = PlatformStruct.create({
-                ...model,
-                period: period?.getStructure() ?? undefined,
-            });
-            this.sharedStruct = struct;
+        if (!this.sharedPrivateStruct || !this.sharedPrivateStruct.privateConfig) {
+            throw new Error('[Platform] Failed to load platform shared private struct');
+        }
 
-            return struct as any;
-        });
+        return this.sharedPrivateStruct;
     }
 
-    static async getShared(): Promise<Platform> {
-        return QueueHandler.schedule('Platform.getShared', async () => {
+    static async getForEditing(): Promise<Platform> {
+        return QueueHandler.schedule('Platform.getModel', async () => {
             // Build a new one
             let model = await this.getByID('1');
             if (!model) {
+                console.info('[Platform] Creating new platform');
+
                 // Create a new platform
                 model = new Platform();
                 model.id = '1';
@@ -86,16 +88,75 @@ export class Platform extends QueryableModel {
         });
     }
 
-    static clearCache() {
-        this.sharedStruct = null;
+    static async getShared(): Promise<Readonly<Platform> & { save: never }> {
+        return QueueHandler.schedule('Platform.getShared', async () => {
+            if (this.shared) {
+                return this.shared;
+            }
+
+            // Build a new one
+            const model = await this.getForEditing();
+            deepFreeze(model);
+            this.shared = model;
+            return model as any;
+        });
+    }
+
+    static async loadCaches(): Promise<void> {
+        await QueueHandler.schedule('Platform.loadCaches', async () => {
+            if (this.sharedPrivateStruct && this.sharedStruct) {
+                // Already loaded (possible if multiple calls to loadCaches were made)
+                return;
+            }
+            // Build a new one
+            const model = await this.getForEditing();
+            await this.setCachesFromModel(model);
+        });
+    }
+
+    private static async setCachesFromModel(model: Platform) {
+        // Set structure cache
+        const period = await RegistrationPeriod.getByID(model.periodId);
+        const struct = PlatformStruct.create({
+            ...model,
+            period: period?.getStructure() ?? undefined,
+        });
+
+        // We clone to avoid the chance of updating the platform model
+        this.sharedPrivateStruct = struct.clone() as PlatformStruct & { privateConfig: PlatformPrivateConfig };
+
+        const clone = struct.clone();
+        clone.privateConfig = null;
+        clone.setShared();
+        this.sharedStruct = clone;
+    }
+
+    static async clearCache() {
+        await this.clearCacheWithoutRefresh();
+        await this.loadCaches();
+    }
+
+    static async clearCacheWithoutRefresh() {
+        await QueueHandler.schedule('Platform.loadCaches', async () => {
+            this.sharedStruct = null;
+            this.sharedPrivateStruct = null;
+        });
+        await QueueHandler.schedule('Platform.getShared', async () => {
+            this.shared = null;
+        });
     }
 
     async save() {
+        let update = false;
+        if (this.existsInDatabase) {
+            update = true;
+        }
         const s = await super.save();
-        Platform.clearCache();
 
-        // Force update cache immediately
-        await Platform.getSharedStruct();
+        if (update) {
+            // Force update cache immediately
+            await Platform.clearCache();
+        }
 
         return s;
     }

package/src/models/index.ts

@@ -2,7 +2,7 @@ export { Organization } from './Organization';
 export { User } from './User';
 export { Payment } from './Payment';
 export { Registration } from './Registration';
-export { Member, RegistrationWithMember, MemberWithRegistrations } from './Member';
+export * from './Member';
 export { MergedMember } from './MergedMember';
 
 export * from './EmailVerificationCode';