@stamhoofd/backend 2.43.2 → 2.44.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.43.2",
+    "version": "2.44.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -36,14 +36,14 @@
         "@simonbackx/simple-encoding": "2.15.1",
         "@simonbackx/simple-endpoints": "1.14.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.43.2",
-        "@stamhoofd/backend-middleware": "2.43.2",
-        "@stamhoofd/email": "2.43.2",
-        "@stamhoofd/models": "2.43.2",
-        "@stamhoofd/queues": "2.43.2",
-        "@stamhoofd/sql": "2.43.2",
-        "@stamhoofd/structures": "2.43.2",
-        "@stamhoofd/utility": "2.43.2",
+        "@stamhoofd/backend-i18n": "2.44.0",
+        "@stamhoofd/backend-middleware": "2.44.0",
+        "@stamhoofd/email": "2.44.0",
+        "@stamhoofd/models": "2.44.0",
+        "@stamhoofd/queues": "2.44.0",
+        "@stamhoofd/sql": "2.44.0",
+        "@stamhoofd/structures": "2.44.0",
+        "@stamhoofd/utility": "2.44.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -60,5 +60,5 @@
         "postmark": "^4.0.5",
         "stripe": "^16.6.0"
     },
-    "gitHead": "06abe49aaa20e7baa4ee44b48f4fae33ae30ae3e"
+    "gitHead": "1168aea7895e1aba48cd3123b09fc0b09a2b336f"
 }

package/src/crons/{clear-excel-cache.test.ts → clearExcelCache.test.ts}

@@ -1,6 +1,6 @@
 import { Dirent } from 'fs';
 import fs from 'fs/promises';
-import { clearExcelCacheHelper } from './clear-excel-cache';
+import { clearExcelCacheHelper } from './clearExcelCache';
 
 const testPath = '/Users/user/project/backend/app/api/.cache';
 jest.mock('fs/promises');

package/src/crons/endFunctionsOfUsersWithoutRegistration.ts

@@ -0,0 +1,18 @@
+import { FlagMomentCleanup } from '../helpers/FlagMomentCleanup';
+
+let lastCleanupYear: number = -1;
+let lastCleanupMonth: number = -1;
+
+export async function endFunctionsOfUsersWithoutRegistration() {
+    const now = new Date();
+    const currentYear = now.getFullYear();
+    const currentMonth = now.getMonth();
+
+    if (lastCleanupMonth === currentMonth && currentYear === lastCleanupYear) {
+        return;
+    }
+
+    await FlagMomentCleanup.endFunctionsOfUsersWithoutRegistration();
+    lastCleanupYear = currentYear;
+    lastCleanupMonth = currentMonth;
+}

package/src/crons.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 import { Database } from '@simonbackx/simple-database';
 import { logger, StyledText } from '@simonbackx/simple-logging';
@@ -9,7 +8,8 @@ import { Formatter, sleep } from '@stamhoofd/utility';
 import AWS from 'aws-sdk';
 import { DateTime } from 'luxon';
 
-import { clearExcelCache } from './crons/clear-excel-cache';
+import { clearExcelCache } from './crons/clearExcelCache';
+import { endFunctionsOfUsersWithoutRegistration } from './crons/endFunctionsOfUsersWithoutRegistration';
 import { ExchangePaymentEndpoint } from './endpoints/organization/shared/ExchangePaymentEndpoint';
 import { checkSettlements } from './helpers/CheckSettlements';
 import { ForwardHandler } from './helpers/ForwardHandler';
@@ -740,6 +740,12 @@ registeredCronJobs.push({
     running: false,
 });
 
