@stamhoofd/backend 2.140.0 → 2.142.0

package/src/crons/settlement-sync.ts

@@ -0,0 +1,109 @@
+// Nightly settlement sync for all providers. Everything is an upsert and synced payouts are
+// skipped, so the windowed re-walk is cheap.
+import { registerCron } from '@stamhoofd/crons';
+import { Email } from '@stamhoofd/email';
+import { Settlement } from '@stamhoofd/models/models/Settlement.js';
+import { PaymentProvider } from '@stamhoofd/structures';
+import { SettlementStatus } from '@stamhoofd/structures/settlements/SettlementStatus.js';
+import { Formatter } from '@stamhoofd/utility';
+
+import { SettlementSyncRunner } from '../helpers/SettlementSyncRunner.js';
+import { isApplicationFeeInvoicingEnabled } from './stripe-invoices.js';
+
+registerCron('settlement-sync', syncSettlements);
+
+/**
+ * How many days of settlements the nightly run re-walks.
+ */
+const SYNC_WINDOW_DAYS = 30;
+
+/**
+ * Fees received in a platform payout are billed by the monthly invoicer, so pendingFees taking a
+ * while to reach 0 is normal. Older than this it means the invoicer failed or skipped something.
+ */
+const MAXIMUM_PENDING_FEES_AGE_MS = 31 * 24 * 60 * 60 * 1000;
+
+let lastSettlementSync: Date | null = null;
+
+async function syncSettlements() {
+    if (STAMHOOFD.environment !== 'production') {
+        return;
+    }
+
+    // Between 5 and 6 AM Brussels time.
+    if (Formatter.luxon().hour !== 5) {
+        return;
+    }
+
+    // Wait for the next day before doing a new sync
+    const today = new Date();
+    if (lastSettlementSync && Formatter.dateIso(lastSettlementSync) === Formatter.dateIso(today)) {
+        console.log('Settlement sync done for this day');
+        return;
+    }
+
+    console.log('Syncing settlements...');
+
+    const start = new Date(today.getTime() - SYNC_WINDOW_DAYS * 24 * 60 * 60 * 1000);
+
+    const runner = new SettlementSyncRunner();
+    await runner.run({
+        start,
+        providers: [PaymentProvider.Stripe, PaymentProvider.Mollie],
+        stripe: { retryUnsynced: true },
+    });
+
+    await reportProblemSettlements();
+
+    lastSettlementSync = new Date();
+}
+
+/**
+ * Every unsynced settlement or non-zero delta is a real question to answer, not noise.
+ *
+ * Exported for tests only.
+ */
+export async function reportProblemSettlements() {
+    // Only payouts that actually arrived: money that failed or was canceled holds no transactions
+    // to reconcile
+    const unexplained = await Settlement.select()
+        .where('status', SettlementStatus.Paid)
+        .where('unexplainedAmount', '!=', 0)
+        .limit(50)
+        .fetch();
+
+    const unsynced = await Settlement.select()
+        .where('status', SettlementStatus.Paid)
+        .where('syncedAt', null)
+        .limit(50)
+        .fetch();
+
+    // Fees only stop being pending once the invoicer bills them: while it is off, every platform
+    // payout would be reported forever
+    const stalePendingFees = isApplicationFeeInvoicingEnabled()
+        ? await Settlement.select()
+                .where('status', SettlementStatus.Paid)
+                .where('pendingFees', '!=', 0)
+                .where('settledAt', '<', new Date(Date.now() - MAXIMUM_PENDING_FEES_AGE_MS))
+                .limit(50)
+                .fetch()
+        : [];
+
+    if (unexplained.length === 0 && unsynced.length === 0 && stalePendingFees.length === 0) {
+        return;
+    }
+
+    const total = new Set([...unexplained, ...unsynced, ...stalePendingFees].map(s => s.id)).size;
+
+    const describe = (settlement: Settlement) => {
+        return settlement.provider + ' ' + settlement.externalId + ' (' + Formatter.dateIso(settlement.settledAt) + ', ' + Formatter.price(settlement.unexplainedAmount) + ' onverklaard, ' + Formatter.price(settlement.pendingFees) + ' niet-gefactureerde kosten, ' + Formatter.price(settlement.uncollectibleFees) + ' niet-aanrekenbare kosten, ' + settlement.syncFailureCount + ' mislukte pogingen)';
+    };
+
+    Email.sendWebmaster({
+        subject: 'Uitbetalingen met problemen: ' + total,
+        html: 'Deze uitbetalingen kloppen niet of konden niet gesynchroniseerd worden: <br><br>'
+            + 'Onverklaard verschil:<br>' + (unexplained.map(describe).join('<br>') || 'geen') + '<br><br>'
+            + 'Niet gesynchroniseerd:<br>' + (unsynced.map(describe).join('<br>') || 'geen') + '<br><br>'
+            + 'Kosten te lang niet gefactureerd:<br>' + (stalePendingFees.map(describe).join('<br>') || 'geen'),
+    });
+}

