@stamhoofd/backend 2.43.2 → 2.44.0

package/src/endpoints/organization/dashboard/{cached-outstanding-balance/GetCachedOutstandingBalanceCountEndpoint.ts → receivable-balances/GetReceivableBalancesCountEndpoint.ts}

@@ -3,14 +3,14 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { CountFilteredRequest, CountResponse } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context';
-import { GetCachedOutstandingBalanceEndpoint } from './GetCachedOutstandingBalanceEndpoint';
+import { GetReceivableBalancesEndpoint } from './GetReceivableBalancesEndpoint';
 
 type Params = Record<string, never>;
 type Query = CountFilteredRequest;
 type Body = undefined;
 type ResponseBody = CountResponse;
 
-export class GetCachedOutstandingBalanceCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+export class GetReceivableBalancesCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
@@ -18,7 +18,7 @@ export class GetCachedOutstandingBalanceCountEndpoint extends Endpoint<Params, Q
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, '/cached-outstanding-balance/count', {});
+        const params = Endpoint.parseParameters(request.url, '/receivable-balances/count', {});
 
         if (params) {
             return [true, params as Params];
@@ -29,7 +29,7 @@ export class GetCachedOutstandingBalanceCountEndpoint extends Endpoint<Params, Q
     async handle(request: DecodedRequest<Params, Query, Body>) {
         await Context.setOrganizationScope();
         await Context.authenticate();
-        const query = await GetCachedOutstandingBalanceEndpoint.buildQuery(request.query);
+        const query = await GetReceivableBalancesEndpoint.buildQuery(request.query);
 
         const count = await query
             .count();

package/src/endpoints/organization/dashboard/{cached-outstanding-balance/GetCachedOutstandingBalanceEndpoint.ts → receivable-balances/GetReceivableBalancesEndpoint.ts}

@@ -1,24 +1,24 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { CachedOutstandingBalance } from '@stamhoofd/models';
+import { CachedBalance } from '@stamhoofd/models';
 import { compileToSQLFilter, compileToSQLSorter } from '@stamhoofd/sql';
-import { CachedOutstandingBalance as CachedOutstandingBalanceStruct, CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
+import { ReceivableBalance as ReceivableBalanceStruct, CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
-import { cachedOutstandingBalanceFilterCompilers } from '../../../../sql-filters/cached-outstanding-balance';
-import { cachedOutstandingBalanceSorters } from '../../../../sql-sorters/cached-outstanding-balance';
+import { receivableBalanceFilterCompilers } from '../../../../sql-filters/receivable-balances';
+import { receivableBalanceSorters } from '../../../../sql-sorters/receivable-balances';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
 type Body = undefined;
-type ResponseBody = PaginatedResponse<CachedOutstandingBalanceStruct[], LimitedFilteredRequest>;
+type ResponseBody = PaginatedResponse<ReceivableBalanceStruct[], LimitedFilteredRequest>;
 
-const sorters = cachedOutstandingBalanceSorters;
-const filterCompilers = cachedOutstandingBalanceFilterCompilers;
+const sorters = receivableBalanceSorters;
+const filterCompilers = receivableBalanceFilterCompilers;
 
-export class GetCachedOutstandingBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+export class GetReceivableBalancesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
@@ -26,7 +26,7 @@ export class GetCachedOutstandingBalanceEndpoint extends Endpoint<Params, Query,
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, '/cached-outstanding-balance', {});
+        const params = Endpoint.parseParameters(request.url, '/receivable-balances', {});
 
         if (params) {
             return [true, params as Params];
@@ -48,9 +48,13 @@ export class GetCachedOutstandingBalanceEndpoint extends Endpoint<Params, Query,
 
         scopeFilter = {
             organizationId: organization.id,
+            $or: {
+                amount: { $neq: 0 },
+                amountPending: { $neq: 0 },
+            },
         };
 
-        const query = CachedOutstandingBalance
+        const query = CachedBalance
             .select();
 
         if (scopeFilter) {
@@ -82,7 +86,7 @@ export class GetCachedOutstandingBalanceEndpoint extends Endpoint<Params, Query,
     }
 
     static async buildData(requestQuery: LimitedFilteredRequest) {
-        const query = await GetCachedOutstandingBalanceEndpoint.buildQuery(requestQuery);
+        const query = await GetReceivableBalancesEndpoint.buildQuery(requestQuery);
         const data = await query.fetch();
 
         // todo: Create objects from data
@@ -107,8 +111,8 @@ export class GetCachedOutstandingBalanceEndpoint extends Endpoint<Params, Query,
             }
         }
 
-        return new PaginatedResponse<CachedOutstandingBalanceStruct[], LimitedFilteredRequest>({
-            results: await AuthenticatedStructures.cachedOutstandingBalances(data),
+        return new PaginatedResponse<ReceivableBalanceStruct[], LimitedFilteredRequest>({
+            results: await AuthenticatedStructures.receivableBalances(data),
             next,
         });
     }
@@ -136,7 +140,7 @@ export class GetCachedOutstandingBalanceEndpoint extends Endpoint<Params, Query,
         }
 
         return new Response(
-            await GetCachedOutstandingBalanceEndpoint.buildData(request.query),
+            await GetReceivableBalancesEndpoint.buildData(request.query),
         );
     }
 }

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

@@ -0,0 +1,57 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { CountFilteredRequest, CountResponse, PermissionLevel } from '@stamhoofd/structures';
+
+import { Webshop } from '@stamhoofd/models';
+import { Context } from '../../../../helpers/Context';
+import { GetWebshopOrdersEndpoint } from './GetWebshopOrdersEndpoint';
+
+type Params = { id: string };
+type Query = CountFilteredRequest;
+type Body = undefined;
+type ResponseBody = CountResponse;
+
+export class GetWebshopOrdersCountEndpoint 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, '/webshop/@id/orders/count', { id: String });
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        // Fast throw first (more in depth checking for patches later)
+        if (!await Context.auth.hasSomeAccess(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        const webshopId = request.params.id;
+
+        const webshop = await Webshop.getByID(webshopId);
+        if (!webshop || !await Context.auth.canAccessWebshop(webshop, PermissionLevel.Read)) {
+            throw Context.auth.notFoundOrNoAccess('Je hebt geen toegang tot de bestellingen van deze webshop');
+        }
+
+        const query = GetWebshopOrdersEndpoint.buildQuery(webshopId, request.query);
+
+        const count = await query
+            .count();
+
+        return new Response(
+            CountResponse.create({
+                count,
+            }),
+        );
+    }
+}

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