+registeredCronJobs.push({
+    name: 'endFunctionsOfUsersWithoutRegistration',
+    method: endFunctionsOfUsersWithoutRegistration,
+    running: false,
+});
+
 async function run(name: string, handler: () => Promise<void>) {
     try {
         await logger.setContext({

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

@@ -0,0 +1,116 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { ChargeOrganizationsRequest, LimitedFilteredRequest, Organization as OrganizationStruct } from '@stamhoofd/structures';
+
+import { QueueHandler } from '@stamhoofd/queues';
+import { Context } from '../../../helpers/Context';
+import { fetchToAsyncIterator } from '../../../helpers/fetchToAsyncIterator';
+import { OrganizationCharger } from '../../../helpers/OrganizationCharger';
+import { GetOrganizationsEndpoint } from './GetOrganizationsEndpoint';
+
+type Params = Record<string, never>;
+type Query = LimitedFilteredRequest;
+type Body = ChargeOrganizationsRequest;
+type ResponseBody = undefined;
+
+export class ChargeOrganizationsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
+    bodyDecoder = ChargeOrganizationsRequest as Decoder<ChargeOrganizationsRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'POST') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/admin/charge-organizations', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    private static throwIfInvalidBody(body: Body) {
+        if (!body.description?.trim()?.length) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Invalid description',
+                human: 'Beschrijving is verplicht',
+                field: 'description',
+            });
+        }
+
+        if (!body.price) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Invalid price',
+                human: 'Bedrag kan niet 0 zijn',
+                field: 'price',
+            });
+        }
+
+        if (body.amount === 0) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Invalid amount',
+                human: 'Aantal kan niet 0 zijn',
+                field: 'amount',
+            });
+        }
+
+        if (body.organizationId === undefined) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Invalid organization id',
+                human: 'Organisatie is verplicht',
+                field: 'organizationId',
+            });
+        }
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.authenticate();
+
+        if (!Context.auth.hasPlatformFullAccess()) {
+            throw Context.auth.error();
+        }
+
+        const body = request.body;
+        ChargeOrganizationsEndpoint.throwIfInvalidBody(body);
+
+        const queueId = 'charge-organizations';
+
+        if (QueueHandler.isRunning(queueId)) {
+            throw new SimpleError({
+                code: 'charge_pending',
+                message: 'Charge organizations already pending',
+                human: 'Er is al een aanrekening bezig, even geduld.',
+            });
+        }
+
+        await QueueHandler.schedule(queueId, async () => {
+            const dataGenerator = fetchToAsyncIterator(request.query, {
+                fetch: GetOrganizationsEndpoint.buildData,
+            });
+
+            const organizationId = body.organizationId;
+            const chargeOrganizations = organizationId === null
+                ? OrganizationCharger.chargeFromPlatform
+                : (args: { organizationsToCharge: OrganizationStruct[]; price: number; amount?: number; description: string }) => OrganizationCharger.chargeMany({
+                        chargingOrganizationId: organizationId,
+                        ...args });
+
+            for await (const data of dataGenerator) {
+                await chargeOrganizations({
+                    organizationsToCharge: data,
+                    price: body.price,
+                    amount: body.amount ?? 1,
+                    description: body.description,
+                });
+            }
+        });
+
+        return new Response(undefined);
+    }
+}

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

@@ -95,12 +95,10 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
         return query;
     }
 
