@stamhoofd/backend 2.83.4 → 2.84.0

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

@@ -49,11 +49,6 @@ export class GetEmailTemplatesEndpoint extends Endpoint<Params, Query, Body, Res
                 throw Context.auth.error();
             }
         }
-        else {
-            if (!Context.auth.hasPlatformFullAccess()) {
-                throw Context.auth.error();
-            }
-        }
 
         if (request.query.types?.length === 0) {
             throw new SimpleError({
@@ -120,6 +115,14 @@ export class GetEmailTemplatesEndpoint extends Endpoint<Params, Query, Body, Res
             defaultTemplates.unshift(...orgDefaults);
         }
 
-        return new Response(templates.concat(defaultTemplates).map(template => EmailTemplateStruct.create(template)));
+        const allTemplates: EmailTemplate[] = [];
+
+        for (const template of templates.concat(defaultTemplates)) {
+            if (await Context.auth.canAccessEmailTemplate(template)) {
+                allTemplates.push(template);
+            }
+        }
+
+        return new Response(allTemplates.map(template => EmailTemplateStruct.create(template)));
     }
 }

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

@@ -0,0 +1,88 @@
+import { PatchableArray, PatchableArrayAutoEncoder } from '@simonbackx/simple-encoding';
+import { Request } from '@simonbackx/simple-endpoints';
+import { EmailTemplate, GroupFactory, Organization, OrganizationFactory, Platform, RegistrationPeriod, 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 { testServer } from '../../../../../tests/helpers/TestServer';
+import { PatchEmailTemplatesEndpoint } from './PatchEmailTemplatesEndpoint';
+
+const baseUrl = `/v${Version}/email-templates`;
+
+describe('Endpoint.PatchEmailTemplatesEndpoint', () => {
+    const endpoint = new PatchEmailTemplatesEndpoint();
+    let period: RegistrationPeriod;
+
+    const patchEmailTemplates = async (body: PatchableArrayAutoEncoder<EmailTemplateStruct>, token: Token, organization?: Organization) => {
+        const request = Request.buildJson('PATCH', baseUrl, organization?.getApiHost(), body);
+        request.headers.authorization = 'Bearer ' + token.accessToken;
+        return await testServer.test(endpoint, request);
+    };
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    beforeAll(async () => {
+        period = await new RegistrationPeriodFactory({
+            startDate: new Date(2023, 0, 1),
+            endDate: new Date(2023, 11, 31),
+        }).create();
+    });
+
+    describe('User with platform role who has full permission for all organizations', () => {
+        test('should be allowed to patch templates for organizations', async () => {
+            const role = PermissionRoleDetailed.create({
+                name: 'Beroepsmedewerker',
+                resources: new Map([[PermissionsResourceType.OrganizationTags, new Map([[
+                    '',
+                    ResourcePermissions.create({
+                        level: PermissionLevel.Full,
+                    }),
+                ]])]]),
+            });
+
+            const globalPermissions = Permissions.create({
+                level: PermissionLevel.None,
+                roles: [
+                    role,
+                ],
+            });
+
+            const platform = await Platform.getForEditing();
+            platform.privateConfig.roles.push(role);
+            await platform.save();
+
+            const user = await new UserFactory({
+                globalPermissions,
+            })
+                .create();
+
+            const organization = await new OrganizationFactory({ period }).create();
+            const group = await new GroupFactory({ organization }).create();
+
+            const token = await Token.createToken(user);
+
+            const template = new EmailTemplate();
+            template.subject = 'test template 1';
+            template.type = EmailTemplateType.RegistrationConfirmation;
+            template.json = {};
+            template.html = 'html test';
+            template.text = 'text test';
+            template.organizationId = organization.id;
+            template.groupId = group.id;
+            await template.save();
+
+            const body: PatchableArrayAutoEncoder<EmailTemplateStruct> = new PatchableArray();
+
+            body.addPatch(
+                EmailTemplateStruct.patch(({
+                    id: template.id,
+                    subject: 'new subject',
+                })),
+            );
+
+            const response = await patchEmailTemplates(body, token);
+            expect(response.body).toBeDefined();
+        });
+    });
+});

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

@@ -4,7 +4,6 @@ import { EmailTemplate, Group, Webshop } from '@stamhoofd/models';
 import { EmailTemplate as EmailTemplateStruct, PermissionLevel } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context';
-import { SimpleError } from '@simonbackx/simple-errors';
 
 type Params = Record<string, never>;
 type Body = PatchableArrayAutoEncoder<EmailTemplateStruct>;
@@ -37,11 +36,6 @@ export class PatchEmailTemplatesEndpoint extends Endpoint<Params, Query, Body, R
                 throw Context.auth.error();
             }
         }
