@stamhoofd/backend 2.134.0 → 2.136.0

package/src/endpoints/organization/webshops/OrderConfirmationEmailLanguage.test.ts

@@ -0,0 +1,156 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { EmailMocker } from '@stamhoofd/email';
+import { EmailTemplateFactory, OrganizationFactory, WebshopFactory } from '@stamhoofd/models';
+import { Cart, CartItem, Customer, EmailContent, EmailTemplateType, OrderData, PaymentMethod, Product, ProductPrice } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Country } from '@stamhoofd/types/Country';
+import { Language } from '@stamhoofd/types/Language';
+
+import { testServer } from '../../../../tests/helpers/TestServer.js';
+import { PlaceOrderEndpoint } from './PlaceOrderEndpoint.js';
+
+describe('Order confirmation email language', () => {
+    const endpoint = new PlaceOrderEndpoint();
+
+    test('renders $t in the language the customer used while ordering', async () => {
+        // Make French a valid locale so its real translations (loaded from disk) are actually used.
+        TestUtils.setEnvironment('locales', { [Country.Belgium]: [Language.Dutch, Language.French] });
+
+        const organization = await new OrganizationFactory({}).create();
+        const freeProductPrice = ProductPrice.create({ name: 'Free', price: 0, stock: 100 });
+        const product = Product.create({ name: 'Product', stock: 100, prices: [freeProductPrice] });
+        const webshop = await new WebshopFactory({
+            organizationId: organization.id,
+            products: [product],
+        }).create();
+
+        // Confirmation email template for this webshop (auto-includes {{orderStatus}} etc.)
+        await new EmailTemplateFactory({
+            organization,
+            webshopId: webshop.id,
+            type: EmailTemplateType.OrderConfirmationOnline,
+        }).create();
+
+        // The order status label (OrderStatus.Created) is rendered via $t inside the confirmation
+        // email. These are the translations looked up in shared/locales/dist/locales/digit/{nl,fr}-BE.json,
+        // hardcoded on purpose so we don't verify $t with the same $t machinery we're testing.
+        const dutchStatusName = 'Nieuw';
+        const frenchStatusName = 'Nouveau';
+
+        const placeFreeOrderInLanguage = async (language: string) => {
+            EmailMocker.transactional.reset();
+
+            const orderData = OrderData.create({
+                paymentMethod: PaymentMethod.Unknown,
+                cart: Cart.create({
+                    items: [CartItem.create({ product, productPrice: freeProductPrice, amount: 1 })],
+                }),
+                customer: Customer.create({ firstName: 'John', lastName: 'Doe', email: 'john@example.com', phone: '+32412345678' }),
+            });
+
+            const r = Request.buildJson('POST', `/webshop/${webshop.id}/order`, organization.getApiHost(), orderData);
+            r.headers['accept-language'] = language;
+            await testServer.test(endpoint, r);
+
+            const emails = await EmailMocker.transactional.getSucceededEmails();
+            expect(emails).toHaveLength(1);
+            return emails[0];
+        };
+
+        // French order → the $t status label is rendered in French, without Dutch leaking in
+        const frenchEmail = await placeFreeOrderInLanguage('fr');
+        expect(frenchEmail.html).toContain(frenchStatusName);
+        expect(frenchEmail.html).not.toContain(dutchStatusName);
+
+        // Dutch order → rendered in Dutch, without French leaking in
+        const dutchEmail = await placeFreeOrderInLanguage('nl');
+        expect(dutchEmail.html).toContain(dutchStatusName);
+        expect(dutchEmail.html).not.toContain(frenchStatusName);
+    });
+
+    test('selects the translated template that matches the language the customer ordered in', async () => {
+        TestUtils.setEnvironment('locales', { [Country.Belgium]: [Language.Dutch, Language.French] });
+
+        const organization = await new OrganizationFactory({}).create();
+        const freeProductPrice = ProductPrice.create({ name: 'Free', price: 0, stock: 100 });
+        const product = Product.create({ name: 'Product', stock: 100, prices: [freeProductPrice] });
+        const webshop = await new WebshopFactory({
+            organizationId: organization.id,
+            products: [product],
+        }).create();
+
+        // The template has default (Dutch) content and a French translation. The French translation
+        // must be selected for a French order, the default content for a Dutch order.
+        // Both order-table replacements are included: their headers/titles are localized per
+        // recipient (consumer) language, independently of the selected template translation.
+        const tables = '{{orderTable}} {{orderDetailsTable}}';
+        await new EmailTemplateFactory({
+            organization,
+            webshopId: webshop.id,
+            type: EmailTemplateType.OrderConfirmationOnline,
+            subject: 'Standaard onderwerp',
+            html: `<p>Standaard inhoud ${tables}</p>`,
+            text: 'Standaard inhoud',
+            language: Language.Dutch,
+            translations: new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français', html: `<p>Contenu français ${tables}</p>`, text: 'Contenu français' })],
+            ]),
+        }).create();
+
+        // Table headers/titles rendered via $t inside the order tables. Hardcoded on purpose so we
+        // don't verify $t with the same $t machinery we're testing.
+        // orderTable column headers (%Sc / %M4) and an orderDetailsTable row title (%xA).
+        const dutch = { orderColumn: 'Artikel', amountColumn: 'Aantal', orderNumberTitle: 'Bestelnummer' };
+        const french = { orderColumn: 'Article', amountColumn: 'Nombre', orderNumberTitle: 'Numéro de commande' };
+
+        const placeFreeOrderInLanguage = async (language: string) => {
+            EmailMocker.transactional.reset();
+
+            const orderData = OrderData.create({
+                paymentMethod: PaymentMethod.Unknown,
+                cart: Cart.create({
+                    items: [CartItem.create({ product, productPrice: freeProductPrice, amount: 1 })],
+                }),
+                customer: Customer.create({ firstName: 'John', lastName: 'Doe', email: 'john@example.com', phone: '+32412345678' }),
+            });
+
+            const r = Request.buildJson('POST', `/webshop/${webshop.id}/order`, organization.getApiHost(), orderData);
+            r.headers['accept-language'] = language;
+            await testServer.test(endpoint, r);
+
+            const emails = await EmailMocker.transactional.getSucceededEmails();
+            expect(emails).toHaveLength(1);
+            return emails[0];
+        };
+
+        // French order → the French translation of the template is used
+        const frenchEmail = await placeFreeOrderInLanguage('fr');
+        expect(frenchEmail.subject).toBe('Sujet français');
+        expect(frenchEmail.html).toContain('Contenu français');
+        expect(frenchEmail.html).not.toContain('Standaard inhoud');
+
+        // Both order tables are rendered in the recipient's (consumer) language, French
+        expect(frenchEmail.html).toContain(french.orderColumn);
+        expect(frenchEmail.html).toContain(french.amountColumn);
+        expect(frenchEmail.html).toContain(french.orderNumberTitle);
+        // No Dutch table headers/titles leak into the French email
+        expect(frenchEmail.html).not.toContain(dutch.orderColumn);
+        expect(frenchEmail.html).not.toContain(dutch.amountColumn);
+        expect(frenchEmail.html).not.toContain(dutch.orderNumberTitle);
+
+        // Dutch order → Dutch is the default language, so the default content is used
+        const dutchEmail = await placeFreeOrderInLanguage('nl');
+        expect(dutchEmail.subject).toBe('Standaard onderwerp');
+        expect(dutchEmail.html).toContain('Standaard inhoud');
+        expect(dutchEmail.html).not.toContain('Contenu français');
+
+        // Both order tables are rendered in Dutch
+        expect(dutchEmail.html).toContain(dutch.orderColumn);
+        expect(dutchEmail.html).toContain(dutch.amountColumn);
+        expect(dutchEmail.html).toContain(dutch.orderNumberTitle);
+        // No French table headers/titles leak into the Dutch email
+        expect(dutchEmail.html).not.toContain(french.orderColumn);
+        expect(dutchEmail.html).not.toContain(french.amountColumn);
+        expect(dutchEmail.html).not.toContain(french.orderNumberTitle);
+    });
+});