-    async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.authenticate();
-
+    static async buildData(requestQuery: LimitedFilteredRequest): Promise<PaginatedResponse<OrganizationStruct[], LimitedFilteredRequest>> {
         const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 100;
 
-        if (request.query.limit > maxLimit) {
+        if (requestQuery.limit > maxLimit) {
             throw new SimpleError({
                 code: 'invalid_field',
                 field: 'limit',
@@ -108,7 +106,7 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
             });
         }
 
-        if (request.query.limit < 1) {
+        if (requestQuery.limit < 1) {
             throw new SimpleError({
                 code: 'invalid_field',
                 field: 'limit',
@@ -116,34 +114,40 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
             });
         }
 
-        const data = await GetOrganizationsEndpoint.buildQuery(request.query).fetch();
+        const data = await GetOrganizationsEndpoint.buildQuery(requestQuery).fetch();
         const organizations = Organization.fromRows(data, 'organizations');
 
         let next: LimitedFilteredRequest | undefined;
 
-        if (organizations.length >= request.query.limit) {
+        if (organizations.length >= requestQuery.limit) {
             const lastObject = organizations[organizations.length - 1];
-            const nextFilter = getSortFilter(lastObject, sorters, request.query.sort);
+            const nextFilter = getSortFilter(lastObject, sorters, requestQuery.sort);
 
             next = new LimitedFilteredRequest({
-                filter: request.query.filter,
+                filter: requestQuery.filter,
                 pageFilter: nextFilter,
-                sort: request.query.sort,
-                limit: request.query.limit,
-                search: request.query.search,
+                sort: requestQuery.sort,
+                limit: requestQuery.limit,
+                search: requestQuery.search,
             });
 
-            if (JSON.stringify(nextFilter) === JSON.stringify(request.query.pageFilter)) {
-                console.error('Found infinite loading loop for', request.query);
+            if (JSON.stringify(nextFilter) === JSON.stringify(requestQuery.pageFilter)) {
+                console.error('Found infinite loading loop for', requestQuery);
                 next = undefined;
             }
         }
 
-        return new Response(
-            new PaginatedResponse<OrganizationStruct[], LimitedFilteredRequest>({
-                results: await AuthenticatedStructures.organizations(organizations),
-                next,
-            }),
-        );
+        return new PaginatedResponse<OrganizationStruct[], LimitedFilteredRequest>({
+            results: await AuthenticatedStructures.organizations(organizations),
+            next,
+        });
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.authenticate();
+
+        const paginatedResponse = await GetOrganizationsEndpoint.buildData(request.query);
+
+        return new Response(paginatedResponse);
     }
 }

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

@@ -53,6 +53,11 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             event.organizationId = put.organizationId;
             event.meta = put.meta;
 
+            if (event.organizationId === null && event.meta.groups !== null) {
+                event.meta.groups = null;
+                console.error('Removed groups because organizationId is null for new event');
+            }
+
             if (event.meta.groups && event.meta.groups.length === 0) {
                 throw new SimpleError({
                     code: 'invalid_field',
@@ -131,6 +136,11 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 event.organizationId = patch.organizationId;
             }
 
+            if (event.organizationId === null && event.meta.groups !== null) {
+                event.meta.groups = null;
+                console.error('Removed groups because organizationId is null for event', event.id);
+            }
+
             if (event.meta.groups && event.meta.groups.length === 0) {
                 throw new SimpleError({
                     code: 'invalid_field',

package/src/endpoints/global/registration/{GetUserDetailedBillingStatusEndpoint.ts → GetUserDetailedPayableBalanceEndpoint.ts}

@@ -1,6 +1,6 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { BalanceItem, Member, Organization, Payment } from '@stamhoofd/models';
-import { OrganizationDetailedBillingStatus, OrganizationDetailedBillingStatusItem } from '@stamhoofd/structures';
+import { DetailedPayableBalanceCollection, DetailedPayableBalance } from '@stamhoofd/structures';
 
 import { Formatter } from '@stamhoofd/utility';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -9,15 +9,17 @@ import { Context } from '../../../helpers/Context';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = undefined;
-type ResponseBody = OrganizationDetailedBillingStatus;
+type ResponseBody = DetailedPayableBalanceCollection;
 
-export class GetUserDetailedBilingStatusEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+export class GetUserDetailedPayableBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, '/user/billing/status/detailed', {});
+        const params = request.getVersion() >= 339
+            ? Endpoint.parseParameters(request.url, '/user/payable-balance/detailed', {})
+            : Endpoint.parseParameters(request.url, '/user/billing/status/detailed', {});
 
         if (params) {
             return [true, params as Params];
@@ -36,7 +38,7 @@ export class GetUserDetailedBilingStatusEndpoint extends Endpoint<Params, Query,
         // todo: this is a duplicate query
         const { payments, balanceItemPayments } = await BalanceItem.loadPayments(balanceItemModels);
 
-        return new Response(await GetUserDetailedBilingStatusEndpoint.getDetailedBillingStatus(balanceItemModels, payments));
+        return new Response(await GetUserDetailedPayableBalanceEndpoint.getDetailedBillingStatus(balanceItemModels, payments));
     }
 
     static async getDetailedBillingStatus(balanceItemModels: BalanceItem[], paymentModels: Payment[]) {
@@ -47,7 +49,7 @@ export class GetUserDetailedBilingStatusEndpoint extends Endpoint<Params, Query,
 
         // Group by organization you'll have to pay to
         if (organizationIds.length === 0) {
-            return OrganizationDetailedBillingStatus.create({});
+            return DetailedPayableBalanceCollection.create({});
         }
 
         // Optimization: prevent fetching the organization we already have
@@ -70,9 +72,9 @@ export class GetUserDetailedBilingStatusEndpoint extends Endpoint<Params, Query,
         const organizations = await AuthenticatedStructures.organizations(organizationModels);
         const payments = await AuthenticatedStructures.paymentsGeneral(paymentModels, false);
 
-        return OrganizationDetailedBillingStatus.create({
+        return DetailedPayableBalanceCollection.create({
             organizations: organizations.map((o) => {
-                return OrganizationDetailedBillingStatusItem.create({
+                return DetailedPayableBalance.create({
                     organization: o,
                     balanceItems: balanceItems.filter(b => b.organizationId == o.id),
                     payments: payments.filter(p => p.organizationId === o.id),

package/src/endpoints/global/registration/{GetUserBillingStatusEndpoint.ts → GetUserPayableBalanceEndpoint.ts}

@@ -1,6 +1,6 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { CachedOutstandingBalance, Member, Organization } from '@stamhoofd/models';
-import { OrganizationBillingStatus, OrganizationBillingStatusItem } from '@stamhoofd/structures';
+import { CachedBalance, Member, Organization } from '@stamhoofd/models';
+import { PayableBalanceCollection, PayableBalance } from '@stamhoofd/structures';
 
 import { Formatter } from '@stamhoofd/utility';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -9,15 +9,17 @@ import { Context } from '../../../helpers/Context';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = undefined;
-type ResponseBody = OrganizationBillingStatus;
+type ResponseBody = PayableBalanceCollection;
 
-export class GetUserBilingStatusEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+export class GetUserPayableBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, '/user/billing/status', {});
+        const params = request.getVersion() >= 339
+            ? Endpoint.parseParameters(request.url, '/user/payable-balance', {})
+            : Endpoint.parseParameters(request.url, '/user/billing/status', {});
 
         if (params) {
             return [true, params as Params];
@@ -31,14 +33,14 @@ export class GetUserBilingStatusEndpoint extends Endpoint<Params, Query, Body, R
 
         const memberIds = await Member.getMemberIdsWithRegistrationForUser(user);
 
-        return new Response(await GetUserBilingStatusEndpoint.getBillingStatusForObjects([user.id, ...memberIds], organization));
+        return new Response(await GetUserPayableBalanceEndpoint.getBillingStatusForObjects([user.id, ...memberIds], organization));
     }
 
     static async getBillingStatusForObjects(objectIds: string[], organization?: Organization | null) {
         // Load cached balances
-        const cachedOutstandingBalances = await CachedOutstandingBalance.getForObjects(objectIds, organization?.id);
+        const receivableBalances = await CachedBalance.getForObjects(objectIds, organization?.id);
 
-        const organizationIds = Formatter.uniqueArray(cachedOutstandingBalances.map(b => b.organizationId));
+        const organizationIds = Formatter.uniqueArray(receivableBalances.map(b => b.organizationId));
 
         let addOrganization = false;
         const i = organization ? organizationIds.indexOf(organization.id) : -1;
@@ -55,10 +57,10 @@ export class GetUserBilingStatusEndpoint extends Endpoint<Params, Query, Body, R
 
         const authenticatedOrganizations = await AuthenticatedStructures.organizations(organizations);
 
-        const billingStatus = OrganizationBillingStatus.create({});
+        const billingStatus = PayableBalanceCollection.create({});
 
         for (const organization of authenticatedOrganizations) {
-            const items = cachedOutstandingBalances.filter(b => b.organizationId === organization.id);
+            const items = receivableBalances.filter(b => b.organizationId === organization.id);
 
             let amount = 0;
             let amountPending = 0;
@@ -68,7 +70,7 @@ export class GetUserBilingStatusEndpoint extends Endpoint<Params, Query, Body, R
                 amountPending += item.amountPending;
             }
 
-            billingStatus.organizations.push(OrganizationBillingStatusItem.create({
+            billingStatus.organizations.push(PayableBalance.create({
                 organization,
                 amount,
                 amountPending,

package/src/endpoints/organization/dashboard/billing/{GetOrganizationDetailedBillingStatusEndpoint.ts → GetOrganizationDetailedPayableBalanceEndpoint.ts}

@@ -1,33 +1,29 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { OrganizationDetailedBillingStatus, PaymentStatus } from '@stamhoofd/structures';
+import { DetailedPayableBalanceCollection, PaymentStatus } from '@stamhoofd/structures';
 
 import { BalanceItem, Payment } from '@stamhoofd/models';
 import { SQL } from '@stamhoofd/sql';
 import { Context } from '../../../../helpers/Context';
-import { GetUserDetailedBilingStatusEndpoint } from '../../../global/registration/GetUserDetailedBillingStatusEndpoint';
+import { GetUserDetailedPayableBalanceEndpoint } from '../../../global/registration/GetUserDetailedPayableBalanceEndpoint';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type ResponseBody = OrganizationDetailedBillingStatus;
+type ResponseBody = DetailedPayableBalanceCollection;
 type Body = undefined;
 
-export class GetOrganizationDetailedBillingStatusEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+export class GetOrganizationDetailedPayableBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {
             return [false];
         }
 
-        if (request.getVersion() <= 334) {
-            // Deprecated
-            const params = Endpoint.parseParameters(request.url, '/billing/status/detailed', {});
-
-            if (params) {
-                return [true, params as Params];
-            }
-            return [false];
-        }
-
-        const params = Endpoint.parseParameters(request.url, '/organization/billing/status/detailed', {});
+        const params = request.getVersion() >= 339
+            ? Endpoint.parseParameters(request.url, '/organization/payable-balance/detailed', {})
+            : (
+                    request.getVersion() <= 334
+                        ? Endpoint.parseParameters(request.url, '/organization/billing/status', {})
+                        : Endpoint.parseParameters(request.url, '/organization/billing/status/detailed', {})
+                );
 
         if (params) {
             return [true, params as Params];
@@ -53,6 +49,6 @@ export class GetOrganizationDetailedBillingStatusEndpoint extends Endpoint<Param
             )
             .fetch();
 
-        return new Response(await GetUserDetailedBilingStatusEndpoint.getDetailedBillingStatus(balanceItemModels, paymentModels));
+        return new Response(await GetUserDetailedPayableBalanceEndpoint.getDetailedBillingStatus(balanceItemModels, paymentModels));
     }
 }

package/src/endpoints/organization/dashboard/billing/{GetOrganizationBillingStatusEndpoint.ts → GetOrganizationPayableBalanceEndpoint.ts}

@@ -1,21 +1,23 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { OrganizationBillingStatus } from '@stamhoofd/structures';
+import { PayableBalanceCollection } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context';
-import { GetUserBilingStatusEndpoint } from '../../../global/registration/GetUserBillingStatusEndpoint';
+import { GetUserPayableBalanceEndpoint } from '../../../global/registration/GetUserPayableBalanceEndpoint';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type ResponseBody = OrganizationBillingStatus;
+type ResponseBody = PayableBalanceCollection;
 type Body = undefined;
 
-export class GetDetailedBillingStatusEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+export class GetOrganizationPayableBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, '/organization/billing/status', {});
+        const params = request.getVersion() >= 339
+            ? Endpoint.parseParameters(request.url, '/organization/payable-balance', {})
+            : Endpoint.parseParameters(request.url, '/organization/billing/status', {});
 
         if (params) {
             return [true, params as Params];
@@ -32,6 +34,6 @@ export class GetDetailedBillingStatusEndpoint extends Endpoint<Params, Query, Bo
             throw Context.auth.error();
         }
 
-        return new Response(await GetUserBilingStatusEndpoint.getBillingStatusForObjects([organization.id], null));
+        return new Response(await GetUserPayableBalanceEndpoint.getBillingStatusForObjects([organization.id], null));
     }
 }

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

@@ -9,6 +9,7 @@ type Query = undefined;
 type Body = undefined;
 type ResponseBody = BalanceItemWithPayments[];
 
+// Rename to ReceiveableBalance
 export class GetMemberBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {

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

@@ -0,0 +1,98 @@
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { DetailedReceivableBalance, PaymentStatus, ReceivableBalanceType } from '@stamhoofd/structures';
+
+import { BalanceItem, BalanceItemPayment, CachedBalance, Payment } from '@stamhoofd/models';
+import { Context } from '../../../../helpers/Context';
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
+import { SQL } from '@stamhoofd/sql';
+
+type Params = { id: string; type: ReceivableBalanceType };
+type Query = undefined;
+type ResponseBody = DetailedReceivableBalance;
+type Body = undefined;
+
+export class GetReceivableBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/receivable-balances/@type/@id', {
+            type: String,
+            id: String,
+        });
+
+        if (params && Object.values(ReceivableBalanceType).includes(params.type as unknown as ReceivableBalanceType)) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        // If the user has permission, we'll also search if he has access to the organization's key
+        if (!await Context.auth.canManageFinances(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        const balanceItemModels = await CachedBalance.balanceForObjects(organization.id, [request.params.id], request.params.type);
+        let paymentModels: Payment[] = [];
+
+        switch (request.params.type) {
+            case ReceivableBalanceType.organization: {
+                paymentModels = await Payment.select()
+                    .where('organizationId', organization.id)
+                    .where('payingOrganizationId', request.params.id)
+                    .andWhere(
+                        SQL.whereNot('status', PaymentStatus.Failed),
+                    )
+                    .fetch();
+                break;
+            }
+
+            case ReceivableBalanceType.member: {
+                paymentModels = await Payment.select()
+                    .where('organizationId', organization.id)
+                    .join(
+                        SQL.join(BalanceItemPayment.table)
+                            .where(SQL.column(BalanceItemPayment.table, 'paymentId'), SQL.column(Payment.table, 'id')),
+                    )
+                    .join(
+                        SQL.join(BalanceItem.table)
+                            .where(SQL.column(BalanceItemPayment.table, 'balanceItemId'), SQL.column(BalanceItem.table, 'id')),
+                    )
+                    .where(SQL.column(BalanceItem.table, 'memberId'), request.params.id)
+                    .andWhere(
+                        SQL.whereNot('status', PaymentStatus.Failed),
+                    )
+                    .groupBy(SQL.column(Payment.table, 'id'))
+                    .fetch();
+                break;
+            }
+        }
+
+        const balanceItems = await BalanceItem.getStructureWithPayments(balanceItemModels);
+        const payments = await AuthenticatedStructures.paymentsGeneral(paymentModels, false);
+
+        const balances = await CachedBalance.getForObjects([request.params.id], organization.id);
+
+        const created = new CachedBalance();
+        created.amount = 0;
+        created.amountPending = 0;
+        created.organizationId = organization.id;
+        created.objectId = request.params.id;
+        created.objectType = request.params.type;
+
+        const base = await AuthenticatedStructures.receivableBalance(balances.length === 1 ? balances[0] : created);
+
+        return new Response(
+            DetailedReceivableBalance.create({
+                ...base,
+                balanceItems,
+                payments,
+            }),
+        );
+    }
+}