@stamhoofd/backend 2.137.4 → 2.138.0

package/src/services/PasswordForgotService.ts

@@ -0,0 +1,38 @@
+import type { I18n } from '@stamhoofd/backend-i18n';
+import type { Organization } from '@stamhoofd/models';
+import { PasswordToken, Platform, User } from '@stamhoofd/models';
+import { getAppHost } from '@stamhoofd/structures';
+
+/**
+ * Builds the password recovery links. Which app the link points to depends on whether the user is an
+ * administrator of the organization.
+ */
+export class PasswordForgotService {
+    /**
+     * Create a new password token for the user and build the recovery url for it.
+     */
+    static async getPasswordRecoveryUrl(user: User, organization: Organization | null, i18n: I18n, validUntil?: Date) {
+        // Send an e-mail to say you already have an account + follow password forgot flow
+        const token = await PasswordToken.createToken(user, validUntil);
+        return await this.getPasswordRecoveryUrlForToken(token, organization, i18n, user);
+    }
+
+    /**
+     * Build the recovery url for an already created password token.
+     * Pass the user to avoid an extra query when it is already loaded.
+     */
+    static async getPasswordRecoveryUrlForToken(token: PasswordToken, organization: Organization | null, i18n: I18n, user?: User) {
+        const tokenUser = user ?? await User.getByID(token.userId);
+        if (!tokenUser) {
+            throw new Error('PasswordToken without a valid user');
+        }
+
+        if (tokenUser.organizationId !== null && ((tokenUser.organizationId ?? null) !== (organization?.id ?? null))) {
+            throw new Error('Unexpected mismatch in organization id for PasswordToken');
+        }
+
+        const hasOrganizationPermissions = organization ? tokenUser.permissions?.forOrganization(organization, await Platform.getSharedStruct())?.isEmpty === false : false;
+        const host = 'https://' + getAppHost(hasOrganizationPermissions ? 'dashboard' : 'registration', organization, hasOrganizationPermissions, i18n);
+        return host + '/reset-password?token=' + encodeURIComponent(token.token);
+    }
+}

package/src/services/PaymentService.ts

@@ -1,6 +1,7 @@
 import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
 import type { Member, User } from '@stamhoofd/models';
-import { BalanceItem, BalanceItemPayment, Group, MolliePayment, Organization, PayconiqPayment, Payment, Platform, sendEmailTemplate, UsedRegisterCode } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, Group, MolliePayment, Organization, PayconiqPayment, Payment, Platform, UsedRegisterCode } from '@stamhoofd/models';
+import { sendEmailTemplate } from '../helpers/EmailBuilder.js';
 import { QueueHandler } from '@stamhoofd/queues';
 import type { Checkoutable, PaymentConfiguration, PrivatePaymentConfiguration } from '@stamhoofd/structures';
 import { AuditLogSource, BalanceItemPaymentDetailed, BalanceItemType, EmailTemplateType, Invoice, PaymentCustomer, PaymentGeneral, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, PaymentType, Recipient, Replacement, VATExcemptReason, Version } from '@stamhoofd/structures';
@@ -22,6 +23,7 @@ import { PaymentMandateService } from './PaymentMandateService.js';
 import { ReferralService } from './ReferralService.js';
 import { VATService } from './VATService.js';
 import { STPackageService } from './STPackageService.js';