package/src/crons/stripe-invoices.ts

@@ -1,22 +1,28 @@
 import { registerCron } from '@stamhoofd/crons';
-import { Formatter } from '@stamhoofd/utility';
-import { StripeInvoicer } from '../helpers/StripeInvoicer.js';
 import { Organization, Platform } from '@stamhoofd/models';
+import { Formatter } from '@stamhoofd/utility';
+
+import { ApplicationFeeInvoicer } from '../helpers/ApplicationFeeInvoicer.js';
 
 registerCron('stripe-invoices', createStripeInvoices);
 
 let lastStripeInvoice: Date | null = null;
 
-async function createStripeInvoices() {
-    if (STAMHOOFD.environment !== 'production' && STAMHOOFD.environment !== 'development') {
-        return;
-    }
-
-    if (STAMHOOFD.userMode === 'platform') {
-        return;
-    }
+/**
+ * Whether application fees are billed automatically. The sync stores what we received either way,
+ * so anything that reports on uninvoiced fees has to ask this first: while it is off, fees staying
+ * uninvoiced is the expected state, not a problem.
+ *
+ * The settlements feature is not released yet: allow production at go-live.
+ */
+export function isApplicationFeeInvoicingEnabled(): boolean {
+    return (STAMHOOFD.environment as string) === 'development'
+        && STAMHOOFD.userMode !== 'platform'
+        && STAMHOOFD.STRIPE_CONNECT_METHOD !== 'standard';
+}
 
-    if (STAMHOOFD.STRIPE_CONNECT_METHOD === 'standard') {
+async function createStripeInvoices() {
+    if (!isApplicationFeeInvoicingEnabled()) {
         return;
     }
 
@@ -41,9 +47,9 @@ async function createStripeInvoices() {
 
     const membershipOrganization = await Organization.getByID(membershipOrganizationId, true);
 
-    const invoicer = new StripeInvoicer({
+    const invoicer = new ApplicationFeeInvoicer({
         secretKey: STAMHOOFD.STRIPE_SECRET_KEY,
     });
-    await invoicer.generateAllInvoices(membershipOrganization, { forceLast: Formatter.dateIso(today) === '2026-07-04' });
+    await invoicer.generateInvoices(membershipOrganization);
     lastStripeInvoice = new Date();
 }

package/src/crons.ts

@@ -3,7 +3,6 @@ import { registerCron } from '@stamhoofd/crons';
 import { Group, Organization, Payment, Registration, STPackage, Webshop } from '@stamhoofd/models';
 import { SQL } from '@stamhoofd/sql';
 import { PaymentMethod, PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
-import { checkSettlements } from './helpers/CheckSettlements.js';
 import { OrganizationDNSService } from './services/OrganizationDNSService.js';
 import { PaymentService } from './services/PaymentService.js';
 import { RegistrationService } from './services/RegistrationService.js';
@@ -193,7 +192,6 @@ async function checkOldPayments() {
 // 5 days - 10 days
 async function checkOldDirectDebitPayments() {
     let timeout = 60 * 1000 * 60 * 24 * 5;
-    const timeout2 = 60 * 1000 * 60 * 24 * 10;
 
     if (STAMHOOFD.environment === 'development') {
         // For Mollie, webhooks won't work, so we poll in the backend
@@ -207,8 +205,7 @@ async function checkOldDirectDebitPayments() {
                 PaymentMethod.DirectDebit,
             ])
                 .and('status', [PaymentStatus.Created, PaymentStatus.Pending])
-                .and('createdAt', '<', new Date(new Date().getTime() - timeout))
-                .and('createdAt', '>', new Date(new Date().getTime() - timeout2)),
+                .and('createdAt', '<', new Date(new Date().getTime() - timeout)),
         )
         .orderBy('createdAt', 'ASC')
         .limit(500)
@@ -357,7 +354,6 @@ async function checkReservedUntil() {
     }
 }
 
-registerCron('checkSettlements', checkSettlements);
 registerCron('checkExpirationEmails', checkExpirationEmails);
 registerCron('checkReservedUntil', checkReservedUntil);
 registerCron('checkDNS', checkDNS);

package/src/endpoints/admin/organizations/PatchOrganizationsEndpoint.test.ts

@@ -0,0 +1,165 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { BalanceItemFactory, Invoice, Organization, OrganizationFactory, Payment } from '@stamhoofd/models';
+import { ApplicationFee } from '@stamhoofd/models/models/ApplicationFee.js';
+import { SettlementCharge } from '@stamhoofd/models/models/SettlementCharge.js';
+import { PatchableArray } from '@simonbackx/simple-encoding';
+import type { PatchableArrayAutoEncoder } from '@simonbackx/simple-encoding';
+import type { Organization as OrganizationStruct } from '@stamhoofd/structures';
+import { PaymentMethod, PaymentStatus } from '@stamhoofd/structures';
+import { ApplicationFeeType } from '@stamhoofd/structures/settlements/ApplicationFeeType.js';
+import { SettlementChargeType } from '@stamhoofd/structures/settlements/SettlementChargeType.js';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
+import { v4 as uuidv4 } from 'uuid';
+import { testServer } from '../../../../tests/helpers/TestServer.js';
+import { initPlatformAdmin } from '../../../../tests/init/index.js';
+import { initMembershipOrganization } from '../../../../tests/init/initMembershipOrganization.js';
+import { PatchOrganizationsEndpoint } from './PatchOrganizationsEndpoint.js';
+
+const baseUrl = `/admin/organizations`;
+const endpoint = new PatchOrganizationsEndpoint();
+
+describe('Endpoint.PatchOrganizationsEndpoint', () => {
+    let membershipOrganization: Organization;
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'organization');
+    });
+
+    beforeAll(async () => {
+        membershipOrganization = await initMembershipOrganization();
+    });
+
+    const deleteOrganization = async (organization: Organization) => {
+        const { adminToken } = await initPlatformAdmin();
+
+        const patch: PatchableArrayAutoEncoder<OrganizationStruct> = new PatchableArray();
+        patch.addDelete(organization.id);
+
+        // Platform admins are not scoped to an organization, so no host is required
+        const request = Request.patch({
+            path: baseUrl,
+            host: '',
+            body: patch,
+            headers: {
+                authorization: 'Bearer ' + adminToken.accessToken,
+            },
+        });
+
+        return await testServer.test(endpoint, request);
+    };
+
+    const createPayment = async ({ payingOrganizationId }: { payingOrganizationId: string | null }) => {
+        const payment = new Payment();
+        payment.organizationId = membershipOrganization.id;
+        payment.payingOrganizationId = payingOrganizationId;
+        payment.method = PaymentMethod.Transfer;
+        payment.status = PaymentStatus.Succeeded;
+        payment.price = 10_00;
+        await payment.save();
+        return payment;
+    };
+
+    const createApplicationFee = async ({ payingOrganizationId }: { payingOrganizationId: string }) => {
+        const charge = new SettlementCharge();
+        charge.type = SettlementChargeType.ApplicationFeeService;
+        charge.externalId = uuidv4();
+        charge.amount = -30_00;
+        charge.organizationId = payingOrganizationId;
+        charge.occurredAt = new Date();
+        await charge.save();
+
+        const fee = new ApplicationFee();
+        fee.externalId = uuidv4();
+        fee.type = ApplicationFeeType.Service;
+        fee.amount = 30_00;
+        fee.organizationId = membershipOrganization.id;
+        fee.payingOrganizationId = payingOrganizationId;
+        fee.settlementChargeId = charge.id;
+        fee.occurredAt = new Date();
+        await fee.save();
+        return fee;
+    };
+
+    const createInvoice = async ({ payingOrganizationId }: { payingOrganizationId: string | null }) => {
+        const invoice = new Invoice();
+        invoice.organizationId = membershipOrganization.id;
+        invoice.payingOrganizationId = payingOrganizationId;
+        await invoice.save();
+        return invoice;
+    };
+
+    test('An organization without financial records can be deleted', async () => {
+        const organization = await new OrganizationFactory({}).create();
+
+        const response = await deleteOrganization(organization);
+
+        expect(response.status).toBe(200);
+        expect(await Organization.getByID(organization.id)).toBeUndefined();
+    });
+
+    const payerRecords = [
+        {
+            name: 'a balance item it owes',
+            create: async (organization: Organization) => {
+                await new BalanceItemFactory({
+                    organizationId: membershipOrganization.id,
+                    payingOrganizationId: organization.id,
+                    amount: 1,
+                    unitPrice: 10_00,
+                }).create();
+            },
+        },
+        {
+            name: 'a payment it made',
+            create: async (organization: Organization) => {
+                await createPayment({ payingOrganizationId: organization.id });
+            },
+        },
+        {
+            name: 'an application fee it was charged',
+            create: async (organization: Organization) => {
+                await createApplicationFee({ payingOrganizationId: organization.id });
+            },
+        },
+        {
+            name: 'an invoice it has to pay',
+            create: async (organization: Organization) => {
+                await createInvoice({ payingOrganizationId: organization.id });
+            },
+        },
+    ];
+
+    test.each(payerRecords)('An organization with $name cannot be deleted', async ({ create }) => {
+        const organization = await new OrganizationFactory({}).create();
+        await create(organization);
+
+        await expect(deleteOrganization(organization)).rejects.toThrow(STExpect.errorWithCode('organization_has_financial_records'));
+        expect(await Organization.getByID(organization.id)).toBeDefined();
+    });
+
+    test('Financial records the organization received do not block the delete', async () => {
+        const organization = await new OrganizationFactory({}).create();
+
+        await new BalanceItemFactory({
+            organizationId: organization.id,
+            amount: 1,
+            unitPrice: 10_00,
+        }).create();
+
+        const payment = new Payment();
+        payment.organizationId = organization.id;
+        payment.method = PaymentMethod.Transfer;
+        payment.status = PaymentStatus.Succeeded;
+        payment.price = 10_00;
+        await payment.save();
+
+        const invoice = new Invoice();
+        invoice.organizationId = organization.id;
+        await invoice.save();
+
+        const response = await deleteOrganization(organization);
+
+        expect(response.status).toBe(200);
+        expect(await Organization.getByID(organization.id)).toBeUndefined();
+    });
+});

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

@@ -3,7 +3,8 @@ import { PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encodin
 import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Organization, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from '@stamhoofd/models';
+import { BalanceItem, Invoice, Organization, OrganizationRegistrationPeriod, Payment, Platform, RegistrationPeriod } from '@stamhoofd/models';
+import { ApplicationFee } from '@stamhoofd/models/models/ApplicationFee.js';
 import { Organization as OrganizationStruct } from '@stamhoofd/structures';
 
 import { Formatter } from '@stamhoofd/utility';
@@ -61,6 +62,22 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
                 });
             }
 
+            // Financial records may not disappear together with the organization that had to pay them
+            const payerRecordCounts = await Promise.all([
+                BalanceItem.select().where('payingOrganizationId', id).count(),
+                Payment.select().where('payingOrganizationId', id).count(),
+                ApplicationFee.select().where('payingOrganizationId', id).count(),
+                Invoice.select().where('payingOrganizationId', id).count(),
+            ]);
+
+            if (payerRecordCounts.some(count => count > 0)) {
+                throw new SimpleError({
+                    code: 'organization_has_financial_records',
+                    message: 'Organization is still referenced as paying organization',
+                    human: $t('Er zijn nog openstaande bedragen, betalingen, transactiekosten of facturen waarvoor {organization} moet betalen of betaald heeft. Die gegevens mogen niet verloren gaan.', { organization: organization.name }),
+                });
+            }
+
             await organization.delete();
         }
 

