@stamhoofd/backend 2.83.5 → 2.84.1

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

@@ -4,8 +4,8 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Email } from '@stamhoofd/email';
-import { BalanceItem, BalanceItemPayment, Group, Member, MemberWithRegistrations, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment, Platform, RateLimiter, Registration, User } from '@stamhoofd/models';
-import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItem as BalanceItemStruct, BalanceItemType, IDRegisterCheckout, PaymentCustomer, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, Payment as PaymentStruct, PaymentType, PermissionLevel, PlatformFamily, PlatformMember, RegisterItem, RegisterResponse, Version } from '@stamhoofd/structures';
+import { BalanceItem, BalanceItemPayment, CachedBalance, Group, Member, MemberWithRegistrations, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment, Platform, RateLimiter, Registration, User } from '@stamhoofd/models';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItem as BalanceItemStruct, BalanceItemType, IDRegisterCheckout, PaymentCustomer, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, Payment as PaymentStruct, PaymentType, PermissionLevel, PlatformFamily, PlatformMember, RegisterItem, RegisterResponse, TranslatedString, Version } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -99,6 +99,9 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
         }
 
+        // Update balances before we start
+        await BalanceItemService.flushCaches(organization.id);
+
         const deleteRegistrationIds = request.body.cart.deleteRegistrationIds;
         const deleteRegistrationModels = (deleteRegistrationIds.length ? (await Registration.getByIDs(...deleteRegistrationIds)) : []).filter(r => r.organizationId === organization.id);
 
@@ -117,10 +120,17 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             memberBalanceItemsStructs = balanceItemsModels.map(i => i.getStructure());
         }
 
-        const memberIds = Formatter.uniqueArray(
-            [...request.body.memberIds, ...deleteRegistrationModels.map(i => i.memberId), ...balanceItemsModels.map(i => i.memberId).filter(m => m !== null)],
-        );
-        const members = await Member.getBlobByIds(...memberIds);
+        let members: MemberWithRegistrations[] = [];
+        if (request.body.asOrganizationId) {
+            const memberIds = Formatter.uniqueArray(
+                [...request.body.memberIds, ...deleteRegistrationModels.map(i => i.memberId), ...balanceItemsModels.map(i => i.memberId).filter(m => m !== null)],
+            );
+            members = await Member.getBlobByIds(...memberIds);
+        }
+        else {
+            // Load the user family (required to correctly calculate discounts across family members)
+            members = await Member.getMembersWithRegistrationForUser(user);
+        }
         const groupIds = request.body.groupIds;
         const groups = await Group.getByIDs(...groupIds);
 
@@ -144,17 +154,38 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
         }
 