+import { OrganizationAdminService } from './OrganizationAdminService.js';
 
 export class PaymentService {
     static async updateReversedPaymentsFor(payment: Payment) {
@@ -237,7 +239,7 @@ export class PaymentService {
         const payingOrganization = await Organization.getByID(payment.payingOrganizationId, true);
 
         await sendEmailTemplate(organization, {
-            recipients: await payingOrganization.getFinanceAdminRecipients(),
+            recipients: await OrganizationAdminService.getFinanceAdminRecipients(payingOrganization),
             defaultReplacements: [
                 Replacement.create({
                     token: 'payingOrganizationName',
@@ -274,7 +276,7 @@ export class PaymentService {
         const payingOrganization = await Organization.getByID(payment.payingOrganizationId, true);
 
         await sendEmailTemplate(organization, {
-            recipients: await payingOrganization.getFinanceAdminRecipients(),
+            recipients: await OrganizationAdminService.getFinanceAdminRecipients(payingOrganization),
             defaultReplacements: [
                 Replacement.create({
                     token: 'payingOrganizationName',

package/src/services/PlatformMembershipService.test.ts

@@ -0,0 +1,180 @@
+import { MemberFactory, MemberPlatformMembership, OrganizationFactory, Platform, RegistrationFactory, RegistrationPeriodFactory } from '@stamhoofd/models';
+import { PlatformMembershipType, PlatformMembershipTypeBehaviour, PlatformMembershipTypeConfig, PlatformMembershipTypeConfigPrice, ReduceablePrice } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Formatter } from '@stamhoofd/utility';
+import { PlatformMembershipService } from './PlatformMembershipService.js';
+
+describe('PlatformMembershipService.calculatePrice', () => {
+    const membershipPrice = 25_00;
+
+    beforeEach(() => {
+        TestUtils.setEnvironment('userMode', 'platform');
+        vitest.useFakeTimers({ shouldAdvanceTime: true, toFake: ['Date'] }).setSystemTime(new Date(2024, 4, 1, 0, 0, 0, 0));
+    });
+
+    afterEach(() => {
+        vitest.useRealTimers();
+    });
+
+    async function setupDaysMembership(maximumDays: number) {
+        const period = await new RegistrationPeriodFactory({
+            startDate: new Date(2024, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2024, 11, 31, 23, 59, 59, 999),
+        }).create();
+        const organization = await new OrganizationFactory({ period }).create();
+        const member = await new MemberFactory({ organization }).create();
+        const membershipType = PlatformMembershipType.create({
+            name: 'Days membership',
+            behaviour: PlatformMembershipTypeBehaviour.Days,
+            periods: new Map([
+                [period.id, PlatformMembershipTypeConfig.create({
+                    startDate: period.startDate,
+                    endDate: period.endDate,
+                    maximumDays,
+                })],
+            ]),
+        });
+
+        const platform = await Platform.getForEditing();
+        platform.periodId = period.id;
+        platform.config.membershipTypes = [membershipType];
+        await platform.save();
+
+        const membership = new MemberPlatformMembership();
+        membership.memberId = member.id;
+        membership.membershipTypeId = membershipType.id;
+        membership.organizationId = organization.id;
+        membership.periodId = period.id;
+
+        return { member, membership };
+    }
+
+    /**
+     * Creates a period membership type with a single configured price, and a membership that is
+     * ready to be priced. The period has a previous period, which is required to become eligible
+     * for a trial.
+     */
+    async function setupPeriodMembership(options: { trialDays?: number } = {}) {
+        const previousPeriod = await new RegistrationPeriodFactory({
+            startDate: new Date(2023, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2023, 11, 31, 23, 59, 59, 0),
+        }).create();
+
+        const period = await new RegistrationPeriodFactory({
+            startDate: new Date(2024, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2024, 11, 31, 23, 59, 59, 0),
+            previousPeriodId: previousPeriod.id,
+        }).create();
+
+        const organization = await new OrganizationFactory({ period }).create();
+        const member = await new MemberFactory({ organization }).create();
+
+        const membershipType = PlatformMembershipType.create({
+            name: 'Period membership',
+            behaviour: PlatformMembershipTypeBehaviour.Period,
+            periods: new Map([
+                [period.id, PlatformMembershipTypeConfig.create({
+                    startDate: period.startDate,
+                    endDate: period.endDate,
+                    trialDays: options.trialDays ?? 0,
+                    prices: [
+                        PlatformMembershipTypeConfigPrice.create({
+                            prices: new Map([['', ReduceablePrice.create({ price: membershipPrice })]]),
+                        }),
+                    ],
+                })],
+            ]),
+        });
+
+        const platform = await Platform.getForEditing();
+        platform.periodId = period.id;
+        platform.config.membershipTypes = [membershipType];
+        await platform.save();
+
+        const membership = new MemberPlatformMembership();
+        membership.memberId = member.id;
+        membership.membershipTypeId = membershipType.id;
+        membership.organizationId = organization.id;
+        membership.periodId = period.id;
+        membership.startDate = period.startDate;
+        membership.endDate = period.endDate;
+
+        return { member, membership, organization, period };
+    }
+
+    test('allows the inclusive maximum number of days', async () => {
+        const { member, membership } = await setupDaysMembership(2);
+        membership.startDate = new Date(2024, 4, 1, 0, 0, 0, 0);
+        membership.endDate = new Date(2024, 4, 2, 0, 0, 0, 0);
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).resolves.toBeUndefined();
+        expect(membership.maximumFreeAmount).toBe(2);
+    });
+
+    test('rejects days memberships that exceed maximum days', async () => {
+        const { member, membership } = await setupDaysMembership(2);
+        membership.startDate = new Date(2024, 4, 1, 0, 0, 0, 0);
+        membership.endDate = new Date(2024, 4, 3, 0, 0, 0, 0);
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).rejects.toMatchObject({
+            code: 'invalid_field',
+            field: 'endDate',
+        });
+    });
+
+    test('calculates the configured price of a period membership', async () => {
+        const { member, membership } = await setupPeriodMembership();
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).resolves.toBeUndefined();
+
+        expect(membership.price).toBe(membershipPrice);
+        expect(membership.priceWithoutDiscount).toBe(membershipPrice);
+        expect(membership.freeAmount).toBe(0);
+        expect(membership.maximumFreeAmount).toBe(1);
+        expect(membership.trialUntil).toBeNull();
+    });
+
+    test('does not recalculate the price of a locked membership', async () => {
+        const { member, membership } = await setupPeriodMembership();
+        membership.locked = true;
+        membership.price = 1_00;
+        membership.priceWithoutDiscount = 2_00;
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).resolves.toBeUndefined();
+
+        expect(membership.price).toBe(1_00);
+        expect(membership.priceWithoutDiscount).toBe(2_00);
+    });
+
+    test('rejects a membership with an unknown membership type', async () => {
+        const { member, membership } = await setupPeriodMembership();
+        membership.membershipTypeId = 'unknown-membership-type';
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).rejects.toMatchObject({
+            code: 'invalid_membership_type',
+        });
+
+        // The price is not silently set to zero
+        expect(membership.price).toBe(0);
+        expect(membership.priceWithoutDiscount).toBe(0);
+    });
+
+    test('grants a trial period only when the member has a registration with a trial', async () => {
+        const { member, membership, organization } = await setupPeriodMembership({ trialDays: 14 });
+
+        // Without a registration that had a trial, the member is not eligible for a trial
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).resolves.toBeUndefined();
+        expect(membership.trialUntil).toBeNull();
+
+        const registration = await new RegistrationFactory({ member, organization }).create();
+        registration.trialUntil = new Date(2024, 4, 20, 12, 0, 0, 0);
+        await registration.save();
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).resolves.toBeUndefined();
+
+        // The trial ends trialDays after the start date of the membership
+        expect(membership.trialUntil).not.toBeNull();
+        expect(Formatter.dateIso(membership.trialUntil!)).toBe('2024-01-15');
+        expect(membership.price).toBe(membershipPrice);
+    });
+});

package/src/services/PlatformMembershipService.ts

@@ -1,6 +1,7 @@
 import { Model } from '@simonbackx/simple-database';
+import { SimpleError } from '@simonbackx/simple-errors';
 import { logger } from '@simonbackx/simple-logging';
-import { Group, Member, MemberPlatformMembership, Organization, Platform, Registration, RegistrationPeriod } from '@stamhoofd/models';
+import { BalanceItem, Group, Member, MemberPlatformMembership, Organization, Platform, Registration, RegistrationPeriod } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
 import { AuditLogSource, PlatformMembershipTypeBehaviour } from '@stamhoofd/structures';
@@ -331,7 +332,7 @@ export class PlatformMembershipService {
                         membership.endDate = periodConfig.endDate;
                         membership.expireDate = periodConfig.expireDate;
                         membership.generated = true;
-                        await membership.calculatePrice(me, cheapestMembership.registration);
+                        await PlatformMembershipService.calculatePrice(membership, me, cheapestMembership.registration);
 
                         // Check if we have a not-locked but non-generated one that is cheaper
                         // if so, we stop and don't create a new one (but still delete others if required)
@@ -353,7 +354,7 @@ export class PlatformMembershipService {
                             if (!m.locked && m.generated) {
                                 // Update the price and dates of this active membership (could have changed)
                                 try {
-                                    await m.calculatePrice(me, cheapestMembership.registration);
+                                    await PlatformMembershipService.calculatePrice(m, me, cheapestMembership.registration);
                                 } catch (e) {
                                     // Ignore error: membership might not be available anymore
                                     if (!silent) {
@@ -381,7 +382,7 @@ export class PlatformMembershipService {
                                 // Update price
                                 if (!m.locked) {
                                     try {
-                                        await m.calculatePrice(me);
+                                        await PlatformMembershipService.calculatePrice(m, me);
                                     } catch (e) {
                                     // Ignore error: membership might not be available anymore
                                         if (!silent) {
@@ -419,4 +420,280 @@ export class PlatformMembershipService {
             });
         });
     }
+
+    /**
+     * Returns the last trial until date for this member. Null if this member does not have any trials
+     */
+    private static async isElegibleForTrial(membership: MemberPlatformMembership, member: Member) {
+        const period = await RegistrationPeriod.getByID(membership.periodId);
+        if (!period) {
+            return null;
+        }
+
+        if (!period.previousPeriodId) {
+            // We have no previous period = no data = no trials
+            return null;
+        }
+
+        const platform = await Platform.getSharedStruct();
+        const typeIds = platform.config.membershipTypes.filter(m => m.behaviour === PlatformMembershipTypeBehaviour.Period).map(m => m.id);
+
+        const previousMembership = await MemberPlatformMembership.select()
+            .where('memberId', member.id)
+            .where('deletedAt', null)
+            .where('periodId', period.previousPeriodId)
+            .where('membershipTypeId', typeIds)
+            .first(false);
+
+        const hasBlockingMemberships = !!previousMembership;
+
+        if (hasBlockingMemberships) {
+            return null;
+        }
+
+        // The member needs to be registered for at least one registration that had a trial
+        const registrations = await Registration.select()
+            .where('memberId', member.id)
+            .where('periodId', period.id)
+            .where('organizationId', membership.organizationId)
+            .where('deactivatedAt', null)
+            .where('registeredAt', '!=', null)
+            .where('trialUntil', '!=', null)
+            .fetch();
+
+        if (registrations.length === 0) {
+            return null;
+        }
+
+        const latestTrialUntil = new Date(Math.max(...registrations.map(r => r.trialUntil!.getTime())));
+        return latestTrialUntil;
+    }
+
+    private static async correctDates(membership: MemberPlatformMembership, member: Member, registration?: Registration) {
+        if (membership.locked) {
+            // price of locked membership cannot be changed
+            return;
+        }
+
+        const platform = await Platform.getSharedPrivateStruct();
+        const membershipType = platform.config.membershipTypes.find(m => m.id === membership.membershipTypeId);
+
+        if (!membershipType) {
+            throw new SimpleError({
+                code: 'invalid_membership_type',
+                message: 'Unknown membership type',
+                human: $t(`%GM`),
+            });
+        }
+
+        const periodConfig = membershipType.periods.get(membership.periodId);
+
+        if (!periodConfig) {
+            throw new SimpleError({
+                code: 'period_unavailable',
+                message: 'Membership not available for this period',
+                human: $t(`%GN`),
+            });
+        }
+
+        if (membershipType.behaviour === PlatformMembershipTypeBehaviour.Days) {
+            // Make sure time is equal between start and end date
+            let startBrussels = Formatter.luxon(membership.startDate);
+            let endBrussels = Formatter.luxon(membership.endDate);
+            startBrussels = startBrussels.set({ hour: 0, minute: 0, second: 0, millisecond: 0 });
+            endBrussels = endBrussels.set({ hour: 23, minute: 59, second: 59, millisecond: 0 });
+            membership.startDate = startBrussels.toJSDate();
+            membership.endDate = endBrussels.toJSDate();
+            membership.expireDate = null;
+        } else {
+            membership.endDate = Formatter.luxon(periodConfig.endDate).set({ hour: 23, minute: 59, second: 59, millisecond: 0 }).toJSDate();
+            membership.expireDate = periodConfig.expireDate ? Formatter.luxon(periodConfig.expireDate).set({ hour: 23, minute: 59, second: 59, millisecond: 0 }).toJSDate() : null;
+
+            // Alter start date
+            if (registration) {
+                const preferredStartDate = registration.startDate ?? registration.registeredAt ?? membership.createdAt;
+                membership.startDate = periodConfig.startDate;
+
+                if (preferredStartDate > periodConfig.startDate && preferredStartDate < periodConfig.endDate) {
+                    let startBrussels = Formatter.luxon(preferredStartDate);
+                    startBrussels = startBrussels.set({ hour: 0, minute: 0, second: 0, millisecond: 0 });
+                    membership.startDate = startBrussels.toJSDate();
+                }
+            } else {
+                // Keep the set date, but make sure it is at 0:00 in CET
+                let startBrussels = Formatter.luxon(membership.startDate);
+                startBrussels = startBrussels.set({ hour: 0, minute: 0, second: 0, millisecond: 0 });
+                membership.startDate = startBrussels.toJSDate();
+            }
+        }
+
+        let minimumStartDate = Formatter.luxon(periodConfig.startDate).set({ hour: 0, minute: 0, second: 0, millisecond: 0 }).toJSDate();
+
+        if (!membership.existsInDatabase) {
+            if (membershipType.behaviour === PlatformMembershipTypeBehaviour.Days) {
+                // Cannot create a membership in the past
+                minimumStartDate = Formatter.luxon(new Date()).set({ hour: 0, minute: 0, second: 0, millisecond: 0 }).toJSDate();
+            }
+        }
+
+        if (membership.startDate < minimumStartDate) {
+            membership.startDate = minimumStartDate;
+        }
+
+        if (membership.endDate < membership.startDate) {
+            membership.endDate = Formatter.luxon(membership.startDate).set({ hour: 23, minute: 59, second: 59, millisecond: 0 }).toJSDate();
+        }
+
+        const maximumEndDate = periodConfig.getMaximumEndDate(membership.startDate, membershipType.behaviour);
+        if (membership.endDate > maximumEndDate) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'endDate',
+                message: 'End date is after the maximum allowed end date',
+                human: $t('%15C', { date: Formatter.date(maximumEndDate) }),
+            });
+        }
+
+        if (periodConfig.trialDays) {
+            // Check whether you are elegible for a trial
+            const latestTrialDate = await PlatformMembershipService.isElegibleForTrial(membership, member);
+            if (latestTrialDate !== null) {
+                // Allowed to set trial until, maximum periodConfig.trialDays after startDate
+                let trialUntil = Formatter.luxon(membership.startDate).plus({ days: periodConfig.trialDays });
+                trialUntil = trialUntil.set({ hour: 23, minute: 59, second: 59, millisecond: 0 });
+
+                if (trialUntil.toJSDate() > latestTrialDate) {
+                    // Use the latest trial date instead
+                    trialUntil = Formatter.luxon(latestTrialDate);
+                }
+
+                // Max end date
+                if (trialUntil.toJSDate() > membership.endDate) {
+                    trialUntil = Formatter.luxon(membership.endDate).set({ hour: 23, minute: 59, second: 59, millisecond: 0 });
+                }
+
+                membership.trialUntil = trialUntil.toJSDate();
+            } else {
+                membership.trialUntil = null;
+            }
+        } else {
+            // No trial
+            membership.trialUntil = null;
+        }
+    }
+
+    static async calculatePrice(membership: MemberPlatformMembership, member: Member, registration?: Registration) {
+        if (membership.locked) {
+            // price of locked membership cannot be changed
+            return;
+        }
+
+        const platform = await Platform.getSharedPrivateStruct();
+        const membershipType = platform.config.membershipTypes.find(m => m.id === membership.membershipTypeId);
+
+        if (!membershipType) {
+            throw new SimpleError({
+                code: 'invalid_membership_type',
+                message: 'Unknown membership type',
+                human: $t(`%GM`),
+            });
+        }
+
+        const periodConfig = membershipType.periods.get(membership.periodId);
+
+        if (!periodConfig) {
+            throw new SimpleError({
+                code: 'period_unavailable',
+                message: 'Membership not available for this period',
+                human: $t(`%GN`),
+            });
+        }
+
+        const organization = await Organization.getByID(membership.organizationId);
+        if (!organization) {
+            throw new SimpleError({
+                // todo
+                code: 'not_found',
+                message: 'Organization not found',
+                human: $t(`%GO`),
+            });
+        }
+
+        const tagIds = organization.meta.tags;
+        const shouldApplyReducedPrice = member.details.shouldApplyReducedPrice;
+
+        // Correct dates so we get the correct price config
+        await PlatformMembershipService.correctDates(membership, member, registration);
+        const priceConfig = periodConfig.getPriceConfigForDate(membership.trialUntil ?? membership.startDate);
+        const earliestPriceConfig = periodConfig.getPriceConfigForDate(new Date(1950, 0, 1));
+
+        let freeDays = 0;
+
+        const d = membership.createdAt ?? new Date();
+
+        if (periodConfig.amountFree) {
+            // Check if this organization has rights to free memberships
+            const alreadyUsed = await MemberPlatformMembership.select()
+                .where('organizationId', membership.organizationId)
+                .where('membershipTypeId', membership.membershipTypeId)
+                .where('periodId', membership.periodId)
+                .where('deletedAt', null)
+                .whereNot('id', membership.id)
+                .where(
+                    SQL.where('createdAt', SQLWhereSign.Less, d)
+                        .or(
+                            SQL.where('createdAt', SQLWhereSign.Equal, d)
+                                .and('id', SQLWhereSign.Less, membership.id),
+                        ),
+                )
+                .sum(SQL.column('maximumFreeAmount'));
+
+            if (alreadyUsed < periodConfig.amountFree) {
+                freeDays = periodConfig.amountFree - alreadyUsed;
+                console.log('Free membership created for ', membership.id, periodConfig.amountFree, alreadyUsed);
+            } else {
+                console.log('No free membership created for', membership.id, periodConfig.amountFree, alreadyUsed);
+            }
+        }
+
+        if (membershipType.behaviour === PlatformMembershipTypeBehaviour.Days) {
+            const days = Math.round((membership.endDate.getTime() - membership.startDate.getTime()) / (1000 * 60 * 60 * 24));
+            membership.maximumFreeAmount = days;
+            membership.priceWithoutDiscount = earliestPriceConfig.calculatePrice(tagIds, false, days);
+            membership.price = priceConfig.calculatePrice(tagIds, shouldApplyReducedPrice, Math.max(0, days - freeDays));
+            membership.freeAmount = Math.min(days, freeDays);
+        } else {
+            membership.priceWithoutDiscount = earliestPriceConfig.getBasePrice(tagIds, false);
+            membership.price = priceConfig.getBasePrice(tagIds, shouldApplyReducedPrice);
+            membership.maximumFreeAmount = membership.price > 0 ? 1 : 0;
+            membership.freeAmount = 0;
+
+            if (freeDays > 0) {
+                membership.price = 0;
+                membership.freeAmount = 1;
+            }
+        }
+
+        // Never charge itself
+        const chargeVia = platform.membershipOrganizationId;
+        if (membership.organizationId === chargeVia) {
+            membership.price = 0;
+            membership.priceWithoutDiscount = 0;
+            membership.freeAmount = 0;
+            membership.maximumFreeAmount = 0;
+        }
+
+        if (membership.balanceItemId) {
+            membership.maximumFreeAmount = membership.freeAmount;
+
+            // Also update the balance item
+            const balanceItem = await BalanceItem.getByID(membership.balanceItemId);
+            if (balanceItem) {
+                balanceItem.unitPrice = membership.price;
+                await balanceItem.save();
+
+                // await BalanceItem.updateOutstanding([balanceItem]);
+            }
+        }
+    }
 }

package/src/services/ReferralService.ts

@@ -6,6 +6,7 @@ import { BalanceItem, Organization, Platform, RegisterCode, UsedRegisterCode } f
 import { BalanceItemStatus, BalanceItemType } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { VATService } from './VATService.js';
+import { OrganizationAdminService } from './OrganizationAdminService.js';
 
 export class ReferralService {
     /**
@@ -76,7 +77,7 @@ export class ReferralService {
         }
 
         if (otherOrganization) {
-            const admins = await otherOrganization.getAdminToEmails();
+            const admins = await OrganizationAdminService.getAdminToEmails(otherOrganization);
             if (admins) {
                 if (code.invoiceValue) {
                     // Delay email until everything is validated and saved
@@ -196,7 +197,7 @@ export class ReferralService {
             await item.save();
         }
 
-        const admins = await receivingOrganization.getAdminRecipients();
+        const admins = await OrganizationAdminService.getAdminRecipients(receivingOrganization);
         if (admins) {
             if (code.invoiceValue) {
                 Email.send({

package/src/services/RegistrationService.ts

@@ -1,6 +1,7 @@
 import { ManyToOneRelation } from '@simonbackx/simple-database';
 import { encodeObject } from '@simonbackx/simple-encoding';
-import { BalanceItem, Document, Group, Member, Organization, Registration, RegistrationInvitation, sendEmailTemplate } from '@stamhoofd/models';
+import { BalanceItem, Document, Group, Member, Organization, Platform, Registration, RegistrationInvitation } from '@stamhoofd/models';
+import { sendEmailTemplate } from '../helpers/EmailBuilder.js';
 import { QueueHandler } from '@stamhoofd/queues';
 import { AppliedRegistrationDiscount, AuditLogSource, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, EmailTemplateType, getAppHost, GroupType, Recipient, Replacement, StockReservation, Version } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
@@ -150,6 +151,7 @@ export const RegistrationService = {
         }
 
         const allowedEmails = member.details.getNotificationEmails();
+        const platform = await Platform.getSharedStruct();
 
         return member.users.map(user => Recipient.create({
             firstName: user.firstName,
@@ -167,7 +169,7 @@ export const RegistrationService = {
                 }),
                 Replacement.create({
                     token: 'registerUrl',
-                    value: 'https://' + getAppHost('registration', organization, user.permissions?.forOrganization(organization)?.isEmpty === false),
+                    value: 'https://' + getAppHost('registration', organization, user.permissions?.forOrganization(organization, platform, { inheritFromPlatform: false })?.isEmpty === false),
                 }),
                 Replacement.create({
                     token: 'groupName',