package/src/endpoints/global/registration-invitations/PatchRegistrationInvitationsEndpoint.test.ts

@@ -2,17 +2,18 @@ import type { PatchableArrayAutoEncoder } from '@simonbackx/simple-encoding';
 import { PatchableArray } from '@simonbackx/simple-encoding';
 import { Request } from '@simonbackx/simple-endpoints';
 import type { Organization, User } from '@stamhoofd/models';
-import { GroupFactory, MemberFactory, OrganizationFactory, RegistrationFactory, RegistrationInvitationFactory, Token, UserFactory } from '@stamhoofd/models';
+import { GroupFactory, MemberFactory, OrganizationFactory, RegistrationFactory, RegistrationInvitation, RegistrationInvitationFactory, Token, UserFactory } from '@stamhoofd/models';
 import type { RegistrationInvitation as RegistrationInvitationStruct } from '@stamhoofd/structures';
-import { PermissionLevel, Permissions, PermissionsResourceType, RegistrationInvitationRequest, ResourcePermissions, TranslatedString } from '@stamhoofd/structures';
+import { GroupType, PermissionLevel, Permissions, PermissionsResourceType, RegistrationInvitationRequest, ResourcePermissions, TranslatedString } from '@stamhoofd/structures';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer.js';
 import { PatchRegistrationInvitationsEndpoint } from './PatchRegistrationInvitationsEndpoint.js';
 
 describe('Endpoint.PatchRegistrationInvitationsEndpoint', () => {
     const endpoint = new PatchRegistrationInvitationsEndpoint();
 
-    const patchInvitations = async ({ patch, organization, user }: { patch: PatchableArrayAutoEncoder<RegistrationInvitationRequest>; organization: Organization; user: User | null }) => {
-        const request = Request.buildJson('PATCH', '/registration-invitations', organization.getApiHost(), patch);
+    const patchInvitations = async ({ patch, organization, user }: { patch: PatchableArrayAutoEncoder<RegistrationInvitationRequest>; organization: Organization | null; user: User | null }) => {
+        const request = Request.buildJson('PATCH', '/registration-invitations', organization?.getApiHost(), patch);
         if (user) {
             const token = await Token.createToken(user);
             request.headers.authorization = 'Bearer ' + token.accessToken;
@@ -401,4 +402,153 @@ describe('Endpoint.PatchRegistrationInvitationsEndpoint', () => {
             })).rejects.toThrow('Je hebt geen toegangsrechten om deze uitnodiging te verwijderen.');
         });
     });