package/src/endpoints/organization/webshops/PlaceOrderEndpoint.test.ts

@@ -6,8 +6,10 @@ import type { Organization, StripeAccount, User } from '@stamhoofd/models';
 import { Order, OrganizationFactory, Payment, Token, UserFactory, Webshop, WebshopFactory } from '@stamhoofd/models';
 import type { OrderResponse } from '@stamhoofd/structures';
 import { Address, Cart, CartItem, CartItemOption, Customer, Option, OptionMenu, OrderData, PaymentConfiguration, PaymentMethod, PermissionLevel, Permissions, PrivateOrder, PrivatePaymentConfiguration, Product, ProductPrice, ProductType, SeatingPlan, SeatingPlanRow, SeatingPlanSeat, SeatingPlanSection, TransferSettings, WebshopAuthType, WebshopDeliveryMethod, WebshopMetaData, WebshopOnSiteMethod, WebshopPrivateMetaData, WebshopTakeoutMethod, WebshopTimeSlot } from '@stamhoofd/structures';
-import { STExpect } from '@stamhoofd/test-utils';
+import { I18n } from '@stamhoofd/backend-i18n';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { Country } from '@stamhoofd/types/Country';
+import { Language } from '@stamhoofd/types/Language';
 import sinon from 'sinon';
 import { v4 as uuidv4 } from 'uuid';
 
