@stamhoofd/backend 2.111.0 → 2.112.0

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

@@ -4,12 +4,13 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { Document, Group, Member, RateLimiter, Registration } from '@stamhoofd/models';
 import { MemberDetails, MembersBlob, MemberWithRegistrationsBlob } from '@stamhoofd/structures';
 
-import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
-import { Context } from '../../../helpers/Context';
-import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
-import { PatchOrganizationMembersEndpoint } from '../../global/members/PatchOrganizationMembersEndpoint';
-import { shouldCheckIfMemberIsDuplicateForPatch } from '../members/shouldCheckIfMemberIsDuplicate';
 import { OneToManyRelation } from '@simonbackx/simple-database';
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../helpers/Context.js';
+import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer.js';
+import { didUitpasReviewChange, updateMemberDetailsUitpasNumber, updateMemberDetailsUitpasNumberForPatch } from '../../../helpers/updateMemberDetailsUitpasNumber.js';
+import { PatchOrganizationMembersEndpoint } from '../../global/members/PatchOrganizationMembersEndpoint.js';
+import { shouldCheckIfMemberIsDuplicateForPatch } from '../members/shouldCheckIfMemberIsDuplicate.js';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = PatchableArrayAutoEncoder<MemberWithRegistrationsBlob>;
@@ -60,7 +61,9 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
             member.organizationId = organization?.id ?? null;
 
             const securityCode = struct.details.securityCode; // will get cleared after the filter
-            Context.auth.filterMemberPut(member, struct, {asUserManager: true});
+            Context.auth.filterMemberPut(member, struct, { asUserManager: true });
+
+            await updateMemberDetailsUitpasNumber(struct.details);
             struct.details.cleanData();
             member.details = struct.details;
 
@@ -102,7 +105,15 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
 
                 shouldCheckDuplicate = shouldCheckIfMemberIsDuplicateForPatch(struct, member.details);
 
+                const previousUitpasNumber = member.details.uitpasNumberDetails?.uitpasNumber ?? null;
+
+                const originalReviewTimes = member.details.reviewTimes;
                 member.details.patchOrPut(struct.details);
+
+                if (struct.details.uitpasNumberDetails || didUitpasReviewChange(struct.details.reviewTimes, originalReviewTimes)) {
+                    await updateMemberDetailsUitpasNumberForPatch(member.id, member.details, previousUitpasNumber);
+                }
+
                 member.details.cleanData();
                 this.throwIfInvalidDetails(member.details);
             }

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

@@ -1,16 +1,16 @@
 import { PatchMap } from '@simonbackx/simple-encoding';
 import { Request } from '@simonbackx/simple-endpoints';
 import { EmailMocker } from '@stamhoofd/email';
