@stamhoofd/models 2.39.0 → 2.40.0

package/src/models/Organization.ts

@@ -1,123 +1,122 @@
-import { column, Database, Model } from "@simonbackx/simple-database";
+import { column, Database, Model } 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";
-import { Address, Country, DNSRecordStatus, EmailTemplateType, OrganizationEmail, OrganizationMetaData, OrganizationPrivateMetaData, Organization as OrganizationStruct, PaymentMethod, PaymentProvider, PrivatePaymentConfiguration, Recipient, Replacement, STPackageType, TransferSettings } from "@stamhoofd/structures";
+import { I18n } from '@stamhoofd/backend-i18n';
+import { Email, EmailInterfaceRecipient } from '@stamhoofd/email';
+import { Address, Country, DNSRecordStatus, EmailTemplateType, OrganizationEmail, OrganizationMetaData, OrganizationPrivateMetaData, Organization as OrganizationStruct, PaymentMethod, PaymentProvider, PrivatePaymentConfiguration, Recipient, Replacement, STPackageType, TransferSettings } from '@stamhoofd/structures';
 import { AWSError } from 'aws-sdk';
 import SES from 'aws-sdk/clients/sesv2';
 import { PromiseResult } from 'aws-sdk/lib/request';
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv4 } from 'uuid';
 
-import { QueueHandler } from "@stamhoofd/queues";
-import { validateDNSRecords } from "../helpers/DNSValidator";
-import { getEmailBuilderForTemplate } from "../helpers/EmailBuilder";
+import { QueueHandler } from '@stamhoofd/queues';
+import { validateDNSRecords } from '../helpers/DNSValidator';
+import { getEmailBuilderForTemplate } from '../helpers/EmailBuilder';
 import { OrganizationServerMetaData } from '../structures/OrganizationServerMetaData';
