@stamhoofd/backend 2.43.3 → 2.44.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.43.3",
+    "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.3",
-        "@stamhoofd/backend-middleware": "2.43.3",
-        "@stamhoofd/email": "2.43.3",
-        "@stamhoofd/models": "2.43.3",
-        "@stamhoofd/queues": "2.43.3",
-        "@stamhoofd/sql": "2.43.3",
-        "@stamhoofd/structures": "2.43.3",
-        "@stamhoofd/utility": "2.43.3",
+        "@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": "1258338deacc6d61a53da939dda894dca3415c84"
+    "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/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,
+            }),
+        );
+    }
+}

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/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, Order, 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, PrivateOrder, 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';
@@ -446,34 +446,72 @@ export class AuthenticatedStructures {
         return result;
     }
 
-    static async cachedOutstandingBalances(balances: CachedOutstandingBalance[]): Promise<CachedOutstandingBalanceStruct[]> {
+    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/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;
+    }
+}

package/src/helpers/StripeHelper.ts

@@ -27,19 +27,29 @@ export class StripeHelper {
 
             if (charge.payment_method_details?.bancontact) {
                 if (charge.payment_method_details.bancontact.iban_last4) {
-                    payment.iban = 'xxxx ' + charge.payment_method_details.bancontact.iban_last4;
+                    payment.iban = '•••• ' + charge.payment_method_details.bancontact.iban_last4;
                 }
                 payment.ibanName = charge.payment_method_details.bancontact.verified_name;
             }
             if (charge.payment_method_details?.ideal) {
                 if (charge.payment_method_details.ideal.iban_last4) {
-                    payment.iban = 'xxxx ' + charge.payment_method_details.ideal.iban_last4;
+                    payment.iban = '•••• ' + charge.payment_method_details.ideal.iban_last4;
                 }
                 payment.ibanName = charge.payment_method_details.ideal.verified_name;
             }
             if (charge.payment_method_details?.card) {
                 if (charge.payment_method_details.card.last4) {
-                    payment.iban = 'xxxx ' + charge.payment_method_details.card.last4;
+                    payment.iban = '•••• ' + charge.payment_method_details.card.last4;
+                }
+            }
+            if (charge.payment_method_details?.sepa_debit) {
+                if (charge.payment_method_details.sepa_debit.last4) {
+                    if (charge.payment_method_details.sepa_debit.country === 'BE') {
+                        payment.iban = charge.payment_method_details.sepa_debit.country + '•• ' + charge.payment_method_details.sepa_debit.bank_code + '• •••• ' + charge.payment_method_details.sepa_debit.last4;
+                    }
+                    else {
+                        payment.iban = '•••• ' + charge.payment_method_details.sepa_debit.last4;
+                    }
                 }
             }
             await payment.save();
@@ -139,7 +149,7 @@ export class StripeHelper {
 
         console.log('session', session);
 
-        if (session.status === 'complete') {
+        if (session.payment_status === 'paid') {
             // This is a direct charge
             const payment_intent = session.payment_intent;
             if (payment_intent !== null && typeof payment_intent !== 'string') {
@@ -158,7 +168,7 @@ export class StripeHelper {
             // Cancel the session
             const session = await stripe.checkout.sessions.expire(model.stripeSessionId);
 
-            if (session.status === 'complete') {
+            if (session.payment_status === 'paid') {
                 return PaymentStatus.Succeeded;
             }
             if (session.status === 'expired') {
@@ -166,6 +176,11 @@ export class StripeHelper {
             }
         }
 
+        if (session.status === 'complete') {
+            // Small difference to detect if the payment is almost done
+            return PaymentStatus.Pending;
+        }
+
         return PaymentStatus.Created;
     }
 
@@ -231,10 +246,18 @@ export class StripeHelper {
         // Bancontact or iDEAL: use payment intends
         if (payment.method === PaymentMethod.Bancontact || payment.method === PaymentMethod.iDEAL) {
             const paymentMethod = await stripe.paymentMethods.create({
-                type: payment.method.toLowerCase() as 'bancontact',
+                type: payment.method.toLowerCase() as 'bancontact' | 'ideal',
                 billing_details: {
-                    name: customer.name && customer.name.length > 2 ? customer.name : 'Onbekend',
-                    email: customer.email,
+                    name: payment.customer?.dynamicName || (customer.name.length > 2 ? customer.name : 'Onbekend'),
+                    email: payment.customer?.dynamicEmail || customer.email,
+                    address: payment.customer?.company?.address
+                        ? {
+                                city: payment.customer.company.address.city,
+                                country: payment.customer.company.address.country,
+                                line1: payment.customer.company.address.street + ' ' + payment.customer.company.address.number,
+                                postal_code: payment.customer.company.address.postalCode,
+                            }
+                        : undefined,
                 },
             });
 
@@ -315,7 +338,7 @@ export class StripeHelper {
                 mode: 'payment',
                 success_url: redirectUrl,
                 cancel_url: cancelUrl,
-                payment_method_types: ['card'],
+                payment_method_types: payment.method === PaymentMethod.DirectDebit ? ['sepa_debit'] : ['card'],
                 line_items: stripeLineItems,
                 currency: 'eur',
                 locale: i18n.language as 'nl',
@@ -329,8 +352,10 @@ export class StripeHelper {
                         : undefined,
                     metadata: fullMetadata,
                     statement_descriptor: Formatter.slug(statementDescriptor).substring(0, 22).toUpperCase(),
+
                 },
-                customer_email: customer.email,
+                customer_email: payment.customer?.dynamicEmail || customer.email,
+                customer_creation: 'if_required',
                 metadata: fullMetadata,
                 expires_at: Math.floor(Date.now() / 1000) + 30 * 60, // Expire in 30 minutes
             });

package/src/sql-filters/orders.ts

@@ -2,10 +2,9 @@ import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQLFilterDefinit
 
 export const orderFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    'id': createSQLColumnFilterCompiler('id'),
-    'name': createSQLColumnFilterCompiler('name'),
-    'organizationId': createSQLColumnFilterCompiler('organizationId'),
-    '#': createSQLColumnFilterCompiler('number'),
+    id: createSQLColumnFilterCompiler('id'),
+    organizationId: createSQLColumnFilterCompiler('organizationId'),
+    number: createSQLColumnFilterCompiler('number'),
     // 'startDate': createSQLColumnFilterCompiler('startDate'),
     // 'endDate': createSQLColumnFilterCompiler('endDate'),
     // 'groupIds': createSQLExpressionFilterCompiler(

package/src/sql-filters/{cached-outstanding-balance.ts → receivable-balances.ts}

@@ -3,7 +3,7 @@ import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterComp
 /**
  * Defines how to filter cached balance items in the database from StamhoofdFilter objects
  */
-export const cachedOutstandingBalanceFilterCompilers: SQLFilterDefinitions = {
+export const receivableBalanceFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
     id: createSQLColumnFilterCompiler('id'),
     organizationId: createSQLColumnFilterCompiler('organizationId'),

package/src/sql-sorters/orders.ts

@@ -11,7 +11,7 @@ export const orderSorters: SQLSortDefinitions<Order> = {
     // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
     // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
 
-    '#': {
+    number: {
         getValue(a) {
             return a.number;
         },
@@ -22,7 +22,7 @@ export const orderSorters: SQLSortDefinitions<Order> = {
             });
         },
     },
-    'id': {
+    id: {
         getValue(a) {
             return a.id;
         },
@@ -33,18 +33,7 @@ export const orderSorters: SQLSortDefinitions<Order> = {
             });
         },
     },
-    'name': {
-        getValue(a) {
-            return a.id;
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('name'),
-                direction,
-            });
-        },
-    },
-    'createdAt': {
+    createdAt: {
         getValue(a) {
             return Formatter.dateTimeIso(a.createdAt);
         },

package/src/sql-sorters/{cached-outstanding-balance.ts → receivable-balances.ts}

@@ -1,7 +1,7 @@
-import { CachedOutstandingBalance } from '@stamhoofd/models';
+import { CachedBalance } from '@stamhoofd/models';
 import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
 
-export const cachedOutstandingBalanceSorters: SQLSortDefinitions<CachedOutstandingBalance> = {
+export const receivableBalanceSorters: SQLSortDefinitions<CachedBalance> = {
     // WARNING! TEST NEW SORTERS THOROUGHLY!
     // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
     // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields.