@stamhoofd/models 2.78.3 → 2.79.0

package/src/helpers/EmailBuilder.ts

@@ -1,4 +1,4 @@
-import { Email, EmailAddress, EmailBuilder } from '@stamhoofd/email';
+import { Email, EmailAddress, EmailBuilder, EmailInterfaceRecipient } from '@stamhoofd/email';
 import { BalanceItem as BalanceItemStruct, EmailTemplateType, OrganizationEmail, Platform as PlatformStruct, ReceivableBalanceType, Recipient, Replacement } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
@@ -104,40 +104,37 @@ export async function getDefaultEmailFrom(organization: Organization | null, opt
 
     if (organization) {
         // Default email address for the chosen email type
-        let from = organization.getDefaultFrom(organization.i18n, false, options.type ?? 'broadcast');
+        let from = organization.getDefaultFrom(organization.i18n, options.type ?? 'broadcast');
 
         const sender: OrganizationEmail | undefined = (preferEmailId ? organization.privateMeta.emails.find(e => e.id === preferEmailId) : null) ?? organization.privateMeta.emails.find(e => e.default) ?? organization.privateMeta.emails[0];
-        let replyTo: string | undefined = undefined;
+        let replyTo: EmailInterfaceRecipient | undefined = undefined;
 
         if (sender) {
-            replyTo = sender.email;
+            replyTo = {
+                email: sender.email,
+                name: sender.name,
+            };
 
             // Can we send from this e-mail or reply-to?
             if (await canSendFromEmail(sender.email, organization)) {
-                from = sender.email;
+                from = {
+                    email: sender.email,
+                    name: sender.name,
+                };
                 replyTo = undefined;
             }
 
-            // Include name in form field
-            if (sender.name) {
-                from = '"' + sender.name.replaceAll('"', '\\"') + '" <' + from + '>';
-            }
-            else {
-                from = '"' + organization.name.replaceAll('"', '\\"') + '" <' + from + '>';
+            // Default to organization name
+            if (!from.name) {
+                from.name = organization.name;
             }
 
             if (replyTo) {
-                if (sender.name) {
-                    replyTo = '"' + sender.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
-                }
-                else {
-                    replyTo = '"' + organization.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
+                if (!replyTo.name) {
+                    replyTo.name = organization.name;
                 }
             }
         }
-        else {
-            from = '"' + organization.name.replaceAll('"', '\\"') + '" <' + from + '>';
-        }
 
         return {
             from, replyTo,
@@ -151,42 +148,41 @@ export async function getDefaultEmailFrom(organization: Organization | null, opt
     const broadcastDomain = i18n.localizedDomains.defaultBroadcastEmail();
 
     const domain = (options.type === 'transactional' ? transactionalDomain : broadcastDomain);
-    let from = 'hallo@' + domain;
+    let from: EmailInterfaceRecipient = {
+        email: 'hallo@' + domain,
+    };
 
     // Platform
     const sender: OrganizationEmail | undefined = (preferEmailId ? platform.privateConfig.emails.find(e => e.id === preferEmailId) : null) ?? platform.privateConfig.emails.find(e => e.default) ?? platform.privateConfig.emails[0];
-    let replyTo: string | undefined = undefined;
+    let replyTo: EmailInterfaceRecipient | undefined = undefined;
 
     if (sender) {
-        replyTo = sender.email;
+        replyTo = {
+            email: sender.email,
+            name: sender.name,
+        };
 
         // Are we allowed to send an e-mail from this domain?
         if (await canSendFromEmail(sender.email, null)) {
             // Allowed to send from
-            from = sender.email;
+            from = {
+                email: sender.email,
+                name: sender.name,
+            };
             replyTo = undefined;
         }
 
-        // Include name in form field
-        if (sender.name) {
-            from = '"' + sender.name.replaceAll('"', '\\"') + '" <' + from + '>';
-        }
-        else {
-            from = '"' + platform.config.name.replaceAll('"', '\\"') + '" <' + from + '>';
+        // Default to platform name
+        if (!from.name) {
+            from.name = platform.config.name;
         }
 
         if (replyTo) {
-            if (sender.name) {
-                replyTo = '"' + sender.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
-            }
-            else {
-                replyTo = '"' + platform.config.name.replaceAll('"', '\\"') + '" <' + replyTo + '>';
+            if (!replyTo.name) {
+                replyTo.name = platform.config.name;
             }
         }
     }
-    else {
-        from = '"' + platform.config.name.replaceAll('"', '\\"') + '" <' + from + '>';
-    }
 
     return {
         from, replyTo,
@@ -206,7 +202,7 @@ export async function sendEmailTemplate(organization: Organization | null, optio
     }
 }
 
-export async function getEmailBuilderForTemplate(organization: Organization | null, options: Omit<EmailBuilderOptions, 'subject' | 'html'> & { template: Omit<EmailTemplateOptions, 'organizationId'> }) {
+async function getEmailBuilderForTemplate(organization: Organization | null, options: Omit<EmailBuilderOptions, 'subject' | 'html'> & { template: Omit<EmailTemplateOptions, 'organizationId'> }) {
     const template = await getEmailTemplate({
         ...options.template,
         organizationId: organization?.id ?? null,
@@ -226,8 +222,8 @@ export async function getEmailBuilderForTemplate(organization: Organization | nu
 export type EmailBuilderOptions = {
     defaultReplacements?: Replacement[];
     recipients: Recipient[];
-    from: string;
-    replyTo?: string | null;
+    from: EmailInterfaceRecipient;
+    replyTo?: EmailInterfaceRecipient | null;
     subject: string;
     html: string;
     attachments?: {
@@ -239,7 +235,7 @@ export type EmailBuilderOptions = {
     type?: 'transactional' | 'broadcast';
     unsubscribeType?: 'all' | 'marketing';
     fromStamhoofd?: boolean;
-    singleBcc?: string;
+    singleBcc?: EmailInterfaceRecipient;
     replaceAll?: { from: string; to: string }[]; // replace in all e-mails, not recipient dependent
     callback?: (error: Error | null) => void; // for each email
 };
@@ -333,8 +329,6 @@ export async function getEmailBuilder(organization: Organization | null, email:
     }
     email.recipients = cleaned;
 
-    const fromAddress = Email.parseEmailStr(email.from)[0];
-
     // Update recipients
     for (const recipient of email.recipients) {
         recipient.replacements = recipient.replacements.slice();
@@ -346,7 +340,8 @@ export async function getEmailBuilder(organization: Organization | null, email:
         await fillRecipientReplacements(recipient, {
             organization,
             platform,
-            fromAddress,
+            from: email.from,
+            replyTo: email.replyTo ?? null,
         });
     }
 
@@ -382,7 +377,7 @@ export async function getEmailBuilder(organization: Organization | null, email:
         return {
             from: email.from,
             replyTo: email.replyTo ?? undefined,
-            bcc: emailIndex === 1 ? email.singleBcc : undefined,
+            bcc: emailIndex === 1 && email.singleBcc ? [email.singleBcc] : undefined,
             to: [
                 {
                     // Name will get cleaned by email service
@@ -404,12 +399,13 @@ export async function getEmailBuilder(organization: Organization | null, email:
 export async function fillRecipientReplacements(recipient: Recipient, options: {
     organization: Organization | null;
     platform?: PlatformStruct;
-    fromAddress: string | null;
+    from: EmailInterfaceRecipient | null;
+    replyTo: EmailInterfaceRecipient | null;
 }) {
     if (!options.platform) {
         options.platform = await Platform.getSharedPrivateStruct();
     }
-    const { organization, platform, fromAddress } = options;
+    const { organization, platform, from, replyTo } = options;
     recipient.replacements = recipient.replacements.slice();
 
     // Default signInUrl
@@ -454,11 +450,19 @@ export async function fillRecipientReplacements(recipient: Recipient, options: {
         );
     }
 
-    if (fromAddress) {
+    if (from || replyTo) {
         recipient.replacements.push(Replacement.create({
             token: 'fromAddress',
-            value: fromAddress,
+            value: replyTo?.email ?? from!.email,
         }));
+
+        const name = replyTo?.name ?? from?.name;
+        if (name) {
+            recipient.replacements.push(Replacement.create({
+                token: 'fromName',
+                value: name,
+            }));
+        }
     }
 
     recipient.replacements.push(...recipient.getDefaultReplacements());
@@ -469,6 +473,6 @@ export async function fillRecipientReplacements(recipient: Recipient, options: {
     }
 
     // Defaults
-    const extra = platform.config.getEmailReplacements();
+    const extra = platform.config.getEmailReplacements(platform);
     recipient.replacements.push(...extra);
 }

package/src/index.ts

@@ -1,24 +1,13 @@
-export * from './factories/AddressFactory';
-export * from './factories/EmergencyContactFactory';
-export * from './factories/GroupFactory';
-export * from './factories/MemberFactory';
-export * from './factories/OrganizationFactory';
-export * from './factories/ParentFactory';
-export * from './factories/RecordFactory';
-export * from './factories/RegisterCodeFactory';
-export * from './factories/RegistrationFactory';
-export * from './factories/UserFactory';
-export * from './factories/WebshopFactory';
-export * from './factories/BalanceItemFactory';
-export * from './factories/RegistrationPeriodFactory';
-
 // Helpers
 export * from './helpers/EmailBuilder';
 export * from './helpers/GroupBuilder';
+export * from './helpers/MemberMerger';
 export * from './helpers/RateLimiter';
 export * from './helpers/WebshopCounter';
-export * from './helpers/MemberMerger';
 
 // Models
 export * from './models';
 export * from './structures/OrganizationServerMetaData';
+
+// Factories
+export * from './factories';

package/src/models/Email.test.ts

@@ -1,4 +1,4 @@
-import { EmailRecipientFilter, EmailRecipientFilterType, EmailRecipientsStatus, EmailRecipient as EmailRecipientStruct, EmailRecipientSubfilter, EmailStatus, LimitedFilteredRequest, PaginatedResponse } from '@stamhoofd/structures';
+import { EmailRecipientFilter, EmailRecipientFilterType, EmailRecipientsStatus, EmailRecipient as EmailRecipientStruct, EmailRecipientSubfilter, EmailStatus, LimitedFilteredRequest, OrganizationMetaData, PaginatedResponse } from '@stamhoofd/structures';
 import { Email } from './Email';
 import { EmailRecipient } from './EmailRecipient';
 import { EmailMocker } from '@stamhoofd/email';
@@ -43,7 +43,7 @@ async function buildEmail(data: {
     model.status = data.status ?? EmailStatus.Draft;
     model.attachments = [];
     model.fromAddress = data.fromAddress ?? 'test@stamhoofd.be';
-    model.fromName = data.fromName ?? 'Stamhoofd Test Suite';
+    model.fromName = data.fromName ?? null;
 
     await model.save();
 
@@ -493,10 +493,9 @@ describe('Model.Email', () => {
             },
         });
 
-        const organization = await new OrganizationFactory({
-        }).create();
+        const organization = await new OrganizationFactory({}).create();
 
-        const platform = await Platform.getShared();
+        const platform = await Platform.getForEditing();
         platform.membershipOrganizationId = organization.id;
         await platform.save();
 
@@ -530,4 +529,217 @@ describe('Model.Email', () => {
             replyTo: undefined,
         });
     }, 15_000);
+
+    describe('Replacements', () => {
+        it('[Regression] When sending an email the organization fromAddress is replaced to the reply-to if it is not allowed to be sent from', async () => {
+            TestUtils.setEnvironment('domains', {
+                ...STAMHOOFD.domains,
+                defaultTransactionalEmail: {
+                    '': 'my-platform.com',
+                },
+                defaultBroadcastEmail: {
+                    '': 'broadcast.my-platform.com',
+                },
+            });
+
+            const organization = await new OrganizationFactory({}).create();
+
+            const model = await buildEmail({
+                organizationId: organization.id,
+                recipients: [
+                    EmailRecipientStruct.create({
+                        email: 'example@domain.be',
+                    }),
+                ],
+                fromAddress: 'custom@customdomain.com',
+                fromName: 'Custom Name',
+                html: '{{fromAddress}}',
+                text: '{{fromAddress}}',
+                subject: '{{fromAddress}}',
+            });
+
+            await model.send();
+            await model.refresh();
+
+            // Check if it was sent correctly
+            expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+            expect(model.recipientCount).toBe(1);
+            expect(model.status).toBe(EmailStatus.Sent);
+
+            // Both have succeeded
+            expect(EmailMocker.broadcast.getSucceededCount()).toBe(1);
+            expect(EmailMocker.broadcast.getFailedCount()).toBe(0);
+
+            // Check to header
+            expect(EmailMocker.broadcast.getSucceededEmail(0)).toMatchObject({
+                to: 'example@domain.be',
+                from: '"Custom Name" <noreply-' + organization.uri + '@broadcast.my-platform.com>',
+                replyTo: '"Custom Name" <custom@customdomain.com>', // domain has changed here
+                subject: 'custom@customdomain.com',
+                html: 'custom@customdomain.com',
+                text: 'custom@customdomain.com',
+            });
+        }, 15_000);
+
+        it('Default organization replacements work as expected', async () => {
+            TestUtils.setEnvironment('domains', {
+                ...STAMHOOFD.domains,
+                defaultTransactionalEmail: {
+                    '': 'my-platform.com',
+                },
+                defaultBroadcastEmail: {
+                    '': 'broadcast.my-platform.com',
+                },
+            });
+
+            const brightYellow = '#FFD700';
+            const expectedContrastColor = '#000'; // black
+
+            const organization = await new OrganizationFactory({
+                meta: OrganizationMetaData.create({
+                    color: brightYellow,
+                }),
+            }).create();
+
+            const model = await buildEmail({
+                organizationId: organization.id,
+                recipients: [
+                    EmailRecipientStruct.create({
+                        email: 'example@domain.be',
+                    }),
+                ],
+                fromAddress: 'custom@customdomain.com',
+                html: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                text: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                subject: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+            });
+
+            await model.send();
+            await model.refresh();
+
+            // Check if it was sent correctly
+            expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+            expect(model.recipientCount).toBe(1);
+            expect(model.status).toBe(EmailStatus.Sent);
+
+            // Both have succeeded
+            expect(EmailMocker.broadcast.getSucceededCount()).toBe(1);
+            expect(EmailMocker.broadcast.getFailedCount()).toBe(0);
+
+            // Check to header
+            expect(EmailMocker.broadcast.getSucceededEmail(0)).toMatchObject({
+                subject: `${brightYellow};${expectedContrastColor};${organization.name};${organization.name}`,
+                html: `${brightYellow};${expectedContrastColor};${organization.name};${organization.name}`,
+                text: `${brightYellow};${expectedContrastColor};${organization.name};${organization.name}`,
+            });
+        }, 15_000);
+
+        it('Organization replacements default to platform replacements if not set', async () => {
+            TestUtils.setEnvironment('domains', {
+                ...STAMHOOFD.domains,
+                defaultTransactionalEmail: {
+                    '': 'my-platform.com',
+                },
+                defaultBroadcastEmail: {
+                    '': 'broadcast.my-platform.com',
+                },
+            });
+
+            const brightBlue = '#0000FF';
+            const expectedContrastColor = '#fff'; // white
+
+            const platform = await Platform.getForEditing();
+            platform.config.color = brightBlue;
+            await platform.save();
+
+            const organization = await new OrganizationFactory({
+                meta: OrganizationMetaData.create({
+                    color: null,
+                }),
+            }).create();
+
+            const model = await buildEmail({
+                organizationId: organization.id,
+                recipients: [
+                    EmailRecipientStruct.create({
+                        email: 'example@domain.be',
+                    }),
+                ],
+                fromAddress: 'custom@customdomain.com',
+                fromName: 'Custom Name',
+                html: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                text: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                subject: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+            });
+
+            await model.send();
+            await model.refresh();
+
+            // Check if it was sent correctly
+            expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+            expect(model.recipientCount).toBe(1);
+            expect(model.status).toBe(EmailStatus.Sent);
+
+            // Both have succeeded
+            expect(EmailMocker.broadcast.getSucceededCount()).toBe(1);
+            expect(EmailMocker.broadcast.getFailedCount()).toBe(0);
+
+            // Check to header
+            expect(EmailMocker.broadcast.getSucceededEmail(0)).toMatchObject({
+                subject: `${brightBlue};${expectedContrastColor};${organization.name};Custom Name`,
+                html: `${brightBlue};${expectedContrastColor};${organization.name};Custom Name`,
+                text: `${brightBlue};${expectedContrastColor};${organization.name};Custom Name`,
+            });
+        }, 15_000);
+
+        it('Platform replacements are used for platform level emails', async () => {
+            TestUtils.setEnvironment('domains', {
+                ...STAMHOOFD.domains,
+                defaultTransactionalEmail: {
+                    '': 'my-platform.com',
+                },
+                defaultBroadcastEmail: {
+                    '': 'broadcast.my-platform.com',
+                },
+            });
+
+            const darkRed = '#8B0000';
+            const expectedContrastColor = '#fff'; // white
+
+            const platform = await Platform.getForEditing();
+            platform.config.color = darkRed;
+            await platform.save();
+
+            const model = await buildEmail({
+                recipients: [
+                    EmailRecipientStruct.create({
+                        email: 'example@domain.be',
+                    }),
+                ],
+                fromAddress: 'custom@customdomain.com',
+                html: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                text: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                subject: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+            });
+
+            await model.send();
+            await model.refresh();
+
+            // Check if it was sent correctly
+            expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+            expect(model.recipientCount).toBe(1);
+            expect(model.status).toBe(EmailStatus.Sent);
+
+            // Both have succeeded
+            expect(EmailMocker.broadcast.getSucceededCount()).toBe(1);
+            expect(EmailMocker.broadcast.getFailedCount()).toBe(0);
+
+            // Check to header
+            expect(EmailMocker.broadcast.getSucceededEmail(0)).toMatchObject({
+                subject: `${darkRed};${expectedContrastColor};${platform.config.name};${platform.config.name}`,
+                html: `${darkRed};${expectedContrastColor};${platform.config.name};${platform.config.name}`,
+                text: `${darkRed};${expectedContrastColor};${platform.config.name};${platform.config.name}`,
+            });
+        }, 15_000);
+    });
 });

package/src/models/Email.ts

@@ -1,18 +1,17 @@
 import { column } from '@simonbackx/simple-database';
-import { EmailAttachment, EmailPreview, EmailRecipientFilter, EmailRecipientFilterType, EmailRecipientsStatus, EmailRecipient as EmailRecipientStruct, EmailStatus, Email as EmailStruct, EmailTemplateType, getExampleRecipient, LimitedFilteredRequest, PaginatedResponse, Recipient, Replacement, SortItemDirection, StamhoofdFilter } from '@stamhoofd/structures';
+import { EmailAttachment, EmailPreview, EmailRecipientFilter, EmailRecipientFilterType, EmailRecipientsStatus, EmailRecipient as EmailRecipientStruct, EmailStatus, Email as EmailStruct, EmailTemplateType, getExampleRecipient, LimitedFilteredRequest, PaginatedResponse, SortItemDirection, StamhoofdFilter } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from 'uuid';
 
 import { AnyDecoder, ArrayDecoder } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { I18n } from '@stamhoofd/backend-i18n';
-import { Email as EmailClass } from '@stamhoofd/email';
+import { Email as EmailClass, EmailInterfaceRecipient } from '@stamhoofd/email';
 import { QueueHandler } from '@stamhoofd/queues';
 import { QueryableModel, SQL, SQLWhereSign } from '@stamhoofd/sql';
-import { Formatter } from '@stamhoofd/utility';
 import { canSendFromEmail, fillRecipientReplacements, getEmailBuilder } from '../helpers/EmailBuilder';
 import { EmailRecipient } from './EmailRecipient';
-import { Organization } from './Organization';
 import { EmailTemplate } from './EmailTemplate';
+import { Organization } from './Organization';
 
 export class Email extends QueryableModel {
     static table = 'emails';
@@ -183,33 +182,35 @@ export class Email extends QueryableModel {
 
     getFromAddress() {
         if (!this.fromName) {
-            return this.fromAddress!;
+            return {
+                email: this.fromAddress!,
+            };
         }
 
-        const cleanedName = Formatter.emailSenderName(this.fromName);
-        if (cleanedName.length < 2) {
-            return this.fromAddress!;
-        }
-        return '"' + cleanedName + '" <' + this.fromAddress + '>';
+        return {
+            name: this.fromName,
+            email: this.fromAddress!,
+        };
     }
 
-    getDefaultFromAddress(organization?: Organization | null): string {
+    getDefaultFromAddress(organization?: Organization | null): EmailInterfaceRecipient {
         const i18n = new I18n($getLanguage(), $getCountry());
-        let address = 'noreply@' + i18n.localizedDomains.defaultBroadcastEmail();
+        let address: EmailInterfaceRecipient = {
+            email: 'noreply@' + i18n.localizedDomains.defaultBroadcastEmail(),
+        };
 
         if (organization) {
-            address = organization.getDefaultFrom(organization.i18n, false, 'broadcast');
+            address = organization.getDefaultFrom(organization.i18n, 'broadcast');
         }
 
         if (!this.fromName) {
             return address;
         }
 
-        const cleanedName = Formatter.emailSenderName(this.fromName);
-        if (cleanedName.length < 2) {
-            return address;
-        }
-        return '"' + cleanedName + '" <' + address + '>';
+        return {
+            name: this.fromName,
+            email: address.email,
+        };
     }
 
     async setFromTemplate(type: EmailTemplateType) {
@@ -274,7 +275,7 @@ export class Email extends QueryableModel {
             upToDate.throwIfNotReadyToSend();
 
             let from = upToDate.getDefaultFromAddress(organization);
-            let replyTo: string | null = upToDate.getFromAddress();
+            let replyTo: EmailInterfaceRecipient | null = upToDate.getFromAddress();
 
             if (!from) {
                 throw new SimpleError({
@@ -679,7 +680,8 @@ export class Email extends QueryableModel {
 
         await fillRecipientReplacements(virtualRecipient, {
             organization: this.organizationId ? (await Organization.getByID(this.organizationId))! : null,
-            fromAddress: this.fromAddress,
+            from: this.getFromAddress(),
+            replyTo: null,
         });
 
         recipientRow.replacements = virtualRecipient.replacements;

package/src/models/Member.ts

@@ -1,12 +1,14 @@
 import { column, Database, ManyToManyRelation, ManyToOneRelation, OneToManyRelation } from '@simonbackx/simple-database';
 import { QueryableModel, SQL } from '@stamhoofd/sql';
-import { MemberDetails, RegistrationWithMember as RegistrationWithMemberStruct, TinyMember } from '@stamhoofd/structures';
+import { MemberDetails, NationalRegisterNumberOptOut, RegistrationWithMember as RegistrationWithMemberStruct, TinyMember } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from 'uuid';
 
 import { Group, MemberResponsibilityRecord, Payment, Registration, User } from './';
-export type MemberWithRegistrations = Member & {
+export type MemberWithUsers = Member & {
     users: User[];
+};
+export type MemberWithRegistrations = MemberWithUsers & {
     registrations: (Registration & { group: Group })[];
 };
 
@@ -353,29 +355,37 @@ export class Member extends QueryableModel {
     }
 
     async isSafeToMergeDuplicateWithoutSecurityCode() {
-        // If responsibilities: not safe
-        const responsibilities = await MemberResponsibilityRecord.where({ memberId: this.id }, { limit: 1 });
-        if (responsibilities.length > 0) {
+        if (this.details.recordAnswers.size > 0) {
             return false;
         }
 
-        if (this.details.recordAnswers.size > 0) {
+        if (this.details.parents.length > 0) {
             return false;
         }
 
-        if (this.details.reviewTimes.isReviewed('details')) {
+        if (this.details.emergencyContacts.length > 0) {
             return false;
         }
 
-        if (this.details.parents.length > 0) {
+        if (this.details.uitpasNumber) {
             return false;
         }
 
-        if (this.details.emergencyContacts.length > 0) {
+        if (this.details.nationalRegisterNumber !== null && this.details.nationalRegisterNumber !== NationalRegisterNumberOptOut) {
             return false;
         }
 
-        if (this.details.uitpasNumber) {
+        if (this.details.requiresFinancialSupport !== null) {
+            return false;
+        }
+
+        if (this.details.address || this.details.phone || this.details.email || this.details.alternativeEmails.length > 0 || this.details.unverifiedAddresses.length > 0 || this.details.unverifiedPhones.length > 0 || this.details.unverifiedEmails.length > 0) {
+            return false;
+        }
+
+        // If responsibilities: not safe
+        const responsibilities = await MemberResponsibilityRecord.where({ memberId: this.id }, { limit: 1 });
+        if (responsibilities.length > 0) {
             return false;
         }