+
+    describe('Without organization scope (platform admins)', () => {
+        beforeEach(() => {
+            TestUtils.setEnvironment('userMode', 'platform');
+        });
+
+        test('A platform admin can invite for an event group', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const group = await new GroupFactory({ organization, type: GroupType.EventRegistration, name: new TranslatedString('test event') }).create();
+
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({
+                    level: PermissionLevel.Full,
+                }),
+            }).create();
+
+            const member = await new MemberFactory({
+                organization,
+                firstName: 'John',
+                lastName: 'Doe',
+                birthDay: { year: 1994, month: 6, day: 24 },
+            }).create();
+
+            const patch: PatchableArrayAutoEncoder<RegistrationInvitationRequest> = new PatchableArray();
+
+            patch.addPut(RegistrationInvitationRequest.create({
+                groupId: group.id,
+                memberId: member.id,
+            }));
+
+            const response = await patchInvitations({
+                patch,
+                organization: null,
+                user: admin,
+            });
+
+            expect(response.body).toHaveLength(1);
+            expect(response.body[0].group.id).toBe(group.id);
+            expect(response.body[0].member.id).toBe(member.id);
+
+            // The invitation belongs to the organization of the group
+            const invitation = await RegistrationInvitation.getByID(response.body[0].id);
+            expect(invitation?.organizationId).toBe(organization.id);
+        });
+
+        test('Should fail for a user without platform access', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const group = await new GroupFactory({ organization, type: GroupType.EventRegistration, name: new TranslatedString('test event') }).create();
+
+            const user = await new UserFactory({
+                organization,
+                permissions: Permissions.create({
+                    level: PermissionLevel.Full,
+                }),
+            }).create();
+
+            const member = await new MemberFactory({
+                organization,
+                firstName: 'John',
+                lastName: 'Doe',
+                birthDay: { year: 1994, month: 6, day: 24 },
+            }).create();
+
+            const patch: PatchableArrayAutoEncoder<RegistrationInvitationRequest> = new PatchableArray();
+
+            patch.addPut(RegistrationInvitationRequest.create({
+                groupId: group.id,
+                memberId: member.id,
+            }));
+
+            await expect(patchInvitations({
+                patch,
+                organization: null,
+                user,
+            })).rejects.toThrow(STExpect.simpleError({ code: 'permission_denied' }));
+        });
+
+        test('Should fail for a platform admin without access to the group', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const group = await new GroupFactory({ organization, type: GroupType.EventRegistration, name: new TranslatedString('test event') }).create();
+
+            // Some platform access (passes the fast throw), but no rights on this group or its organization
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({
+                    level: PermissionLevel.None,
+                    resources: new Map([
+                        [PermissionsResourceType.OrganizationTags, new Map([
+                            ['unrelated-tag-id', ResourcePermissions.create({
+                                level: PermissionLevel.Read,
+                            })],
+                        ])],
+                    ]),
+                }),
+            }).create();
+
+            const member = await new MemberFactory({
+                organization,
+                firstName: 'John',
+                lastName: 'Doe',
+                birthDay: { year: 1994, month: 6, day: 24 },
+            }).create();
+
+            const patch: PatchableArrayAutoEncoder<RegistrationInvitationRequest> = new PatchableArray();
+
+            patch.addPut(RegistrationInvitationRequest.create({
+                groupId: group.id,
+                memberId: member.id,
+            }));
+
+            await expect(patchInvitations({
+                patch,
+                organization: null,
+                user: admin,
+            })).rejects.toThrow(STExpect.simpleError({ code: 'permission_denied' }));
+        });
+
+        test('A platform admin can delete an invitation', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const group = await new GroupFactory({ organization, type: GroupType.EventRegistration, name: new TranslatedString('test event') }).create();
+
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({
+                    level: PermissionLevel.Full,
+                }),
+            }).create();
+
+            const member = await new MemberFactory({
+                organization,
+                firstName: 'John',
+                lastName: 'Doe',
+                birthDay: { year: 1994, month: 6, day: 24 },
+            }).create();
+
+            const invitation = await new RegistrationInvitationFactory({ member, group, organization }).create();
+
+            const patch: PatchableArrayAutoEncoder<RegistrationInvitationRequest> = new PatchableArray();
+
+            patch.addDelete(invitation.id);
+
+            const response = await patchInvitations({
+                patch,
+                organization: null,
+                user: admin,
+            });
+
+            expect(response.body).toHaveLength(0);
+            expect(await RegistrationInvitation.getByID(invitation.id)).toBeUndefined();
+        });
+    });
 });

