@stamhoofd/backend 2.134.0 → 2.136.0

package/src/helpers/MembershipCharger.ts

@@ -2,16 +2,15 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { BalanceItem, Member, MemberPlatformMembership, Platform, RegistrationPeriod } from '@stamhoofd/models';
 import { SQL, SQLOrderBy, SQLWhereSign } from '@stamhoofd/sql';
 import { BalanceItemRelation, BalanceItemRelationType, BalanceItemType, TranslatedString } from '@stamhoofd/structures';
-import { Formatter } from '@stamhoofd/utility';
+import { Formatter, sleep } from '@stamhoofd/utility';
 
 export const MembershipCharger = {
     async charge() {
         console.log('Charging memberships...');
 
-        // Loop all
-        let lastId = '';
         const platform = await Platform.getShared();
         const chargeVia = platform.membershipOrganizationId;
+        const nextPeriodId = platform.nextPeriodId;
 
         if (!chargeVia) {
             throw new SimpleError({
@@ -46,27 +45,17 @@ export const MembershipCharger = {
 
         let createdCount = 0;
         let createdPrice = 0;
-        const chunkSize = 100;
-
-        while (true) {
-            const memberships = await MemberPlatformMembership.select()
-                .where('id', SQLWhereSign.Greater, lastId)
-                .where('deletedAt', null)
-                .where('locked', false)
-                .where(SQL.where('trialUntil', null).or('trialUntil', SQLWhereSign.LessEqual, new Date()))
-                .limit(chunkSize)
-                .orderBy(
-                    new SQLOrderBy({
-                        column: SQL.column('id'),
-                        direction: 'ASC',
-                    }),
-                )
-                .fetch();
+        let q = MemberPlatformMembership.select()
+            .where('deletedAt', null)
+            .where('locked', false)
+            .where(SQL.where('trialUntil', null).or('trialUntil', SQLWhereSign.LessEqual, new Date()));
 
-            if (memberships.length === 0) {
-                break;
-            }
+        if (nextPeriodId) {
+            q = q.where('periodId', '!=', nextPeriodId);
+        }
 
+        // allBatched() paginates by id ASC internally, so we must not set a custom order by here.
+        for await (const memberships of q.limit(100).allBatched()) {
             const memberIds = Formatter.uniqueArray(memberships.map(m => m.memberId));
             const members = await Member.getByIDs(...memberIds);
             const createdBalanceItems: BalanceItem[] = [];
@@ -153,17 +142,6 @@ export const MembershipCharger = {
                 createdCount += 1;
                 createdPrice += membership.price;
             }
-
-            if (memberships.length < chunkSize) {
-                break;
-            }
-
-            const z = lastId;
-            lastId = memberships[memberships.length - 1].id;
-
-            if (lastId === z) {
-                throw new Error('Unexpected infinite loop found in MembershipCharger');
-            }
         }
 
         console.log('Charged ' + Formatter.integer(createdCount) + '  memberships, for a total value of ' + Formatter.price(createdPrice));
@@ -178,6 +156,7 @@ export const MembershipCharger = {
         const chunkSize = 100;
 
         while (true) {
+            await sleep(200);
             const q = MemberPlatformMembership.select()
                 .where('id', SQLWhereSign.Greater, lastId)
                 .where('balanceItemId', null)

package/src/helpers/UitpasTokenRepository.ts

@@ -39,26 +39,27 @@ export class UitpasTokenRepository {
         return await QueueHandler.schedule('uitpas/token-' + (organizationId ?? 'platform'), handler);
     }
 
-    static async storeIfValid(organizationId: string | null, clientId: string, clientSecret: string): Promise<boolean> {
+    static async storeIfValid(organizationId: string | null, clientId: string, clientSecret: string): Promise<void> {
         if (!clientId || !clientSecret) { // empty strings
-            return false; // not valid
+            throw new SimpleError({
+                statusCode: 400,
+                code: 'invalid_uitpas_client_credentials',
+                message: `Empty UiTPAS client credentials`,
+                human: $t(`%ZdU`),
+            });
         }
+
         let model = new UitpasClientCredential();
         model.organizationId = organizationId;
         model.clientId = clientId;
         model.clientSecret = clientSecret;
-        return await UitpasTokenRepository.handleInQueue(organizationId, async () => {
-            let repo = new UitpasTokenRepository(model);
-            try {
-                await repo.getNewAccessToken();
-            } catch (e) {
-                return false; // not valid
-            }
+        await UitpasTokenRepository.handleInQueue(organizationId, async () => {
+            const repo = new UitpasTokenRepository(model);
+            await repo.getNewAccessToken();
             // valid -> store
             model = await UitpasTokenRepository.setModelInDb(organizationId, model);
             repo.uitpasClientCredential = model; // update the uitpasClientCredential in the repo
-            repo = UitpasTokenRepository.setRepoInMemory(organizationId, repo);
-            return true;
+            UitpasTokenRepository.setRepoInMemory(organizationId, repo);
         });
     }
 

package/src/helpers/XlsxTransformerColumnHelper.test.ts

@@ -1,6 +1,7 @@
 import type { XlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
 import type { PlatformMember } from '@stamhoofd/structures';
 import {
+    EmergencyContact,
     Group,
     GroupCategory,
     GroupCategorySettings,
@@ -166,4 +167,66 @@ describe('XlsxTransformerColumnHelper', () => {
             expect(getColumn(ageGroupsCategory.id).getValue(member).value).toBe('Kapoenen, Welpen');
         });
     });
+
+    describe('createColumnsForEmergencyContacts', () => {
+        function createMember(emergencyContacts: EmergencyContact[]) {
+            const organization = Organization.create({});
+            const blob = MembersBlob.create({
+                organizations: [organization],
+                members: [
+                    MemberWithRegistrationsBlob.create({
+                        details: MemberDetails.create({ firstName: 'John', lastName: 'Doe', emergencyContacts }),
+                    }),
+                ],
+            });
+
+            const family = PlatformFamily.create(blob, { platform: Platform.create({}), contextOrganization: organization });
+            return family.members[0];
+        }
+
+        function getValue(member: PlatformMember, id: string) {
+            const columns = XlsxTransformerColumnHelper.createColumnsForEmergencyContacts();
+            const column = columns.find(c => 'id' in c && c.id === id) as XlsxTransformerConcreteColumn<PlatformMember> | undefined;
+
+            if (!column) {
+                throw new Error(`Column ${id} not found`);
+            }
+
+            return column.getValue(member).value;
+        }
+
+        it('returns the values of the first two emergency contacts', () => {
+            const member = createMember([
+                EmergencyContact.create({ name: 'An Peeters', title: 'Oma', phone: '0470 12 34 56' }),
+                EmergencyContact.create({ name: 'Jan Janssens', title: 'Buur', phone: '0470 65 43 21' }),
+            ]);
+
+            expect(getValue(member, 'emergencyContact.0.name')).toBe('An Peeters');
+            expect(getValue(member, 'emergencyContact.0.title')).toBe('Oma');
+            expect(getValue(member, 'emergencyContact.0.phone')).toBe('0470 12 34 56');
+
+            expect(getValue(member, 'emergencyContact.1.name')).toBe('Jan Janssens');
+            expect(getValue(member, 'emergencyContact.1.title')).toBe('Buur');
+            expect(getValue(member, 'emergencyContact.1.phone')).toBe('0470 65 43 21');
+        });
+
+        it('returns empty values when the member has fewer emergency contacts', () => {
+            const member = createMember([
+                EmergencyContact.create({ name: 'An Peeters', title: 'Oma', phone: '0470 12 34 56' }),
+            ]);
+
+            expect(getValue(member, 'emergencyContact.1.name')).toBe('');
+            expect(getValue(member, 'emergencyContact.1.title')).toBe('');
+            expect(getValue(member, 'emergencyContact.1.phone')).toBe('');
+        });
+
+        it('returns an empty value for a contact without a phone number', () => {
+            const member = createMember([
+                EmergencyContact.create({ name: 'An Peeters', title: 'Oma', phone: null }),
+            ]);
+
+            expect(getValue(member, 'emergencyContact.0.name')).toBe('An Peeters');
+            expect(getValue(member, 'emergencyContact.0.phone')).toBe('');
+        });
+    });
 });

package/src/helpers/XlsxTransformerColumnHelper.ts

@@ -1,6 +1,6 @@
 import type { XlsxTransformerColumn, XlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
 import { isXlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
-import type { Address, GroupCategory, Parent, PlatformMember, RecordAnswer, RecordSettings } from '@stamhoofd/structures';
+import type { Address, EmergencyContact, GroupCategory, Parent, PlatformMember, RecordAnswer, RecordSettings } from '@stamhoofd/structures';
 import { CountryHelper, ParentTypeHelper, RecordCategory, RecordType } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
@@ -24,6 +24,52 @@ export class XlsxTransformerColumnHelper {
         ];
     }
 
+    /**
+     * Emergency contacts are an unbounded array, so only the first two get their own columns. The combined
+     * 'emergencyContacts' column in the members loader lists all of them.
+     */
+    static createColumnsForEmergencyContacts(): XlsxTransformerColumn<PlatformMember>[] {
+        return [
+            ...this.createColumnsForEmergencyContact(0),
+            ...this.createColumnsForEmergencyContact(1),
+        ];
+    }
+
+    static createColumnsForEmergencyContact(contactIndex: number): XlsxTransformerColumn<PlatformMember>[] {
+        const getContact = (member: PlatformMember): EmergencyContact | null | undefined => member.patchedMember.details.emergencyContacts[contactIndex];
+
+        const identifier = `Noodcontact ${contactIndex + 1}`;
+        const getId = (value: string) => `emergencyContact.${contactIndex}.${value}`;
+        const getName = (value: string) => `${identifier} - ${value}`;
+
+        return [
+            {
+                id: getId('name'),
+                name: getName($t(`%1Os`)),
+                width: 20,
+                getValue: (member: PlatformMember) => ({
+                    value: getContact(member)?.name ?? '',
+                }),
+            },
+            {
+                id: getId('title'),
+                name: getName($t(`%f5`)),
+                width: 20,
+                getValue: (member: PlatformMember) => ({
+                    value: getContact(member)?.title ?? '',
+                }),
+            },
+            {
+                id: getId('phone'),
+                name: getName($t(`%wD`)),
+                width: 20,
+                getValue: (member: PlatformMember) => ({
+                    value: getContact(member)?.phone ?? '',
+                }),
+            },
+        ];
+    }
+
     static createColumnsForAddresses<T>({ limit, getAddresses, matchIdStart }: { limit: number; getAddresses: (object: T) => Address[]; matchIdStart: string }): XlsxTransformerColumn<T>[] {
         const result: XlsxTransformerColumn<unknown>[] = [];
 

package/src/seeds/1783097277-update-member-last-registered.sql

@@ -0,0 +1,6 @@
+UPDATE `members` m
+SET m.lastRegisteredAt = (
+    SELECT MAX(r.registeredAt)
+    FROM registrations r
+    WHERE r.memberId = m.id
+);

package/src/seeds/1783939632-mark-zero-price-payments-succeeded.ts

@@ -0,0 +1,90 @@
+import { Migration } from '@simonbackx/simple-database';
+import { Organization, Payment } from '@stamhoofd/models';
+import { QueryableModel } from '@stamhoofd/sql';
+import { PaymentStatus } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { SeedTools } from '../helpers/SeedTools.js';
+import { PaymentService } from '../services/PaymentService.js';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    console.log('Start marking zero-price payments as succeeded.');
+
+    let succeeded = 0;
+
+    const result = await SeedTools.loopBatched({
+        // Keyset pagination on id: marking a payment as succeeded drops it from this filter,
+        // but rows are never skipped because each next batch is fetched by id > lastId.
+        query: Payment.select()
+            .where('price', 0)
+            .where('status', [PaymentStatus.Created, PaymentStatus.Pending]),
+        batchSize: 100,
+        batchAction: async (payments: Payment[]) => {
+            // Load the organizations of this batch in bulk
+            const organizationIds = Formatter.uniqueArray(
+                payments.map(p => p.organizationId).filter((id): id is string => id !== null),
+            );
+            const organizations = organizationIds.length ? await Organization.getByIDs(...organizationIds) : [];
+
+            // Load the attached balance item payments of this batch in bulk, and collect the ids of
+            // the payments that move money on at least one balance item. Those need the PaymentService
+            // side effects (marking balance items as paid, flushing caches, ...); the rest can be
+            // updated directly.
+            const { balanceItemPayments } = await Payment.loadBalanceItems(payments);
+            const paymentIdsWithNonZeroBalanceItemPayment = new Set(
+                balanceItemPayments.filter(bip => bip.price !== 0).map(bip => bip.paymentId),
+            );
+
+            for (const payment of payments) {
+                // Only route through the PaymentService when the payment moves money on at least one
+                // balance item. When all attached balance item payments are zero (or there are none),
+                // update the status directly to avoid those side effects.
+                const hasNonZeroBalanceItemPayment = paymentIdsWithNonZeroBalanceItemPayment.has(payment.id);
+
+                try {
+                    if (hasNonZeroBalanceItemPayment) {
+                        if (!payment.organizationId) {
+                            console.warn('Payment without organizationId, skipping', payment.id);
+                            continue;
+                        }
+
+                        const organization = organizations.find(o => o.id === payment.organizationId);
+                        if (!organization) {
+                            console.warn('Organization not found for payment, skipping', payment.id, payment.organizationId);
+                            continue;
+                        }
+
+                        // Attribute the payment to its original date instead of the migration run date.
+                        await PaymentService.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Succeeded, payment.createdAt);
+                    } else {
+                        // No side effects needed: update the status directly.
+                        payment.status = PaymentStatus.Succeeded;
+                        payment.paidAt = payment.createdAt;
+                        await payment.save({
+                            skipMarkSaved: true,
+                            skipSendEvents: true,
+                        });
+                    }
+                    succeeded++;
+                } catch (e) {
+                    // Isolate failures per payment: one bad row should not abort (and wedge) the whole migration.
+                    console.error('Failed to mark payment as succeeded, skipping', payment.id, e);
+                }
+
+                if (QueryableModel.shutdownMigrations) {
+                    break;
+                }
+            }
+
+            if (QueryableModel.shutdownMigrations) {
+                throw new Error('Stopping migration gracefully');
+            }
+        },
+    });
+
+    console.log(`Finished marking zero-price payments as succeeded: ${succeeded} of ${result.total} payments.`);
+});

package/src/seeds/1784057557-fix-invisible-trial-registrations.ts

@@ -0,0 +1,143 @@
+import { Migration } from '@simonbackx/simple-database';
+import { BalanceItem, Organization, Registration } from '@stamhoofd/models';
+import { QueryableModel } from '@stamhoofd/sql';
+import { BalanceItemStatus } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { SeedTools } from '../helpers/SeedTools.js';
+import { BalanceItemService } from '../services/BalanceItemService.js';
+
+/**
+ * Registrations with a trial period that were made via the member portal were never activated: their
+ * balance items are only due after the trial, so they were not part of the payment, and nothing ever
+ * marked them valid. The result is a registration that exists in the database, but is invisible in the
+ * registration lists and the member portal, and a balance item that stays Hidden and is never billed.
+ *
+ * markPaid (without a payment) puts them in the exact same state as a registration made after the fix:
+ * it marks the balance item due (Hidden -> Due) and marks the registration valid without shortening the
+ * trial period.
+ */
+export async function fixInvisibleTrialRegistrations() {
+    let fixed = 0;
+    let skipped = 0;
+    let expired = 0;
+
+    const now = new Date();
+
+    const result = await SeedTools.loopBatched({
+        // Keyset pagination on id: activating a registration drops it from this filter, but rows are
+        // never skipped because each next batch is fetched by id > lastId.
+        //
+        // For now, only registrations whose trial is still running are activated. Activating one whose
+        // trial already ended would mark its balance item due right away (its dueAt is in the past), so
+        // the member would immediately owe the full price - as an overdue amount - for a trial they
+        // never got, since the registration was invisible to them the whole time. Most of the affected
+        // registrations are in that state, so this deliberately does not fix all of them yet: what
+        // should happen to them (bill them anyway, give them a new payment deadline, or don't charge
+        // them at all) is still to be decided. Leaving them untouched keeps that decision open, no data
+        // is lost and a later seed can still pick them up.
+        query: Registration.select()
+            .whereNot('trialUntil', null)
+            .where('registeredAt', null)
+            .where('deactivatedAt', null),
+        batchSize: 100,
+        batchAction: async (registrations: Registration[]) => {
+            const organizationIds = Formatter.uniqueArray(registrations.map(r => r.organizationId));
+            const organizations = organizationIds.length ? await Organization.getByIDs(...organizationIds) : [];
+
+            for (const registration of registrations) {
+                try {
+                    const organization = organizations.find(o => o.id === registration.organizationId);
+                    if (!organization) {
+                        console.warn('Organization not found for registration, skipping', registration.id, registration.organizationId);
+                        skipped++;
+                        continue;
+                    }
+
+                    // The trial already ended. Activating it now would mark the balance item due right
+                    // away (its dueAt is in the past), so the member would immediately owe the full
+                    // price for a trial they never got. Leave it alone.
+                    if (registration.trialUntil === null || registration.trialUntil <= now) {
+                        expired++;
+                        continue;
+                    }
+
+                    // The registration was invisible, so the member may have been registered for the same
+                    // group again in the meantime. Activating this one would create a duplicate.
+                    const activeDuplicates = await Registration.select()
+                        .where('memberId', registration.memberId)
+                        .where('groupId', registration.groupId)
+                        .where('periodId', registration.periodId)
+                        .whereNot('registeredAt', null)
+                        .where('deactivatedAt', null)
+                        .count();
+
+                    if (activeDuplicates > 0) {
+                        console.log('Member is already registered for this group again, skipping', registration.id);
+                        skipped++;
+                        continue;
+                    }
+
+                    // Do not send a registration confirmation email for a registration that was made a
+                    // long time ago. The flag is only read when the registration is marked valid.
+                    if (registration.sendConfirmationEmail) {
+                        registration.sendConfirmationEmail = false;
+                        await registration.save();
+                    }
+
+                    // All the balance items of a trial registration are deferred (Hidden + dueAt), so they
+                    // all need to be marked due. The base and option items also mark the registration valid.
+                    const balanceItems = await BalanceItem.select()
+                        .where('registrationId', registration.id)
+                        .where('status', BalanceItemStatus.Hidden)
+                        .fetch();
+
+                    for (const balanceItem of balanceItems) {
+                        await BalanceItemService.markPaid(balanceItem, null, organization);
+                    }
+
+                    // A trial registration always has at least one balance item, but don't leave the
+                    // registration invisible if it somehow doesn't.
+                    await registration.refresh();
+                    if (registration.registeredAt === null) {
+                        console.warn('Registration has no hidden balance items to activate it, skipping', registration.id);
+                        skipped++;
+                        continue;
+                    }
+
+                    // markValid stamps registeredAt with the current date. Attribute the registration to
+                    // the date it was really made instead of the date this migration runs.
+                    registration.registeredAt = registration.createdAt;
+                    await registration.save();
+
+                    fixed++;
+                } catch (e) {
+                    // Isolate failures per registration: one bad row should not abort (and wedge) the whole migration.
+                    console.error('Failed to fix trial registration, skipping', registration.id, e);
+                    skipped++;
+                }
+
+                if (QueryableModel.shutdownMigrations) {
+                    break;
+                }
+            }
+
+            if (QueryableModel.shutdownMigrations) {
+                throw new Error('Stopping migration gracefully');
+            }
+        },
+    });
+
+    console.log(`Finished fixing invisible trial registrations: ${fixed} fixed, ${expired} left alone because their trial already ended, ${skipped} skipped of ${result.total} registrations.`);
+
+    return { fixed, skipped, expired };
+}
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    console.log('Start fixing invisible trial registrations.');
+    await fixInvisibleTrialRegistrations();
+});

package/src/services/BalanceItemService.ts

@@ -189,7 +189,7 @@ export class BalanceItemService {
         userUpdateQueue.addItem(organizationId, userId);
     }
 
-    static cheduleMemberUpdate(organizationId: string, memberId: string) {
+    static scheduleMemberUpdate(organizationId: string, memberId: string) {
         memberUpdateQueue.addItem(organizationId, memberId);
     }
 

package/src/services/PaymentService.ts

@@ -1208,16 +1208,38 @@ export class PaymentService {
         privatePaymentConfiguration: PrivatePaymentConfiguration;
         adminUserId?: string | null;
     }) {
-        if (balanceItems.size === 0) {
+        // Balance items that aren't due yet and that aren't being paid now (amount 0) are not part of
+        // this payment: a registration in its trial period is the main example, nothing is due during
+        // the trial. They still have to be marked due and valid, so the registration is activated and
+        // the amount is billed once the trial ends. Marking them via markPaid means the 'paid' side
+        // effects run exactly once (guarded by the paidAt column), also when they are really paid later.
+        //
+        // Items that the caller does pay (a non-zero amount) are always part of the payment, even when
+        // they have a dueAt: balance items that are due soon are part of the outstanding balance and
+        // can be paid before their due date (and are charged by direct debit).
+        const notDueYetBalanceItems = [...balanceItems.keys()].filter(item => item.dueAt !== null && item.dueAt > new Date() && (balanceItems.get(item) ?? 0) === 0);
+        const payableBalanceItems = new Map([...balanceItems].filter(([item]) => !notDueYetBalanceItems.includes(item)));
+
+        // Passing no payment keeps paid: false, so a trial period isn't shortened.
+        const markNotDueYetValid = async () => {
+            for (const balanceItem of notDueYetBalanceItems) {
+                await BalanceItemService.markPaid(balanceItem, null, organization);
+            }
+        };
+
+        if (payableBalanceItems.size === 0) {
+            // Nothing to pay now, so no payment is created. The not-due-yet items still need to be
+            // marked valid, otherwise their registration stays invisible.
+            await markNotDueYetValid();
             return null;
         }
 
         // Calculate total price to pay
-        const { price, roundingAmount, hasNegative, names } = this.calculateTotalPrice({ balanceItems, organization, members });
+        const { price, roundingAmount, hasNegative, names } = this.calculateTotalPrice({ balanceItems: payableBalanceItems, organization, members });
         PaymentService.validateTotalPrice({ price, roundingAmount, checkout });
 
         const { customer, prefix } = await this.validateCustomer({ user, checkout, payingOrganization });
-        this.validateVATRates({ customer, sellingOrganization: organization, balanceItems });
+        this.validateVATRates({ customer, sellingOrganization: organization, balanceItems: payableBalanceItems });
 
         const { method, type, mandate } = await this.validatePaymentMethod({
             method: checkout.paymentMethod ?? PaymentMethod.Unknown,
@@ -1226,7 +1248,7 @@ export class PaymentService {
             customer,
             price,
             hasNegative,
-            balanceItems,
+            balanceItems: payableBalanceItems,
             paymentConfiguration,
             user,
             payingOrganization: payingOrganization ?? null,
@@ -1283,7 +1305,7 @@ export class PaymentService {
 
         payment.provider = provider;
         payment.stripeAccountId = stripeAccount?.id ?? null;
-        await ServiceFeeHelper.setServiceFee(payment, organization, serviceFeeType, [...balanceItems.entries()].map(([_, p]) => p));
+        await ServiceFeeHelper.setServiceFee(payment, organization, serviceFeeType, [...payableBalanceItems.entries()].map(([_, p]) => p));
         await ServiceFeeHelper.setTransferFee({ payment, organization, stripeAccount });
 
         // Add transfer description
@@ -1320,7 +1342,7 @@ export class PaymentService {
         const description = organization.name + ' ' + payment.id;
 
         try {
-            for (const [balanceItem, price] of balanceItems) {
+            for (const [balanceItem, price] of payableBalanceItems) {
                 // Create one balance item payment to pay it in one payment
                 const balanceItemPayment = new BalanceItemPayment();
                 balanceItemPayment.balanceItemId = balanceItem.id;
@@ -1332,7 +1354,7 @@ export class PaymentService {
             }
 
             // Update cached balance items pending amount (only created balance items, because those are involved in the payment)
-            await BalanceItemService.updatePaidAndPending([...balanceItems.keys()]);
+            await BalanceItemService.updatePaidAndPending([...payableBalanceItems.keys()]);
 
             // Update balance items
             if (payment.method === PaymentMethod.Transfer) {
@@ -1445,6 +1467,9 @@ export class PaymentService {
             throw e;
         }
 
+        // The items that aren't due yet are not paid by this payment, so they are marked valid separately
+        await markNotDueYetValid();
+
         // TypeScript thinks status cannot change to Failed, but it can.
         if (payment.status === PaymentStatus.Succeeded || (payment.status as PaymentStatus) === PaymentStatus.Failed) {
             // force update
@@ -1454,7 +1479,7 @@ export class PaymentService {
         } else if (payment.method === PaymentMethod.Transfer || payment.method === PaymentMethod.PointOfSale || payment.method === PaymentMethod.Unknown || (payment.method === PaymentMethod.DirectDebit && mandate)) {
             // Mark valid (not same as paid) if needed
             let hasBundleDiscount = false;
-            for (const [balanceItem] of balanceItems) {
+            for (const [balanceItem] of payableBalanceItems) {
                 // Mark valid
                 await BalanceItemService.markPaid(balanceItem, payment, organization);
 

package/src/services/PlatformMembershipService.ts

@@ -4,7 +4,7 @@ import { Group, Member, MemberPlatformMembership, Organization, Platform, Regist
 import { QueueHandler } from '@stamhoofd/queues';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
 import { AuditLogSource, PlatformMembershipTypeBehaviour } from '@stamhoofd/structures';
-import { Formatter, Sorter } from '@stamhoofd/utility';
+import { Formatter, sleep, Sorter } from '@stamhoofd/utility';
 import { AuditLogService } from './AuditLogService.js';
 import { MemberNumberService } from './MemberNumberService.js';
 
@@ -50,6 +50,7 @@ export class PlatformMembershipService {
             console.log('Starting updateAllMemberships');
             await logger.setContext({ tags: ['silent-seed', 'seed'] }, async () => {
                 while (true) {
+                    await sleep(200);
                     const rawMembers = await Member.where({
                         id: {
                             value: id,

package/src/services/RegistrationService.ts

@@ -70,6 +70,11 @@ export const RegistrationService = {
             const registrationMemberRelation = new ManyToOneRelation(Member, 'member');
             registrationMemberRelation.foreignKey = Member.registrations.foreignKey;
             await Document.updateForRegistration(registration.setRelation(registrationMemberRelation, member));
+
+            // update lastRegisteredAt (should not be awaited)
+            member.tryUpdateLastRegisteredAt(registration)
+                // errors should never stop other logic, lastRegisteredAt is only used for sorting
+                .catch(console.error);
         }
 
         // Update group occupancy

package/src/services/uitpas/UitpasService.ts

@@ -368,14 +368,13 @@ export class UitpasService {
     }
 
     /**
-     * Store the uitpas client credentials if they are valid
+     * Store the uitpas client credentials if they are valid, throws otherwise
      * @param organizationId null for platform
      * @param clientId
      * @param clientSecret
-     * @returns wether the credentials were valid and thus stored successfully
      */
-    static async storeIfValid(organizationId: string | null, clientId: string, clientSecret: string): Promise<boolean> {
-        return await UitpasTokenRepository.storeIfValid(organizationId, clientId, clientSecret);
+    static async storeIfValid(organizationId: string | null, clientId: string, clientSecret: string): Promise<void> {
+        await UitpasTokenRepository.storeIfValid(organizationId, clientId, clientSecret);
     }
 
     static async clearClientCredentialsFor(organizationId: string | null) {