-import { BalanceItemFactory, Group, GroupFactory, MemberFactory, MemberWithRegistrations, Organization, OrganizationFactory, OrganizationRegistrationPeriodFactory, Registration, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
-import { AccessRight, BalanceItemCartItem, BalanceItemStatus, BalanceItemType, BooleanStatus, Company, GroupOption, GroupOptionMenu, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, OrganizationPackages, PaymentCustomer, PaymentMethod, PermissionLevel, Permissions, PermissionsResourceType, ReduceablePrice, RegisterItemOption, ResourcePermissions, STPackageStatus, STPackageType, UserPermissions, Version } from '@stamhoofd/structures';
+import { BalanceItemFactory, Group, GroupFactory, Member, MemberFactory, MemberWithRegistrations, Organization, OrganizationFactory, OrganizationRegistrationPeriodFactory, Registration, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
+import { AccessRight, BalanceItemCartItem, BalanceItemStatus, BalanceItemType, BooleanStatus, Company, GroupOption, GroupOptionMenu, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, OrganizationPackages, PaymentCustomer, PaymentMethod, PermissionLevel, Permissions, PermissionsResourceType, ReduceablePrice, RegisterItemOption, ResourcePermissions, STPackageStatus, STPackageType, UitpasNumberDetails, UitpasSocialTariff, UitpasSocialTariffStatus, UserPermissions, Version } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { v4 as uuidv4 } from 'uuid';
-import { assertBalances } from '../../../../tests/assertions/assertBalances';
-import { testServer } from '../../../../tests/helpers/TestServer';
-import { initAdmin, initPermissionRole } from '../../../../tests/init';
-import { initPayconiq } from '../../../../tests/init/initPayconiq';
-import { BalanceItemService } from '../../../services/BalanceItemService';
-import { RegisterMembersEndpoint } from './RegisterMembersEndpoint';
+import { assertBalances } from '../../../../tests/assertions/assertBalances.js';
+import { testServer } from '../../../../tests/helpers/TestServer.js';
+import { initAdmin, initPermissionRole, initUitpasApi } from '../../../../tests/init/index.js';
+import { initPayconiq } from '../../../../tests/init/initPayconiq.js';
+import { BalanceItemService } from '../../../services/BalanceItemService.js';
+import { RegisterMembersEndpoint } from './RegisterMembersEndpoint.js';
 
 const baseUrl = `/v${Version}/members/register`;
 
@@ -1248,6 +1248,289 @@ describe('Endpoint.RegisterMembers', () => {
             const result = await post(body, organization, token);
             expect(result).toBeDefined();
         });
+
+        describe('Uitpas number', () => {
+            test('should update social tariff status and throw error if the price changed', async () => {
+                // #region arrange
+                initUitpasApi();
+                const { member, group, groupPrice, organization, token } = await initData();
+                member.details.uitpasNumberDetails = UitpasNumberDetails.create({
+                    // expired
+                    uitpasNumber: '0900000031618',
+                    socialTariff: UitpasSocialTariff.create({
+                        // but last time checked it was active
+                        status: UitpasSocialTariffStatus.Active,
+                        updatedAt: new Date(2000, 0, 1),
+                        endDate: new Date(2000, 0, 1),
+                    }),
+                });
+
+                await member.save();
+
+                const body = IDRegisterCheckout.create({
+                    cart: IDRegisterCart.create({
+                        items: [
+                            IDRegisterItem.create({
+                                id: uuidv4(),
+                                replaceRegistrationIds: [],
+                                options: [],
+                                groupPrice,
+                                organizationId: organization.id,
+                                groupId: group.id,
+                                memberId: member.id,
+                            }),
+                        ],
+                        balanceItems: [],
+                        deleteRegistrationIds: [],
+                    }),
+                    administrationFee: 0,
+                    freeContribution: 0,
+                    paymentMethod: PaymentMethod.PointOfSale,
+                    // reduced price
+                    totalPrice: 12_5000,
+                    customer: null,
+                });
+                // #endregion
+
+                // act
+
+                // should throw error
+                await expect(async () => await post(body, organization, token))
+                    .rejects
+                    .toThrow(STExpect.errorWithCode('changed_price'));
+
+                // should update status
+                const updatedMember = await Member.getByID(member.id);
+                expect(updatedMember!.details.uitpasNumberDetails?.uitpasNumber).toEqual('0900000031618');
+                expect(updatedMember!.details.uitpasNumberDetails?.socialTariff?.status).toEqual(UitpasSocialTariffStatus.Expired);
+                expect(updatedMember!.details.uitpasNumberDetails?.socialTariff?.updatedAt.getTime()).not.toEqual(new Date(2000, 0, 1).getTime());
+                expect(updatedMember!.details.uitpasNumberDetails?.socialTariff?.endDate?.getTime()).not.toEqual(new Date(2000, 0, 1).getTime());
+            });
+
+            test('should not update social tariff status if updated less than 1 week ago', async () => {
+                // #region arrange
+                initUitpasApi();
+                const { member, group, groupPrice, organization, token } = await initData();
+
+                const now = new Date();
+                const weekInMs = 7 * 24 * 3600 * 1000;
+                const oneHourInMs = 3600 * 1000;
+                const lessThanAWeekAgo = new Date(now.getTime() - weekInMs + oneHourInMs);
+
+                member.details.uitpasNumberDetails = UitpasNumberDetails.create({
+                    // expired
+                    uitpasNumber: '0900000031618',
+                    socialTariff: UitpasSocialTariff.create({
+                        // but last time checked it was active
+                        status: UitpasSocialTariffStatus.Active,
+                        updatedAt: lessThanAWeekAgo,
+                        endDate: new Date(2000, 0, 1),
+                    }),
+                });
+
+                await member.save();
+
+                const body = IDRegisterCheckout.create({
+                    cart: IDRegisterCart.create({
+                        items: [
+                            IDRegisterItem.create({
+                                id: uuidv4(),
+                                replaceRegistrationIds: [],
+                                options: [],
+                                groupPrice,
+                                organizationId: organization.id,
+                                groupId: group.id,
+                                memberId: member.id,
+                            }),
+                        ],
+                        balanceItems: [],
+                        deleteRegistrationIds: [],
+                    }),
+                    administrationFee: 0,
+                    freeContribution: 0,
+                    paymentMethod: PaymentMethod.PointOfSale,
+                    // reduced price
+                    totalPrice: 12_5000,
+                    customer: null,
+                });
+                // #endregion
+
+                // act
+                const response = await post(body, organization, token);
+
+                // assert
+                expect(response.body).toBeDefined();
+                expect(response.body.registrations.length).toBe(1);
+
+                // should not update status
+                const updatedMember = await Member.getByID(member.id);
+                expect(updatedMember!.details.uitpasNumberDetails?.uitpasNumber).toEqual('0900000031618');
+                expect(updatedMember!.details.uitpasNumberDetails?.socialTariff?.status).toEqual(UitpasSocialTariffStatus.Active);
+            });
+
+            test('should not apply reduced price if social tariff status is unknown and uitpas api is unavailable', async () => {
+                const mocker = initUitpasApi();
+                mocker.forceFailure();
+
+                const { member, group, groupPrice, organization, token } = await initData();
+                member.details.uitpasNumberDetails = UitpasNumberDetails.create({
+                    // active
+                    uitpasNumber: '0900011354829',
+                    socialTariff: UitpasSocialTariff.create({
+                        // but last time checked it was active
+                        status: UitpasSocialTariffStatus.Unknown,
+                        updatedAt: new Date(2000, 0, 1),
+                        endDate: new Date(2000, 0, 1),
+                    }),
+                });
+
+                await member.save();
+
+                const body = IDRegisterCheckout.create({
+                    cart: IDRegisterCart.create({
+                        items: [
+                            IDRegisterItem.create({
+                                id: uuidv4(),
+                                replaceRegistrationIds: [],
+                                options: [],
+                                groupPrice,
+                                organizationId: organization.id,
+                                groupId: group.id,
+                                memberId: member.id,
+                            }),
+                        ],
+                        balanceItems: [],
+                        deleteRegistrationIds: [],
+                    }),
+                    administrationFee: 0,
+                    freeContribution: 0,
+                    paymentMethod: PaymentMethod.PointOfSale,
+                    // normal price
+                    totalPrice: 25_0000,
+                    customer: null,
+                });
+
+                // act
+                const response = await post(body, organization, token);
+
+                // assert
+                expect(response.body).toBeDefined();
+                expect(response.body.registrations.length).toBe(1);
+
+                // should not update status
+                const updatedMember = await Member.getByID(member.id);
+                expect(updatedMember!.details.uitpasNumberDetails?.uitpasNumber).toEqual('0900011354829');
+                expect(updatedMember!.details.uitpasNumberDetails?.socialTariff?.status).toEqual(UitpasSocialTariffStatus.Unknown);
+            });
+
+            test('should apply reduced price based on legacy rule if uitpas api is not connected and status is unkown', async () => {
+                TestUtils.setEnvironment('UITPAS_API_CLIENT_SECRET', undefined);
+
+                const { member, group, groupPrice, organization, token } = await initData();
+                member.details.uitpasNumberDetails = UitpasNumberDetails.create({
+                    // active
+                    uitpasNumber: '0900011354819', // Second last number is 1, so has social tariffs in legacy mode
+                    socialTariff: UitpasSocialTariff.create({
+                        // but last time checked it was active
+                        status: UitpasSocialTariffStatus.Unknown,
+                        updatedAt: new Date(2000, 0, 1),
+                        endDate: new Date(2000, 0, 1),
+                    }),
+                });
+
+                await member.save();
+
+                const body = IDRegisterCheckout.create({
+                    cart: IDRegisterCart.create({
+                        items: [
+                            IDRegisterItem.create({
+                                id: uuidv4(),
+                                replaceRegistrationIds: [],
+                                options: [],
+                                groupPrice,
+                                organizationId: organization.id,
+                                groupId: group.id,
+                                memberId: member.id,
+                            }),
+                        ],
+                        balanceItems: [],
+                        deleteRegistrationIds: [],
+                    }),
+                    administrationFee: 0,
+                    freeContribution: 0,
+                    paymentMethod: PaymentMethod.PointOfSale,
+                    // normal price
+                    totalPrice: 12_5000,
+                    customer: null,
+                });
+
+                // act
+                const response = await post(body, organization, token);
+
+                // assert
+                expect(response.body).toBeDefined();
+                expect(response.body.registrations.length).toBe(1);
+
+                // should not update status
+                const updatedMember = await Member.getByID(member.id);
+                expect(updatedMember!.details.uitpasNumberDetails?.uitpasNumber).toEqual('0900011354819');
+                expect(updatedMember!.details.uitpasNumberDetails?.socialTariff?.status).toEqual(UitpasSocialTariffStatus.Unknown);
+            });
+
+            test('should not apply reduced price based on legacy rule if uitpas api is not connected and status is unkown', async () => {
+                TestUtils.setEnvironment('UITPAS_API_CLIENT_SECRET', undefined);
+
+                const { member, group, groupPrice, organization, token } = await initData();
+                member.details.uitpasNumberDetails = UitpasNumberDetails.create({
+                    // active
+                    uitpasNumber: '0900011354829', // Second last number isnot 1, so does not have social tariffs in legacy mode
+                    socialTariff: UitpasSocialTariff.create({
+                        // but last time checked it was active
+                        status: UitpasSocialTariffStatus.Unknown,
+                        updatedAt: new Date(2000, 0, 1),
+                        endDate: new Date(2000, 0, 1),
+                    }),
+                });
+
+                await member.save();
+
+                const body = IDRegisterCheckout.create({
+                    cart: IDRegisterCart.create({
+                        items: [
+                            IDRegisterItem.create({
+                                id: uuidv4(),
+                                replaceRegistrationIds: [],
+                                options: [],
+                                groupPrice,
+                                organizationId: organization.id,
+                                groupId: group.id,
+                                memberId: member.id,
+                            }),
+                        ],
+                        balanceItems: [],
+                        deleteRegistrationIds: [],
+                    }),
+                    administrationFee: 0,
+                    freeContribution: 0,
+                    paymentMethod: PaymentMethod.PointOfSale,
+                    // normal price
+                    totalPrice: 25_0000,
+                    customer: null,
+                });
+
+                // act
+                const response = await post(body, organization, token);
+
+                // assert
+                expect(response.body).toBeDefined();
+                expect(response.body.registrations.length).toBe(1);
+
+                // should not update status
+                const updatedMember = await Member.getByID(member.id);
+                expect(updatedMember!.details.uitpasNumberDetails?.uitpasNumber).toEqual('0900011354829');
+                expect(updatedMember!.details.uitpasNumberDetails?.socialTariff?.status).toEqual(UitpasSocialTariffStatus.Unknown);
+            });
+        });
     });
 
     describe('Register as organization', () => {

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

@@ -13,6 +13,7 @@ import { BuckarooHelper } from '../../../helpers/BuckarooHelper.js';
 import { Context } from '../../../helpers/Context.js';
 import { ServiceFeeHelper } from '../../../helpers/ServiceFeeHelper.js';
 import { StripeHelper } from '../../../helpers/StripeHelper.js';
+import { updateMemberDetailsUitpasNumber } from '../../../helpers/updateMemberDetailsUitpasNumber.js';
 import { BalanceItemService } from '../../../services/BalanceItemService.js';
 import { PaymentService } from '../../../services/PaymentService.js';
 import { RegistrationService } from '../../../services/RegistrationService.js';
@@ -167,6 +168,8 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
         }
 
+        const isBulkUpdate = members.length > 5;
+
         for (const member of members) {
             if (!await Context.auth.canAccessMember(
                 member,
@@ -179,6 +182,25 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                     statusCode: 403,
                 });
             }
+
+            // update uitpas social tariff
+            if (!isBulkUpdate && member.details.uitpasNumberDetails
+                && member.details.uitpasNumberDetails.socialTariff.shouldUpdateForRegsitration(member.details.requiresFinancialSupport)
+            ) {
+                let isUpdated: boolean = false;
+
+                try {
+                    isUpdated = await updateMemberDetailsUitpasNumber(member.details);
+                }
+                catch (e) {
+                    // catch all errors
+                }
+
+                if (isUpdated) {
+                    member.details.cleanData();
+                    await member.save();
+                }
+            }
         }
 
         const platformMembers: PlatformMember[] = [];

