@stamhoofd/backend 2.133.0 → 2.135.0

package/src/endpoints/global/members/PatchOrganizationMembersEndpoint.test.ts

@@ -3,10 +3,10 @@ import type { PatchableArrayAutoEncoder } from '@simonbackx/simple-encoding';
 import { PatchableArray, PatchMap } from '@simonbackx/simple-encoding';
 import type { Endpoint } from '@simonbackx/simple-endpoints';
 import { Request } from '@simonbackx/simple-endpoints';
-import { GroupFactory, Member, MemberFactory, OrganizationFactory, OrganizationTagFactory, Platform, RegistrationFactory, Token, UserFactory } from '@stamhoofd/models';
+import { GroupFactory, Member, MemberFactory, MemberPlatformMembership, OrganizationFactory, OrganizationTagFactory, Platform, RegistrationFactory, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import { SQL } from '@stamhoofd/sql';
 import type { PatchAnswers } from '@stamhoofd/structures';
-import { Address, EmergencyContact, MemberDetails, MemberWithRegistrationsBlob, OrganizationMetaData, OrganizationRecordsConfiguration, Parent, PermissionLevel, Permissions, PermissionsResourceType, RecordCategory, RecordSettings, RecordTextAnswer, ResourcePermissions, ReviewTime, ReviewTimes, TranslatedString, UitpasNumberDetails, UitpasSocialTariff, UitpasSocialTariffStatus, Version } from '@stamhoofd/structures';
+import { Address, EmergencyContact, MemberDetails, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberWithRegistrationsBlob, OrganizationMetaData, OrganizationRecordsConfiguration, Parent, PermissionLevel, Permissions, PermissionsResourceType, PlatformMembershipType, PlatformMembershipTypeConfig, RecordCategory, RecordSettings, RecordTextAnswer, ResourcePermissions, ReviewTime, ReviewTimes, TranslatedString, UitpasNumberDetails, UitpasSocialTariff, UitpasSocialTariffStatus, Version } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { Country } from '@stamhoofd/types/Country';
 import { testServer } from '../../../../tests/helpers/TestServer.js';
@@ -4034,4 +4034,192 @@ describe('Endpoint.PatchOrganizationMembersEndpoint', () => {
             });
         });
     });