-        const blob = await AuthenticatedStructures.membersBlob(members, true);
         const platformMembers: PlatformMember[] = [];
 
         if (request.body.asOrganizationId) {
-            const _m = PlatformFamily.createSingles(blob, {
-                platform: await Platform.getSharedStruct(),
-                contextOrganization: await AuthenticatedStructures.organization(organization),
-            });
-            platformMembers.push(..._m);
+            const memberIds = Formatter.uniqueArray(
+                [...request.body.memberIds, ...deleteRegistrationModels.map(i => i.memberId), ...balanceItemsModels.map(i => i.memberId).filter(m => m !== null)],
+            );
+
+            // todo: optimize performance of this
+            // Load family for each member
+            // this is required for family based discounts
+            const platformStruct = await Platform.getSharedStruct();
+            const contextOrganization = await AuthenticatedStructures.organization(organization);
+            for (const memberId of memberIds) {
+                const familyMembers = (await Member.getFamilyWithRegistrations(memberId));
+                members.push(...familyMembers);
+                const blob = await AuthenticatedStructures.membersBlob(familyMembers, true);
+                const family = PlatformFamily.create(blob, {
+                    platform: platformStruct,
+                    contextOrganization,
+                });
+                const platformMember = family.members.find(m => m.id === memberId);
+                if (!platformMember) {
+                    throw new SimpleError({
+                        code: 'invalid_data',
+                        message: 'Something went wrong while configuring the data',
+                    });
+                }
+                platformMembers.push(platformMember);
+            }
         }
         else {
+            const blob = await AuthenticatedStructures.membersBlob(members, true);
             const family = PlatformFamily.create(blob, {
                 platform: await Platform.getSharedStruct(),
                 contextOrganization: await AuthenticatedStructures.organization(organization),
@@ -190,9 +221,6 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         // Validate the cart
         checkout.validate({ memberBalanceItems: memberBalanceItemsStructs });
 
-        // Recalculate the price
-        checkout.updatePrices();
-
         const totalPrice = checkout.totalPrice;
 
         if (totalPrice !== request.body.totalPrice) {
@@ -202,13 +230,6 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             });
         }
 
-        if (totalPrice < 0) {
-            throw new SimpleError({
-                code: 'empty_data',
-                message: $t(`725715e5-b0ac-43c1-adef-dd42b8907327`),
-            });
-        }
-
         // Who is going to pay?
         let whoWillPayNow: 'member' | 'organization' | 'nobody' = 'member'; // if this is set to 'organization', there will also be created separate balance items so the member can pay back the paying organization
 
@@ -277,7 +298,8 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
             let reuseRegistration: Registration | null = null;
 
-            if (item.replaceRegistrations.length === 1) {
+            // For now don't reuse replace registrations - it has too many side effects and not a lot of added value
+            if (item.replaceRegistrations.length === 1 && item.replaceRegistrations[0].group.id === item.group.id) {
                 // Try to reuse this specific one
                 reuseRegistration = (await Registration.getByID(item.replaceRegistrations[0].registration.id)) ?? null;
             }
@@ -286,9 +308,20 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
             if (!reuseRegistration) {
                 // Otherwise try to reuse a registration in the same period, for the same group that has been deactived for less than 7 days since the start of the new registration
-                reuseRegistration = existingRegistrations.find(r => r.deactivatedAt !== null && r.deactivatedAt.getTime() > startDate.getTime() - 7 * 24 * 60 * 60 * 1000) ?? null;
+                const possibleReuseRegistrations = existingRegistrations.filter(r =>
+                    r.deactivatedAt !== null
+                    && r.deactivatedAt.getTime() > startDate.getTime() - 7 * 24 * 60 * 60 * 1000,
+                );
+
+                // Never reuse a registration that has a balance - that means they had a cancellation fee and not all balance items were canceled (we don't want to merge in that state)
+                const balances = await CachedBalance.getForObjects(possibleReuseRegistrations.map(r => r.id), null);
+
+                reuseRegistration = possibleReuseRegistrations.find((r) => {
+                    const balance = balances.filter(b => b.objectId === r.id).reduce((a, b) => a + b.amountOpen + b.amountPaid + b.amountPending, 0);
+                    return balance === 0;
+                }) ?? null;
 
-                if (reuseRegistration && reuseRegistration.startDate && reuseRegistration.startDate < startDate && reuseRegistration.startDate >= group.settings.startDate && !item.trial) {
+                if (!item.customStartDate && reuseRegistration && reuseRegistration.startDate && reuseRegistration.startDate < startDate && reuseRegistration.startDate >= group.settings.startDate && !item.trial) {
                     startDate = reuseRegistration.startDate;
                 }
             }
@@ -370,7 +403,6 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         console.log('Registering members using whoWillPayNow', whoWillPayNow, checkout.paymentMethod, totalPrice);
 
         const createdBalanceItems: BalanceItem[] = [];
-        const unrelatedCreatedBalanceItems: BalanceItem[] = [];
         const deletedBalanceItems: BalanceItem[] = [];
         const shouldMarkValid = whoWillPayNow === 'nobody' || checkout.paymentMethod === PaymentMethod.Transfer || checkout.paymentMethod === PaymentMethod.PointOfSale || checkout.paymentMethod === PaymentMethod.Unknown;
 
@@ -415,12 +447,14 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
 
             // We can alter right away since whoWillPayNow is nobody, and shouldMarkValid will always be true
-            // Find all balance items of this registration and set them to zero
-            deletedBalanceItems.push(...(await BalanceItem.deleteForDeletedRegistration(existingRegistration.id, {
-                cancellationFeePercentage: deleted ? checkout.cancellationFeePercentage : 0,
-            })));
-
-            // todo: add cancelation fee
+            // Find all balance items of this registration and set them to Canceled
+            if ((deleted ? checkout.cancellationFeePercentage : 0) !== 100_00) {
+                // Only cancel balances if we don't charge 100% cancellation fee
+                // Also - this avoid creating a new cancellation fee balance item together with canceling the registration balance item, which is more complicated
+                deletedBalanceItems.push(...(await BalanceItem.deleteForDeletedRegistration(existingRegistration.id, {
+                    cancellationFeePercentage: deleted ? checkout.cancellationFeePercentage : 0,
+                })));
+            }
 
             // Clear the registration
             let group = groups.find(g => g.id === existingRegistration.groupId);
@@ -436,7 +470,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             deactivatedRegistrationGroupIds.push(existingRegistration.groupId);
         }
 
-        async function createBalanceItem({ registration, skipZero, amount, unitPrice, description, type, relations }: { amount?: number; skipZero?: boolean; registration: RegistrationWithMemberAndGroup; unitPrice: number; description: string; relations: Map<BalanceItemRelationType, BalanceItemRelation>; type: BalanceItemType }) {
+        async function createBalanceItem({ registration, skipZero, amount, unitPrice, description, type, relations }: { amount?: number; skipZero?: boolean; registration: { id: string; payingOrganizationId: string | null; memberId: string; trialUntil: Date | null }; unitPrice: number; description: string; relations: Map<BalanceItemRelationType, BalanceItemRelation>; type: BalanceItemType }) {
             // NOTE: We also need to save zero-price balance items because for online payments, we need to know which registrations to activate after payment
             if (skipZero === true) {
                 if (unitPrice === 0 || amount === 0) {
@@ -463,7 +497,10 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
             else {
                 balanceItem.memberId = registration.memberId;
-                balanceItem.userId = user.id;
+
+                if (!checkout.asOrganizationId) {
+                    balanceItem.userId = user.id;
+                }
             }
 
             balanceItem.status = BalanceItemStatus.Hidden;
@@ -485,7 +522,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             // Reserve registration for 30 minutes (if needed)
             const group = groups.find(g => g.id === registration.groupId);
 
-            if (group && group.settings.maxMembers !== null) {
+            if (group && group.settings.maxMembers !== null && whoWillPayNow !== 'nobody') {
                 registration.reservedUntil = new Date(new Date().getTime() + 1000 * 60 * 30);
             }
 
@@ -501,14 +538,14 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                     BalanceItemRelationType.Member,
                     BalanceItemRelation.create({
                         id: item.member.id,
-                        name: item.member.patchedMember.name,
+                        name: new TranslatedString(item.member.patchedMember.name),
                     }),
                 ],
                 [
                     BalanceItemRelationType.Group,
                     BalanceItemRelation.create({
                         id: item.group.id,
-                        name: item.group.settings.name.toString(),
+                        name: item.group.settings.name,
                     }),
                 ],
             ];
@@ -518,7 +555,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                     BalanceItemRelationType.GroupPrice,
                     BalanceItemRelation.create({
                         id: item.groupPrice.id,
-                        name: item.groupPrice.name.toString(),
+                        name: item.groupPrice.name,
                     }),
                 ]);
             }
@@ -550,14 +587,106 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                             BalanceItemRelationType.GroupOptionMenu,
                             BalanceItemRelation.create({
                                 id: option.optionMenu.id,
-                                name: option.optionMenu.name,
+                                name: new TranslatedString(option.optionMenu.name),
                             }),
                         ],
                         [
                             BalanceItemRelationType.GroupOption,
                             BalanceItemRelation.create({
                                 id: option.option.id,
-                                name: option.option.name,
+                                name: new TranslatedString(option.option.name),
+                            }),
+                        ],
+                    ]),
+                });
+            }
+
+            // Discounts
+            for (const discount of checkout.cart.bundleDiscounts) {
+                const discountValue = discount.getTotalFor(item);
+
+                if (discountValue !== 0) {
+                    // Base price
+                    await createBalanceItem({
+                        registration,
+                        unitPrice: -discountValue,
+                        type: BalanceItemType.RegistrationBundleDiscount,
+                        description: discount.name,
+                        relations: new Map([
+                            ...sharedRelations,
+                            [
+                                BalanceItemRelationType.Discount,
+                                BalanceItemRelation.create({
+                                    id: discount.bundle.id,
+                                    name: discount.bundle.name,
+                                }),
+                            ],
+                        ]),
+                    });
+                }
+            }
+        }
+
+        // Discounts for existing registrations that have changed
+        for (const discount of checkout.cart.bundleDiscounts) {
+            const loopMap = new Map(discount.registrations);
+
+            // We'll just cancel discount balance items for deleted registrations instead of creating a counter balance item
+            // for (const deleteRegistration of discount.deleteRegistrations) {
+            //    loopMap.set(deleteRegistration, 0);
+            // }
+
+            for (const [registration, newDiscountValue] of loopMap) {
+                const oldDiscountValue = registration.registration.discounts.get(discount.bundle.id)?.amount ?? 0;
+
+                // Saving the discount change directly on the registration now is not safe , because it can only be applied after the payment has succeededs)
+                // Solution: let the balance item handle it in its 'paid' handlers
+                const difference = newDiscountValue - oldDiscountValue;
+
+                if (difference === 0) {
+                    continue;
+                }
+
+                // Create balance items
+                const sharedRelations: [BalanceItemRelationType, BalanceItemRelation][] = [
+                    [
+                        BalanceItemRelationType.Member,
+                        BalanceItemRelation.create({
+                            id: registration.member.id,
+                            name: new TranslatedString(registration.member.patchedMember.name),
+                        }),
+                    ],
+                    [
+                        BalanceItemRelationType.Group,
+                        BalanceItemRelation.create({
+                            id: registration.group.id,
+                            name: registration.group.settings.name,
+                        }),
+                    ],
+                ];
+
+                if (registration.group.settings.prices.length > 1) {
+                    sharedRelations.push([
+                        BalanceItemRelationType.GroupPrice,
+                        BalanceItemRelation.create({
+                            id: registration.registration.groupPrice.id,
+                            name: registration.registration.groupPrice.name,
+                        }),
+                    ]);
+                }
+
+                await createBalanceItem({
+                    registration: registration.registration,
+                    unitPrice: -difference,
+                    type: BalanceItemType.RegistrationBundleDiscount,
+                    description: discount.name,
+                    relations: new Map([
+                        ...sharedRelations,
+                        [
+                            BalanceItemRelationType.Discount,
+                            BalanceItemRelation.create({
+                                id: discount.bundle.id,
+                                name: discount.bundle.name,
                             }),
                         ],
                     ]),
@@ -600,6 +729,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
             else {
                 balanceItem.userId = user.id;
+
                 // Connect this to the oldest member
                 if (oldestMember) {
                     balanceItem.memberId = oldestMember.id;
@@ -614,7 +744,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
         if (checkout.cart.balanceItems.length && whoWillPayNow === 'nobody') {
             throw new SimpleError({
-                code: 'invalid_data',
+                code: 'cannot_pay_balance_items',
                 message: 'Not possible to pay balance items as the organization',
                 statusCode: 400,
             });
@@ -625,7 +755,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
         // Delay marking as valid as late as possible so any errors will prevent creating valid balance items
         // Keep a copy because createdBalanceItems will be altered - and we don't want to mark added items as valid
-        const markValidList = [...createdBalanceItems, ...unrelatedCreatedBalanceItems];
+        const markValidList = [...createdBalanceItems];
 
         async function markValidIfNeeded() {
             if (shouldMarkValid) {
@@ -633,6 +763,12 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                     // Mark valid
                     await BalanceItemService.markPaid(balanceItem, payment, organization);
                 }
+
+                // Flush balance caches so we return an up-to-date balance
+                await BalanceItemService.flushRegistrationDiscountsCache();
+
+                // We'll need to update the returned registrations as their values will have changed by marking the registration as valid
+                await Registration.refreshAll(registrations);
             }
         }
 
@@ -654,8 +790,6 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                 createdBalanceItems.push(balanceItem);
             }
 
-            // Make sure every price is accurate before creating a payment
-            await BalanceItem.updateOutstanding([...createdBalanceItems, ...unrelatedCreatedBalanceItems]);
             try {
                 const response = await this.createPayment({
                     balanceItems: mappedBalanceItems,
@@ -673,17 +807,13 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
             finally {
                 // Update cached balance items pending amount (only created balance items, because those are involved in the payment)
-                await BalanceItem.updateOutstanding(createdBalanceItems);
+                await BalanceItemService.updatePaidAndPending(createdBalanceItems);
             }
         }
         else {
             await markValidIfNeeded();
-            await BalanceItem.updateOutstanding([...createdBalanceItems, ...unrelatedCreatedBalanceItems]);
         }
 
-        // Reallocate
-        await BalanceItemService.reallocate([...createdBalanceItems, ...unrelatedCreatedBalanceItems, ...deletedBalanceItems], organization.id);
-
         // Update occupancy
         for (const group of groups) {
             if (registrations.some(r => r.groupId === group.id) || deactivatedRegistrationGroupIds.some(id => id === group.id)) {
@@ -692,12 +822,12 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
         }
 
-        const updatedMembers = await Member.getBlobByIds(...memberIds);
+        const updatedMembers = await Member.getBlobByIds(...members.map(m => m.id));
 
         return new Response(RegisterResponse.create({
             payment: payment ? PaymentStruct.create(payment) : null,
             members: await AuthenticatedStructures.membersBlob(updatedMembers),
-            registrations: registrations.map(r => Member.getRegistrationWithMemberStructure(r)),
+            registrations: registrations.map(r => Member.getRegistrationWithTinyMemberStructure(r)),
             paymentUrl,
         }));
     }
@@ -748,10 +878,19 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         if (totalPrice < 0) {
             // todo: try to make it non-negative by reducing some balance items
             throw new SimpleError({
-                code: 'empty_data',
+                code: 'negative_price',
                 message: $t(`725715e5-b0ac-43c1-adef-dd42b8907327`),
             });
         }
+
+        if (totalPrice !== checkout.totalPrice) {
+            // Changed!
+            throw new SimpleError({
+                code: 'changed_price',
+                message: $t(`e424d549-2bb8-4103-9a14-ac4063d7d454`, { total: Formatter.price(totalPrice) }),
+            });
+        }
+
         const payment = new Payment();
         payment.method = checkout.paymentMethod ?? PaymentMethod.Unknown;
 

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

@@ -1,18 +1,24 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { RegistrationPeriod as RegistrationPeriodStruct } from '@stamhoofd/structures';
+import { assertSort, CountFilteredRequest, getSortFilter, LimitedFilteredRequest, RegistrationPeriod as RegistrationPeriodStruct, PaginatedResponse, StamhoofdFilter } from '@stamhoofd/structures';
 
+import { SimpleError } from '@simonbackx/simple-errors';
 import { RegistrationPeriod } from '@stamhoofd/models';
+import { applySQLSorter, compileToSQLFilter, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import { registrationPeriodFilterCompilers } from '../../../sql-filters/registration-periods';
+import { registrationPeriodSorters } from '../../../sql-sorters/registration-periods';
+import { Decoder } from '@simonbackx/simple-encoding';
 
 type Params = Record<string, never>;
-type Query = undefined;
+type Query = LimitedFilteredRequest;
 type Body = undefined;
-type ResponseBody = RegistrationPeriodStruct[];
+type ResponseBody = PaginatedResponse<RegistrationPeriodStruct[], LimitedFilteredRequest>;
 
-/**
- * One endpoint to create, patch and delete members and their registrations and payments
- */
+const filterCompilers: SQLFilterDefinitions = registrationPeriodFilterCompilers;
+const sorters: SQLSortDefinitions<RegistrationPeriod> = registrationPeriodSorters;
+
+export class GetRegistrationPeriodsEndpoint 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];
@@ -26,11 +32,103 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
         return [false];
     }
 
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+        const scopeFilter: StamhoofdFilter | undefined = undefined;
+        const query = RegistrationPeriod.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 GetRegistrationPeriodsEndpoint.buildQuery(requestQuery);
+        const registrationPeriods = await query.fetch();
+
+        let next: LimitedFilteredRequest | undefined;
+
+        if (registrationPeriods.length >= requestQuery.limit) {
+            const lastObject = registrationPeriods[registrationPeriods.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<RegistrationPeriodStruct[], LimitedFilteredRequest>({
+            results: registrationPeriods.map(p => p.getStructure()),
+            next,
+        });
+    }
+
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const periods = await RegistrationPeriod.all();
+        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 maxLimit = 100;
+
+        if (request.query.limit > maxLimit) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be more than ' + maxLimit,
+            });
+        }
+
+        if (request.query.limit < 1) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be less than 1',
+            });
+        }
 
         return new Response(
-            periods.map(p => p.getStructure()),
+            await GetRegistrationPeriodsEndpoint.buildData(request.query),
         );
     }
 }

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