-        else {
-            if (!Context.auth.hasPlatformFullAccess()) {
-                throw Context.auth.error();
-            }
-        }
 
         const templates: EmailTemplate[] = [];
 

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

@@ -2,7 +2,7 @@ import { AutoEncoderPatchType, cloneObject, Decoder, isPatchableArray, isPatchMa
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
 import { Organization, OrganizationRegistrationPeriod, PayconiqPayment, Platform, RegistrationPeriod, StripeAccount, Webshop } from '@stamhoofd/models';
-import { BuckarooSettings, Company, MemberResponsibility, OrganizationMetaData, OrganizationPatch, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel, PermissionRoleDetailed, PermissionRoleForResponsibility, PermissionsResourceType, ResourcePermissions } from '@stamhoofd/structures';
+import { BuckarooSettings, Company, MemberResponsibility, OrganizationMetaData, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel, PermissionRoleDetailed, PermissionRoleForResponsibility, PermissionsResourceType, ResourcePermissions } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
@@ -23,7 +23,7 @@ type ResponseBody = OrganizationStruct;
  */
 
 export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = OrganizationPatch as Decoder<AutoEncoderPatchType<OrganizationStruct>>;
+    bodyDecoder = OrganizationStruct.patchType() as Decoder<AutoEncoderPatchType<OrganizationStruct>>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'PATCH') {
@@ -330,7 +330,8 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                 if (!organizationPeriod || organizationPeriod.organizationId !== organization.id) {
                     throw new SimpleError({
                         code: 'invalid_field',
-                        message: 'De periode die je wilt instellen bestaat niet (meer)',
+                        message: 'The period you want to set does not exist (anymore)',
+                        human: $t('a3795bf6-ed50-4aa6-9caf-33820292c159'),
                         field: 'period',
                     });
                 }
@@ -339,7 +340,8 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                 if (!period || (period.organizationId && period.organizationId !== organization.id)) {
                     throw new SimpleError({
                         code: 'invalid_field',
-                        message: 'De periode die je wilt instellen bestaat niet (meer)',
+                        message: 'The period you want to set does not exist (anymore)',
+                        human: $t('a3795bf6-ed50-4aa6-9caf-33820292c159'),
                         field: 'period',
                     });
                 }
@@ -347,7 +349,8 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                 if (period.locked) {
                     throw new SimpleError({
                         code: 'invalid_field',
-                        message: 'De periode die je wilt instellen is reeds afgesloten',
+                        message: 'The period you want to set is already closed',
+                        human: $t('b6bc2fef-71ac-43a1-b430-50945427a9e3'),
                         field: 'period',
                     });
                 }
@@ -356,7 +359,8 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                 if (period.startDate > new Date(Date.now() + maximumStart)) {
                     throw new SimpleError({
                         code: 'invalid_field',
-                        message: 'Het werkjaar die je wilt instellen is nog niet gestart',
+                        message: 'The period you want to set has not started yet',
+                        human: $t('e0fff936-3f3c-46b8-adcf-c723c33907a2'),
                         field: 'period',
                     });
                 }

package/src/endpoints/organization/dashboard/payments/GetMemberBalanceEndpoint.ts

@@ -1,15 +1,15 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { BalanceItem, Member } from '@stamhoofd/models';
-import { BalanceItemWithPayments } from '@stamhoofd/structures';
 
-import { Context } from '../../../../helpers/Context';
+import { SimpleError } from '@simonbackx/simple-errors';
 
 type Params = { id: string };
 type Query = undefined;
 type Body = undefined;
-type ResponseBody = BalanceItemWithPayments[];
+type ResponseBody = undefined;
 
-// Rename to ReceiveableBalance
+/**
+ * @deprecated
+ */
 export class GetMemberBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {
@@ -24,25 +24,10 @@ export class GetMemberBalanceEndpoint extends Endpoint<Params, Query, Body, Resp
         return [false];
     }
 
-    async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
-        await Context.authenticate();
-
-        if (!await Context.auth.hasSomeAccess(organization.id)) {
-            throw Context.auth.error();
-        }
-
-        const member = (await Member.getWithRegistrations(request.params.id));
-
-        if (!member || !await Context.auth.hasFinancialMemberAccess(member)) {
-            throw Context.auth.notFoundOrNoAccess($t(`baf6fd8e-1937-4c8b-8510-fa811473c157`));
-        }
-
-        // Get all balance items for this member or users
-        const balanceItems = await BalanceItem.balanceItemsForUsersAndMembers(organization.id, member.users.map(u => u.id), [member.id]);
-
-        return new Response(
-            await BalanceItem.getStructureWithPayments(balanceItems),
-        );
+    async handle(_: DecodedRequest<Params, Query, Body>): Promise<Response<ResponseBody>> {
+        throw new SimpleError({
+            code: 'moved',
+            message: 'This endpoint has been moved to /receivable-balances/member/@id',
+        });
     }
 }