+
+    describe('Overlapping and incompatible platform memberships', () => {
+        // Two non-overlapping halves of the same period (werkjaar).
+        const firstHalf = { startDate: new Date(2024, 0, 1, 0, 0, 0, 0), endDate: new Date(2024, 5, 30, 23, 59, 59, 0) };
+        const secondHalf = { startDate: new Date(2024, 6, 1, 0, 0, 0, 0), endDate: new Date(2024, 11, 31, 23, 59, 59, 0) };
+
+        async function setup({ incompatibleWithB = false, existingRange, putRange, existingLocked = false, existingGenerated = false }: {
+            incompatibleWithB?: boolean;
+            existingRange?: { startDate: Date; endDate: Date };
+            putRange?: { startDate: Date; endDate: Date };
+            existingLocked?: boolean;
+            existingGenerated?: boolean;
+        }) {
+            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),
+            }).create();
+
+            const organization = await new OrganizationFactory({ period }).create();
+
+            const typeB = PlatformMembershipType.create({
+                name: 'Type B',
+                periods: new Map([
+                    [period.id, PlatformMembershipTypeConfig.create({
+                        startDate: period.startDate,
+                        endDate: period.endDate,
+                    })],
+                ]),
+            });
+
+            const typeA = PlatformMembershipType.create({
+                name: 'Type A',
+                incompatibleMembershipTypeIds: incompatibleWithB ? [typeB.id] : [],
+                periods: new Map([
+                    [period.id, PlatformMembershipTypeConfig.create({
+                        startDate: period.startDate,
+                        endDate: period.endDate,
+                    })],
+                ]),
+            });
+
+            const platform = await Platform.getForEditing();
+            platform.periodId = period.id;
+            platform.config.membershipTypes = [typeA, typeB];
+            await platform.save();
+
+            const user = await new UserFactory({
+                permissions: Permissions.create({ level: PermissionLevel.Full }),
+                organization,
+            }).create();
+            const token = await Token.createToken(user);
+
+            const member = await new MemberFactory({ organization }).create();
+            const group = await new GroupFactory({ organization, period }).create();
+            await new RegistrationFactory({ member, group }).create();
+
+            // The member already has a membership of type B in this period
+            const existing = new MemberPlatformMembership();
+            existing.memberId = member.id;
+            existing.membershipTypeId = typeB.id;
+            existing.organizationId = organization.id;
+            existing.periodId = period.id;
+            existing.startDate = existingRange?.startDate ?? period.startDate;
+            existing.endDate = existingRange?.endDate ?? period.endDate;
+            existing.locked = existingLocked;
+            existing.generated = existingGenerated;
+            await existing.save();
+
+            const arr: Body = new PatchableArray();
+            const memberPatch = MemberWithRegistrationsBlob.patch({ id: member.id });
+            memberPatch.platformMemberships.addPut(MemberPlatformMembershipStruct.create({
+                memberId: member.id,
+                membershipTypeId: typeA.id,
+                organizationId: organization.id,
+                periodId: period.id,
+                startDate: putRange?.startDate ?? period.startDate,
+                endDate: putRange?.endDate ?? period.endDate,
+            }));
+            arr.addPatch(memberPatch);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+
+            return { period, organization, typeA, typeB, member, request };
+        }
+
+        async function getTypeAMemberships(memberId: string, membershipTypeId: string) {
+            return await MemberPlatformMembership.select()
+                .where('memberId', memberId)
+                .where('membershipTypeId', membershipTypeId)
+                .where('deletedAt', null)
+                .fetch();
+        }
+
+        describe('Overlapping memberships of a different type are never allowed', () => {
+            test('Blocks an overlapping membership of an incompatible type', async () => {
+                const { typeA, member, request } = await setup({ incompatibleWithB: true });
+
+                await expect(testServer.test(endpoint, request)).rejects.toThrow(expect.objectContaining({
+                    code: 'invalid_field',
+                    field: 'membershipTypeId',
+                    message: 'Overlapping membership type',
+                }));
+
+                // The overlapping membership was not created
+                expect((await getTypeAMemberships(member.id, typeA.id)).length).toBe(0);
+            });
+
+            test('Blocks an overlapping membership even when the type is not marked incompatible', async () => {
+                const { typeA, member, request } = await setup({ incompatibleWithB: false });
+
+                await expect(testServer.test(endpoint, request)).rejects.toThrow(expect.objectContaining({
+                    code: 'invalid_field',
+                    field: 'membershipTypeId',
+                    message: 'Overlapping membership type',
+                }));
+
+                // The overlapping membership was not created
+                expect((await getTypeAMemberships(member.id, typeA.id)).length).toBe(0);
+            });
+        });
+
+        describe('Non-overlapping memberships in the same period', () => {
+            test('Blocks an incompatible type even when the dates do not overlap', async () => {
+                const { typeA, member, request } = await setup({
+                    incompatibleWithB: true,
+                    existingRange: firstHalf,
+                    putRange: secondHalf,
+                });
+
+                await expect(testServer.test(endpoint, request)).rejects.toThrow(expect.objectContaining({
+                    code: 'invalid_field',
+                    field: 'membershipTypeId',
+                    message: 'Incompatible membership type',
+                }));
+
+                // The incompatible membership was not created
+                expect((await getTypeAMemberships(member.id, typeA.id)).length).toBe(0);
+            });
+
+            test('Allows a compatible type when the dates do not overlap', async () => {
+                const { typeA, member, request } = await setup({
+                    incompatibleWithB: false,
+                    existingRange: firstHalf,
+                    putRange: secondHalf,
+                });
+
+                const result = await testServer.test(endpoint, request);
+                expect(result.status).toBe(200);
+
+                expect((await getTypeAMemberships(member.id, typeA.id)).length).toBe(1);
+            });
+
+            test('Reports a locked incompatible membership with a specific message', async () => {
+                const { typeA, member, request } = await setup({
+                    incompatibleWithB: true,
+                    existingRange: firstHalf,
+                    putRange: secondHalf,
+                    existingLocked: true,
+                });
+
+                await expect(testServer.test(endpoint, request)).rejects.toThrow(expect.objectContaining({
+                    code: 'invalid_field',
+                    field: 'membershipTypeId',
+                    message: 'Incompatible locked membership type',
+                }));
+
+                expect((await getTypeAMemberships(member.id, typeA.id)).length).toBe(0);
+            });
+
+            test('Reports a generated incompatible membership with a specific message', async () => {
+                const { typeA, member, request } = await setup({
+                    incompatibleWithB: true,
+                    existingRange: firstHalf,
+                    putRange: secondHalf,
+                    existingGenerated: true,
+                });
+
+                await expect(testServer.test(endpoint, request)).rejects.toThrow(expect.objectContaining({
+                    code: 'invalid_field',
+                    field: 'membershipTypeId',
+                    message: 'Incompatible generated membership type',
+                }));
+
+                expect((await getTypeAMemberships(member.id, typeA.id)).length).toBe(0);
+            });
+        });
+    });
 });