package/src/endpoints/global/registration-invitations/PatchRegistrationInvitationsEndpoint.ts

@@ -35,11 +35,15 @@ export class PatchRegistrationInvitationsEndpoint extends Endpoint<Params, Query
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
+        const organization = await Context.setOptionalOrganizationScope();
         await Context.authenticate();
 
         // Fast throw first (more in depth checking for patches later)
-        if (!await Context.auth.hasSomeAccess(organization.id)) {
+        if (organization) {
+            if (!await Context.auth.hasSomeAccess(organization.id)) {
+                throw Context.auth.error();
+            }
+        } else if (!Context.auth.hasSomePlatformAccess()) {
             throw Context.auth.error();
         }
 
@@ -48,11 +52,11 @@ export class PatchRegistrationInvitationsEndpoint extends Endpoint<Params, Query
 
         const puts = request.body.getPuts();
         for (const { put } of puts) {
-            await this.checkCanCreateRegistrationInvitation(put, organization.id);
+            const group = await this.checkCanCreateRegistrationInvitation(put, organization?.id ?? null);
 
             const invitation = new RegistrationInvitation();
             invitation.id = put.id;
-            invitation.organizationId = organization.id;
+            invitation.organizationId = group.organizationId;
             invitation.groupId = put.groupId;
             invitation.memberId = put.memberId;
 
@@ -125,12 +129,13 @@ export class PatchRegistrationInvitationsEndpoint extends Endpoint<Params, Query
     /**
      * Will throw if not allowed to invite.
      * @param invitation
-     * @param organizationId id of organization to invite for, should match the organizationId in the invitation
+     * @param organizationId organization scope of the request; when set, the group must belong to it (platform admins can invite without a scope)
+     * @returns the group to invite for
      */
-    private async checkCanCreateRegistrationInvitation(invitation: RegistrationInvitationRequest, organizationId: string) {
+    private async checkCanCreateRegistrationInvitation(invitation: RegistrationInvitationRequest, organizationId: string | null): Promise<Group> {
         const group = await Group.getByID(invitation.groupId);
 
-        if (!group || group.organizationId !== organizationId || !await Context.auth.canAccessGroup(group, PermissionLevel.Write)) {
+        if (!group || (organizationId !== null && group.organizationId !== organizationId) || !await Context.auth.canAccessGroup(group, PermissionLevel.Write)) {
             throw Context.auth.error($t(`%1ST`));
         }
 
@@ -147,7 +152,7 @@ export class PatchRegistrationInvitationsEndpoint extends Endpoint<Params, Query
 
         if (!member
             // in userMode 'organization' we can only invite members from the same organization
-            || (STAMHOOFD.userMode === 'organization' && member.organizationId !== organizationId)
+            || (STAMHOOFD.userMode === 'organization' && member.organizationId !== group.organizationId)
             // read access is suficient
             || !await Context.auth.canAccessMember(member, PermissionLevel.Read)
         ) {
@@ -163,5 +168,7 @@ export class PatchRegistrationInvitationsEndpoint extends Endpoint<Params, Query
                 human: $t('%1S2'),
             });
         }
+
+        return group;
     }
 }

package/src/endpoints/organization/dashboard/balance-items/GetBalanceItemBreakdownEndpoint.test.ts

@@ -2,7 +2,7 @@ import { Request } from '@simonbackx/simple-endpoints';
 import type { BalanceItem, Organization, User } from '@stamhoofd/models';
 import { BalanceItemFactory, BalanceItemPayment, OrderFactory, OrganizationFactory, Payment, Token, UserFactory, WebshopFactory } from '@stamhoofd/models';
 import type { StamhoofdFilter } from '@stamhoofd/structures';
-import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, Cart, CartItem, CartItemOption, CartItemPrice, Customer, Option, OptionMenu, OrderData, PaymentMethod, PaymentProvider, PaymentStatus, PermissionLevel, Permissions, Product, ProductPrice, Settlement, TranslatedString } from '@stamhoofd/structures';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, Cart, CartItem, CartItemOption, CartItemPrice, Customer, Option, OptionMenu, OrderData, PaymentMethod, PaymentProvider, PaymentStatus, PermissionLevel, Permissions, Product, ProductPrice, SettlementReference, TranslatedString } from '@stamhoofd/structures';
 import { BreakdownRequest } from '@stamhoofd/structures/breakdown/BreakdownRequest.js';
 import type { BalanceItemBreakdown } from '@stamhoofd/structures/PaymentBreakdown.js';
 import { BreakdownAmountType, BreakdownObjectType, BreakdownPathItem, BreakdownTab } from '@stamhoofd/structures/PaymentBreakdown.js';