-import { OrganizationRegistrationPeriod, StripeAccount } from "./";
+import { OrganizationRegistrationPeriod, StripeAccount } from './';
 
 export class Organization extends Model {
-    static table = "organizations";
+    static table = 'organizations';
 
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     name: string;
 
     /// URL to a website page or a Facebook page (including http)
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     website: string | null = null;
 
     /// A custom domain name that is used to host the register application (should be unique)
     // E.g. inschrijven.scoutswetteren.be
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     registerDomain: string | null = null;
 
     // Unique representation of this organization from a string, that is used to provide the default domains
     // in uri.stamhoofd.be
-    @column({ type: "string" })
+    @column({ type: 'string' })
     uri: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     periodId: string;
 
     /**
      * Public meta data
      */
-    @column({ type: "json", decoder: OrganizationMetaData })
+    @column({ type: 'json', decoder: OrganizationMetaData })
     meta: OrganizationMetaData;
 
     /**
      * Data only accessible by the owners / users with special permissions
      */
-    @column({ type: "json", decoder: OrganizationPrivateMetaData })
-    privateMeta: OrganizationPrivateMetaData = OrganizationPrivateMetaData.create({})
+    @column({ type: 'json', decoder: OrganizationPrivateMetaData })
+    privateMeta: OrganizationPrivateMetaData = OrganizationPrivateMetaData.create({});
 
     /**
      * Data only accessible by the server
      */
-    @column({ type: "json", decoder: OrganizationServerMetaData })
-    serverMeta: OrganizationServerMetaData = OrganizationServerMetaData.create({})
+    @column({ type: 'json', decoder: OrganizationServerMetaData })
+    serverMeta: OrganizationServerMetaData = OrganizationServerMetaData.create({});
 
-    @column({ type: "json", decoder: Address })
+    @column({ type: 'json', decoder: Address })
     address: Address;
 
     @column({
-        type: "string", beforeSave: function (this: Organization) {
-            return this.name+"\n"+this.address.toString()
-        }
+        type: 'string', beforeSave: function (this: Organization) {
+            return this.name + '\n' + this.address.toString();
+        },
     })
-    searchIndex: string
+    searchIndex: string;
 
     @column({
-        type: "datetime", beforeSave(old?: any) {
+        type: 'datetime', beforeSave(old?: any) {
             if (old !== undefined) {
                 return old;
             }
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
-        }
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
+        },
     })
-    createdAt: Date
+    createdAt: Date;
 
     @column({
-        type: "datetime", beforeSave() {
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
+        type: 'datetime', beforeSave() {
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
         },
-        skipUpdate: true
+        skipUpdate: true,
     })
-    updatedAt: Date
+    updatedAt: Date;
 
-    @column({type: 'boolean'})
+    @column({ type: 'boolean' })
     active = true;
 
     /**
      * Return default locale confiruation
      */
     get i18n() {
-        return new I18n("nl", this.address.country)
+        return new I18n('nl', this.address.country);
     }
 
     /**
      * Makes sure empty name is replaced with organization name
      */
     get mappedTransferSettings(): TransferSettings {
-        return this.meta.transferSettings.fillMissing(TransferSettings.create({creditor: this.name}));
+        return this.meta.transferSettings.fillMissing(TransferSettings.create({ creditor: this.name }));
     }
 
-
     // Methods
     static async getByURI(uri: string): Promise<Organization | undefined> {
         const [rows] = await Database.select(
             `SELECT ${this.getDefaultSelect()} FROM ${this.table} WHERE \`uri\` = ? LIMIT 1`,
-            [uri]
+            [uri],
         );
 
         if (rows.length == 0) {
@@ -132,25 +131,25 @@ export class Organization extends Model {
     static async getByEmail(email: string): Promise<Organization | undefined> {
         if (email.startsWith('noreply-')) {
             // Trim
-            email = email.substring("noreply-".length)
+            email = email.substring('noreply-'.length);
         }
-        
+
         for (const domain of [
             ...Object.values(STAMHOOFD.domains.defaultBroadcastEmail ?? {}),
             ...Object.values(STAMHOOFD.domains.defaultTransactionalEmail ?? {}),
         ]) {
-            if (email.endsWith("@" + domain)) {
-                const uri = email.substring(0, email.length - ("@" + domain).length)
-                return await Organization.getByURI(uri)
+            if (email.endsWith('@' + domain)) {
+                const uri = email.substring(0, email.length - ('@' + domain).length);
+                return await Organization.getByURI(uri);
             }
         }
 
-        const at = email.indexOf("@");
-        const domain = email.substring(at+1)
+        const at = email.indexOf('@');
+        const domain = email.substring(at + 1);
 
         const [rows] = await Database.select(
             `SELECT ${this.getDefaultSelect()} FROM ${this.table} WHERE privateMeta->"$.value.mailDomain" = ? LIMIT 1`,
-            [domain]
+            [domain],
         );
 
         if (rows.length == 0) {
@@ -161,13 +160,11 @@ export class Organization extends Model {
         return this.fromRow(rows[0][this.table]);
     }
 
-    
-
     // Methods
     static async getByRegisterDomain(host: string): Promise<Organization | undefined> {
         const [rows] = await Database.select(
             `SELECT ${this.getDefaultSelect()} FROM ${this.table} WHERE \`registerDomain\` = ? LIMIT 1`,
-            [host]
+            [host],
         );
 
         if (rows.length == 0) {
@@ -186,38 +183,38 @@ export class Organization extends Model {
     static async getFromRequest(request: DecodedRequest<any, any, any>): Promise<Organization> {
         const organization = await Organization.fromApiHost(request.host);
 
-        const i18n = I18n.fromRequest(request)
-        i18n.switchToLocale({ country: organization.address.country })
+        const i18n = I18n.fromRequest(request);
+        i18n.switchToLocale({ country: organization.address.country });
 
-        return organization
+        return organization;
     }
 
     /**
      * Get an Organization by looking at the host of a request
      * Format is 2331c59a-0cbe-4279-871c-ea9d0474cd54.api.stamhoofd.app
      */
-    static async fromApiHost(host: string, options?: {allowInactive?: boolean}): Promise<Organization> {
-        const splitted = host.split('.')
+    static async fromApiHost(host: string, options?: { allowInactive?: boolean }): Promise<Organization> {
+        const splitted = host.split('.');
         if (splitted.length < 2) {
             throw new SimpleError({
-                code: "invalid_host",
-                message: "Please specify the organization in the hostname",
+                code: 'invalid_host',
+                message: 'Please specify the organization in the hostname',
             });
         }
-        const id = splitted[0]
+        const id = splitted[0];
         const organization = await this.getByID(id);
         if (!organization) {
             throw new SimpleError({
-                code: "invalid_organization",
-                message: "No organization known for host " + host,
+                code: 'invalid_organization',
+                message: 'No organization known for host ' + host,
             });
         }
 
         if (!organization.active && !options?.allowInactive) {
             throw new SimpleError({
-                code: "archived",
-                message: "This organization is archived",
-                human: 'Deze groep is gearchiveerd'
+                code: 'archived',
+                message: 'This organization is archived',
+                human: 'Deze groep is gearchiveerd',
             });
         }
         return organization;
@@ -230,73 +227,74 @@ export class Organization extends Model {
         if (this.registerDomain) {
             let d = this.registerDomain;
 
-            if (i18n && i18n.language != this.i18n.language) {
-                d += "/"+i18n.language
+            if (i18n && i18n.language !== this.i18n.language) {
+                d += '/' + i18n.language;
             }
 
             return d;
         }
-        return this.getDefaultHost(i18n)
+        return this.getDefaultHost(i18n);
     }
 
     getDefaultHost(i18n?: I18n): string {
         if (!STAMHOOFD.domains.registration) {
             return STAMHOOFD.domains.dashboard + '/' + (i18n?.locale ?? this.i18n.locale) + '/leden/' + this.uri;
         }
-        let defaultDomain = STAMHOOFD.domains.registration[this.address.country] ?? STAMHOOFD.domains.registration[""];
+        let defaultDomain = STAMHOOFD.domains.registration[this.address.country] ?? STAMHOOFD.domains.registration[''];
 
-        if (i18n && i18n.language != this.i18n.language) {
-            defaultDomain += "/"+i18n.language
+        if (i18n && i18n.language !== this.i18n.language) {
+            defaultDomain += '/' + i18n.language;
         }
 
-        return this.uri + "." + defaultDomain;
+        return this.uri + '.' + defaultDomain;
     }
 
     get marketingDomain(): string {
-        return STAMHOOFD.domains.marketing[this.address.country] ?? STAMHOOFD.domains.marketing[""];
+        return STAMHOOFD.domains.marketing[this.address.country] ?? STAMHOOFD.domains.marketing[''];
     }
 
     getApiHost(): string {
         const defaultDomain = STAMHOOFD.domains.api;
         if (!defaultDomain) {
-            throw new Error("Missing hostname in environment")
+            throw new Error('Missing hostname in environment');
         }
-        return this.id+"." + defaultDomain;
+        return this.id + '.' + defaultDomain;
     }
 
-    private _cachedPeriod?: OrganizationRegistrationPeriod
+    private _cachedPeriod?: OrganizationRegistrationPeriod;
 
     async getPeriod() {
         if (this._cachedPeriod) {
             return this._cachedPeriod;
         }
 
-        const oPeriods = await OrganizationRegistrationPeriod.where({ periodId: this.periodId, organizationId: this.id }, {limit: 1})
-        
+        const oPeriods = await OrganizationRegistrationPeriod.where({ periodId: this.periodId, organizationId: this.id }, { limit: 1 });
+
         let oPeriod: OrganizationRegistrationPeriod;
         if (oPeriods.length == 0) {
             // Automatically create a period
             oPeriod = await QueueHandler.schedule('create-missing-organization-period', async () => {
                 // Race condition check
-                const updatedPeriods =  await OrganizationRegistrationPeriod.where({ periodId: this.periodId, organizationId: this.id }, {limit: 1})
+                const updatedPeriods = await OrganizationRegistrationPeriod.where({ periodId: this.periodId, organizationId: this.id }, { limit: 1 });
 
                 if (updatedPeriods.length) {
-                    return updatedPeriods[0]
+                    return updatedPeriods[0];
                 }
 
-                console.log('Automatically creating new organization registration period for organization ' + this.id + ' and period ' + this.periodId + ' - organization period is missing')
-                const created = new OrganizationRegistrationPeriod()
-                created.organizationId = this.id
-                created.periodId = this.periodId
-                await created.save()
-                return created
-            })
-        } else {
+                console.log('Automatically creating new organization registration period for organization ' + this.id + ' and period ' + this.periodId + ' - organization period is missing');
+                const created = new OrganizationRegistrationPeriod();
+                created.organizationId = this.id;
+                created.periodId = this.periodId;
+                await created.save();
+                return created;
+            });
+        }
+        else {
             oPeriod = oPeriods[0];
         }
 
-        this._cachedPeriod = oPeriod
-        return oPeriod
+        this._cachedPeriod = oPeriod;
+        return oPeriod;
     }
 
     getBaseStructure(): OrganizationStruct {
@@ -310,147 +308,151 @@ export class Organization extends Model {
             uri: this.uri,
             website: this.website,
             createdAt: this.createdAt,
-        })
+        });
     }
 
     async updateDNSRecords() {
         const organization = this;
 
         // Check initial status
-        let isValidRecords = true
+        let isValidRecords = true;
         for (const record of organization.privateMeta.dnsRecords) {
-            if (record.status != DNSRecordStatus.Valid) {
-                isValidRecords = false
+            if (record.status !== DNSRecordStatus.Valid) {
+                isValidRecords = false;
             }
         }
-        
-       const { allValid } = await validateDNSRecords(organization.privateMeta.dnsRecords)
 
-       if (organization.registerDomain ?? organization.privateMeta.pendingRegisterDomain) {
-            const registerDomainRecord = (organization.privateMeta.pendingRegisterDomain ?? organization.registerDomain)+"."
-            const records = organization.privateMeta.dnsRecords.filter(r => r.name === registerDomainRecord)
-            const areRegisterDomainRecordsValid = records.length === 0 || records.every(r => r.status === DNSRecordStatus.Valid)
+        const { allValid } = await validateDNSRecords(organization.privateMeta.dnsRecords);
+
+        if (organization.registerDomain ?? organization.privateMeta.pendingRegisterDomain) {
+            const registerDomainRecord = (organization.privateMeta.pendingRegisterDomain ?? organization.registerDomain) + '.';
+            const records = organization.privateMeta.dnsRecords.filter(r => r.name === registerDomainRecord);
+            const areRegisterDomainRecordsValid = records.length === 0 || records.every(r => r.status === DNSRecordStatus.Valid);
 
             if (areRegisterDomainRecordsValid) {
                 // We can setup the register domain if needed
                 if (organization.privateMeta.pendingRegisterDomain !== null) {
-                    organization.registerDomain = organization.privateMeta.pendingRegisterDomain
+                    organization.registerDomain = organization.privateMeta.pendingRegisterDomain;
                     organization.privateMeta.pendingRegisterDomain = null;
 
-                    console.log("Did set register domain for "+this.id+" to "+organization.registerDomain)
+                    console.log('Did set register domain for ' + this.id + ' to ' + organization.registerDomain);
                 }
-            } else {
+            }
+            else {
                 // Clear register domain
                 if (organization.registerDomain) {
                     // We need to clear it, to prevent sending e-mails with invalid links
-                    organization.privateMeta.pendingRegisterDomain = organization.privateMeta.pendingRegisterDomain ?? organization.registerDomain
-                    organization.registerDomain = null
+                    organization.privateMeta.pendingRegisterDomain = organization.privateMeta.pendingRegisterDomain ?? organization.registerDomain;
+                    organization.registerDomain = null;
 
-                    console.log("Cleared register domain for "+this.id+" because of invalid non txt records")
+                    console.log('Cleared register domain for ' + this.id + ' because of invalid non txt records');
                 }
             }
         }
 
         if (allValid) {
             if (organization.privateMeta.pendingMailDomain !== null) {
-                organization.privateMeta.mailDomain = organization.privateMeta.pendingMailDomain
+                organization.privateMeta.mailDomain = organization.privateMeta.pendingMailDomain;
                 organization.privateMeta.pendingMailDomain = null;
             }
 
-            const wasUnstable = organization.serverMeta.isDNSUnstable
-            organization.serverMeta.markDNSValid()
+            const wasUnstable = organization.serverMeta.isDNSUnstable;
+            organization.serverMeta.markDNSValid();
 
-            const didSendDomainSetupMail = organization.serverMeta.didSendDomainSetupMail
-            const didSendWarning = organization.serverMeta.DNSRecordWarningCount > 0
-            organization.serverMeta.DNSRecordWarningCount = 0
+            const didSendDomainSetupMail = organization.serverMeta.didSendDomainSetupMail;
+            const didSendWarning = organization.serverMeta.DNSRecordWarningCount > 0;
+            organization.serverMeta.DNSRecordWarningCount = 0;
 
-            const wasActive = this.privateMeta.mailDomainActive
-            await this.updateAWSMailIdenitity()
+            const wasActive = this.privateMeta.mailDomainActive;
+            await this.updateAWSMailIdenitity();
 
             // yay! Do not Save until after doing AWS changes
-            await organization.save()
+            await organization.save();
 
             if (wasUnstable && !organization.serverMeta.isDNSUnstable) {
-                console.warn('DNS settings became stable for ' + this.name + ' '+this.id)
+                console.warn('DNS settings became stable for ' + this.name + ' ' + this.id);
 
                 await this.sendEmailTemplate({
                     type: EmailTemplateType.OrganizationStableDNS,
-                    bcc: true
-                })
-
-            } else if (!wasActive && this.privateMeta.mailDomainActive && (!didSendDomainSetupMail || didSendWarning) && !organization.serverMeta.isDNSUnstable) {
-                organization.serverMeta.didSendDomainSetupMail = true
-                await organization.save()
+                    bcc: true,
+                });
+            }
+            else if (!wasActive && this.privateMeta.mailDomainActive && (!didSendDomainSetupMail || didSendWarning) && !organization.serverMeta.isDNSUnstable) {
+                organization.serverMeta.didSendDomainSetupMail = true;
+                await organization.save();
 
                 if (!didSendDomainSetupMail) {
                     await this.sendEmailTemplate({
-                        type: EmailTemplateType.OrganizationDNSSetupComplete
-                    })
-                } else {
+                        type: EmailTemplateType.OrganizationDNSSetupComplete,
+                    });
+                }
+                else {
                     await this.sendEmailTemplate({
-                        type: EmailTemplateType.OrganizationValidDNS
-                    })
+                        type: EmailTemplateType.OrganizationValidDNS,
+                    });
                 }
             }
-        } else {
+        }
+        else {
             // DNS settings gone broken
             if (organization.privateMeta.mailDomain) {
-                organization.privateMeta.pendingMailDomain = organization.privateMeta.pendingMailDomain ?? organization.privateMeta.mailDomain
-                organization.privateMeta.mailDomain = null
+                organization.privateMeta.pendingMailDomain = organization.privateMeta.pendingMailDomain ?? organization.privateMeta.mailDomain;
+                organization.privateMeta.mailDomain = null;
             }
 
-            const wasDNSUnstable = organization.serverMeta.isDNSUnstable
+            const wasDNSUnstable = organization.serverMeta.isDNSUnstable;
 
-            organization.serverMeta.markDNSFailure()
+            organization.serverMeta.markDNSFailure();
 
             // disable AWS emails
-            this.privateMeta.mailDomainActive = false
+            this.privateMeta.mailDomainActive = false;
 
             // save
-            await organization.save()
+            await organization.save();
 
             if (!wasDNSUnstable && organization.serverMeta.isDNSUnstable) {
                 // DNS became instable
-                console.warn('DNS settings became instable for ' + this.name + ' '+this.id)
+                console.warn('DNS settings became instable for ' + this.name + ' ' + this.id);
 
                 await this.sendEmailTemplate({
                     type: EmailTemplateType.OrganizationUnstableDNS,
-                    bcc: true
-                })
-            } else if (!organization.serverMeta.isDNSUnstable && organization.serverMeta.didSendDomainSetupMail && organization.serverMeta.DNSRecordWarningCount == 0) {
-                organization.serverMeta.DNSRecordWarningCount += 1
-                await organization.save()
+                    bcc: true,
+                });
+            }
+            else if (!organization.serverMeta.isDNSUnstable && organization.serverMeta.didSendDomainSetupMail && organization.serverMeta.DNSRecordWarningCount == 0) {
+                organization.serverMeta.DNSRecordWarningCount += 1;
+                await organization.save();
 
                 await this.sendEmailTemplate({
-                    type: EmailTemplateType.OrganizationInvalidDNS
-                })
+                    type: EmailTemplateType.OrganizationInvalidDNS,
+                });
             }
         }
     }
 
     async sendEmailTemplate(data: {
-        type: EmailTemplateType,
-        personal?: boolean,
-        replyTo?: string,
-        bcc?: boolean
+        type: EmailTemplateType;
+        personal?: boolean;
+        replyTo?: string;
+        bcc?: boolean;
     }) {
         const recipients = await this.getAdminRecipients();
-        const defaultI18n = new I18n("nl", Country.Belgium)
+        const defaultI18n = new I18n('nl', Country.Belgium);
         const i18n = this.i18n;
 
         const replaceAll = [
             {
                 from: defaultI18n.localizedDomains.marketing(),
-                to: i18n.localizedDomains.marketing()
+                to: i18n.localizedDomains.marketing(),
             },
             {
-                from: defaultI18n.$t("59b85264-c4c3-4cf6-8923-9b43282b2787"),
-                to: i18n.$t("59b85264-c4c3-4cf6-8923-9b43282b2787")
+                from: defaultI18n.$t('59b85264-c4c3-4cf6-8923-9b43282b2787'),
+                to: i18n.$t('59b85264-c4c3-4cf6-8923-9b43282b2787'),
             },
             {
-                from: defaultI18n.$t("6b3555a2-ace4-4f37-a1fd-18921552f2b5"),
-                to: i18n.$t("6b3555a2-ace4-4f37-a1fd-18921552f2b5")
-            }
+                from: defaultI18n.$t('6b3555a2-ace4-4f37-a1fd-18921552f2b5'),
+                to: i18n.$t('6b3555a2-ace4-4f37-a1fd-18921552f2b5'),
+            },
         ];
 
         // Create e-mail builder
@@ -458,7 +460,7 @@ export class Organization extends Model {
             replaceAll,
             recipients,
             template: {
-                type: data.type
+                type: data.type,
             },
             from: data.personal ? Email.getPersonalEmailFor(this.i18n) : Email.getInternalEmailFor(this.i18n),
             singleBcc: data.bcc ? 'simon@stamhoofd.be' : undefined,
@@ -467,26 +469,25 @@ export class Organization extends Model {
             defaultReplacements: [
                 Replacement.create({
                     token: 'mailDomain',
-                    value: this.privateMeta.mailDomain ?? this.privateMeta.pendingMailDomain ?? ''
-                })
+                    value: this.privateMeta.mailDomain ?? this.privateMeta.pendingMailDomain ?? '',
+                }),
             ],
             unsubscribeType: 'marketing',
-            fromStamhoofd: true
-        })
+            fromStamhoofd: true,
+        });
 
         if (builder) {
-            Email.schedule(builder)
+            Email.schedule(builder);
         }
     }
 
     async deleteAWSMailIdenitity(mailDomain: string) {
-
         // Protect specific domain names
-        if (["stamhoofd.be", "stamhoofd.nl", "stamhoofd.shop", "stamhoofd.app", "stamhoofd.email"].includes(mailDomain)) {
-            return
+        if (['stamhoofd.be', 'stamhoofd.nl', 'stamhoofd.shop', 'stamhoofd.app', 'stamhoofd.email'].includes(mailDomain)) {
+            return;
         }
 
-        if (STAMHOOFD.environment != "production") {
+        if (STAMHOOFD.environment !== 'production') {
             // Temporary ignore this
             return;
         }
@@ -494,30 +495,30 @@ export class Organization extends Model {
         const sesv2 = new SES();
 
         // Check if mail identitiy already exists..
-        let exists = false
-        let existing: PromiseResult<SES.GetEmailIdentityResponse, AWSError> | undefined = undefined
+        let exists = false;
+        let existing: PromiseResult<SES.GetEmailIdentityResponse, AWSError> | undefined = undefined;
         try {
             existing = await sesv2.getEmailIdentity({
-                EmailIdentity: mailDomain
-            }).promise()
-            exists = true
+                EmailIdentity: mailDomain,
+            }).promise();
+            exists = true;
 
             // Check if DKIM keys are the same
             if (existing.VerifiedForSendingStatus === true) {
-                console.log("Cant delete AWS mail idenitiy @"+this.id+" for "+mailDomain+": already validated and might be in use by other organizations")
-                return
+                console.log('Cant delete AWS mail idenitiy @' + this.id + ' for ' + mailDomain + ': already validated and might be in use by other organizations');
+                return;
             }
 
-            console.log("Deleting AWS mail idenitiy @"+this.id+" for "+mailDomain)
+            console.log('Deleting AWS mail idenitiy @' + this.id + ' for ' + mailDomain);
 
             await sesv2.deleteEmailIdentity({
-                EmailIdentity: mailDomain
-            }).promise()
-            console.log("Deleted AWS mail idenitiy @"+this.id+" for "+this.privateMeta.mailDomain)
-
-        } catch (e) {
-            console.error("Could not delete AWS email identitiy @"+this.id+" for "+this.privateMeta.mailDomain)
-            console.error(e)
+                EmailIdentity: mailDomain,
+            }).promise();
+            console.log('Deleted AWS mail idenitiy @' + this.id + ' for ' + this.privateMeta.mailDomain);
+        }
+        catch (e) {
+            console.error('Could not delete AWS email identitiy @' + this.id + ' for ' + this.privateMeta.mailDomain);
+            console.error(e);
         }
     }
 