@@ -573,4 +575,69 @@ describe('Endpoint.PlaceOrderEndpoint', () => {
             expect(payment.customer!.equals(orderModel.data.customer.toPaymentCustomer())).toBe(true);
         });
     });
+
+    describe('Order language', () => {
+        function buildFreeOrderData() {
+            return OrderData.create({
+                paymentMethod: PaymentMethod.Unknown,
+                checkoutMethod: onSiteMethod,
+                timeSlot: slot4,
+                cart: Cart.create({
+                    items: [
+                        CartItem.create({
+                            product,
+                            productPrice: freeProductPrice,
+                            amount: 1,
+                        }),
+                    ],
+                }),
+                customer,
+            });
+        }
+
+        test('Stores the request language on a placed order', async () => {
+            const r = Request.buildJson('POST', `/webshop/${webshop.id}/order`, organization.getApiHost(), buildFreeOrderData());
+            r.headers['accept-language'] = 'en';
+
+            const response = await testServer.test(endpoint, r);
+            expect(response.body.order.consumerLanguage).toEqual('en');
+
+            // Persisted in the dedicated column
+            const orderModel = (await Order.getByID(response.body.order.id))!;
+            expect(orderModel.consumerLanguage).toEqual('en');
+        });
+
+        test('Falls back to the webshop default language when the request language is unknown', async () => {
+            webshop.meta.defaultLanguage = Language.French;
+            await webshop.save();
+
+            // The struct default is Dutch, so the server-side fallback to the webshop default is observable.
+            const r = Request.buildJson('POST', `/webshop/${webshop.id}/order`, organization.getApiHost(), buildFreeOrderData());
+
+            const response = await testServer.test(endpoint, r);
+            expect(response.body.order.consumerLanguage).toEqual(Language.French);
+
+            const orderModel = (await Order.getByID(response.body.order.id))!;
+            expect(orderModel.consumerLanguage).toEqual(Language.French);
+        });
+
+        test('runWithLocale overrides the global language used for $t evaluation', async () => {
+            // Allow French to be a valid locale for this test (test env has no locales configured).
+            TestUtils.setEnvironment('locales', { [Country.Belgium]: [Language.Dutch, Language.French] });
+
+            const i18n = new I18n(Language.French, Country.Belgium);
+
+            expect(I18n.override).toBeNull();
+            expect((global as any).$getLanguage()).toEqual(Language.Dutch);
+
+            await I18n.runWithLocale(i18n, async () => {
+                expect(I18n.override).toBe(i18n);
+                expect((global as any).$getLanguage()).toEqual(Language.French);
+            });
+
+            // Restored afterwards
+            expect(I18n.override).toBeNull();
+            expect((global as any).$getLanguage()).toEqual(Language.Dutch);
+        });
+    });
 });

