@stamhoofd/backend 2.135.0 → 2.136.1

package/src/endpoints/organization/dashboard/email-templates/PatchEmailTemplatesEndpoint.test.ts

@@ -1,10 +1,12 @@
 import type { PatchableArrayAutoEncoder } from '@simonbackx/simple-encoding';
-import { PatchableArray } from '@simonbackx/simple-encoding';
+import { PatchableArray, PatchMap } from '@simonbackx/simple-encoding';
 import { Request } from '@simonbackx/simple-endpoints';
 import type { Organization, RegistrationPeriod } from '@stamhoofd/models';
 import { EmailTemplate, GroupFactory, OrganizationFactory, Platform, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
-import { EmailTemplate as EmailTemplateStruct, EmailTemplateType, PermissionLevel, PermissionRoleDetailed, Permissions, PermissionsResourceType, ResourcePermissions, Version } from '@stamhoofd/structures';
-import { TestUtils } from '@stamhoofd/test-utils';
+import { EmailContent, EmailTemplate as EmailTemplateStruct, EmailTemplateType, PermissionLevel, PermissionRoleDetailed, Permissions, PermissionsResourceType, ResourcePermissions, Version } from '@stamhoofd/structures';
+import { Language } from '@stamhoofd/types/Language';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
+import { v4 as uuidv4 } from 'uuid';
 import { testServer } from '../../../../../tests/helpers/TestServer.js';
 import { PatchEmailTemplatesEndpoint } from './PatchEmailTemplatesEndpoint.js';
 
@@ -87,4 +89,270 @@ describe('Endpoint.PatchEmailTemplatesEndpoint', () => {
             expect(response.body).toBeDefined();
         });
     });