@@ -530,13 +531,13 @@ export class Organization extends Model {
         }
 
         // Protect specific domain names
-        if (["stamhoofd.be", "stamhoofd.nl", "stamhoofd.shop", "stamhoofd.app", "stamhoofd.email"].includes(this.privateMeta.mailDomain)) {
-            console.error("Tried to validate AWS mail identity with protected domains @"+this.id)
+        if (['stamhoofd.be', 'stamhoofd.nl', 'stamhoofd.shop', 'stamhoofd.app', 'stamhoofd.email'].includes(this.privateMeta.mailDomain)) {
+            console.error('Tried to validate AWS mail identity with protected domains @' + this.id);
             this.privateMeta.mailDomainActive = false;
-            return
+            return;
         }
 
-        if (STAMHOOFD.environment != "production") {
+        if (STAMHOOFD.environment !== 'production') {
             // Temporary ignore this
             this.privateMeta.mailDomainActive = true;
             return;
@@ -545,80 +546,81 @@ export class Organization extends Model {
         const sesv2 = new SES();
 
         // Check if mail identitiy already exists..
-        let exists = false
-        let existing: PromiseResult<SES.GetEmailIdentityResponse, AWSError> | undefined = undefined
+        let exists = false;
+        let existing: PromiseResult<SES.GetEmailIdentityResponse, AWSError> | undefined = undefined;
         try {
             existing = await sesv2.getEmailIdentity({
-                EmailIdentity: this.privateMeta.mailDomain
-            }).promise()
-            exists = true
+                EmailIdentity: this.privateMeta.mailDomain,
+            }).promise();
+            exists = true;
 
-            console.log("AWS mail idenitiy exists already: just checking the verification status in AWS @"+this.id)
+            console.log('AWS mail idenitiy exists already: just checking the verification status in AWS @' + this.id);
 
-            if (existing.ConfigurationSetName !== "stamhoofd-domains") {
+            if (existing.ConfigurationSetName !== 'stamhoofd-domains') {
                 // Not allowed to use this identity
                 this.privateMeta.mailDomainActive = false;
-                console.error("Organization is not allowed to use email identity "+this.privateMeta.mailDomain+" @"+this.id+", got "+existing.ConfigurationSetName)
+                console.error('Organization is not allowed to use email identity ' + this.privateMeta.mailDomain + ' @' + this.id + ', got ' + existing.ConfigurationSetName);
                 return;
             }
 
-            this.privateMeta.mailDomainActive = existing.VerifiedForSendingStatus ?? false
+            this.privateMeta.mailDomainActive = existing.VerifiedForSendingStatus ?? false;
 
             if (existing.VerifiedForSendingStatus !== true) {
-                console.error("Not validated @"+this.id)
+                console.error('Not validated @' + this.id);
             }
-            
-            if (existing.VerifiedForSendingStatus !== true && existing.DkimAttributes?.Status === "FAILED") {
-                console.error("AWS failed to verify DKIM records. Triggering a forced recheck @"+this.id)
+
+            if (existing.VerifiedForSendingStatus !== true && existing.DkimAttributes?.Status === 'FAILED') {
+                console.error('AWS failed to verify DKIM records. Triggering a forced recheck @' + this.id);
                 await sesv2.deleteEmailIdentity({
-                    EmailIdentity: this.privateMeta.mailDomain
-                }).promise()
+                    EmailIdentity: this.privateMeta.mailDomain,
+                }).promise();
 
                 // Recreate it immediately
-                exists = false
+                exists = false;
             }
-        } catch (e) {
-            console.error(e)
+        }
+        catch (e) {
+            console.error(e);
         }
 
         if (!exists) {
-            console.log("Creating email identity in AWS SES...")
+            console.log('Creating email identity in AWS SES...');
 
             const result = await sesv2.createEmailIdentity({
                 EmailIdentity: this.privateMeta.mailDomain,
-                ConfigurationSetName: "stamhoofd-domains",
+                ConfigurationSetName: 'stamhoofd-domains',
                 DkimSigningAttributes: {
                     DomainSigningPrivateKey: this.serverMeta.privateDKIMKey!,
-                    DomainSigningSelector: "stamhoofd"
+                    DomainSigningSelector: 'stamhoofd',
                 },
                 Tags: [
                     {
-                        "Key": "OrganizationId",
-                        "Value": this.id
+                        Key: 'OrganizationId',
+                        Value: this.id,
                     },
                     {
-                        "Key": "Environment",
-                        "Value": STAMHOOFD.environment ?? "Unknown"
-                    }
-                ]
+                        Key: 'Environment',
+                        Value: STAMHOOFD.environment ?? 'Unknown',
+                    },
+                ],
 
-            }).promise()
-            this.privateMeta.mailDomainActive = result.VerifiedForSendingStatus ?? false
+            }).promise();
+            this.privateMeta.mailDomainActive = result.VerifiedForSendingStatus ?? false;
 
             // Disable email forwarding of bounces and complaints
             // We handle this now with the configuration set
             await sesv2.putEmailIdentityFeedbackAttributes({
                 EmailIdentity: this.privateMeta.mailDomain,
-                EmailForwardingEnabled: false
-            }).promise()
+                EmailForwardingEnabled: false,
+            }).promise();
         }
 
         if (this.privateMeta.mailFromDomain && (!exists || (existing && (!existing.MailFromAttributes || existing.MailFromAttributes.MailFromDomain !== this.privateMeta.mailFromDomain)))) {
             // Also set a from domain, to fix SPF
-            console.log("Setting mail from domain: "+this.privateMeta.mailFromDomain+" for "+this.id)
+            console.log('Setting mail from domain: ' + this.privateMeta.mailFromDomain + ' for ' + this.id);
             const params = {
                 EmailIdentity: this.privateMeta.mailDomain,
-                BehaviorOnMxFailure: "USE_DEFAULT_VALUE",
+                BehaviorOnMxFailure: 'USE_DEFAULT_VALUE',
                 MailFromDomain: this.privateMeta.mailFromDomain,
             };
             await sesv2.putEmailIdentityMailFromAttributes(params).promise();
@@ -626,15 +628,15 @@ export class Organization extends Model {
     }
 
     async checkDrips() {
-        const days7 = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
+        const days7 = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
 
         // Welcome drip
         // Created maximum 7 days ago
         if (this.createdAt > days7 && !this.serverMeta.hasEmail(EmailTemplateType.OrganizationDripWelcome)) {
             await this.sendEmailTemplate({
                 type: EmailTemplateType.OrganizationDripWelcome,
-                personal: true
-            })
+                personal: true,
+            });
 
             this.serverMeta.addEmail(EmailTemplateType.OrganizationDripWelcome);
             await this.save();
@@ -645,13 +647,13 @@ export class Organization extends Model {
         // Webshop trial checkin
         if (!this.serverMeta.hasEmail(EmailTemplateType.OrganizationDripWebshopTrialCheckin)) {
             if (this.meta.packages.isWebshopsTrial) {
-                const activeTime = this.meta.packages.getActiveTime(STPackageType.TrialWebshops)
+                const activeTime = this.meta.packages.getActiveTime(STPackageType.TrialWebshops);
                 if (activeTime !== null && activeTime > 4 * 24 * 60 * 60 * 1000) {
                     // 7 days checkin
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.OrganizationDripWebshopTrialCheckin,
-                        personal: true
-                    })
+                        personal: true,
+                    });
 
                     this.serverMeta.addEmail(EmailTemplateType.OrganizationDripWebshopTrialCheckin);
                     this.serverMeta.addEmail(EmailTemplateType.OrganizationDripMembersTrialCheckin); // also mark members checkin
@@ -665,13 +667,13 @@ export class Organization extends Model {
         // Members trial checkin
         if (!this.serverMeta.hasEmail(EmailTemplateType.OrganizationDripMembersTrialCheckin)) {
             if (this.meta.packages.isMembersTrial) {
-                const activeTime = this.meta.packages.getActiveTime(STPackageType.TrialMembers)
+                const activeTime = this.meta.packages.getActiveTime(STPackageType.TrialMembers);
                 if (activeTime !== null && activeTime > 4 * 24 * 60 * 60 * 1000) {
                     // 7 days checkin
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.OrganizationDripMembersTrialCheckin,
-                        personal: true
-                    })
+                        personal: true,
+                    });
 
                     this.serverMeta.addEmail(EmailTemplateType.OrganizationDripMembersTrialCheckin);
                     this.serverMeta.addEmail(EmailTemplateType.OrganizationDripWebshopTrialCheckin); // Also mark webshop trial checkin
@@ -685,12 +687,12 @@ export class Organization extends Model {
         // Webshop trial expired after 1 week
         if (!this.serverMeta.hasEmail(EmailTemplateType.OrganizationDripWebshopTrialExpired)) {
             if (!this.meta.packages.useWebshops) {
-                const deactivatedTime = this.meta.packages.getDeactivatedTime(STPackageType.TrialWebshops)
+                const deactivatedTime = this.meta.packages.getDeactivatedTime(STPackageType.TrialWebshops);
                 if (deactivatedTime !== null && deactivatedTime < 14 * 24 * 60 * 60 * 1000 && deactivatedTime > 7 * 24 * 60 * 60 * 1000) {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.OrganizationDripWebshopTrialExpired,
-                        personal: true
-                    })
+                        personal: true,
+                    });
 
                     this.serverMeta.addEmail(EmailTemplateType.OrganizationDripWebshopTrialExpired);
                     this.serverMeta.addEmail(EmailTemplateType.OrganizationDripMembersTrialExpired); // also mark members
@@ -703,12 +705,12 @@ export class Organization extends Model {
 
         if (!this.serverMeta.hasEmail(EmailTemplateType.OrganizationDripMembersTrialExpired)) {
             if (!this.meta.packages.useMembers) {
-                const deactivatedTime = this.meta.packages.getDeactivatedTime(STPackageType.TrialMembers)
+                const deactivatedTime = this.meta.packages.getDeactivatedTime(STPackageType.TrialMembers);
                 if (deactivatedTime !== null && deactivatedTime < 14 * 24 * 60 * 60 * 1000 && deactivatedTime > 7 * 24 * 60 * 60 * 1000) {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.OrganizationDripMembersTrialExpired,
-                        personal: true
-                    })
+                        personal: true,
+                    });
 
                     this.serverMeta.addEmail(EmailTemplateType.OrganizationDripMembersTrialExpired);
                     this.serverMeta.addEmail(EmailTemplateType.OrganizationDripWebshopTrialExpired); // also mark webshops
@@ -722,17 +724,17 @@ export class Organization extends Model {
         // trial expired reminder (after 10 months)
         if (!this.serverMeta.hasEmail(EmailTemplateType.OrganizationDripTrialExpiredReminder)) {
             if (!this.meta.packages.isPaid && !this.meta.packages.wasPaid) {
-                const deactivatedTime1 = this.meta.packages.getDeactivatedTime(STPackageType.TrialWebshops)
-                const deactivatedTime2 = this.meta.packages.getDeactivatedTime(STPackageType.TrialMembers)
+                const deactivatedTime1 = this.meta.packages.getDeactivatedTime(STPackageType.TrialWebshops);
+                const deactivatedTime2 = this.meta.packages.getDeactivatedTime(STPackageType.TrialMembers);
 
-                const deactivatedTime = deactivatedTime1 && deactivatedTime2 ? Math.max(deactivatedTime1, deactivatedTime2) : (deactivatedTime1 ? deactivatedTime1 : deactivatedTime2)
+                const deactivatedTime = deactivatedTime1 && deactivatedTime2 ? Math.max(deactivatedTime1, deactivatedTime2) : (deactivatedTime1 ? deactivatedTime1 : deactivatedTime2);
 
                 if (deactivatedTime !== null && deactivatedTime > 10 * 30 * 24 * 60 * 60 * 1000 && deactivatedTime < 13 * 31 * 24 * 60 * 60 * 1000) {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.OrganizationDripTrialExpiredReminder,
                         personal: true,
-                        bcc: true
-                    })
+                        bcc: true,
+                    });
 
                     this.serverMeta.addEmail(EmailTemplateType.OrganizationDripTrialExpiredReminder);
                     await this.save();
@@ -744,14 +746,14 @@ export class Organization extends Model {
 
         if (!this.serverMeta.hasEmail(EmailTemplateType.OrganizationDripWebshopNotRenewed)) {
             if (!this.meta.packages.useWebshops) {
-                const deactivatedTime = this.meta.packages.getDeactivatedTime(STPackageType.Webshops)
-                
-                if (deactivatedTime !== null && deactivatedTime > 30 * 24 * 60 * 60 * 1000 && deactivatedTime < 30*3 * 24 * 60 * 60 * 1000) {
+                const deactivatedTime = this.meta.packages.getDeactivatedTime(STPackageType.Webshops);
+
+                if (deactivatedTime !== null && deactivatedTime > 30 * 24 * 60 * 60 * 1000 && deactivatedTime < 30 * 3 * 24 * 60 * 60 * 1000) {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.OrganizationDripWebshopNotRenewed,
                         personal: true,
-                        bcc: true
-                    })
+                        bcc: true,
+                    });
 
                     this.serverMeta.addEmail(EmailTemplateType.OrganizationDripWebshopNotRenewed);
                     await this.save();
@@ -763,14 +765,14 @@ export class Organization extends Model {
 
         if (!this.serverMeta.hasEmail(EmailTemplateType.OrganizationDripMembersNotRenewed)) {
             if (!this.meta.packages.useMembers) {
-                const deactivatedTime = this.meta.packages.getDeactivatedTime(STPackageType.Members)
-                
-                if (deactivatedTime !== null && deactivatedTime > 30 * 24 * 60 * 60 * 1000 && deactivatedTime < 30*3 * 24 * 60 * 60 * 1000) {
+                const deactivatedTime = this.meta.packages.getDeactivatedTime(STPackageType.Members);
+
+                if (deactivatedTime !== null && deactivatedTime > 30 * 24 * 60 * 60 * 1000 && deactivatedTime < 30 * 3 * 24 * 60 * 60 * 1000) {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.OrganizationDripMembersNotRenewed,
                         personal: true,
-                        bcc: true
-                    })
+                        bcc: true,
+                    });
 
                     this.serverMeta.addEmail(EmailTemplateType.OrganizationDripMembersNotRenewed);
                     await this.save();
@@ -792,18 +794,18 @@ export class Organization extends Model {
             return [
                 {
                     name: sender.name,
-                    email: sender.email
-                }
-            ]
+                    email: sender.email,
+                },
+            ];
         }
 
-        return await this.getAdminToEmails()
+        return await this.getAdminToEmails();
     }
 
     async getAdmins() {
         // Circular reference fix
         const User = (await import('./User')).User;
-        return await User.getAdmins([this.id], {verified: true});
+        return await User.getAdmins([this.id], { verified: true });
     }
 
     /**
@@ -813,66 +815,66 @@ export class Organization extends Model {
         const admins = await this.getAdmins();
 
         // Only full access
-        return admins.filter(a => a.permissions && a.permissions.forOrganization(this)?.hasFullAccess())
+        return admins.filter(a => a.permissions && a.permissions.forOrganization(this)?.hasFullAccess());
     }
 
     /**
      * These email addresess are private
      */
     async getAdminToEmails(): Promise<EmailInterfaceRecipient[]> {
-        const filtered = await this.getFullAdmins()
+        const filtered = await this.getFullAdmins();
 
-        if (STAMHOOFD.environment === "production") {
+        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"))
+                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 f;
                 }
             }
         }
 
