@stamhoofd/backend 2.134.0 → 2.136.0

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/organization/PatchOrganizationEndpoint.ts

@@ -161,6 +161,8 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                 }
                 organization.privateMeta.privateKey = request.body.privateMeta.privateKey ?? organization.privateMeta.privateKey;
                 organization.privateMeta.featureFlags = patchObject(organization.privateMeta.featureFlags, request.body.privateMeta.featureFlags);
+                organization.privateMeta.externalSyncData = patchObject(organization.privateMeta.externalSyncData, request.body.privateMeta.externalSyncData);
+                organization.privateMeta.externalGroupNumber = patchObject(organization.privateMeta.externalGroupNumber, request.body.privateMeta.externalGroupNumber);
                 organization.privateMeta.balanceNotificationSettings = patchObject(organization.privateMeta.balanceNotificationSettings, request.body.privateMeta.balanceNotificationSettings);
                 organization.privateMeta.invoiceSettings = patchObject(organization.privateMeta.invoiceSettings, request.body.privateMeta.invoiceSettings);
                 organization.privateMeta.recordAnswers = request.body.privateMeta.recordAnswers.applyTo(organization.privateMeta.recordAnswers);

package/src/endpoints/organization/dashboard/organization/SetUitpasClientCredentialsEndpoint.ts

@@ -84,14 +84,7 @@ export class SetUitpasClientCredentialsEndpoint extends Endpoint<Params, Query,
 
         // store the client credentials and store new status in one operation
         if (!reEvaluation) {
-            const valid = await UitpasService.storeIfValid(organization.id, request.body.clientId, request.body.clientSecret);
-            if (!valid) {
-                throw new SimpleError({
-                    message: 'The provided client credentials are not valid',
-                    code: 'invalid_client_credentials',
-                    human: $t('%1BG'),
-                });
-            }
+            await UitpasService.storeIfValid(organization.id, request.body.clientId, request.body.clientSecret);
         }
         organization.meta.uitpasClientCredentialsStatus = UitpasClientCredentialsStatus.NotChecked;
         await organization.save();

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/dashboard/webshops/PatchWebshopEndpoint.test.ts

@@ -0,0 +1,49 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { OrganizationFactory, Token, UserFactory, Webshop, WebshopFactory } from '@stamhoofd/models';
+import { PermissionLevel, Permissions, PrivateWebshop, WebshopMetaData } from '@stamhoofd/structures';
+import { Language } from '@stamhoofd/types/Language';
+import { TestUtils } from '@stamhoofd/test-utils';
+
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { PatchWebshopEndpoint } from './PatchWebshopEndpoint.js';
+
+describe('Endpoint.PatchWebshop', () => {
+    const endpoint = new PatchWebshopEndpoint();
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    async function createAdminContext() {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({
+            organization,
+            permissions: Permissions.create({
+                level: PermissionLevel.Full,
+            }),
+        }).create();
+        const token = await Token.createToken(user);
+
+        return { organization, token };
+    }
+
+    test('defaultLanguage can be updated', async () => {
+        const { organization, token } = await createAdminContext();
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+        const patch = PrivateWebshop.patch({
+            meta: WebshopMetaData.patch({
+                defaultLanguage: Language.French,
+            }),
+        });
+        const request = Request.buildJson('PATCH', '/webshop/' + webshop.id, organization.getApiHost(), patch);
+        request.headers.authorization = 'Bearer ' + token.accessToken;
+
+        const response = await testServer.test(endpoint, request);
+        expect(response.body.meta.defaultLanguage).toBe(Language.French);
+
+        // Persisted in the database
+        const reloaded = await Webshop.getByID(webshop.id);
+        expect(reloaded?.meta.defaultLanguage).toBe(Language.French);
+    });
+});

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

@@ -0,0 +1,71 @@
+import type { PatchableArrayAutoEncoder } from '@simonbackx/simple-encoding';
+import { PatchableArray } from '@simonbackx/simple-encoding';
+import { Request } from '@simonbackx/simple-endpoints';
+import { Order, OrganizationFactory, Token, UserFactory, WebshopFactory } from '@stamhoofd/models';
+import { Cart, CartItem, Customer, OrderData, PaymentMethod, PermissionLevel, Permissions, PrivateOrder, Product, ProductPrice, WebshopMetaData } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Language } from '@stamhoofd/types/Language';
+import { v4 as uuidv4 } from 'uuid';
+
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { PatchWebshopOrdersEndpoint } from './PatchWebshopOrdersEndpoint.js';
+
+describe('Endpoint.PatchWebshopOrders', () => {
+    const endpoint = new PatchWebshopOrdersEndpoint();
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    test('Manually created orders use the webshop default language', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({
+            organization,
+            permissions: Permissions.create({
+                level: PermissionLevel.Full,
+            }),
+        }).create();
+        const token = await Token.createToken(user);
+
+        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,
+            meta: WebshopMetaData.patch({ defaultLanguage: Language.French }),
+            products: [product],
+        }).create();
+
+        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',
+            }),
+        });
+
+        const patchArray: PatchableArrayAutoEncoder<PrivateOrder> = new PatchableArray();
+        patchArray.addPut(PrivateOrder.create({
+            id: uuidv4(),
+            data: orderData,
+            webshopId: webshop.id,
+        }));
+
+        const r = Request.buildJson('PATCH', `/webshop/${webshop.id}/orders`, organization.getApiHost(), patchArray);
+        r.headers.authorization = 'Bearer ' + token.accessToken;
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toHaveLength(1);
+        expect(response.body[0].consumerLanguage).toEqual(Language.French);
+
+        // Persisted in the dedicated column
+        const orderModel = (await Order.getByID(response.body[0].id))!;
+        expect(orderModel.consumerLanguage).toEqual(Language.French);
+    });
+});

package/src/endpoints/organization/dashboard/webshops/PatchWebshopOrdersEndpoint.ts

@@ -123,6 +123,10 @@ export class PatchWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Re
                 model.status = struct.status;
                 model.data = struct.data;
 
+                // Manually created orders have no customer request language, so use the webshop's
+                // default language for any future emails to this order.
+                model.consumerLanguage = webshop.meta.defaultLanguage;
+
                 // For now, we don't invalidate tickets, because they will get invalidated at scan time (the order status is checked)
                 // This allows you to revalidate a ticket without needing to generate a new one (e.g. when accidentally canceling an order)
                 // -> the user doesn't need to download the ticket again

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

@@ -1,6 +1,7 @@
 import { Request } from '@simonbackx/simple-endpoints';
 import { OrganizationFactory, Token, UserFactory, WebshopFactory } from '@stamhoofd/models';
 import { PermissionLevel, Permissions, WebshopAuthType, WebshopMetaData } from '@stamhoofd/structures';
+import { Language } from '@stamhoofd/types/Language';
 
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer.js';
@@ -30,6 +31,16 @@ describe('Endpoint.GetWebshop', () => {
         expect((response.body as any).privateMeta).toBeUndefined();
     });
 
+    test('Webshop defaults to Dutch as its default language', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+        const r = Request.buildJson('GET', '/webshop/' + webshop.id, organization.getApiHost());
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body.meta.defaultLanguage).toBe(Language.Dutch);
+    });
+
     test('Allow access without organization scope', async () => {
         const organization = await new OrganizationFactory({}).create();
         const webshop = await new WebshopFactory({ organizationId: organization.id }).create();