package/src/endpoints/organization/dashboard/payments/PatchBalanceItemsEndpoint.ts

@@ -231,11 +231,6 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
             }
         });
 
-        await BalanceItem.updateOutstanding(updateOutstandingBalance, additionalItems);
-
-        // Reallocate
-        await BalanceItemService.reallocate(updateOutstandingBalance, organization.id);
-
         // Reload returnedModels
         const returnedModelsReloaded = await BalanceItem.getByIDs(...returnedModels.map(m => m.id));
 

package/src/endpoints/organization/dashboard/payments/PatchPaymentsEndpoint.ts

@@ -198,11 +198,6 @@ export class PatchPaymentsEndpoint extends Endpoint<Params, Query, Body, Respons
                 for (const balanceItem of balanceItems) {
                     await BalanceItemService.markUpdated(balanceItem, payment, organization);
                 }
-
-                await BalanceItem.updateOutstanding(balanceItems);
-
-                // Reallocate
-                await BalanceItemService.reallocate(balanceItems, organization.id);
             }
 
             changedPayments.push(payment);

package/src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalanceEndpoint.ts

@@ -5,6 +5,7 @@ import { BalanceItem, BalanceItemPayment, CachedBalance, Payment } from '@stamho
 import { Context } from '../../../../helpers/Context';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { SQL } from '@stamhoofd/sql';
+import { BalanceItemService } from '../../../../services/BalanceItemService';
 
 type Params = { id: string; type: ReceivableBalanceType };
 type Query = undefined;
@@ -37,6 +38,9 @@ export class GetReceivableBalanceEndpoint extends Endpoint<Params, Query, Body,
             throw Context.auth.error();
         }
 
+        // Flush caches (this makes sure that we do a reload in the frontend after a registration or change, we get the newest balances)
+        await BalanceItemService.flushCaches(organization.id);
+
         const balanceItemModels = await CachedBalance.balanceForObjects(organization.id, [request.params.id], request.params.type, true);
         let paymentModels: Payment[] = [];
 

package/src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalancesEndpoint.ts

@@ -9,6 +9,7 @@ import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStruct
 import { Context } from '../../../../helpers/Context';
 import { receivableBalanceFilterCompilers } from '../../../../sql-filters/receivable-balances';
 import { receivableBalanceSorters } from '../../../../sql-sorters/receivable-balances';
+import { BalanceItemService } from '../../../../services/BalanceItemService';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;

package/src/endpoints/organization/dashboard/registration-periods/GetOrganizationRegistrationPeriodsEndpoint.test.ts