@@ -1,17 +1,25 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { Order, Webshop } from '@stamhoofd/models';
-import { PaginatedResponse, PermissionLevel, PrivateOrder, WebshopOrdersQuery } from '@stamhoofd/structures';
+import { assertSort, CountFilteredRequest, getSortFilter, LimitedFilteredRequest, PaginatedResponse, PermissionLevel, PrivateOrder, StamhoofdFilter } from '@stamhoofd/structures';
 
+import { Order, Webshop } from '@stamhoofd/models';
+import { compileToSQLFilter, compileToSQLSorter, SQL, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
+import { LimitedFilteredRequestHelper } from '../../../../helpers/LimitedFilteredRequestHelper';
+import { orderFilterCompilers } from '../../../../sql-filters/orders';
+import { orderSorters } from '../../../../sql-sorters/orders';
 
 type Params = { id: string };
-type Query = WebshopOrdersQuery;
+type Query = LimitedFilteredRequest;
 type Body = undefined;
-type ResponseBody = PaginatedResponse<PrivateOrder[], Query>;
+type ResponseBody = PaginatedResponse<PrivateOrder[], LimitedFilteredRequest>;
+
+const filterCompilers: SQLFilterDefinitions = orderFilterCompilers;
+const sorters: SQLSortDefinitions<Order> = orderSorters;
 
 export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = WebshopOrdersQuery as Decoder<WebshopOrdersQuery>;
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {
@@ -26,22 +34,124 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
         return [false];
     }
 
-    async handle(_: DecodedRequest<Params, Query, Body>): Promise<Response<ResponseBody>> {
-        await Promise.resolve();
-        throw new Error('Not implemented');
-        /* const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+    static buildQuery(webshopId: string, q: CountFilteredRequest | LimitedFilteredRequest) {
+        // todo: filter userId???
+        const organization = Context.organization!;
+
+        if (!webshopId) {
+            // todo
+            throw new Error();
+        }
+
+        const ordersTable: string = Order.table;
+
+        const query = SQL
+            .select(SQL.wildcard(ordersTable))
+            .from(SQL.table(ordersTable))
+            // todo: extra check on webshopId to prevent all orders are returned if webshopId is null?
+            .where('webshopId', webshopId)
+            .where(compileToSQLFilter({
+                $or: [
+                    {
+                        organizationId: organization.id,
+                    },
+                    {
+                        organizationId: null,
+                    },
+                ],
+            }, filterCompilers));
+
+        if (q.filter) {
+            query.where(compileToSQLFilter(q.filter, filterCompilers));
+        }
+
+        if (q.search) {
+            let searchFilter: StamhoofdFilter | null = null;
+
+            // todo: detect special search patterns and adjust search filter if needed
+            searchFilter = {
+                name: {
+                    $contains: q.search,
+                },
+            };
+
+            if (searchFilter) {
+                query.where(compileToSQLFilter(searchFilter, filterCompilers));
+            }
+        }
+
+        if (q instanceof LimitedFilteredRequest) {
+            if (q.pageFilter) {
+                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+            }
+
+            q.sort = assertSort(q.sort, [{ key: 'id' }]);
+            query.orderBy(compileToSQLSorter(q.sort, sorters));
+            query.limit(q.limit);
+        }
+
+        return query;
+    }
+
+    static async buildData(webshopId: string, requestQuery: LimitedFilteredRequest) {
+        const query = this.buildQuery(webshopId, requestQuery);
+        const data = await query.fetch();
+
+        const orders: Order[] = Order.fromRows(data, Order.table);
+
+        let next: LimitedFilteredRequest | undefined;
+
+        if (orders.length >= requestQuery.limit) {
+            const lastObject = orders[orders.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<PrivateOrder[], LimitedFilteredRequest>({
+            results: await AuthenticatedStructures.orders(orders),
+            next,
+        });
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>): Promise<Response<ResponseBody>> {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
 
         // Fast throw first (more in depth checking for patches later)
         if (!await Context.auth.hasSomeAccess(organization.id)) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
-        const webshop = await Webshop.getByID(request.params.id)
+        LimitedFilteredRequestHelper.throwIfInvalidLimit({
+            request: request.query,
+            maxLimit: Context.auth.hasSomePlatformAccess() ? 1000 : 100,
+        });
+
+        const webshopId = request.params.id;
+
+        const webshop = await Webshop.getByID(webshopId);
         if (!webshop || !await Context.auth.canAccessWebshop(webshop, PermissionLevel.Read)) {
-            throw Context.auth.notFoundOrNoAccess("Je hebt geen toegang tot de bestellingen van deze webshop")
+            throw Context.auth.notFoundOrNoAccess('Je hebt geen toegang tot de bestellingen van deze webshop');
         }
 
+        return new Response(
+            await GetWebshopOrdersEndpoint.buildData(webshopId, request.query),
+        );
+
+        /*
+
         let orders: Order[] | undefined = undefined
         const limit = 50
 

package/src/helpers/AdminPermissionChecker.ts

@@ -1,6 +1,6 @@
 import { AutoEncoderPatchType, PatchMap } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { BalanceItem, CachedOutstandingBalance, Document, DocumentTemplate, EmailTemplate, Event, Group, Member, MemberPlatformMembership, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, Registration, User, Webshop } from '@stamhoofd/models';
+import { BalanceItem, CachedBalance, Document, DocumentTemplate, EmailTemplate, Event, Group, Member, MemberPlatformMembership, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, Registration, User, Webshop } from '@stamhoofd/models';
 import { AccessRight, EventPermissionChecker, FinancialSupportSettings, GroupCategory, GroupStatus, MemberWithRegistrationsBlob, PermissionLevel, PermissionsResourceType, Platform as PlatformStruct, RecordCategory } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { addTemporaryMemberAccess, hasTemporaryMemberAccess } from './TemporaryMemberAccess';
@@ -259,7 +259,7 @@ export class AdminPermissionChecker {
                 return true;
             }
 
-            const cachedBalance = await CachedOutstandingBalance.getForObjects([member.id]);
+            const cachedBalance = await CachedBalance.getForObjects([member.id]);
             if (cachedBalance.length === 0 || (cachedBalance[0].amount === 0 && cachedBalance[0].amountPending === 0)) {
                 return true;
             }
@@ -398,6 +398,15 @@ export class AdminPermissionChecker {
             orders: Order[];
         },
     ): Promise<boolean> {
+        // These balance items are out of scope - but we do have access to them
+        for (const balanceItem of balanceItems) {
+            if (balanceItem.payingOrganizationId && this.checkScope(balanceItem.payingOrganizationId)) {
+                if (await this.canManagePayments(balanceItem.payingOrganizationId)) {
+                    return true;
+                }
+            }
+        }
+
         for (const balanceItem of balanceItems) {
             if (!this.checkScope(balanceItem.organizationId)) {
                 // Invalid scope

package/src/helpers/AuthenticatedStructures.ts

@@ -1,6 +1,6 @@
 import { SimpleError } from '@simonbackx/simple-errors';
-import { CachedOutstandingBalance, Event, Group, Member, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Organization, OrganizationRegistrationPeriod, Payment, RegistrationPeriod, User, Webshop } from '@stamhoofd/models';
-import { AccessRight, CachedOutstandingBalanceObject, CachedOutstandingBalanceObjectContact, CachedOutstandingBalance as CachedOutstandingBalanceStruct, CachedOutstandingBalanceType, Event as EventStruct, Group as GroupStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberWithRegistrationsBlob, MembersBlob, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, PrivateWebshop, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
+import { CachedBalance, Event, Group, Member, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, RegistrationPeriod, User, Webshop } from '@stamhoofd/models';
+import { AccessRight, ReceivableBalanceObject, ReceivableBalanceObjectContact, ReceivableBalance as ReceivableBalanceStruct, ReceivableBalanceType, Event as EventStruct, Group as GroupStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberWithRegistrationsBlob, MembersBlob, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, PrivateOrder, PrivateWebshop, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
 
 import { Formatter } from '@stamhoofd/utility';
 import { Context } from './Context';
@@ -423,34 +423,95 @@ export class AuthenticatedStructures {
         return result;
     }
 
-    static async cachedOutstandingBalances(balances: CachedOutstandingBalance[]): Promise<CachedOutstandingBalanceStruct[]> {
+    static async orders(orders: Order[]): Promise<PrivateOrder[]> {
+        // Load groups
+        // const groupIds = orders.map(e => e.groupId).filter(id => id !== null);
+        // const groups = groupIds.length > 0 ? await Group.getByIDs(...groupIds) : [];
+        // const groupStructs = await this.groups(groups);
+
+        const result: PrivateOrder[] = [];
+
+        for (const order of orders) {
+            // const group = groupStructs.find(g => g.id == event.groupId) ?? null;
+
+            const struct = PrivateOrder.create({
+                ...order,
+                // todo!!!!!
+                balanceItems: [],
+            });
+
+            result.push(struct);
+        }
+
+        return result;
+    }
+
+    static async receivableBalance(balance: CachedBalance): Promise<ReceivableBalanceStruct> {
+        return (await this.receivableBalances([balance]))[0];
+    }
+
+    static async receivableBalances(balances: CachedBalance[]): Promise<ReceivableBalanceStruct[]> {
         if (balances.length === 0) {
             return [];
         }
 
-        const organizationIds = Formatter.uniqueArray(balances.filter(b => b.objectType === CachedOutstandingBalanceType.organization).map(b => b.objectId));
+        const organizationIds = Formatter.uniqueArray(balances.filter(b => b.objectType === ReceivableBalanceType.organization).map(b => b.objectId));
         const organizations = organizationIds.length > 0 ? await Organization.getByIDs(...organizationIds) : [];
         const admins = await User.getAdmins(organizationIds, { verified: true });
-
         const organizationStructs = await this.organizations(organizations);
 
-        const result: CachedOutstandingBalanceStruct[] = [];
+        const memberIds = Formatter.uniqueArray(balances.filter(b => b.objectType === ReceivableBalanceType.member).map(b => b.objectId));
+        const members = memberIds.length > 0 ? await Member.getBlobByIds(...memberIds) : [];
+
+        const result: ReceivableBalanceStruct[] = [];
         for (const balance of balances) {
-            const organization = organizationStructs.find(o => o.id == balance.objectId) ?? null;
-            let thisAdmins: User[] = [];
-            if (organization) {
-                thisAdmins = admins.filter(a => a.permissions && a.permissions.forOrganization(organization)?.hasAccessRight(AccessRight.OrganizationFinanceDirector));
+            let object = ReceivableBalanceObject.create({
+                id: balance.objectId,
+                name: 'Onbekend',
+            });
+
+            if (balance.objectType === ReceivableBalanceType.organization) {
+                const organization = organizationStructs.find(o => o.id == balance.objectId) ?? null;
+                if (organization) {
+                    const thisAdmins = admins.filter(a => a.permissions && a.permissions.forOrganization(organization)?.hasAccessRight(AccessRight.OrganizationFinanceDirector));
+                    object = ReceivableBalanceObject.create({
+                        id: balance.objectId,
+                        name: organization.name,
+                        contacts: thisAdmins.map(a => ReceivableBalanceObjectContact.create({
+                            firstName: a.firstName ?? '',
+                            lastName: a.lastName ?? '',
+                            emails: [a.email],
+                        })),
+                    });
+                }
+            }
+            else if (balance.objectType === ReceivableBalanceType.member) {
+                const member = members.find(m => m.id === balance.objectId) ?? null;
+                if (member) {
+                    object = ReceivableBalanceObject.create({
+                        id: balance.objectId,
+                        name: member.details.name,
+                        contacts: [
+                            ReceivableBalanceObjectContact.create({
+                                firstName: member.details.firstName ?? '',
+                                lastName: member.details.lastName ?? '',
+                                emails: member.details.getMemberEmails(),
+                            }),
+                            ...member.users.filter(u => !member.details.getMemberEmails().includes(u.email)).map((a) => {
+                                return ReceivableBalanceObjectContact.create({
+                                    firstName: a.firstName ?? '',
+                                    lastName: a.lastName ?? '',
+                                    emails: [a.email],
+                                });
+                            }),
+                        ],
+                    });
+                }
             }
 
-            const struct = CachedOutstandingBalanceStruct.create({
+            const struct = ReceivableBalanceStruct.create({
                 ...balance,
-                object: CachedOutstandingBalanceObject.create({
-                    name: organization?.name ?? 'Onbekend',
-                    contacts: thisAdmins.map(a => CachedOutstandingBalanceObjectContact.create({
-                        name: a.name ?? '',
-                        emails: [a.email],
-                    })),
-                }),
+                object,
             });
 
             result.push(struct);

package/src/helpers/FlagMomentCleanup.ts

@@ -0,0 +1,68 @@
+import { Group, MemberResponsibilityRecord, Platform, Registration } from '@stamhoofd/models';
+import { SQL, SQLWhereExists, SQLWhereSign } from '@stamhoofd/sql';
+import { GroupType } from '@stamhoofd/structures';
+
+export class FlagMomentCleanup {
+    /**
+     * End functions of old members who have no active registration for the current period.
+     */
+    static async endFunctionsOfUsersWithoutRegistration() {
+        console.log('Start cleanup functions');
+        const responsibilitiesToEnd = await this.getActiveMemberResponsibilityRecordsForOrganizationWithoutRegistrationInCurrentPeriod();
+
+        const now = new Date();
+
+        await Promise.all(responsibilitiesToEnd.map(async (responsibility) => {
+            responsibility.endDate = now;
+            await responsibility.save();
+            console.log(`Ended responsibility with id ${responsibility.id}`);
+        }));
+    }
+
+    static async getActiveMemberResponsibilityRecordsForOrganizationWithoutRegistrationInCurrentPeriod() {
+        const currentPeriodId = (await Platform.getShared()).periodId;
+
+        const now = new Date();
+
+        return await MemberResponsibilityRecord.select()
+            .whereNot('organizationId', null)
+            .where(
+                SQL.where('startDate', SQLWhereSign.LessEqual, now)
+                    .or('startDate', null),
+            )
+            .where(
+                SQL.where('endDate', SQLWhereSign.GreaterEqual, now)
+                    .or('endDate', null),
+            )
+            .whereNot(
+                new SQLWhereExists(
+                    SQL.select()
+                        .from(Registration.table)
+                        .join(
+                            SQL.innerJoin(SQL.table(Group.table))
+                                .where(
+                                    SQL.column(Group.table, 'id'),
+                                    SQL.column(Registration.table, 'groupId'),
+                                ),
+                        )
+                        .where(
+                            SQL.column(Registration.table, 'memberId'),
+                            SQL.column(MemberResponsibilityRecord.table, 'memberId'),
+                        ).where(
+                            SQL.column(Registration.table, 'organizationId'),
+                            SQL.column(MemberResponsibilityRecord.table, 'organizationId'),
+                        ).where(
+                            SQL.column(Registration.table, 'periodId'),
+                            currentPeriodId,
+                        ).where(
+                            SQL.column(Registration.table, 'deactivatedAt'),
+                            null,
+                        ).where(
+                            SQL.column(Group.table, 'type'),
+                            GroupType.Membership,
+                        ),
+                ),
+            )
+            .fetch();
+    }
+}

package/src/helpers/LimitedFilteredRequestHelper.ts

@@ -0,0 +1,24 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import { LimitedFilteredRequest } from '@stamhoofd/structures';
+
+export class LimitedFilteredRequestHelper {
+    static throwIfInvalidLimit({ request, maxLimit }: { request: LimitedFilteredRequest; maxLimit: number }) {
+        const requestLimit = request.limit;
+
+        if (requestLimit > maxLimit) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be more than ' + maxLimit,
+            });
+        }
+
+        if (requestLimit < 1) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be less than 1',
+            });
+        }
+    }
+}