package/src/endpoints/global/members/PatchOrganizationMembersEndpoint.ts

@@ -66,6 +66,25 @@ export const duplicateCheckLimiter = new RateLimiter({
     ],
 });
 
+/**
+ * A where clause that matches memberships whose [startDate, endDate] range overlaps
+ * with the given [startDate, endDate] range.
+ */
+function membershipDateRangeOverlaps(startDate: Date, endDate: Date) {
+    return SQL.where(
+        SQL.where('startDate', SQLWhereSign.LessEqual, startDate)
+            .and('endDate', SQLWhereSign.GreaterEqual, startDate),
+    )
+        .or(
+            SQL.where('startDate', SQLWhereSign.LessEqual, endDate)
+                .and('endDate', SQLWhereSign.GreaterEqual, endDate),
+        )
+        .or(
+            SQL.where('startDate', SQLWhereSign.GreaterEqual, startDate)
+                .and('endDate', SQLWhereSign.LessEqual, endDate),
+        );
+}
+
 /**
  * One endpoint to create, patch and delete members and their registrations and payments
  */
@@ -568,26 +587,65 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 // Correct price and dates
                 await membership.calculatePrice(member);
 
+                const incompatible = await MemberPlatformMembership.select()
+                    .where('memberId', member.id)
+                    .whereNot('membershipTypeId', put.membershipTypeId) // same type is checked later and might be auto-deleted
+                    .where('periodId', put.periodId)
+                    .where('deletedAt', null)
+                    .where(membershipDateRangeOverlaps(put.startDate, put.endDate))
+                    .first(false);
+
+                if (incompatible) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        field: 'membershipTypeId',
+                        message: 'Overlapping membership type',
+                        human: $t('%Zd9'),
+                    });
+                }
+
+                // Not overlapping, but in same period.
+                if (membershipType.incompatibleMembershipTypeIds.length > 0) {
+                    const incompatible = await MemberPlatformMembership.select()
+                        .where('memberId', member.id)
+                        .where('membershipTypeId', membershipType.incompatibleMembershipTypeIds)
+                        .where('periodId', put.periodId)
+                        .where('deletedAt', null)
+                        .first(false);
+
+                    if (incompatible) {
+                        if (incompatible.locked) {
+                            throw new SimpleError({
+                                code: 'invalid_field',
+                                field: 'membershipTypeId',
+                                message: 'Incompatible locked membership type',
+                                human: $t('%Zd1'),
+                            });
+                        }
+                        if (incompatible.generated) {
+                            throw new SimpleError({
+                                code: 'invalid_field',
+                                field: 'membershipTypeId',
+                                message: 'Incompatible generated membership type',
+                                human: $t('%Zcx'),
+                            });
+                        }
+                        throw new SimpleError({
+                            code: 'invalid_field',
+                            field: 'membershipTypeId',
+                            message: 'Incompatible membership type',
+                            human: $t('%ZdA'),
+                        });
+                    }
+                }
+
                 // Check duplicate memberships after correcting the dates
                 const existing = await MemberPlatformMembership.select()
                     .where('memberId', member.id)
                     .where('membershipTypeId', put.membershipTypeId)
                     .where('periodId', put.periodId)
                     .where('deletedAt', null)