-        return filtered.flatMap(f => f.getEmailTo() )
+        return filtered.flatMap(f => f.getEmailTo());
     }
 
     /**
      * These email addresess are private
      */
     async getAdminRecipients(): Promise<Recipient[]> {
-        let filtered = await this.getFullAdmins()
+        let filtered = await this.getFullAdmins();
 
-        if (STAMHOOFD.environment === "production") {
+        if (STAMHOOFD.environment === 'production') {
             if (filtered.length > 1) {
                 // remove stamhoofd email addresses
-                filtered = filtered.filter(e => !e.email.endsWith("@stamhoofd.be") && !e.email.endsWith("@stamhoofd.nl"))
+                filtered = filtered.filter(e => !e.email.endsWith('@stamhoofd.be') && !e.email.endsWith('@stamhoofd.nl'));
             }
         }
 
-        return filtered.flatMap(f => {
+        return filtered.flatMap((f) => {
             return Recipient.create({
                 firstName: f.firstName,
                 lastName: f.lastName,
                 email: f.email,
                 replacements: [
                     Replacement.create({
-                        token: "organizationName",
-                        value: this.name
-                    })
-                ]
-            })
-        } )
+                        token: 'organizationName',
+                        value: this.name,
+                    }),
+                ],
+            });
+        });
     }
 
     /**
      * Return default e-mail address if no email addresses are set.
      */
     getDefaultFrom(i18n: I18n, withName = true, type: 'transactional' | 'broadcast' = 'broadcast') {
-        const domain = type === 'transactional' ? i18n.localizedDomains.defaultTransactionalEmail() : i18n.localizedDomains.defaultBroadcastEmail()
+        const domain = type === 'transactional' ? i18n.localizedDomains.defaultTransactionalEmail() : i18n.localizedDomains.defaultBroadcastEmail();
 
         if (!withName) {
-            return ('noreply-' + this.uri+"@"+domain);
+            return ('noreply-' + this.uri + '@' + domain);
         }
-        return '"'+this.name.replaceAll("\"", "\\\"")+'" <'+ ('noreply-' + this.uri+"@"+domain) +'>'
+        return '"' + this.name.replaceAll('"', '\\"') + '" <' + ('noreply-' + this.uri + '@' + domain) + '>';
     }
 
     /**
@@ -880,40 +882,42 @@ export class Organization extends Model {
      */
     getEmail(id: string | null, strongDefault = false): { from: string; replyTo: string | undefined } {
         if (id === null) {
-            return this.getDefaultEmail(strongDefault)
+            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
+        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
+            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
+            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+">" 
+                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+">" 
+                    replyTo = '"' + sender.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
+                }
+                else {
+                    replyTo = '"' + this.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
                 }
             }
