@stamhoofd/backend 2.99.1 → 2.100.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.99.1",
+    "version": "2.100.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -45,14 +45,14 @@
         "@simonbackx/simple-encoding": "2.22.0",
         "@simonbackx/simple-endpoints": "1.20.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.99.1",
-        "@stamhoofd/backend-middleware": "2.99.1",
-        "@stamhoofd/email": "2.99.1",
-        "@stamhoofd/models": "2.99.1",
-        "@stamhoofd/queues": "2.99.1",
-        "@stamhoofd/sql": "2.99.1",
-        "@stamhoofd/structures": "2.99.1",
-        "@stamhoofd/utility": "2.99.1",
+        "@stamhoofd/backend-i18n": "2.100.0",
+        "@stamhoofd/backend-middleware": "2.100.0",
+        "@stamhoofd/email": "2.100.0",
+        "@stamhoofd/models": "2.100.0",
+        "@stamhoofd/queues": "2.100.0",
+        "@stamhoofd/sql": "2.100.0",
+        "@stamhoofd/structures": "2.100.0",
+        "@stamhoofd/utility": "2.100.0",
         "archiver": "^7.0.1",
         "axios": "^1.8.2",
         "cookie": "^0.7.0",
@@ -70,5 +70,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "92d884776091f7182f8699725b7a7b5b8dcf41e7"
+    "gitHead": "648bba95bdd2a6c8665b59e56470289c71e1c0d0"
 }

package/src/endpoints/admin/organizations/PatchOrganizationsEndpoint.ts

@@ -126,7 +126,7 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
             organization.meta = put.meta;
             organization.address = put.address;
 