-                    .where(
-                        SQL.where(
-                            SQL.where('startDate', SQLWhereSign.LessEqual, put.startDate)
-                                .and('endDate', SQLWhereSign.GreaterEqual, put.startDate),
-                        )
-                            .or(
-                                SQL.where('startDate', SQLWhereSign.LessEqual, put.endDate)
-                                    .and('endDate', SQLWhereSign.GreaterEqual, put.endDate),
-                            )
-                            .or(
-                                SQL.where('startDate', SQLWhereSign.GreaterEqual, put.startDate)
-                                    .and('endDate', SQLWhereSign.LessEqual, put.endDate),
-                            ),
-                    )
+                    .where(membershipDateRangeOverlaps(put.startDate, put.endDate))
                     .first(false);
 
                 if (existing && (membershipType.behaviour === PlatformMembershipTypeBehaviour.Days || !existing.generated || existing.locked || existing.price < membership.price)) {

package/src/endpoints/global/registration/RegisterMembersEndpoint.test.ts

@@ -240,6 +240,53 @@ describe('Endpoint.RegisterMembers', () => {
             ]);
         });
 
+        test('Should pay a balance item that is due soon (dueAt in the near future)', async () => {
+            const { member, user, organization, token } = await initData();
+
+            // Items that are due within 7 days are part of the outstanding balance, so a member
+            // can pay them before their due date.
+            const dueAt = new Date(new Date().getTime() + 3 * 24 * 60 * 60 * 1000);
+
+            const balanceItem1 = await new BalanceItemFactory({
+                organizationId: organization.id,
+                memberId: member.id,
+                userId: user.id,
+                type: BalanceItemType.Registration,
+                amount: 10,
+                unitPrice: 200,
+                dueAt,
+                status: BalanceItemStatus.Due,
+            }).create();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [],
+                    balanceItems: [
+                        BalanceItemCartItem.create({
+                            item: balanceItem1.getStructure(),
+                            price: 2000,
+                        }),
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 2000,
+                customer: null,
+            });
+
+            const response = await post(body, organization, token);
+
+            // The member really has to pay it: it must be part of the payment
+            expect(response.body.payment).not.toBeNull();
+            expect(response.body.payment!.price).toBe(2000);
+
+            // Point of sale isn't paid right away, but the amount is pending in the payment
+            await balanceItem1.refresh();
+            expect(balanceItem1.pricePending).toBe(2000);
+        });
+
         test('Should fail if balance item deleted', async () => {
             const { member, user, organization, token } = await initData();
 
@@ -960,17 +1007,120 @@ describe('Endpoint.RegisterMembers', () => {
                 // assert
                 expect(response.body).toBeDefined();
                 expect(response.body.registrations.length).toBe(1);
+                // Nothing is due during a trial, but the registration should still be activated
+                // (marked valid) so it is visible in the registration lists and member portal.
+                expect(response.body.registrations[0]).toMatchObject({
+                    registeredAt: expect.any(Date),
+                    deactivatedAt: null,
+                });
+                const dbRegistration = await Registration.getByID(response.body.registrations[0].id);
+                expect(dbRegistration?.registeredAt).not.toBeNull();
+                expect(dbRegistration?.deactivatedAt).toBeNull();
                 const trialUntil = response.body.registrations[0].trialUntil;
                 expect(trialUntil).not.toBeNull();
                 // 2023-05-14
                 expect(trialUntil!.getFullYear()).toBe(2023);
                 expect(trialUntil!.getMonth()).toBe(4);
                 expect(trialUntil!.getDate()).toBe(19);
+
+                // Nothing is paid during the trial, but the balance item should be due (not hidden)
+                // so it is still billed once the trial ends.
+                const balanceItems = await BalanceItem.where({ registrationId: dbRegistration!.id });
+                expect(balanceItems.length).toBe(1);
+                expect(balanceItems[0]).toMatchObject({
+                    status: BalanceItemStatus.Due,
+                    dueAt: dbRegistration!.trialUntil,
+                    pricePaid: 0,
+                });
             } finally {
                 vitest.useRealTimers();
             }
         }, 20_00000);
 
+        test('A trial registration is activated immediately, while a paid registration in the same cart waits for the online payment', async () => {
+            // #region arrange
+            const { member, group, groupPrice, organization, token } = await initData();
+            await initPayconiq({ organization });
+
+            // The trial group also limits its members, so a reservedUntil is set and has to be cleared again
+            group.settings.trialDays = 5;
+            group.settings.maxMembers = 1;
+            await group.save();
+
+            const paidGroup = await new GroupFactory({
+                organization,
+                price: 1500,
+                maxMembers: 1,
+            }).create();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                            trial: true,
+                        }),
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            groupPrice: paidGroup.settings.prices[0],
+                            organizationId: organization.id,
+                            groupId: paidGroup.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                }),
+                paymentMethod: PaymentMethod.Payconiq,
+                redirectUrl: new URL('https://www.example.com'),
+                cancelUrl: new URL('https://www.example.com'),
+                // Only the non-trial registration has to be paid now
+                totalPrice: 1500,
+            });
+            // #endregion
+
+            // act
+            const response = await post(body, organization, token);
+
+            // assert
+            expect(response.body.registrations.length).toBe(2);
+            expect(response.body.paymentUrl).toMatch(/payconiq-checkout\.test/);
+
+            // The trial is free, so it is activated right away and its reservation is released
+            const trialRegistration = response.body.registrations.find(r => r.group.id === group.id)!;
+            expect(trialRegistration).toMatchObject({
+                registeredAt: expect.any(Date),
+                deactivatedAt: null,
+                reservedUntil: null,
+                trialUntil: expect.any(Date),
+            });
+
+            const trialBalanceItems = await BalanceItem.where({ registrationId: trialRegistration.id });
+            expect(trialBalanceItems.length).toBe(1);
+            expect(trialBalanceItems[0]).toMatchObject({
+                status: BalanceItemStatus.Due,
+                pricePaid: 0,
+            });
+
+            // The paid registration is not activated: it still waits for the online payment
+            const paidRegistration = response.body.registrations.find(r => r.group.id === paidGroup.id)!;
+            expect(paidRegistration).toMatchObject({
+                registeredAt: null,
+                deactivatedAt: null,
+                reservedUntil: expect.any(Date),
+            });
+
+            await group.refresh();
+            expect(group.settings.registeredMembers).toBe(1);
+            expect(group.settings.reservedMembers).toBe(0);
+
+            await paidGroup.refresh();
+            expect(paidGroup.settings.registeredMembers).toBe(0);
+            expect(paidGroup.settings.reservedMembers).toBe(1);
+        });
+
         test('Should update group stock reservations', async () => {
             // #region arrange
             const { organization, group, groupPrice, token, member } = await initData();

package/src/endpoints/global/registration/RegisterMembersEndpoint.ts

@@ -835,9 +835,10 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             const mappedBalanceItems = new Map<BalanceItem, number>();
 
             for (const item of createdBalanceItems) {
-                if (item.dueAt === null) {
-                    mappedBalanceItems.set(item, item.price);
-                }
+                // Items that aren't due yet (the trial period) are not paid now, so they are passed
+                // along with an amount of 0: createPayment keeps them out of the payment itself, but
+                // does mark them due + valid (which activates the registration).
+                mappedBalanceItems.set(item, item.dueAt !== null ? 0 : item.price);
             }
 
             for (const item of checkout.cart.balanceItems) {