-            return { from, replyTo }
+            return { from, replyTo };
         }
-        return this.getDefaultEmail(strongDefault)
+        return this.getDefaultEmail(strongDefault);
     }
 
     /**
@@ -921,91 +925,94 @@ export class Organization extends Model {
      */
     getDefaultEmail(strongDefault = false): { from: string; replyTo: string | undefined } {
         // Send confirmation e-mail
-        let from = strongDefault ? this.getDefaultFrom(this.i18n, false) : this.uri+"@stamhoofd.email";
+        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
+        let replyTo: string | undefined = undefined;
 
         if (sender) {
-            replyTo = sender.email
+            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
+            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+">" 
+                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+">" 
+                    replyTo = '"' + sender.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
+                }
+                else {
+                    replyTo = '"' + this.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
                 }
             }
-        } else {
-            from = '"'+this.name.replaceAll("\"", "\\\"")+"\" <"+from+">" 
+        }
+        else {
+            from = '"' + this.name.replaceAll('"', '\\"') + '" <' + from + '>';
         }
 
         return {
-            from, replyTo
-        }
+            from, replyTo,
+        };
     }
 
     async getPaymentProviderFor(method: PaymentMethod, config: PrivatePaymentConfiguration): Promise<{
-        provider: PaymentProvider | null,
-        stripeAccount: StripeAccount | null
-    }>  {
-        let stripeAccount = (config.stripeAccountId ? (await StripeAccount.getByID(config.stripeAccountId)) : null) ?? null
+        provider: PaymentProvider | null;
+        stripeAccount: StripeAccount | null;
+    }> {
+        let stripeAccount = (config.stripeAccountId ? (await StripeAccount.getByID(config.stripeAccountId)) : null) ?? null;
         if (stripeAccount && stripeAccount.organizationId !== this.id) {
-            console.warn('Stripe account '+stripeAccount.id+' is not linked to organization '+this.id);
-            stripeAccount = null
+            console.warn('Stripe account ' + stripeAccount.id + ' is not linked to organization ' + this.id);
+            stripeAccount = null;
         }
-        const provider = this.privateMeta.getPaymentProviderFor(method, stripeAccount?.meta)
+        const provider = this.privateMeta.getPaymentProviderFor(method, stripeAccount?.meta);
         if (provider === null && ![PaymentMethod.Unknown, PaymentMethod.Transfer, PaymentMethod.PointOfSale].includes(method)) {
             if (!stripeAccount && config.stripeAccountId) {
                 console.warn('Missing stripe account id ' + config.stripeAccountId);
             }
             throw new SimpleError({
                 code: 'payment_provider_not_configured',
-                message: 'Payment provider not configured for '+method,
-                human: 'Deze betaalmethode werd helaas niet volledig geconfigureerd. Probeer later even opnieuw, neem contact met ons op of kies een andere betaalmethode.'
-            })
+                message: 'Payment provider not configured for ' + method,
+                human: 'Deze betaalmethode werd helaas niet volledig geconfigureerd. Probeer later even opnieuw, neem contact met ons op of kies een andere betaalmethode.',
+            });
         }
 
         if (provider !== PaymentProvider.Stripe && stripeAccount) {
-            stripeAccount = null
+            stripeAccount = null;
         }
         return {
             provider,
-            stripeAccount
-        }
+            stripeAccount,
+        };
     }
 
     async getConnectedPaymentProviders(): Promise<PaymentProvider[]> {
-        const allPaymentMethods = Object.values(PaymentMethod)
-        const providers: PaymentProvider[] = []
+        const allPaymentMethods = Object.values(PaymentMethod);
+        const providers: PaymentProvider[] = [];
 
-        let stripeAccounts: (StripeAccount|null)[] = await StripeAccount.where({ organizationId: this.id, status: 'active' })
+        let stripeAccounts: (StripeAccount | null)[] = await StripeAccount.where({ organizationId: this.id, status: 'active' });
 
         if (stripeAccounts.length === 0) {
-            stripeAccounts = [null]
+            stripeAccounts = [null];
         }
 
         for (const account of stripeAccounts) {
             for (const method of allPaymentMethods) {
-                const provider = this.privateMeta.getPaymentProviderFor(method, account?.meta)
+                const provider = this.privateMeta.getPaymentProviderFor(method, account?.meta);
                 if (provider && !providers.includes(provider)) {
-                    providers.push(provider)
+                    providers.push(provider);
                 }
             }
         }
 
-        return providers
+        return providers;
     }
 }