@@ -0,0 +1,89 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { EmailTemplate, GroupFactory, Organization, OrganizationFactory, Platform, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
+import { EmailTemplateType, PermissionLevel, PermissionRoleDetailed, Permissions, PermissionsResourceType, ResourcePermissions, Version } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { testServer } from '../../../../../tests/helpers/TestServer';
+import { GetEmailTemplatesEndpoint } from './GetEmailTemplatesEndpoint';
+
+const baseUrl = `/v${Version}/email-templates`;
+
+describe('Endpoint.GetEmailTemplatesEndpoint', () => {
+    const endpoint = new GetEmailTemplatesEndpoint();
+    let period: RegistrationPeriod;
+
+    const getEmailTemplates = async ({ token, organization = undefined, types = null, groupIds = null, webshopId = null }: { token: Token; organization?: Organization; types?: EmailTemplateType[] | null; groupIds?: string[] | null; webshopId?: string | null }) => {
+        const request = Request.buildJson('GET', baseUrl, organization?.getApiHost());
+
+        request.query = {
+            types,
+            groupIds,
+            webshopId,
+        };
+
+        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();
+    });
+
+    test('User with platform role who has full permission for all organizations should see 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 response = await getEmailTemplates({
+            token,
+            types: [EmailTemplateType.RegistrationConfirmation],
+            groupIds: [group.id],
+        });
+
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(1);
+    });
+});