+
+    describe('Translations', () => {
+        const createOrganizationWithAdmin = async () => {
+            const organization = await new OrganizationFactory({ period }).create();
+            const user = await new UserFactory({
+                organization,
+                permissions: Permissions.create({
+                    level: PermissionLevel.Full,
+                }),
+            }).create();
+            const token = await Token.createToken(user);
+            return { organization, token };
+        };
+
+        const createTemplate = async (organization: Organization, options: { translations?: Map<Language, EmailContent>; language?: Language } = {}) => {
+            const template = new EmailTemplate();
+            template.subject = 'Default subject';
+            template.type = EmailTemplateType.SavedMembersEmail;
+            template.json = {};
+            template.html = '<p>Default</p>';
+            template.text = 'Default';
+            template.organizationId = organization.id;
+            if (options.translations) {
+                template.translations = options.translations;
+            }
+            template.language = options.language ?? null;
+            await template.save();
+            return template;
+        };
+
+        test('a template can be created with a default language and translations', async () => {
+            const { organization, token } = await createOrganizationWithAdmin();
+
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+            body.addPut(EmailTemplateStruct.create({
+                id: uuidv4(),
+                subject: 'Default subject',
+                html: '<p>Default</p>',
+                text: 'Default',
+                type: EmailTemplateType.SavedMembersEmail,
+                language: Language.Dutch,
+                translations: new Map([
+                    [Language.French, EmailContent.create({ subject: 'Sujet français', html: '<p>Français</p>', text: 'Français' })],
+                ]),
+            }));
+
+            const response = await patchEmailTemplates(body, token, organization);
+            expect(response.body).toHaveLength(1);
+            expect(response.body[0].language).toBe(Language.Dutch);
+            expect(response.body[0].translations.get(Language.French)!.subject).toBe('Sujet français');
+
+            const saved = await EmailTemplate.getByID(response.body[0].id);
+            expect(saved!.language).toBe(Language.Dutch);
+            expect(saved!.translations.get(Language.French)!.subject).toBe('Sujet français');
+        });
+
+        test('the first language can be set without creating a translation', async () => {
+            const { organization, token } = await createOrganizationWithAdmin();
+            const template = await createTemplate(organization);
+
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+            body.addPatch(EmailTemplateStruct.patch({
+                id: template.id,
+                language: Language.French,
+            }));
+
+            await patchEmailTemplates(body, token, organization);
+
+            const saved = await EmailTemplate.getByID(template.id);
+            expect(saved!.language).toBe(Language.French);
+            expect(saved!.translations.size).toBe(0);
+            expect(saved!.subject).toBe('Default subject');
+        });
+
+        test('a translation can be added to an existing template without changing other content', async () => {
+            const { organization, token } = await createOrganizationWithAdmin();
+            const template = await createTemplate(organization, {
+                language: Language.Dutch,
+                translations: new Map([
+                    [Language.English, EmailContent.create({ subject: 'English subject' })],
+                ]),
+            });
+
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+            body.addPatch(EmailTemplateStruct.patch({
+                id: template.id,
+                translations: new PatchMap([[Language.French, EmailContent.create({ subject: 'Sujet français' })]]),
+            }));
+
+            const response = await patchEmailTemplates(body, token, organization);
+            expect(response.body).toHaveLength(1);
+
+            const saved = await EmailTemplate.getByID(template.id);
+            expect(saved!.subject).toBe('Default subject');
+            expect(saved!.language).toBe(Language.Dutch);
+            expect(saved!.translations.size).toBe(2);
+            expect(saved!.translations.get(Language.English)!.subject).toBe('English subject');
+            expect(saved!.translations.get(Language.French)!.subject).toBe('Sujet français');
+        });
+
+        test('a translation can be deleted', async () => {
+            const { organization, token } = await createOrganizationWithAdmin();
+            const template = await createTemplate(organization, {
+                language: Language.Dutch,
+                translations: new Map([
+                    [Language.English, EmailContent.create({ subject: 'English subject' })],
+                    [Language.French, EmailContent.create({ subject: 'Sujet français' })],
+                ]),
+            });
+
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+            body.addPatch(EmailTemplateStruct.patch({
+                id: template.id,
+                translations: new PatchMap([[Language.French, null]]),
+            }));
+
+            await patchEmailTemplates(body, token, organization);
+
+            const saved = await EmailTemplate.getByID(template.id);
+            expect(saved!.language).toBe(Language.Dutch);
+            expect(saved!.translations.size).toBe(1);
+            expect(saved!.translations.get(Language.French)).toBeUndefined();
+            expect(saved!.translations.get(Language.English)!.subject).toBe('English subject');
+        });
+
+        test('removing the default language applies the move-over patch atomically', async () => {
+            const { organization, token } = await createOrganizationWithAdmin();
+            const template = await createTemplate(organization, {
+                language: Language.Dutch,
+                translations: new Map([
+                    [Language.French, EmailContent.create({ subject: 'Sujet français', html: '<p>Français</p>', text: 'Français' })],
+                ]),
+            });
+
+            // The UI removes the default language by moving the first remaining translation
+            // into the default content in a single patch
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+            body.addPatch(EmailTemplateStruct.patch({
+                id: template.id,
+                language: Language.French,
+                subject: 'Sujet français',
+                html: '<p>Français</p>',
+                text: 'Français',
+                translations: new PatchMap([[Language.French, null]]),
+            }));
+
+            await patchEmailTemplates(body, token, organization);
+
+            const saved = await EmailTemplate.getByID(template.id);
+            expect(saved!.language).toBe(Language.French);
+            expect(saved!.subject).toBe('Sujet français');
+            expect(saved!.html).toBe('<p>Français</p>');
+            expect(saved!.translations.size).toBe(0);
+        });
+
+        test('removing the last language keeps the content', async () => {
+            const { organization, token } = await createOrganizationWithAdmin();
+            const template = await createTemplate(organization, { language: Language.Dutch });
+
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+            body.addPatch(EmailTemplateStruct.patch({
+                id: template.id,
+                language: null,
+            }));
+
+            await patchEmailTemplates(body, token, organization);
+
+            const saved = await EmailTemplate.getByID(template.id);
+            expect(saved!.language).toBeNull();
+            expect(saved!.subject).toBe('Default subject');
+            expect(saved!.html).toBe('<p>Default</p>');
+        });
+
+        test('patching only the subject keeps the translations', async () => {
+            const { organization, token } = await createOrganizationWithAdmin();
+            const template = await createTemplate(organization, {
+                language: Language.Dutch,
+                translations: new Map([
+                    [Language.French, EmailContent.create({ subject: 'Sujet français' })],
+                ]),
+            });
+
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+            body.addPatch(EmailTemplateStruct.patch({
+                id: template.id,
+                subject: 'New default subject',
+            }));
+
+            await patchEmailTemplates(body, token, organization);
+
+            const saved = await EmailTemplate.getByID(template.id);
+            expect(saved!.subject).toBe('New default subject');
+            expect(saved!.language).toBe(Language.Dutch);
+            expect(saved!.translations.get(Language.French)!.subject).toBe('Sujet français');
+        });
+
+        test('rejects a translation without a default language', async () => {
+            const { organization, token } = await createOrganizationWithAdmin();
+            const template = await createTemplate(organization);
+
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+            body.addPatch(EmailTemplateStruct.patch({
+                id: template.id,
+                translations: new PatchMap([[Language.French, EmailContent.create({ subject: 'Sujet français' })]]),
+            }));
+
+            await expect(patchEmailTemplates(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_translations'));
+        });
+
+        test('rejects a translation for the default language itself', async () => {
+            const { organization, token } = await createOrganizationWithAdmin();
+            const template = await createTemplate(organization, { language: Language.Dutch });
+
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+            body.addPatch(EmailTemplateStruct.patch({
+                id: template.id,
+                translations: new PatchMap([[Language.Dutch, EmailContent.create({ subject: 'Nederlands onderwerp' })]]),
+            }));
+
+            await expect(patchEmailTemplates(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_translations'));
+        });
+
+        test('rejects clearing the default language while translations remain', async () => {
+            const { organization, token } = await createOrganizationWithAdmin();
+            const template = await createTemplate(organization, {
+                language: Language.Dutch,
+                translations: new Map([
+                    [Language.French, EmailContent.create({ subject: 'Sujet français' })],
+                ]),
+            });
+
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+            body.addPatch(EmailTemplateStruct.patch({
+                id: template.id,
+                language: null,
+            }));
+
+            await expect(patchEmailTemplates(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_translations'));
+        });
+
+        test('rejects creating a template with translations but without a default language', async () => {
+            const { organization, token } = await createOrganizationWithAdmin();
+
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+            body.addPut(EmailTemplateStruct.create({
+                id: uuidv4(),
+                subject: 'Default subject',
+                html: '<p>Default</p>',
+                text: 'Default',
+                type: EmailTemplateType.SavedMembersEmail,
+                translations: new Map([
+                    [Language.French, EmailContent.create({ subject: 'Sujet français' })],
+                ]),
+            }));
+
+            await expect(patchEmailTemplates(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_translations'));
+        });
+    });
 });

package/src/endpoints/organization/dashboard/email-templates/PatchEmailTemplatesEndpoint.ts

@@ -1,9 +1,9 @@
 import type { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder } from '@simonbackx/simple-encoding';
-import { PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
+import { PatchableArrayDecoder, patchObject, StringDecoder } from '@simonbackx/simple-encoding';
 import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { EmailTemplate, Group, Platform, Webshop } from '@stamhoofd/models';
-import { EmailTemplate as EmailTemplateStruct, PermissionLevel } from '@stamhoofd/structures';
+import { EmailTemplate as EmailTemplateStruct, PermissionLevel, validateEmailTranslations } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context.js';
 
@@ -51,6 +51,15 @@ export class PatchEmailTemplatesEndpoint extends Endpoint<Params, Query, Body, R
             template.subject = patch.subject ?? template.subject;
             template.text = patch.text ?? template.text;
             template.json = patch.json ?? template.json;
+            template.translations = patchObject(template.translations, patch.translations);
+
+            if (patch.language !== undefined) {
+                template.language = patch.language;
+            }
+
+            if (patch.language !== undefined || patch.translations !== undefined) {
+                validateEmailTranslations(template);
+            }
 
             await template.save();
 
@@ -94,6 +103,10 @@ export class PatchEmailTemplatesEndpoint extends Endpoint<Params, Query, Body, R
             template.subject = struct.subject;
             template.text = struct.text;
             template.json = struct.json;
+            template.translations = struct.translations;
+            template.language = struct.language;
+
+            validateEmailTranslations(template);
 
             template.type = struct.type;
 

package/src/endpoints/organization/dashboard/webshops/GetWebshopOrdersEndpoint.test.ts

@@ -0,0 +1,112 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import type { Organization, User, Webshop } from '@stamhoofd/models';
+import { OrderFactory, OrganizationFactory, Token, UserFactory, WebshopFactory } from '@stamhoofd/models';
+import type { PaginatedResponse, PrivateOrder, StamhoofdFilter } from '@stamhoofd/structures';
+import { Cart, Customer, LimitedFilteredRequest, OrderData, PermissionLevel, Permissions, RecordDateAnswer, RecordSettings, RecordType } from '@stamhoofd/structures';
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { GetWebshopOrdersEndpoint } from './GetWebshopOrdersEndpoint.js';
+
+describe('Endpoint.GetWebshopOrdersEndpoint', () => {
+    const endpoint = new GetWebshopOrdersEndpoint();
+
+    const getOrders = async ({ filter, organization, user }: { filter: StamhoofdFilter | null; organization: Organization; user: User }) => {
+        const token = await Token.createToken(user);
+
+        const request = Request.get({
+            path: '/webshop/orders',
+            host: organization.getApiHost(),
+            query: new LimitedFilteredRequest({
+                filter,
+                limit: 100,
+            }),
+            headers: {
+                authorization: 'Bearer ' + token.accessToken,
+            },
+        });
+
+        return testServer.test<PaginatedResponse<PrivateOrder[], LimitedFilteredRequest>>(endpoint, request);
+    };
+
+    const createOrderWithDateAnswer = async ({ webshop, record, dateValue }: { webshop: Webshop; record: RecordSettings; dateValue: Date | null }) => {
+        const answer = RecordDateAnswer.create({ settings: record });
+        answer.dateValue = dateValue;
+
+        const data = OrderData.create({
+            customer: Customer.create({
+                firstName: 'John',
+                lastName: 'Doe',
+                email: 'john.doe@example.com',
+            }),
+            cart: Cart.create({}),
+        });
+        data.recordAnswers.set(record.id, answer);
+
+        return await new OrderFactory({ webshop, data }).create();
+    };
+
+    describe('Filtering on record answers', () => {
+        test('filters orders on the date of a date record answer', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const user = await new UserFactory({
+                organization,
+                permissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+            const record = RecordSettings.create({ type: RecordType.Date });
+
+            // The order we are looking for: answered with a time of day that is not midnight
+            const matchingOrder = await createOrderWithDateAnswer({
+                webshop,
+                record,
+                dateValue: new Date(2023, 5, 10, 14, 30, 15),
+            });
+
+            // Answered with a different date
+            await createOrderWithDateAnswer({
+                webshop,
+                record,
+                dateValue: new Date(2023, 5, 11, 14, 30, 15),
+            });
+
+            // Did not answer the question
+            await createOrderWithDateAnswer({
+                webshop,
+                record,
+                dateValue: null,
+            });
+
+            // Does not have the record answer at all
+            await new OrderFactory({ webshop }).create();
+
+            const response = await getOrders({
+                organization,
+                user,
+                filter: {
+                    recordAnswers: {
+                        [record.id]: {
+                            // Same filter as the date filter in the UI builds for 'equals'
+                            $and: [
+                                {
+                                    dateValue: {
+                                        $gte: new Date(2023, 5, 10),
+                                    },
+                                },
+                                {
+                                    dateValue: {
+                                        $lte: new Date(2023, 5, 10, 23, 59, 59, 999),
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+            });
+
+            expect(response.status).toBe(200);
+            expect(response.body.results).toIncludeSameMembers([
+                expect.objectContaining({ id: matchingOrder.id }),
+            ]);
+        });
+    });
+});

package/src/endpoints/organization/webshops/OrderConfirmationEmailLanguage.test.ts

@@ -1,7 +1,7 @@
 import { Request } from '@simonbackx/simple-endpoints';
 import { EmailMocker } from '@stamhoofd/email';
 import { EmailTemplateFactory, OrganizationFactory, WebshopFactory } from '@stamhoofd/models';
-import { Cart, CartItem, Customer, EmailTemplateType, OrderData, PaymentMethod, Product, ProductPrice } from '@stamhoofd/structures';
+import { Cart, CartItem, Customer, EmailContent, EmailTemplateType, OrderData, PaymentMethod, Product, ProductPrice } from '@stamhoofd/structures';
 import { TestUtils } from '@stamhoofd/test-utils';
 import { Country } from '@stamhoofd/types/Country';
 import { Language } from '@stamhoofd/types/Language';
@@ -67,4 +67,90 @@ describe('Order confirmation email language', () => {
         expect(dutchEmail.html).toContain(dutchStatusName);
         expect(dutchEmail.html).not.toContain(frenchStatusName);
     });
+
+    test('selects the translated template that matches the language the customer ordered in', async () => {
+        TestUtils.setEnvironment('locales', { [Country.Belgium]: [Language.Dutch, Language.French] });
+
+        const organization = await new OrganizationFactory({}).create();
+        const freeProductPrice = ProductPrice.create({ name: 'Free', price: 0, stock: 100 });
+        const product = Product.create({ name: 'Product', stock: 100, prices: [freeProductPrice] });
+        const webshop = await new WebshopFactory({
+            organizationId: organization.id,
+            products: [product],
+        }).create();
+
+        // The template has default (Dutch) content and a French translation. The French translation
+        // must be selected for a French order, the default content for a Dutch order.
+        // Both order-table replacements are included: their headers/titles are localized per
+        // recipient (consumer) language, independently of the selected template translation.
+        const tables = '{{orderTable}} {{orderDetailsTable}}';
+        await new EmailTemplateFactory({
+            organization,
+            webshopId: webshop.id,
+            type: EmailTemplateType.OrderConfirmationOnline,
+            subject: 'Standaard onderwerp',
+            html: `<p>Standaard inhoud ${tables}</p>`,
+            text: 'Standaard inhoud',
+            language: Language.Dutch,
+            translations: new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français', html: `<p>Contenu français ${tables}</p>`, text: 'Contenu français' })],
+            ]),
+        }).create();
+
+        // Table headers/titles rendered via $t inside the order tables. Hardcoded on purpose so we
+        // don't verify $t with the same $t machinery we're testing.
+        // orderTable column headers (%Sc / %M4) and an orderDetailsTable row title (%xA).
+        const dutch = { orderColumn: 'Artikel', amountColumn: 'Aantal', orderNumberTitle: 'Bestelnummer' };
+        const french = { orderColumn: 'Article', amountColumn: 'Nombre', orderNumberTitle: 'Numéro de commande' };
+
+        const placeFreeOrderInLanguage = async (language: string) => {
+            EmailMocker.transactional.reset();
+
+            const orderData = OrderData.create({
+                paymentMethod: PaymentMethod.Unknown,
+                cart: Cart.create({
+                    items: [CartItem.create({ product, productPrice: freeProductPrice, amount: 1 })],
+                }),
+                customer: Customer.create({ firstName: 'John', lastName: 'Doe', email: 'john@example.com', phone: '+32412345678' }),
+            });
+
+            const r = Request.buildJson('POST', `/webshop/${webshop.id}/order`, organization.getApiHost(), orderData);
+            r.headers['accept-language'] = language;
+            await testServer.test(endpoint, r);
+
+            const emails = await EmailMocker.transactional.getSucceededEmails();
+            expect(emails).toHaveLength(1);
+            return emails[0];
+        };
+
+        // French order → the French translation of the template is used
+        const frenchEmail = await placeFreeOrderInLanguage('fr');
+        expect(frenchEmail.subject).toBe('Sujet français');
+        expect(frenchEmail.html).toContain('Contenu français');
+        expect(frenchEmail.html).not.toContain('Standaard inhoud');
+
+        // Both order tables are rendered in the recipient's (consumer) language, French
+        expect(frenchEmail.html).toContain(french.orderColumn);
+        expect(frenchEmail.html).toContain(french.amountColumn);
+        expect(frenchEmail.html).toContain(french.orderNumberTitle);
+        // No Dutch table headers/titles leak into the French email
+        expect(frenchEmail.html).not.toContain(dutch.orderColumn);
+        expect(frenchEmail.html).not.toContain(dutch.amountColumn);
+        expect(frenchEmail.html).not.toContain(dutch.orderNumberTitle);
+
+        // Dutch order → Dutch is the default language, so the default content is used
+        const dutchEmail = await placeFreeOrderInLanguage('nl');
+        expect(dutchEmail.subject).toBe('Standaard onderwerp');
+        expect(dutchEmail.html).toContain('Standaard inhoud');
+        expect(dutchEmail.html).not.toContain('Contenu français');
+
+        // Both order tables are rendered in Dutch
+        expect(dutchEmail.html).toContain(dutch.orderColumn);
+        expect(dutchEmail.html).toContain(dutch.amountColumn);
+        expect(dutchEmail.html).toContain(dutch.orderNumberTitle);
+        // No French table headers/titles leak into the Dutch email
+        expect(dutchEmail.html).not.toContain(french.orderColumn);
+        expect(dutchEmail.html).not.toContain(french.amountColumn);
+        expect(dutchEmail.html).not.toContain(french.orderNumberTitle);
+    });
 });

package/src/excel-loaders/members.test.ts

@@ -0,0 +1,59 @@
+import type { XlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
+import type { PlatformMember } from '@stamhoofd/structures';
+import { EmergencyContact, MemberDetails, MembersBlob, MemberWithRegistrationsBlob, Organization, Platform, PlatformFamily } from '@stamhoofd/structures';
+import { baseMemberColumns } from './members.js';
+
+describe('Member excel export', () => {
+    describe('emergencyContacts column', () => {
+        function createMember(emergencyContacts: EmergencyContact[]) {
+            const organization = Organization.create({});
+            const blob = MembersBlob.create({
+                organizations: [organization],
+                members: [
+                    MemberWithRegistrationsBlob.create({
+                        details: MemberDetails.create({ firstName: 'John', lastName: 'Doe', emergencyContacts }),
+                    }),
+                ],
+            });
+
+            const family = PlatformFamily.create(blob, { platform: Platform.create({}), contextOrganization: organization });
+            return family.members[0];
+        }
+
+        function getColumn() {
+            const column = baseMemberColumns.find(c => 'id' in c && c.id === 'emergencyContacts') as XlsxTransformerConcreteColumn<PlatformMember> | undefined;
+
+            if (!column) {
+                throw new Error('Column emergencyContacts not found');
+            }
+
+            return column;
+        }
+
+        function getValue(member: PlatformMember) {
+            return getColumn().getValue(member).value;
+        }
+
+        it('lists every emergency contact on its own line, also the ones without a numbered column', () => {
+            const member = createMember([
+                EmergencyContact.create({ name: 'An Peeters', title: 'Oma', phone: '0470 12 34 56' }),
+                EmergencyContact.create({ name: 'Jan Janssens', title: 'Buur', phone: '0470 65 43 21' }),
+                EmergencyContact.create({ name: 'Rita Maes', title: 'Tante', phone: '0470 11 22 33' }),
+            ]);
+
+            expect(getValue(member)).toBe('Oma: An Peeters (0470 12 34 56)\nBuur: Jan Janssens (0470 65 43 21)\nTante: Rita Maes (0470 11 22 33)');
+        });
+
+        it('wraps the text so every line stays visible', () => {
+            const member = createMember([
+                EmergencyContact.create({ name: 'An Peeters', title: 'Oma', phone: '0470 12 34 56' }),
+            ]);
+
+            expect(getColumn().getValue(member).style?.alignment?.wrapText).toBe(true);
+        });
+
+        it('returns an empty value when the member has no emergency contacts', () => {
+            expect(getValue(createMember([]))).toBe('');
+        });
+    });
+});

package/src/excel-loaders/members.ts

@@ -191,6 +191,23 @@ export const baseMemberColumns: XlsxTransformerColumn<PlatformMember>[] = [
 
     ...XlsxTransformerColumnHelper.creatColumnsForParents(),
 
+    // emergency contacts
+    {
+        id: 'emergencyContacts',
+        name: $t(`%ZeJ`),
+        width: 40,
+        getValue: ({ patchedMember: object }: PlatformMember) => ({
+            // One contact per line so the cell stays readable, and wrap the text so all lines are visible
+            value: object.details.emergencyContacts.map(c => c.toString()).join('\n'),
+            style: {
+                alignment: {
+                    wrapText: true,
+                },
+            },
+        }),
+    },
+    ...XlsxTransformerColumnHelper.createColumnsForEmergencyContacts(),
+
     // unverified data
     {
         id: 'unverifiedPhones',

package/src/helpers/AuthenticatedStructures.ts

@@ -406,6 +406,15 @@ export class AuthenticatedStructures {
         const members = await Member.getMembersWithRegistrationForUser(user);
         const filtered: MemberWithUsersRegistrationsAndGroups[] = [];
         for (const member of members) {
+            if (STAMHOOFD.userMode === 'organization') {
+                if (!Context.organization) {
+                    // Don't list any members
+                    continue;
+                }
+                if (member.organizationId !== Context.organization.id) {
+                    continue;
+                }
+            }
             if (await Context.auth.canAccessMember(member, PermissionLevel.Read)) {
                 filtered.push(member);
             }