package/src/endpoints/organization/webshops/PlaceOrderEndpoint.ts

@@ -3,6 +3,7 @@ import type { Decoder } from '@simonbackx/simple-encoding';
 import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
+import { I18n } from '@stamhoofd/backend-i18n';
 import { Email } from '@stamhoofd/email';
 import { BalanceItem, BalanceItemPayment, MolliePayment, Order, PayconiqPayment, Payment, RateLimiter, Webshop, WebshopDiscountCode } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
@@ -132,6 +133,13 @@ export class PlaceOrderEndpoint extends Endpoint<Params, Query, Body, ResponseBo
 
             const order = new Order().setRelation(Order.webshop, webshop);
             order.data = request.body; // TODO: validate
+
+            // Store the language the customer used while placing the order, so future emails to
+            // this order are rendered in the same language. Fall back to the webshop's default
+            // language when it can't be determined from the request.
+            const consumerLanguage = I18n.getLanguageFromRequest(request) ?? webshop.meta.defaultLanguage;
+            order.consumerLanguage = consumerLanguage;
+
             order.organizationId = organization.id;
             order.createdAt = new Date();
             order.createdAt.setMilliseconds(0);

package/src/excel-loaders/members.test.ts

@@ -0,0 +1,59 @@
+import type { XlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
+import type { PlatformMember } from '@stamhoofd/structures';
+import { EmergencyContact, MemberDetails, MembersBlob, MemberWithRegistrationsBlob, Organization, Platform, PlatformFamily } from '@stamhoofd/structures';
+import { baseMemberColumns } from './members.js';
+
+describe('Member excel export', () => {
+    describe('emergencyContacts column', () => {
+        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 getColumn() {
+            const column = baseMemberColumns.find(c => 'id' in c && c.id === 'emergencyContacts') as XlsxTransformerConcreteColumn<PlatformMember> | undefined;
+
+            if (!column) {
+                throw new Error('Column emergencyContacts not found');
+            }
+
+            return column;
+        }
+
+        function getValue(member: PlatformMember) {
+            return getColumn().getValue(member).value;
+        }
+
+        it('lists every emergency contact on its own line, also the ones without a numbered column', () => {
+            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' }),
+                EmergencyContact.create({ name: 'Rita Maes', title: 'Tante', phone: '0470 11 22 33' }),
+            ]);
+
+            expect(getValue(member)).toBe('Oma: An Peeters (0470 12 34 56)\nBuur: Jan Janssens (0470 65 43 21)\nTante: Rita Maes (0470 11 22 33)');
+        });
+
+        it('wraps the text so every line stays visible', () => {
+            const member = createMember([
+                EmergencyContact.create({ name: 'An Peeters', title: 'Oma', phone: '0470 12 34 56' }),
+            ]);
+
+            expect(getColumn().getValue(member).style?.alignment?.wrapText).toBe(true);
+        });
+
+        it('returns an empty value when the member has no emergency contacts', () => {
+            expect(getValue(createMember([]))).toBe('');
+        });
+    });
+});

package/src/excel-loaders/members.ts