package/src/endpoints/organization/dashboard/invoices/GetInvoicesCountEndpoint.ts

@@ -0,0 +1,43 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { CountFilteredRequest, CountResponse } from '@stamhoofd/structures';
+
+import { Context } from '../../../../helpers/Context.js';
+import { GetInvoicesEndpoint } from './GetInvoicesEndpoint.js';
+
+type Params = Record<string, never>;
+type Query = CountFilteredRequest;
+type Body = undefined;
+type ResponseBody = CountResponse;
+
+export class GetInvoicesCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/invoices/count', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOrganizationScope();
+        await Context.authenticate();
+        const query = await GetInvoicesEndpoint.buildQuery(request.query);
+
+        const count = await query
+            .count();
+
+        return new Response(
+            CountResponse.create({
+                count,
+            }),
+        );
+    }
+}

package/src/endpoints/organization/dashboard/invoices/GetInvoicesEndpoint.ts

@@ -0,0 +1,219 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Invoice } from '@stamhoofd/models';
+import { applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
+import { CountFilteredRequest, InvoiceStruct, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
+
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../../helpers/Context.js';
+import { invoiceFilterCompilers } from '../../../../sql-filters/invoices.js';
+import { invoiceSorters } from '../../../../sql-sorters/invoices.js';
+
+type Params = Record<string, never>;
+type Query = LimitedFilteredRequest;
+type Body = undefined;
+type ResponseBody = PaginatedResponse<InvoiceStruct[], LimitedFilteredRequest>;
+
+const filterCompilers = invoiceFilterCompilers;
+const sorters = invoiceSorters;
+
+export class GetInvoicesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/invoices', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+        const organization = Context.organization;
+        let scopeFilter: StamhoofdFilter | undefined = undefined;
+
+        if (!organization) {
+            throw Context.auth.error();
+        }
+
+        if (!await Context.auth.canManageFinances(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        scopeFilter = {
+            organizationId: organization.id,
+        };
+
+        const query = Invoice
+            .select()
+            .setMaxExecutionTime(10 * 1000);
+
+        if (scopeFilter) {
+            query.where(await compileToSQLFilter(scopeFilter, filterCompilers));
+        }
+
+        if (q.filter) {
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
+        }
+
+        if (q.search) {
+            // todo
+
+            let searchFilter: StamhoofdFilter | null = null;
+            searchFilter = {
+                $or: [
+                    {
+                        customer: {
+                            name: {
+                                $contains: q.search,
+                            },
+                        },
+                    },
+                    {
+                        customer: {
+                            company: {
+                                name: {
+                                    $contains: q.search,
+                                },
+                            },
+                        },
+                    },
+                    {
+                        items: {
+                            $elemMatch: {
+                                $or: [
+                                    {
+                                        name: {
+                                            $contains: q.search,
+                                        },
+                                    },
+                                    {
+                                        description: {
+                                            $contains: q.search,
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                ],
+            };
+
+            if (q.search.includes('@')) {
+                searchFilter = {
+                    $or: [
+                        {
+                            customer: {
+                                email: {
+                                    $contains: q.search,
+                                },
+                            },
+                        },
+                        {
+                            customer: {
+                                company: {
+                                    administrationEmail: {
+                                        $contains: 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 this.buildQuery(requestQuery);
+        let invoices: Invoice[];
+
+        try {
+            invoices = await query.fetch();
+        }
+        catch (error) {
+            if (error.message.includes('ER_QUERY_TIMEOUT')) {
+                throw new SimpleError({
+                    code: 'timeout',
+                    message: 'Query took too long',
+                    human: $t(`dce51638-6129-448b-8a15-e6d778f3a76a`),
+                });
+            }
+            throw error;
+        }
+
+        let next: LimitedFilteredRequest | undefined;
+
+        if (invoices.length >= requestQuery.limit) {
+            const lastObject = invoices[invoices.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<InvoiceStruct[], LimitedFilteredRequest>({
+            results: await AuthenticatedStructures.invoices(invoices),
+            next,
+        });
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 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(
+            await GetInvoicesEndpoint.buildData(request.query),
+        );
+    }
+}

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

@@ -5,8 +5,8 @@ import { BalanceItem, Member, Order, User } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { BalanceItemStatus, BalanceItemType, BalanceItemWithPayments, PermissionLevel } from '@stamhoofd/structures';
 
-import { Context } from '../../../../helpers/Context';
-import { BalanceItemService } from '../../../../services/BalanceItemService';
+import { Context } from '../../../../helpers/Context.js';
+import { BalanceItemService } from '../../../../services/BalanceItemService.js';
 
 type Params = Record<string, never>;
 type Query = undefined;