-            const periodId = (await Platform.getShared()).periodId;
+            const periodId = (await Platform.getShared()).periodIdIfPlatform;
             organization.periodId = periodId;
 
             if (put.privateMeta) {

package/src/endpoints/global/events/PatchEventNotificationsEndpoint.test.ts

@@ -84,12 +84,18 @@ describe('Endpoint.PatchEventNotificationsEndpoint', () => {
     });
 
     test('A normal user can create new event notifications for an event', async () => {
+        const startDate = new Date(2024, 8, 1, 0, 0, 0, 0);
+        const endDate = new Date(2025, 7, 31, 0, 0, 0, 0);
+        const registrationPeriod = await new RegistrationPeriodFactory({ startDate, endDate }).create();
         const organization = await new OrganizationFactory({}).create();
+        registrationPeriod.organizationId = organization.id;
+        await registrationPeriod.save();
+
         const user = await new UserFactory({
             organization,
             permissions: minimumUserPermissions,
         }).create();
-        const event = await new EventFactory({ organization }).create();
+        const event = await new EventFactory({ organization, startDate, endDate }).create();
         const recordCategories = await new RecordCategoryFactory({
             records: [
                 {

package/src/endpoints/global/events/PatchEventNotificationsEndpoint.ts

@@ -1,6 +1,6 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, patchObject, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { Event, EventNotification, RegistrationPeriod, Platform } from '@stamhoofd/models';
+import { Event, EventNotification, Platform, RegistrationPeriod } from '@stamhoofd/models';
 import { EmailTemplateType, EventNotificationStatus, EventNotification as EventNotificationStruct, PermissionLevel, RecordCategory } from '@stamhoofd/structures';
 
 import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
@@ -81,7 +81,7 @@ export class PatchEventNotificationsEndpoint extends Endpoint<Params, Query, Bod
                 if (index === 0) {
                     notification.startDate = model.startDate;
                     notification.endDate = model.endDate;
-                    const period = await RegistrationPeriod.getByDate(model.startDate);
+                    const period = await RegistrationPeriod.getByDate(model.startDate, organization?.id ?? null);
 
                     if (!period) {
                         throw new SimpleError({

package/src/endpoints/global/events/PatchEventsEndpoint.test.ts

@@ -0,0 +1,267 @@
+import { PatchableArray } from '@simonbackx/simple-encoding';
+import { Endpoint, Request } from '@simonbackx/simple-endpoints';
+import { EventFactory, Organization, OrganizationFactory, PlatformEventTypeFactory, RegistrationPeriodFactory, Token, User, UserFactory } from '@stamhoofd/models';
+import { AccessRight, Event, Permissions, PermissionsResourceType, ResourcePermissions } from '@stamhoofd/structures';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
+import { testServer } from '../../../../tests/helpers/TestServer';
+import { PatchEventsEndpoint } from './PatchEventsEndpoint';
+
+const baseUrl = `/events`;
+const endpoint = new PatchEventsEndpoint();
+type EndpointType = typeof endpoint;
+type Body = EndpointType extends Endpoint<any, any, infer B, any> ? B : never;
+
+const minimumUserPermissions = Permissions.create({
+    resources: new Map([
+        [PermissionsResourceType.Groups, new Map([
+            ['', ResourcePermissions.create({
+                accessRights: [AccessRight.EventWrite],
+            })],
+        ])],
+    ]),
+});
+
+const TestRequest = {
+    async patch(options: {
+        body?: Body;
+        user?: User;
+        organization?: Organization;
+    }) {
+        const request = Request.buildJson('PATCH', baseUrl, options.organization?.getApiHost(), options.body);
+        if (options.user) {
+            const token = await Token.createToken(options.user);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+        }
+        return await testServer.test(endpoint, request);
+    },
+};
+
+describe('Endpoint.PatchEventsEndpoint', () => {
+    let admin: User;
+
+    beforeAll(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+
+        admin = await new UserFactory({
+            globalPermissions: Permissions.create({
+                resources: new Map([
+                    [PermissionsResourceType.OrganizationTags, new Map([
+                        ['', ResourcePermissions.create({
+                            accessRights: [
+                                AccessRight.EventWrite,
+                            ],
+                        })],
+                    ])],
+                ]),
+            }),
+        }).create();
+    });
+
+    test('A normal user with write access can create an event', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({
+            organization,
+            permissions: minimumUserPermissions,
+        }).create();
+
+        const body: Body = new PatchableArray();
+        const newEvent = Event.create({
+            organizationId: organization.id,
+            typeId: (await new PlatformEventTypeFactory({}).create()).id,
+            name: 'test event',
+            startDate: new Date(Date.now() + 5 * 24 * 60 * 60 * 1000),
+            endDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+        });
+        body.addPut(newEvent);
+
+        const result = await TestRequest.patch({ body, user, organization });
+        expect(result.status).toBe(200);
+        expect(result.body).toHaveLength(1);
+        expect(result.body[0]).toMatchObject({
+            organizationId: newEvent.organizationId,
+            typeId: newEvent.typeId,
+            name: newEvent.name,
+        });
+    });
+
+    test('A normal user with write access cannot create a global event', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({
+            organization,
+            permissions: minimumUserPermissions,
+        }).create();
+
+        const body: Body = new PatchableArray();
+        const newEvent = Event.create({
+            organizationId: null,
+            typeId: (await new PlatformEventTypeFactory({}).create()).id,
+            name: 'test event',
+            startDate: new Date(Date.now() + 5 * 24 * 60 * 60 * 1000),
+            endDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+        });
+        body.addPut(newEvent);
+
+        await expect(TestRequest.patch({ body, user, organization })).rejects.toThrow(
+            STExpect.simpleError({ code: 'permission_denied' }),
+        );
+    });
+
+    test('A normal user with write access cannot make an event global', async () => {
+        const organization = await new OrganizationFactory({}).create();
+
+        const user = await new UserFactory({
+            organization,
+            permissions: minimumUserPermissions,
+        }).create();
+
+        const startDate = new Date(Date.now() + 5 * 24 * 60 * 60 * 1000);
+        const endDate = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
+
+        const body: Body = new PatchableArray();
+
+        const eventToPatch = await new EventFactory({
+            organization,
+            typeId: (await new PlatformEventTypeFactory({
+                maximum: 5,
+            }).create()).id,
+            name: 'test event',
+            startDate,
+            endDate,
+
+        }).create();
+
+        body.addPatch(Event.patch({
+            id: eventToPatch.id,
+            organizationId: null,
+        }));
+
+        await expect(TestRequest.patch({ body, user, organization })).rejects.toThrow(
+            STExpect.simpleError({ code: 'permission_denied' }),
+        );
+    });
+
+    test('An admin can create a global event', async () => {
+        const organization = await new OrganizationFactory({}).create();
+
+        const body: Body = new PatchableArray();
+        const newEvent = Event.create({
+            organizationId: null,
+            typeId: (await new PlatformEventTypeFactory({}).create()).id,
+            name: 'test event',
+            startDate: new Date(Date.now() + 5 * 24 * 60 * 60 * 1000),
+            endDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+        });
+        body.addPut(newEvent);
+
+        const result = await TestRequest.patch({ body, user: admin, organization });
+        expect(result.status).toBe(200);
+        expect(result.body).toHaveLength(1);
+        expect(result.body[0]).toMatchObject({
+            organizationId: newEvent.organizationId,
+            typeId: newEvent.typeId,
+            name: newEvent.name,
+        });
+    });
+
+    describe('userMode organization', () => {
+        beforeEach(async () => {
+            TestUtils.setEnvironment('userMode', 'organization');
+        });
+
+        test('A normal user with write access can create an event where the type has a maximum', async () => {
+            const organization = await new OrganizationFactory({}).create();
+
+            const user = await new UserFactory({
+                organization,
+                permissions: minimumUserPermissions,
+            }).create();
+
+            const startDate = new Date(Date.now() + 5 * 24 * 60 * 60 * 1000);
+            const endDate = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
+
+            // create registration period
+            await new RegistrationPeriodFactory({
+                startDate,
+                endDate,
+                organization,
+            }).create();
+
+            const body: Body = new PatchableArray();
+            const newEvent = Event.create({
+                organizationId: organization.id,
+                typeId: (await new PlatformEventTypeFactory({
+                    maximum: 5,
+                }).create()).id,
+                name: 'test event',
+                startDate,
+                endDate,
+            });
+            body.addPut(newEvent);
+
+            const result = await TestRequest.patch({ body, user, organization });
+            expect(result.status).toBe(200);
+            expect(result.body).toHaveLength(1);
+            expect(result.body[0]).toMatchObject({
+                organizationId: newEvent.organizationId,
+                typeId: newEvent.typeId,
+                name: newEvent.name,
+            });
+        });
+
+        test('A normal user with write access cannot create a global event', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const user = await new UserFactory({
+                organization,
+                permissions: minimumUserPermissions,
+            }).create();
+
+            const body: Body = new PatchableArray();
+            const newEvent = Event.create({
+                organizationId: null,
+                typeId: (await new PlatformEventTypeFactory({}).create()).id,
+                name: 'test event',
+                startDate: new Date(Date.now() + 5 * 24 * 60 * 60 * 1000),
+                endDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+            });
+            body.addPut(newEvent);
+
+            await expect(TestRequest.patch({ body, user, organization })).rejects.toThrow(
+                STExpect.simpleError({ code: 'permission_denied' }),
+            );
+        });
+
+        test('A normal user with write access cannot make an event global', async () => {
+            const organization = await new OrganizationFactory({}).create();
+
+            const user = await new UserFactory({
+                organization,
+                permissions: minimumUserPermissions,
+            }).create();
+
+            const startDate = new Date(Date.now() + 5 * 24 * 60 * 60 * 1000);
+            const endDate = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
+
+            const body: Body = new PatchableArray();
+
+            const eventToPatch = await new EventFactory({
+                organization,
+                typeId: (await new PlatformEventTypeFactory({
+                    maximum: 5,
+                }).create()).id,
+                name: 'test event',
+                startDate,
+                endDate,
+
+            }).create();
+
+            body.addPatch(Event.patch({
+                id: eventToPatch.id,
+                organizationId: null,
+            }));
+
+            await expect(TestRequest.patch({ body, user, organization })).rejects.toThrow(
+                STExpect.simpleError({ code: 'permission_denied' }),
+            );
+        });
+    });
+});

package/src/endpoints/global/events/PatchEventsEndpoint.ts

@@ -33,7 +33,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
     }
 
     async putEventGroup(event: Event, putGroup: GroupStruct) {
-        const period = await RegistrationPeriod.getByDate(event.startDate);
+        const period = await RegistrationPeriod.getByDate(event.startDate, event.organizationId);
 
         if (!period) {
             throw new SimpleError({
@@ -252,7 +252,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                     patch.group.id = event.groupId;
                     patch.group.type = GroupType.EventRegistration;
 
-                    const period = await RegistrationPeriod.getByDate(event.startDate);
+                    const period = await RegistrationPeriod.getByDate(event.startDate, event.organizationId);
                     group = await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(patch.group, period);
                 }
                 else {
@@ -274,7 +274,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             else {
                 if (patch.startDate || patch.endDate) {
                     // Correct period id if needed
-                    const period = await RegistrationPeriod.getByDate(event.startDate);
+                    const period = await RegistrationPeriod.getByDate(event.startDate, event.organizationId);
                     if (event.groupId) {
                         await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
                             if (event.groupId) {
@@ -439,7 +439,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
         }
 
         if (type.maximum && (!event.existsInDatabase || ('typeId' in (await event.getChangedDatabaseProperties()).fields))) {
-            const currentPeriod = await RegistrationPeriod.getByDate(event.startDate);
+            const currentPeriod = await RegistrationPeriod.getByDate(event.startDate, event.organizationId);
             console.log('event.startDate', event.startDate);
             if (currentPeriod) {
                 const count = await SQL.select().from(

package/src/endpoints/global/members/GetMembersEndpoint.ts

@@ -62,7 +62,7 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
                                         $in: tags,
                                     },
                                 },
-                                periodId: platform.periodId,
+                                periodId: platform.periodIdIfPlatform,
                             },
                         },
                     };

package/src/endpoints/global/members/PatchOrganizationMembersEndpoint.ts

@@ -306,7 +306,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                         }
                     }
                     else {
-                        if (registration.periodId !== platform.periodId) {
+                        if (registration.periodId !== platform.periodIdIfPlatform) {
                             return false;
                         }
                     }

package/src/endpoints/global/organizations/SearchOrganizationEndpoint.test.ts

@@ -1,7 +1,8 @@
 import { Request } from '@simonbackx/simple-endpoints';
-import { Organization, OrganizationFactory } from '@stamhoofd/models';
+import { OrganizationFactory } from '@stamhoofd/models';
 import { v4 as uuidv4 } from 'uuid';
 
+import { Database } from '@simonbackx/simple-database';
 import { testServer } from '../../../../tests/helpers/TestServer';
 import { SearchOrganizationEndpoint } from './SearchOrganizationEndpoint';
 
@@ -10,7 +11,9 @@ describe('Endpoint.SearchOrganization', () => {
     const endpoint = new SearchOrganizationEndpoint();
 
     afterEach(async () => {
-        await Organization.delete();
+        await Database.update('UPDATE registration_periods set organizationId = null, customName = ? where organizationId is not null', ['delete']);
+        await Database.delete('DELETE FROM `organizations`');
+        await Database.delete('DELETE FROM `registration_periods` where customName = ?', ['delete']);
     });
 
     test('Search for a given organization using exact search', async () => {

package/src/endpoints/global/platform/PatchPlatformEnpoint.test.ts

@@ -0,0 +1,63 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { Organization, OrganizationFactory, Platform, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
+import { PermissionLevel, Permissions, PlatformConfig, Platform as PlatformStruct, Version } from '@stamhoofd/structures';
+
+import { AutoEncoderPatchType } from '@simonbackx/simple-encoding';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { testServer } from '../../../../tests/helpers/TestServer';
+import { PatchPlatformEndpoint } from './PatchPlatformEnpoint';
+
+describe('Endpoint.PatchPlatform', () => {
+    // Test endpoint
+    const endpoint = new PatchPlatformEndpoint();
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    const patchPlatform = async ({ patch, organization, token }: { patch: AutoEncoderPatchType<PlatformStruct>; organization: Organization; token: Token }) => {
+        const request = Request.buildJson('PATCH', `/v${Version}/platform`, organization.getApiHost(), patch);
+        request.headers.authorization = 'Bearer ' + token.accessToken;
+        return await testServer.test(endpoint, request);
+    };
+
+    describe('userMode organization', () => {
+        beforeEach(async () => {
+            TestUtils.setEnvironment('userMode', 'organization');
+        });
+
+        test('Should return platform with global period', async () => {
+            const organization = await new OrganizationFactory({ }).create();
+
+            const admin = await new UserFactory({
+                organization,
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+
+            admin.organizationId = null;
+            await admin.save();
+
+            const token = await Token.createToken(admin);
+
+            const patch = PlatformStruct.patch({
+                config: PlatformConfig.patch({
+                    name: 'new name',
+                }),
+            });
+
+            // make sure no platform exists
+            await Platform.delete().where('id', '1');
+
+            // create global registration period
+            await new RegistrationPeriodFactory({
+            }).create();
+
+            const response = await patchPlatform({ patch, organization, token });
+            const periodId = response.body.period.id;
+            const period = await RegistrationPeriod.getByID(periodId);
+
+            expect(period).toBeDefined();
+            expect(period?.organizationId).toBeNull();
+        });
+    });
+});

package/src/endpoints/global/platform/PatchPlatformEnpoint.ts

@@ -7,11 +7,11 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { QueueHandler } from '@stamhoofd/queues';
 import { Context } from '../../../helpers/Context';
 import { MembershipCharger } from '../../../helpers/MembershipCharger';
+import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
 import { PeriodHelper } from '../../../helpers/PeriodHelper';
 import { SetupStepUpdater } from '../../../helpers/SetupStepUpdater';
 import { TagHelper } from '../../../helpers/TagHelper';
 import { PlatformMembershipService } from '../../../services/PlatformMembershipService';
-import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
 
 type Params = Record<string, never>;
 type Query = undefined;

package/src/endpoints/global/registration/GetRegistrationsEndpoint.ts

@@ -80,7 +80,7 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
 
                     // Add organization scope filter
                     scopeFilter = {
-                        periodId: platform.periodId,
+                        periodId: platform.periodIdIfPlatform,
                         organization: {
                             $elemMatch: {
                                 tags: {

package/src/endpoints/global/registration/RegisterMembersEndpoint.test.ts

@@ -1,6 +1,6 @@
 import { Request } from '@simonbackx/simple-endpoints';
 import { EmailMocker } from '@stamhoofd/email';
-import { BalanceItem, BalanceItemFactory, Group, GroupFactory, MemberFactory, MemberWithRegistrations, Organization, OrganizationFactory, OrganizationRegistrationPeriodFactory, Registration, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
+import { BalanceItemFactory, Group, GroupFactory, MemberFactory, MemberWithRegistrations, Organization, OrganizationFactory, OrganizationRegistrationPeriodFactory, Registration, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import { BalanceItemCartItem, BalanceItemType, Company, GroupOption, GroupOptionMenu, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, OrganizationPackages, PaymentCustomer, PaymentMethod, PermissionLevel, Permissions, ReduceablePrice, RegisterItemOption, STPackageStatus, STPackageType, UserPermissions, Version } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { v4 as uuidv4 } from 'uuid';
@@ -59,8 +59,8 @@ describe('Endpoint.RegisterMembers', () => {
             organization,
             permissions: permissionLevel !== PermissionLevel.None
                 ? Permissions.create({
-                    level: permissionLevel,
-                })
+                        level: permissionLevel,
+                    })
                 : null,
         })
             .create();
@@ -105,6 +105,7 @@ describe('Endpoint.RegisterMembers', () => {
 
         test('Should fail if demo limit reached', async () => {
             TestUtils.setEnvironment('userMode', 'organization');
+
             const { member, group, groupPrice, organization, token, otherMembers } = await initData({ otherMemberAmount: 10 });
 
             organization.meta.packages = OrganizationPackages.create({

package/src/endpoints/global/registration-periods/GetRegistrationPeriodsEndpoint.ts

@@ -116,6 +116,8 @@ export class GetRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Body
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setUserOrganizationScope();
+
         if (request.request.getVersion() < 371) {
             throw new SimpleError({
                 code: 'client_update_required',
@@ -143,8 +145,6 @@ export class GetRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Body
             });
         }
 
-        await Context.setUserOrganizationScope();
-
         return new Response(
             await GetRegistrationPeriodsEndpoint.buildData(request.query),
         );

package/src/endpoints/global/registration-periods/PatchRegistrationPeriodsEndpoint.ts

@@ -36,7 +36,14 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
     static async isCurrentRegistrationPeriod(organizationId: string | null, periodId: string) {
         if (organizationId === null) {
             const platform = await Platform.getSharedStruct();
-            return platform.period.id === periodId;
+            if (STAMHOOFD.userMode === 'platform') {
+                return platform.period.id === periodId;
+            }
+            throw new SimpleError({
+                code: 'only_platform',
+                message: 'Period id should only be used if userMode is platform',
+                human: $t(`8a50ee7d-f37e-46cc-9ce7-30c7b37cefe8`),
+            });
         }
 
         const organization = await Organization.getByID(organizationId);
@@ -73,7 +80,7 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
             if (put.endDate < put.startDate) {
                 throw new SimpleError({
                     code: 'invalid_field',
-                    message: $t('De einddatum moet na de startdatum liggen.'),
+                    message: $t('186723cd-2cd4-45fd-aa9c-020c9d92b225'),
                     field: 'endDate',
                 });
             }
@@ -141,7 +148,7 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
             if ((patch.startDate || patch.endDate) && model.endDate < model.startDate) {
                 throw new SimpleError({
                     code: 'invalid_field',
-                    message: $t('De einddatum moet na de startdatum liggen.'),
+                    message: $t('186723cd-2cd4-45fd-aa9c-020c9d92b225'),
                     field: 'endDate',
                 });
             }