@@ -254,13 +254,13 @@ describe('Endpoint.GetBalanceItemBreakdownEndpoint', () => {
     });
 
     describe('Grouping by payout', () => {
-        const march = Settlement.create({ id: 'stl_march', reference: '1234567.0312.01', settledAt: new Date(2026, 2, 12), amount: 0 });
-        const april = Settlement.create({ id: 'stl_april', reference: '1234567.0409.01', settledAt: new Date(2026, 3, 9), amount: 0 });
+        const march = SettlementReference.create({ id: 'stl_march', reference: '1234567.0312.01', settledAt: new Date(2026, 2, 12), amount: 0 });
+        const april = SettlementReference.create({ id: 'stl_april', reference: '1234567.0409.01', settledAt: new Date(2026, 3, 9), amount: 0 });
 
         /**
          * Pays a part of a balance item, the way a payment provider settles it afterwards.
          */
-        const payItem = async (organization: Organization, balanceItem: BalanceItem, options: { price: number; settlement?: Settlement; status?: PaymentStatus; method?: PaymentMethod }) => {
+        const payItem = async (organization: Organization, balanceItem: BalanceItem, options: { price: number; settlement?: SettlementReference; status?: PaymentStatus; method?: PaymentMethod }) => {
             const payment = new Payment();
             payment.organizationId = organization.id;
             payment.method = options.method ?? PaymentMethod.Bancontact;