package/src/helpers/OrganizationCharger.ts

@@ -0,0 +1,46 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import { BalanceItem, Platform } from '@stamhoofd/models';
+import { BalanceItemType, Organization as OrganizationStruct } from '@stamhoofd/structures';
+
+export class OrganizationCharger {
+    static async chargeFromPlatform(args: { organizationsToCharge: OrganizationStruct[]; price: number; amount?: number; description: string }) {
+        const platform = await Platform.getShared();
+
+        const chargeVia = platform.membershipOrganizationId;
+
+        if (!chargeVia) {
+            throw new SimpleError({
+                code: 'missing_membership_organization',
+                message: 'Missing membershipOrganizationId',
+                human: 'Er is geen lokale groep verantwoordelijk voor de aanrekening van aansluitingen geconfigureerd',
+            });
+        }
+
+        await OrganizationCharger.chargeMany({ chargingOrganizationId: chargeVia, ...args });
+    }
+
+    static async chargeMany({ chargingOrganizationId, organizationsToCharge, price, amount, description }: { chargingOrganizationId: string; organizationsToCharge: OrganizationStruct[]; price: number; amount?: number; description: string }) {
+        const balanceItems = organizationsToCharge.map(organizationBeingCharged => OrganizationCharger.createBalanceItem({
+            price,
+            amount,
+            description,
+            chargingOrganizationId,
+            organizationBeingCharged,
+        }));
+
+        await Promise.all(balanceItems.map(balanceItem => balanceItem.save()));
+        await BalanceItem.updateOutstanding(balanceItems);
+    }
+
+    private static createBalanceItem({ price, amount, description, chargingOrganizationId, organizationBeingCharged }: { price: number; amount?: number; description: string; chargingOrganizationId: string; organizationBeingCharged: OrganizationStruct }): BalanceItem {
+        const balanceItem = new BalanceItem();
+        balanceItem.unitPrice = price;
+        balanceItem.amount = amount ?? 1;
+        balanceItem.description = description;
+        balanceItem.type = BalanceItemType.Other;
+        balanceItem.payingOrganizationId = organizationBeingCharged.id;
+        balanceItem.organizationId = chargingOrganizationId;
+
+        return balanceItem;
+    }
+}