@@ -191,6 +191,23 @@ export const baseMemberColumns: XlsxTransformerColumn<PlatformMember>[] = [
 
     ...XlsxTransformerColumnHelper.creatColumnsForParents(),
 
+    // emergency contacts
+    {
+        id: 'emergencyContacts',
+        name: $t(`%ZeJ`),
+        width: 40,
+        getValue: ({ patchedMember: object }: PlatformMember) => ({
+            // One contact per line so the cell stays readable, and wrap the text so all lines are visible
+            value: object.details.emergencyContacts.map(c => c.toString()).join('\n'),
+            style: {
+                alignment: {
+                    wrapText: true,
+                },
+            },
+        }),
+    },
+    ...XlsxTransformerColumnHelper.createColumnsForEmergencyContacts(),
+
     // unverified data
     {
         id: 'unverifiedPhones',

package/src/helpers/AuthenticatedStructures.ts

@@ -406,6 +406,15 @@ export class AuthenticatedStructures {
         const members = await Member.getMembersWithRegistrationForUser(user);
         const filtered: MemberWithUsersRegistrationsAndGroups[] = [];
         for (const member of members) {
+            if (STAMHOOFD.userMode === 'organization') {
+                if (!Context.organization) {
+                    // Don't list any members
+                    continue;
+                }
+                if (member.organizationId !== Context.organization.id) {
+                    continue;
+                }
+            }
             if (await Context.auth.canAccessMember(member, PermissionLevel.Read)) {
                 filtered.push(member);
             }

package/src/helpers/GlobalHelper.ts

@@ -17,7 +17,7 @@ export class GlobalHelper {
 
     static loadGlobalTranslateFunction() {
         function getI18n() {
-            return ContextInstance.optional?.i18n ?? new I18n(I18n.defaultLanguage, STAMHOOFD.fixedCountry ?? I18n.defaultCountry);
+            return I18n.override ?? ContextInstance.optional?.i18n ?? new I18n(I18n.defaultLanguage, STAMHOOFD.fixedCountry ?? I18n.defaultCountry);
         }
         (global as any).$t = (key: string, replace?: Record<string, string>) => getI18n().$t(key, replace);
         (global as any).$getLanguage = () => getI18n().language;

package/src/helpers/MemberMerger.test.ts

@@ -1,10 +1,13 @@
 import {
     Address,
+    BalanceItemRelation,
+    BalanceItemRelationType,
     BooleanStatus,
     EmergencyContact,
     Gender,
     MemberDetails,
     Parent,
+    ReceivableBalanceType,
     RecordAnswer,
     RecordSettings,
     ReviewTime,
@@ -16,8 +19,10 @@ import {
 } from '@stamhoofd/structures';
 import { Country } from '@stamhoofd/types/Country';
 import { v4 as uuidv4 } from 'uuid';
-import { Member } from '@stamhoofd/models';
-import { mergeMemberDetails, selectBaseMember } from './MemberMerger.js';
+import { BalanceItem, BalanceItemFactory, CachedBalance, Member, MemberFactory, OrganizationFactory } from '@stamhoofd/models';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { BalanceItemService } from '../services/BalanceItemService.js';
+import { mergeMemberDetails, mergeTwoMembers, selectBaseMember } from './MemberMerger.js';
 
 describe('member merge', () => {
     describe('mergeMemberDetails', () => {
@@ -914,3 +919,66 @@ describe('member merge', () => {
         });
     });
 });
+
+describe('mergeTwoMembers balance items', () => {
+    beforeEach(() => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    const createBalanceItem = async (organizationId: string, member: Member, unitPrice: number) => {
+        return await new BalanceItemFactory({
+            organizationId,
+            memberId: member.id,
+            amount: 1,
+            unitPrice,
+            relations: new Map([
+                [
+                    BalanceItemRelationType.Member,
+                    BalanceItemRelation.create({
+                        id: member.id,
+                        name: new TranslatedString(member.details.name),
+                    }),
+                ],
+            ]),
+        }).create();
+    };
+
+    test('moves the balance items to the base member, rewrites the Member relation and recalculates cached balances', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const base = await new MemberFactory({ organization, firstName: 'Base', lastName: 'Member' }).create();
+        const other = await new MemberFactory({ organization, firstName: 'Other', lastName: 'Member' }).create();
+
+        const baseItem = await createBalanceItem(organization.id, base, 30_00);
+        const otherItem = await createBalanceItem(organization.id, other, 50_00);
+
+        // Warm up the cached balances so both members have a stale value before merging
+        await CachedBalance.updateForMembers(organization.id, [base.id, other.id]);
+
+        await mergeTwoMembers(base, other);
+
+        // The balance item of the removed member now belongs to the base member
+        const movedItem = await BalanceItem.getByID(otherItem.id);
+        expect(movedItem?.memberId).toBe(base.id);
+
+        // Its Member relation is rewritten to point to the base member
+        const relation = movedItem?.relations.get(BalanceItemRelationType.Member);
+        expect(relation?.id).toBe(base.id);
+        expect(relation?.name.toString()).toBe(base.details.name);
+
+        // The balance item that was already on the base member is untouched
+        const keptItem = await BalanceItem.getByID(baseItem.id);
+        expect(keptItem?.memberId).toBe(base.id);
+        expect(keptItem?.relations.get(BalanceItemRelationType.Member)?.id).toBe(base.id);
+
+        // Make sure all scheduled cached balance updates have run
+        await BalanceItemService.flushAll();
+
+        // The base member now owes both balance items
+        const [baseBalance] = await CachedBalance.getForObjects([base.id], organization.id, ReceivableBalanceType.member);
+        expect(baseBalance?.amountOpen).toBe(80_00);
+
+        // The removed member no longer has an outstanding cached balance
+        const [otherBalance] = await CachedBalance.getForObjects([other.id], organization.id, ReceivableBalanceType.member);
+        expect(otherBalance?.amountOpen ?? 0).toBe(0);
+    });
+});

package/src/helpers/MemberMerger.ts

@@ -19,10 +19,14 @@ import type {
     UitpasNumberDetails,
 } from '@stamhoofd/structures';
 import {
+    BalanceItemRelation,
+    BalanceItemRelationType,
     Gender,
     ParentType,
+    TranslatedString,
 } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
+import { BalanceItemService } from '../services/BalanceItemService.js';
 import { PlatformMembershipService } from '../services/PlatformMembershipService.js';
 import { RegistrationService } from '../services/RegistrationService.js';
 import { MemberUserSyncer } from './MemberUserSyncer.js';
@@ -214,7 +218,45 @@ async function mergeResponsibilities(base: Member, other: Member) {
 }
 
 async function mergeBalanceItems(base: Member, other: Member) {
-    await mergeModels(base, other, BalanceItem);
+    const otherModels = await BalanceItem.select()
+        .where('memberId', other.id)
+        .fetch();
+
+    // Keep track of every organization that had balance items for the removed member,
+    // so we can reset its cached balance afterwards.
+    const organizationIds = new Set<string>();
+
+    for (const otherModel of otherModels) {
+        organizationIds.add(otherModel.organizationId);
+
+        otherModel.memberId = base.id;
+
+        // The Member relation stores the member id + name. Update it so it points to the base member.
+        if (otherModel.relations.has(BalanceItemRelationType.Member) && otherModel.relations.get(BalanceItemRelationType.Member)?.id === other.id) {
+            otherModel.relations.set(
+                BalanceItemRelationType.Member,
+                BalanceItemRelation.create({
+                    id: base.id,
+                    name: new TranslatedString(base.details.name),
+                }),
+            );
+        }
+
+        await otherModel.save({
+            skipMarkSaved: true,
+            skipSendEvents: true,
+        });
+
+        // Recalculate the cached balance of the base member (+ related users/organizations/registrations).
+        // We skip the model events above, so we have to schedule the update manually.
+        BalanceItemService.scheduleUpdate(otherModel);
+    }
+
+    // Recalculate the cached balance of the removed member, otherwise stale amounts remain
+    // in the cached balances for a member that no longer exists.
+    for (const organizationId of organizationIds) {
+        BalanceItemService.scheduleMemberUpdate(organizationId, other.id);
+    }
 }
 
 async function mergeDocuments(base: Member, other: Member) {

package/src/helpers/MemberUserSyncer.ts

@@ -380,6 +380,11 @@ export class MemberUserSyncerStatic {
                         }
                     }
 
+                    if (setMemberId && member.organizationId !== user.organizationId) {
+                        // Don't allow linking across scopes
+                        setMemberId = false;
+                    }
+
                     if (setMemberId) {
                         if (name) {
                             user.firstName = name.firstName;

package/src/helpers/MembershipCharger.test.ts

@@ -0,0 +1,110 @@
+import type { Member, Organization, RegistrationPeriod } from '@stamhoofd/models';
+import { BalanceItem, MemberFactory, MemberPlatformMembership, OrganizationFactory, Platform, RegistrationPeriodFactory } from '@stamhoofd/models';
+import { BalanceItemType, PlatformMembershipType, PlatformMembershipTypeBehaviour, PlatformMembershipTypeConfig, PlatformMembershipTypeConfigPrice, ReduceablePrice } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { MembershipCharger } from './MembershipCharger.js';
+
+describe('MembershipCharger', () => {
+    const membershipPrice = 25_00;
+
+    let currentPeriod: RegistrationPeriod;
+    let nextPeriod: RegistrationPeriod;
+    let membershipOrganization: Organization;
+    let payingOrganization: Organization;
+    let membershipType: PlatformMembershipType;
+
+    const buildConfig = (period: RegistrationPeriod) => {
+        return PlatformMembershipTypeConfig.create({
+            startDate: period.startDate,
+            endDate: period.endDate,
+            prices: [
+                PlatformMembershipTypeConfigPrice.create({
+                    prices: new Map([['', ReduceablePrice.create({ price: membershipPrice })]]),
+                }),
+            ],
+        });
+    };
+
+    // Set the period that should not be charged yet (or null to charge every period)
+    const setNextPeriod = async (nextPeriodId: string | null) => {
+        const platform = await Platform.getForEditing();
+        platform.periodId = currentPeriod.id;
+        platform.nextPeriodId = nextPeriodId;
+        platform.membershipOrganizationId = membershipOrganization.id;
+        platform.config.membershipTypes = [membershipType];
+        await platform.save();
+    };
+
+    const createMembership = async (period: RegistrationPeriod, organization: Organization, member: Member) => {
+        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;
+        await membership.save();
+        return membership;
+    };
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    beforeAll(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+
+        currentPeriod = await new RegistrationPeriodFactory({
+            startDate: new Date(2024, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2024, 11, 31, 23, 59, 59, 0),
+        }).create();
+
+        nextPeriod = await new RegistrationPeriodFactory({
+            startDate: new Date(2025, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2025, 11, 31, 23, 59, 59, 0),
+        }).create();
+
+        membershipOrganization = await new OrganizationFactory({}).create();
+        payingOrganization = await new OrganizationFactory({}).create();
+
+        membershipType = PlatformMembershipType.create({
+            name: 'Test membership',
+            behaviour: PlatformMembershipTypeBehaviour.Period,
+            periods: new Map([
+                [currentPeriod.id, buildConfig(currentPeriod)],
+                [nextPeriod.id, buildConfig(nextPeriod)],
+            ]),
+        });
+    });
+
+    test('Charges current period memberships but skips memberships of the next period', async () => {
+        await setNextPeriod(nextPeriod.id);
+
+        const currentMember = await new MemberFactory({}).create();
+        const nextMember = await new MemberFactory({}).create();
+
+        const currentMembership = await createMembership(currentPeriod, payingOrganization, currentMember);
+        const nextMembership = await createMembership(nextPeriod, payingOrganization, nextMember);
+
+        await MembershipCharger.charge();
+
+        const chargedCurrent = await MemberPlatformMembership.getByID(currentMembership.id);
+        expect(chargedCurrent).toBeDefined();
+        expect(chargedCurrent!.balanceItemId).not.toBeNull();
+        expect(chargedCurrent!.locked).toBe(true);
+
+        // The next period membership should be left untouched
+        const chargedNext = await MemberPlatformMembership.getByID(nextMembership.id);
+        expect(chargedNext).toBeDefined();
+        expect(chargedNext!.balanceItemId).toBeNull();
+        expect(chargedNext!.locked).toBe(false);
+
+        // The created balance item should be charged via the membership organization
+        const balanceItem = await BalanceItem.getByID(chargedCurrent!.balanceItemId!);
+        expect(balanceItem).toBeDefined();
+        expect(balanceItem!.type).toBe(BalanceItemType.PlatformMembership);
+        expect(balanceItem!.unitPrice).toBe(membershipPrice);
+        expect(balanceItem!.organizationId).toBe(membershipOrganization.id);
+        expect(balanceItem!.payingOrganizationId).toBe(payingOrganization.id);
+    });
+});