@@ -1,20 +1,28 @@
 import { Request } from '@simonbackx/simple-endpoints';
 import { GroupFactory, Organization, OrganizationFactory, OrganizationRegistrationPeriodFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
-import { GroupType, PermissionLevel, Permissions, Version } from '@stamhoofd/structures';
+import { GroupType, LimitedFilteredRequest, PermissionLevel, Permissions } from '@stamhoofd/structures';
 import { testServer } from '../../../../../tests/helpers/TestServer';
-import { PatchRegistrationPeriodsEndpoint } from './GetOrganizationRegistrationPeriodsEndpoint';
+import { GetOrganizationRegistrationPeriodsEndpoint } from './GetOrganizationRegistrationPeriodsEndpoint';
 
-const baseUrl = `/v${Version}/organization/registration-periods`;
+const baseUrl = `/organization/registration-periods`;
 
 describe('Endpoint.GetOrganizationRegistrationPeriods', () => {
-    const endpoint = new PatchRegistrationPeriodsEndpoint();
+    const endpoint = new GetOrganizationRegistrationPeriodsEndpoint();
 
     let registrationPeriod1: RegistrationPeriod;
     let registrationPeriod2: RegistrationPeriod;
 
     const get = async (organization: Organization, token: Token) => {
-        const request = Request.buildJson('GET', baseUrl, organization.getApiHost());
-        request.headers.authorization = 'Bearer ' + token.accessToken;
+        const request = Request.get({
+            path: baseUrl,
+            host: organization.getApiHost(),
+            query: new LimitedFilteredRequest({
+                limit: 100,
+            }),
+            headers: {
+                authorization: 'Bearer ' + token.accessToken,
+            },
+        });
         return await testServer.test(endpoint, request);
     };
 
@@ -36,11 +44,11 @@ describe('Endpoint.GetOrganizationRegistrationPeriods', () => {
             .create();
     };
 
-    describe('groups', () => {
+    describe('Groups', () => {
         test('Should contain waiting lists', async () => {
             // arrange
             const organization = await initOrganization(registrationPeriod1);
-            await new OrganizationRegistrationPeriodFactory({
+            const organizationPeriod = await new OrganizationRegistrationPeriodFactory({
                 organization,
                 period: registrationPeriod1,
             }).create();
@@ -74,19 +82,21 @@ describe('Endpoint.GetOrganizationRegistrationPeriods', () => {
 
             const groupWithWaitingList = await new GroupFactory({
                 organization,
+                waitingListId: waitingList1.id,
             }).create();
 
-            groupWithWaitingList.waitingListId = waitingList1.id;
-            await groupWithWaitingList.save();
+            // Make sure the group is in a category of the organization period
+            organizationPeriod.settings.rootCategory?.groupIds.push(groupWithWaitingList.id);
+            await organizationPeriod.save();
 
             // act
             const result = await get(organization, token);
 
             // assert
             expect(result.body).toBeDefined();
-            expect(result.body.organizationPeriods.length).toBe(1);
-            const organizationPeriod = result.body.organizationPeriods[0];
-            const groups = organizationPeriod.groups;
+            expect(result.body.results.length).toBe(1);
+            const organizationPeriodStruct = result.body.results[0];
+            const groups = organizationPeriodStruct.groups;
             expect(groups.length).toBe(3);
             expect(groups).toEqual(expect.arrayContaining([
                 expect.objectContaining({
@@ -99,13 +109,13 @@ describe('Endpoint.GetOrganizationRegistrationPeriods', () => {
                     id: waitingList2.id,
                 }),
             ]));
-            expect(organizationPeriod.waitingLists.length).toBe(2);
+            expect(organizationPeriodStruct.waitingLists.length).toBe(2);
         });
 
-        test('Should contain only groups of the organization registration period', async () => {
+        test('Should not contain groups of other organizations or periods', async () => {
             // arrange
             const organization = await initOrganization(registrationPeriod1);
-            await new OrganizationRegistrationPeriodFactory({
+            const organizationPeriod = await new OrganizationRegistrationPeriodFactory({
                 organization,
                 period: registrationPeriod1,
             }).create();
@@ -130,13 +140,28 @@ describe('Endpoint.GetOrganizationRegistrationPeriods', () => {
                 period: registrationPeriod1,
             }).create();
 
+            // Make sure the groups are in a category of the organization period
+            organizationPeriod.settings.rootCategory?.groupIds.push(group1.id);
+            organizationPeriod.settings.rootCategory?.groupIds.push(group2.id);
+
+            await organizationPeriod.save();
+
             // group list of other organization
             const otherOrganization = await initOrganization(registrationPeriod1);
+            const otherOrganizationPeriod = await new OrganizationRegistrationPeriodFactory({
+                organization: otherOrganization,
+                period: registrationPeriod1,
+            }).create();
 
-            await new GroupFactory({
+            const otherGroup1 = await new GroupFactory({
                 organization: otherOrganization,
+                period: registrationPeriod1,
             }).create();
 
+            // Add the group to the other organization's period
+            otherOrganizationPeriod.settings.rootCategory?.groupIds.push(otherGroup1.id);
+            await otherOrganizationPeriod.save();
+
             // group of other period
             await new GroupFactory({
                 organization,
@@ -148,8 +173,8 @@ describe('Endpoint.GetOrganizationRegistrationPeriods', () => {
 
             // assert
             expect(result.body).toBeDefined();
-            expect(result.body.organizationPeriods.length).toBe(1);
-            const groups = result.body.organizationPeriods[0].groups;
+            expect(result.body.results.length).toBe(1);
+            const groups = result.body.results[0].groups;
             expect(groups.length).toBe(2);
             expect(groups).toEqual(expect.arrayContaining([
                 expect.objectContaining({

package/src/endpoints/organization/dashboard/registration-periods/GetOrganizationRegistrationPeriodsEndpoint.ts

@@ -1,20 +1,26 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { RegistrationPeriodList, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct } from '@stamhoofd/structures';
+import { assertSort, CountFilteredRequest, getSortFilter, LimitedFilteredRequest, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, PaginatedResponse, StamhoofdFilter } from '@stamhoofd/structures';
 
-import { Group, OrganizationRegistrationPeriod, RegistrationPeriod } from '@stamhoofd/models';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { OrganizationRegistrationPeriod } from '@stamhoofd/models';
+import { applySQLSorter, compileToSQLFilter, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
-import { Sorter } from '@stamhoofd/utility';
+import { organizationRegistrationPeriodFilterCompilers } from '../../../../sql-filters/organization-registration-periods';
+import { organizationRegistrationPeriodSorters } from '../../../../sql-sorters/organization-registration-periods';
+import { Decoder } from '@simonbackx/simple-encoding';
 
 type Params = Record<string, never>;
-type Query = undefined;
+type Query = LimitedFilteredRequest;
 type Body = undefined;
-type ResponseBody = RegistrationPeriodList;
+type ResponseBody = PaginatedResponse<OrganizationRegistrationPeriodStruct[], LimitedFilteredRequest>;
 
-/**
- * One endpoint to create, patch and delete members and their registrations and payments
- */
+const filterCompilers: SQLFilterDefinitions = organizationRegistrationPeriodFilterCompilers;
+const sorters: SQLSortDefinitions<OrganizationRegistrationPeriod> = organizationRegistrationPeriodSorters;
+
+export class GetOrganizationRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
 
-export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {
             return [false];
@@ -28,38 +34,147 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
         return [false];
     }
 
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+        const organization = Context.organization;
+        let scopeFilter: StamhoofdFilter | undefined = undefined;
+
+        if (organization) {
+            scopeFilter = {
+                organizationId: organization.id,
+            };
+        }
+
+        const query = OrganizationRegistrationPeriod.select();
+
+        if (scopeFilter) {
+            query.where(await compileToSQLFilter(scopeFilter, filterCompilers));
+        }
+
+        if (q.filter) {
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
+        }
+
+        if (q.search) {
+            let searchFilter: StamhoofdFilter | null = null;
+
+            searchFilter = {
+                id: q.search,
+            };
+
+            if (searchFilter) {
+                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
+            }
+        }
+
+        if (q instanceof LimitedFilteredRequest) {
+            if (q.pageFilter) {
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
+            }
+
+            q.sort = assertSort(q.sort, [{ key: 'id' }]);
+            applySQLSorter(query, q.sort, sorters);
+            query.limit(q.limit);
+        }
+
+        return query;
+    }
+
+    static async buildData(requestQuery: LimitedFilteredRequest) {
+        const query = await GetOrganizationRegistrationPeriodsEndpoint.buildQuery(requestQuery);
+        const organizationRegistrationPeriods = await query.fetch();
+
+        let next: LimitedFilteredRequest | undefined;
+
+        if (organizationRegistrationPeriods.length >= requestQuery.limit) {
+            const lastObject = organizationRegistrationPeriods[organizationRegistrationPeriods.length - 1];
+            const nextFilter = getSortFilter(lastObject, sorters, requestQuery.sort);
+
+            next = new LimitedFilteredRequest({
+                filter: requestQuery.filter,
+                pageFilter: nextFilter,
+                sort: requestQuery.sort,
+                limit: requestQuery.limit,
+                search: requestQuery.search,
+            });
+
+            if (JSON.stringify(nextFilter) === JSON.stringify(requestQuery.pageFilter)) {
+                console.error('Found infinite loading loop for', requestQuery);
+                next = undefined;
+            }
+        }
+
+        return new PaginatedResponse<OrganizationRegistrationPeriodStruct[], LimitedFilteredRequest>({
+            results: await AuthenticatedStructures.organizationRegistrationPeriods(organizationRegistrationPeriods),
+            next,
+        });
+    }
+
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
+        if (request.request.getVersion() < 371) {
+            throw new SimpleError({
+                code: 'client_update_required',
+                statusCode: 400,
+                message: 'Er is een noodzakelijke update beschikbaar. Herlaad de pagina en wis indien nodig de cache van jouw browser.',
+                human: $t(`adb0e7c8-aed7-43f5-bfcc-a350f03aaabe`),
+            });
+        }
+
+        const organization = await Context.setOptionalOrganizationScope();
         await Context.authenticate();
 
-        if (!await Context.auth.hasSomeAccess(organization.id)) {
-            throw Context.auth.error();
+        if (organization) {
+            if (!await Context.auth.hasSomeAccess(organization.id)) {
+                throw Context.auth.error();
+            }
+        }
+        else {
+            if (!Context.auth.hasPlatformFullAccess()) {
+                throw Context.auth.error();
+            }
         }
 
-        const organizationPeriods = await OrganizationRegistrationPeriod.where({ organizationId: organization.id });
-        const periods = await RegistrationPeriod.all();
-        const groups = await Group.getAll(organization.id, null);
+        const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 100;
 
-        const structs: OrganizationRegistrationPeriodStruct[] = [];
+        if (request.query.limit > maxLimit) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be more than ' + maxLimit,
+            });
+        }
 
-        for (const period of periods) {
-            const organizationPeriod = organizationPeriods.find(p => p.periodId == period.id);
-            if (!organizationPeriod) {
-                continue;
-            }
+        if (request.query.limit < 1) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be less than 1',
+            });
+        }
 
-            const gs = groups.filter(g => g.periodId === period.id);
-            structs.push(organizationPeriod.getStructure(period, gs));
+        return new Response(
+            await GetOrganizationRegistrationPeriodsEndpoint.buildData(request.query),
+        );
+    }
+
+    /* async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        if (!await Context.auth.hasSomeAccess(organization.id)) {
+            throw Context.auth.error();
         }
 
+        const organizationPeriods = await OrganizationRegistrationPeriod.select().where('organizationId', organization.id).fetch();
+        const periods = await RegistrationPeriod.all();
+
         // Sort
         periods.sort((a, b) => Sorter.byDateValue(a.startDate, b.startDate));
 
         return new Response(
             RegistrationPeriodList.create({
-                organizationPeriods: structs,
+                organizationPeriods: await AuthenticatedStructures.organizationRegistrationPeriods(organizationPeriods, periods),
                 periods: periods.map(p => p.getStructure()),
             }),
         );
-    }
+    } */
 }