@stamhoofd/backend 2.74.0 → 2.75.1

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

@@ -1,6 +1,7 @@
 import { Request } from '@simonbackx/simple-endpoints';
-import { Group, GroupFactory, MemberFactory, MemberWithRegistrations, Organization, OrganizationFactory, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, User, UserFactory } from '@stamhoofd/models';
-import { GroupPrice, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, PayconiqAccount, PaymentMethod, PermissionLevel, Permissions, Version } from '@stamhoofd/structures';
+import { Email } from '@stamhoofd/email';
+import { BalanceItemFactory, Group, GroupFactory, MemberFactory, MemberWithRegistrations, Organization, OrganizationFactory, Registration, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
+import { BalanceItemCartItem, BalanceItemType, Company, GroupOption, GroupOptionMenu, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, OrganizationPackages, PayconiqAccount, PaymentCustomer, PaymentMethod, PermissionLevel, Permissions, ReduceablePrice, RegisterItemOption, STPackageStatus, STPackageType, UserPermissions, Version } from '@stamhoofd/structures';
 import nock from 'nock';
 import { v4 as uuidv4 } from 'uuid';
 import { testServer } from '../../../../tests/helpers/TestServer';
@@ -12,17 +13,9 @@ describe('Endpoint.RegisterMembers', () => {
     // #region global
     const endpoint = new RegisterMembersEndpoint();
     let period: RegistrationPeriod;
-    let organization: Organization;
-    let user: User;
-    let token: Token;
-    let member: MemberWithRegistrations;
-    let group1: Group;
-    let groupPrice1: GroupPrice;
-    let group2: Group;
-    let groupPrice2: GroupPrice;
 
     // #region helpers
-    const post = async (body: IDRegisterCheckout) => {
+    const post = async (body: IDRegisterCheckout, organization: Organization, token: Token) => {
         const request = Request.buildJson('POST', baseUrl, organization.getApiHost(), body);
         request.headers.authorization = 'Bearer ' + token.accessToken;
         return await testServer.test(endpoint, request);
@@ -32,54 +25,162 @@ describe('Endpoint.RegisterMembers', () => {
     // #endregion
 
     beforeAll(async () => {
-        period = await new RegistrationPeriodFactory({}).create();
-        organization = await new OrganizationFactory({ period }).create();
-        organization.meta.registrationPaymentConfiguration.paymentMethods = [PaymentMethod.PointOfSale, PaymentMethod.Payconiq];
-
-        organization.privateMeta.payconiqAccounts = [PayconiqAccount.create({
-            id: uuidv4(),
-            apiKey: 'test',
-            merchantId: 'test',
-            profileId: 'test',
-            name: 'test',
-            iban: 'BE56587127952688', // = random IBAN
-            callbackUrl: 'https://example.com',
-        })];
-
-        user = await new UserFactory({
+        const previousPeriod = await new RegistrationPeriodFactory({
+            startDate: new Date(2022, 0, 1),
+            endDate: new Date(2022, 11, 31),
+        }).create();
+
+        period = await new RegistrationPeriodFactory({
+            startDate: new Date(2023, 0, 1),
+            endDate: new Date(2023, 11, 31),
+        }).create();
+
+        period.previousPeriodId = previousPeriod.id;
+        await period.save();
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    const initOrganization = async (registrationPeriod: RegistrationPeriod = period) => {
+        return await new OrganizationFactory({ period: registrationPeriod })
+            .create();
+    };
+
+    const initData = async ({ otherMemberAmount = 0, permissionLevel = PermissionLevel.Full }: { otherMemberAmount?: number; permissionLevel?: PermissionLevel } = {}) => {
+        const organization = await initOrganization(period);
+
+        const user = await new UserFactory({
             organization,
             permissions: Permissions.create({
-                level: PermissionLevel.Full,
+                level: permissionLevel,
             }),
-        }).create();
-        token = await Token.createToken(user);
-        member = await new MemberFactory({ organization, user }).create();
-    });
+        })
+            .create();
 
-    beforeEach(async () => {
-        // #region groups
-        group1 = await new GroupFactory({
+        const token = await Token.createToken(user);
+
+        const member = await new MemberFactory({ organization, user })
+            .create();
+
+        const otherMembers: MemberWithRegistrations[] = [];
+
+        for (let i = 0; i < otherMemberAmount; i++) {
+            otherMembers.push(await new MemberFactory({ organization, user })
+                .create());
+        }
+
+        const group = await new GroupFactory({
             organization,
             price: 25,
             stock: 5,
-        }).create();
+        })
+            .create();
 
-        groupPrice1 = group1.settings.prices[0];
+        const groupPrice = group.settings.prices[0];
 
-        group2 = await new GroupFactory({
+        return {
             organization,
-            price: 15,
-            stock: 4,
-            maxMembers: 1,
-        }).create();
+            user,
+            token,
+            member,
+            otherMembers,
+            group,
+            groupPrice,
+        };
+    };
 
-        groupPrice2 = group2.settings.prices[0];
-        // #endregion
-    });
+    describe('Register', () => {
+        test('Should fail if cannot manage finances', async () => {
+            // #region arrange
+            const { member, group, groupPrice, organization, token } = await initData();
+            const organization2 = await initOrganization();
+
+            const registration = await new RegistrationFactory({
+                member,
+                group,
+                groupPrice,
+            }).create();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [registration.id],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 5,
+                asOrganizationId: organization2.id,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow('No permission to register as this organization for a different organization');
+            // #endregion
+        });
 
-    describe('Register member', () => {
-        test('Should update registered mmebers', async () => {
+        test('Should fail if demo limit reached', async () => {
             // #region arrange
+            (STAMHOOFD.userMode as string) = 'organization';
+
+            const spySendWebmaster = jest.spyOn(Email, 'sendWebmaster').mockImplementation(() => {
+                // do nothing
+            });
+
+            const { member, group, groupPrice, organization, token, otherMembers } = await initData({ otherMemberAmount: 10 });
+
+            organization.meta.packages = OrganizationPackages.create({
+                packages: new Map([
+                    [STPackageType.TrialMembers, STPackageStatus.create({
+                        startDate: new Date(),
+                    })],
+                ]),
+            });
+
+            for (const member of otherMembers) {
+                const body = IDRegisterCheckout.create({
+                    cart: IDRegisterCart.create({
+                        items: [
+                            IDRegisterItem.create({
+                                id: uuidv4(),
+                                replaceRegistrationIds: [],
+                                options: [],
+                                groupPrice,
+                                organizationId: organization.id,
+                                groupId: group.id,
+                                memberId: member.id,
+                            }),
+                        ],
+                        balanceItems: [],
+                        deleteRegistrationIds: [],
+                    }),
+                    administrationFee: 0,
+                    freeContribution: 0,
+                    paymentMethod: PaymentMethod.PointOfSale,
+                    totalPrice: 25,
+                    asOrganizationId: organization.id,
+                    customer: null,
+                });
+
+                await post(body, organization, token);
+            }
+
             const body = IDRegisterCheckout.create({
                 cart: IDRegisterCart.create({
                     items: [
@@ -87,9 +188,9 @@ describe('Endpoint.RegisterMembers', () => {
                             id: uuidv4(),
                             replaceRegistrationIds: [],
                             options: [],
-                            groupPrice: groupPrice1,
+                            groupPrice,
                             organizationId: organization.id,
-                            groupId: group1.id,
+                            groupId: group.id,
                             memberId: member.id,
                         }),
                     ],
@@ -105,30 +206,1665 @@ describe('Endpoint.RegisterMembers', () => {
             });
             // #endregion
 
-            // act
-            const response = await post(body);
+            // #region act and assert
 
-            // assert
-            expect(response.body).toBeDefined();
-            expect(response.body.registrations.length).toBe(1);
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow('Too many e-mails limited');
+
+            expect(spySendWebmaster).toHaveBeenCalledOnce();
+            // #endregion
+
+            (STAMHOOFD.userMode as string) = 'platform';
+        });
+
+        test('Should fail if balance items changed', async () => {
+            // #region arrange
+            const { member, group, user, groupPrice, organization, token } = await initData();
+
+            const balanceItem1 = await new BalanceItemFactory({
+                organizationId: organization.id,
+                memberId: member.id,
+                userId: user.id,
+                payingOrganizationId: organization.id,
+                type: BalanceItemType.Registration,
+                amount: 10,
+                unitPrice: 2,
+            }).create();
+
+            const cartItem = BalanceItemCartItem.create({
+                item: balanceItem1.getStructure(),
+                price: 20,
+            });
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                        cartItem,
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 45,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await balanceItem1.delete();
+
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Oeps, één of meerdere openstaande bedragen in jouw winkelmandje zijn aangepast'));
+            // #endregion
+        });
+
+        test('Should fail when pay balance item as organization', async () => {
+            // #region arrange
+            const { member, group, user, groupPrice, organization, token } = await initData();
+
+            const balanceItem1 = await new BalanceItemFactory({
+                organizationId: organization.id,
+                memberId: member.id,
+                userId: user.id,
+                payingOrganizationId: organization.id,
+                type: BalanceItemType.Registration,
+                amount: 10,
+                unitPrice: 2,
+            }).create();
+
+            const cartItem = BalanceItemCartItem.create({
+                item: balanceItem1.getStructure(),
+                price: 20,
+            });
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                        cartItem,
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 45,
+                asOrganizationId: organization.id,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Not possible to pay balance items as the organization'));
+            // #endregion
+        });
+
+        test('Should fail if has no write access for member', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token } = await initData();
+            const { member: member2 } = await initData();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member2.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('No permission to register this member'));
+            // #endregion
+        });
+
+        test('Should fail if empty cart', async () => {
+            // #region arrange
+            const { member, user, organization, token } = await initData();
+
+            const balanceItem1 = await new BalanceItemFactory({
+                organizationId: organization.id,
+                memberId: member.id,
+                userId: user.id,
+                payingOrganizationId: organization.id,
+                type: BalanceItemType.Registration,
+                amount: 10,
+                unitPrice: 2,
+            }).create();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 45,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await balanceItem1.delete();
+
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Oeps, jouw mandje is leeg.'));
+            // #endregion
+        });
+
+        test('Should fail if price changed', async () => {
+            // #region arrange
+            const { member, group, groupPrice, organization, token } = await initData();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 30,
+                asOrganizationId: organization.id,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Oeps! De prijs is gewijzigd terwijl je aan het afrekenen was'));
+            // #endregion
+        });
+
+        test('Should fail if member is already registered', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            // register first time
+            await post(body, organization, token);
+
+            // second time should fail
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Already registered'));
+            // #endregion
+        });
+
+        test('Should fail if duplicate registration in cart', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 50,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('duplicate_register_item'));
+            // #endregion
+        });
+
+        test('Should fail register by other organization if disabled by group', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member, user } = await initData();
+
+            const { organization: organization2 } = await initData();
+
+            user.permissions = UserPermissions.create({
+                organizationPermissions: new Map([
+                    [organization2.id, Permissions.create({
+                        level: PermissionLevel.Full,
+                    })],
+                ]),
+            });
+
+            await user.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                customer: null,
+                asOrganizationId: organization2.id,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('allowRegistrationsByOrganization disabled'));
+            // #endregion
+        });
+
+        test('Should fail if invalid payment', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.CreditCard,
+                totalPrice: 25,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Oeps, je hebt geen geldige betaalmethode geselecteerd'));
+            // #endregion
+        });
+
+        test('Should fail if no redirect url for online payment', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+            organization.meta.registrationPaymentConfiguration.paymentMethods.push(PaymentMethod.Bancontact);
+            await organization.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.Bancontact,
+                totalPrice: 25,
+                cancelUrl: new URL('https://www.stamhoofd.be'),
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('redirectUrl or cancelUrl is missing'));
+            // #endregion
+        });
+
+        test('Should fail if no cancel url for online payment', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+            organization.meta.registrationPaymentConfiguration.paymentMethods.push(PaymentMethod.Bancontact);
+            await organization.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.Bancontact,
+                totalPrice: 25,
+                redirectUrl: new URL('https://www.stamhoofd.be'),
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('redirectUrl or cancelUrl is missing'));
+            // #endregion
+        });
+
+        test('Should reserve if group has max members', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+            group.settings.maxMembers = 5;
+            await group.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+            });
+            // #endregion
+
+            // #region act and assert
+            const response = await post(body, organization, token);
+            expect(response.body.registrations.length).toBe(1);
+            expect(response.body.registrations[0].reservedUntil).not.toBeNull();
+            // #endregion
+        });
+
+        test('Should reuse existing registration', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member, user } = await initData();
+            group.settings.allowRegistrationsByOrganization = true;
+            await group.save();
+
+            user.permissions = UserPermissions.create({
+                organizationPermissions: new Map([
+                    [organization.id, Permissions.create({
+                        level: PermissionLevel.Full,
+                    })],
+                ]),
+            });
+
+            await user.save();
+
+            const group2 = await new GroupFactory({
+                organization,
+                price: 25,
+                stock: 5,
+            }).create();
+
+            const firstRegistration = await new RegistrationFactory({
+                member,
+                group: group2,
+                groupPrice: group2.settings.prices[0],
+            }).create();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [firstRegistration.id],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 0,
+                asOrganizationId: organization.id,
+            });
+
+            // #endregion
+
+            // #region act and assert
+            const response = await post(body, organization, token);
+            expect(response.body.registrations.length).toBe(1);
+            expect(response.body.registrations[0].id).toEqual(firstRegistration.id);
+            // #endregion
+        });
+
+        test('Should reuse recently deactivated registration', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member, user } = await initData();
+            group.settings.allowRegistrationsByOrganization = true;
+            await group.save();
+
+            user.permissions = UserPermissions.create({
+                organizationPermissions: new Map([
+                    [organization.id, Permissions.create({
+                        level: PermissionLevel.Full,
+                    })],
+                ]),
+            });
+
+            await user.save();
+
+            const firstRegistration = await new RegistrationFactory({
+                member,
+                group,
+                groupPrice,
+            }).create();
+
+            firstRegistration.deactivatedAt = new Date();
+            await firstRegistration.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                asOrganizationId: organization.id,
+            });
+
+            // #endregion
+
+            // #region act and assert
+            const response = await post(body, organization, token);
+            expect(response.body.registrations.length).toBe(1);
+            expect(response.body.registrations[0].id).toEqual(firstRegistration.id);
+            // #endregion
+        });
+
+        test('Should update registered members', async () => {
+            // #region arrange
+            const { member, group, groupPrice, organization, token } = await initData();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                asOrganizationId: organization.id,
+                customer: null,
+            });
+            // #endregion
+
+            // act
+            const response = await post(body, organization, token);
+
+            // assert
+            expect(response.body).toBeDefined();
+            expect(response.body.registrations.length).toBe(1);
+
+            const updatedGroup = await Group.getByID(group.id);
+            expect(updatedGroup!.settings.registeredMembers).toBe(1);
+            expect(updatedGroup!.settings.reservedMembers).toBe(0);
+        });
+
+        test('Should update reserved members', async () => {
+            // #region arrange
+            const { member, organization, token } = await initData();
+
+            organization.meta.registrationPaymentConfiguration.paymentMethods = [PaymentMethod.PointOfSale, PaymentMethod.Payconiq];
+
+            organization.privateMeta.payconiqAccounts = [PayconiqAccount.create({
+                id: uuidv4(),
+                apiKey: 'testKey',
+                merchantId: 'test',
+                profileId: 'test',
+                name: 'test',
+                iban: 'BE56587127952688', // = random IBAN
+                callbackUrl: 'https://www.example.com',
+            })];
+
+            await organization.save();
+
+            const group2 = await new GroupFactory({
+                organization,
+                price: 15,
+                stock: 4,
+                maxMembers: 1,
+            }).create();
+
+            const groupPrice2 = group2.settings.prices[0];
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice: groupPrice2,
+                            organizationId: organization.id,
+                            groupId: group2.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.Payconiq,
+                redirectUrl: new URL('https://www.example.com'),
+                cancelUrl: new URL('https://www.example.com'),
+                totalPrice: 15,
+                customer: null,
+            });
+
+            nock('https://api.ext.payconiq.com')
+                .post('/v3/payments')
+                .reply(200, {
+                    paymentId: 'testPaymentId',
+                    _links: {
+                        checkout: {
+                            href: 'https://www.example.com',
+                        },
+                    },
+                });
+            // #endregion
+
+            // act
+            const response = await post(body, organization, token);
+
+            // assert
+            expect(response.body).toBeDefined();
+            expect(response.body.registrations.length).toBe(1);
+
+            const updatedGroup = await Group.getByID(group2.id);
+            expect(updatedGroup!.settings.registeredMembers).toBe(0);
+            expect(updatedGroup!.settings.reservedMembers).toBe(1);
+        });
+
+        test('Register for group with trial should set trail period', async () => {
+            // #region arrange
+            const date = new Date('2023-05-14');
+            jest.useFakeTimers().setSystemTime(date);
+
+            try {
+                const { member, group, groupPrice, organization, token } = await initData();
+                group.settings.trialDays = 5;
+                await group.save();
+
+                const body = IDRegisterCheckout.create({
+                    cart: IDRegisterCart.create({
+                        items: [
+                            IDRegisterItem.create({
+                                id: uuidv4(),
+                                replaceRegistrationIds: [],
+                                options: [],
+                                groupPrice: groupPrice,
+                                organizationId: organization.id,
+                                groupId: group.id,
+                                memberId: member.id,
+                                trial: true,
+                            }),
+                        ],
+                        balanceItems: [],
+                        deleteRegistrationIds: [],
+                    }),
+                    administrationFee: 0,
+                    freeContribution: 0,
+                    paymentMethod: PaymentMethod.PointOfSale,
+                    totalPrice: 0,
+                    asOrganizationId: organization.id,
+                    customer: null,
+                });
+                // #endregion
+
+                // act
+                const response = await post(body, organization, token);
+
+                // assert
+                expect(response.body).toBeDefined();
+                expect(response.body.registrations.length).toBe(1);
+                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);
+            }
+            finally {
+                jest.useFakeTimers().resetAllMocks();
+            }
+        });
+
+        test('Should update group stock reservations', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+            groupPrice.stock = 5;
+            await group.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                asOrganizationId: organization.id,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            expect(group?.stockReservations.length).toBe(0);
+
+            await post(body, organization, token);
+
+            const updatedGroup = await Group.getByID(group.id);
+            expect(updatedGroup?.stockReservations.length).toBe(1);
+            // #endregion
+        });
+
+        test('Should fail if group price stock sold out', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member, otherMembers } = await initData({
+                permissionLevel: PermissionLevel.Read, otherMemberAmount: 3 });
+            groupPrice.stock = 2;
+            await group.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                        ...otherMembers.map(m => IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: m.id,
+                        })),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 75,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            expect(group?.stockReservations.length).toBe(0);
+
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Maximum reached'));
+            // #endregion
+        });
+
+        test('Should fail if option stock sold out', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+
+            const option1 = GroupOption.create({
+                name: 'option 1',
+                stock: 4,
+                price: ReduceablePrice.create({
+                    price: 5,
+                    reducedPrice: 3,
+                }),
+            });
+
+            const option2 = GroupOption.create({
+                name: 'option 2',
+                stock: 4,
+                price: ReduceablePrice.create({
+                    price: 3,
+                    reducedPrice: 1,
+                }),
+            });
+
+            const optionMenu = GroupOptionMenu.create({
+                name: 'option menu 1',
+                multipleChoice: true,
+                options: [option1, option2],
+            });
+
+            group.settings.optionMenus = [
+                optionMenu,
+            ];
+
+            await group.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [
+                                RegisterItemOption.create({
+                                    option: option1,
+                                    amount: 2,
+                                    optionMenu,
+                                }),
+                                RegisterItemOption.create({
+                                    option: option2,
+                                    amount: 5,
+                                    optionMenu,
+                                }),
+                            ],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 50,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Stock empty'));
+            // #endregion
+        });
+
+        test('Should fail if max option exceeded', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+
+            const option1 = GroupOption.create({
+                name: 'option 1',
+                stock: 4,
+                maximum: 5,
+                allowAmount: true,
+                price: ReduceablePrice.create({
+                    price: 5,
+                    reducedPrice: 3,
+                }),
+            });
+
+            const option2 = GroupOption.create({
+                name: 'option 2',
+                stock: 5,
+                maximum: 2,
+                allowAmount: true,
+                price: ReduceablePrice.create({
+                    price: 3,
+                    reducedPrice: 1,
+                }),
+            });
+
+            const optionMenu = GroupOptionMenu.create({
+                name: 'option menu 1',
+                multipleChoice: true,
+                options: [option1, option2],
+            });
+
+            group.settings.optionMenus = [
+                optionMenu,
+            ];
+
+            await group.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [
+                                RegisterItemOption.create({
+                                    option: option1,
+                                    amount: 2,
+                                    optionMenu,
+                                }),
+                                RegisterItemOption.create({
+                                    option: option2,
+                                    amount: 5,
+                                    optionMenu,
+                                }),
+                            ],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 50,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Option maximum exceeded'));
+            // #endregion
+        });
+
+        test('Should not fail if max option not exceeded', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+
+            const option1 = GroupOption.create({
+                name: 'option 1',
+                stock: 4,
+                maximum: 5,
+                allowAmount: true,
+                price: ReduceablePrice.create({
+                    price: 5,
+                    reducedPrice: 3,
+                }),
+            });
+
+            const option2 = GroupOption.create({
+                name: 'option 2',
+                stock: 5,
+                maximum: 5,
+                allowAmount: true,
+                price: ReduceablePrice.create({
+                    price: 3,
+                    reducedPrice: 1,
+                }),
+            });
+
+            const optionMenu = GroupOptionMenu.create({
+                name: 'option menu 1',
+                multipleChoice: true,
+                options: [option1, option2],
+            });
+
+            group.settings.optionMenus = [
+                optionMenu,
+            ];
+
+            await group.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [
+                                RegisterItemOption.create({
+                                    option: option1,
+                                    amount: 2,
+                                    optionMenu,
+                                }),
+                                RegisterItemOption.create({
+                                    option: option2,
+                                    amount: 5,
+                                    optionMenu,
+                                }),
+                            ],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 50,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            const result = await post(body, organization, token);
+            expect(result).toBeDefined();
+            // #endregion
+        });
+    });
+
+    describe('Register by other organization', () => {
+        test('Should fail if disabled by group', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member, user } = await initData();
+
+            const { organization: organization2 } = await initData();
+
+            user.permissions = UserPermissions.create({
+                organizationPermissions: new Map([
+                    [organization2.id, Permissions.create({
+                        level: PermissionLevel.Full,
+                    })],
+                ]),
+            });
+
+            await user.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                customer: null,
+                asOrganizationId: organization2.id,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('allowRegistrationsByOrganization disabled'));
+            // #endregion
+        });
+
+        test('Should fail if no customer', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member, user } = await initData();
+            group.settings.allowRegistrationsByOrganization = true;
+            await group.save();
+
+            const { organization: organization2 } = await initData();
+
+            user.permissions = UserPermissions.create({
+                organizationPermissions: new Map([
+                    [organization2.id, Permissions.create({
+                        level: PermissionLevel.Full,
+                    })],
+                ]),
+            });
+
+            await user.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                customer: null,
+                asOrganizationId: organization2.id,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('customer is required when paying as an organization'));
+            // #endregion
+        });
+
+        test('Should fail if no company on customer', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member, user } = await initData();
+            group.settings.allowRegistrationsByOrganization = true;
+            await group.save();
+
+            const { organization: organization2 } = await initData();
+
+            user.permissions = UserPermissions.create({
+                organizationPermissions: new Map([
+                    [organization2.id, Permissions.create({
+                        level: PermissionLevel.Full,
+                    })],
+                ]),
+            });
+
+            await user.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                customer: PaymentCustomer.create({
+                    company: null,
+                }),
+                asOrganizationId: organization2.id,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('customer.company is required'));
+            // #endregion
+        });
+
+        test('Should fail if company does not exist on organization', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member, user } = await initData();
+            group.settings.allowRegistrationsByOrganization = true;
+            await group.save();
+
+            const { organization: organization2 } = await initData();
+
+            user.permissions = UserPermissions.create({
+                organizationPermissions: new Map([
+                    [organization2.id, Permissions.create({
+                        level: PermissionLevel.Full,
+                    })],
+                ]),
+            });
+
+            await user.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                customer: PaymentCustomer.create({
+                    company: Company.create({
+                        name: 'test company',
+                    }),
+                }),
+                asOrganizationId: organization2.id,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Oeps, de facturatiegegevens die je probeerde te selecteren lijken niet meer te bestaan.'));
+            // #endregion
+        });
+
+        test('Should set paying organization id', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member, user } = await initData();
+            group.settings.allowRegistrationsByOrganization = true;
+            await group.save();
+
+            const { organization: organization2 } = await initData();
+            const company = Company.create({
+                name: 'test company',
+            });
+
+            organization2.meta.companies.push(company);
+            await organization2.save();
+
+            user.permissions = UserPermissions.create({
+                organizationPermissions: new Map([
+                    [organization2.id, Permissions.create({
+                        level: PermissionLevel.Full,
+                    })],
+                ]),
+            });
+
+            await user.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                customer: PaymentCustomer.create({
+                    company,
+                }),
+                asOrganizationId: organization2.id,
+            });
+            // #endregion
+
+            // #region act and assert
+            const response = await post(body, organization, token);
+            expect(response.body.registrations.length).toBe(1);
+            expect(response.body.registrations[0].payingOrganizationId).toEqual(organization2.id);
+            // #endregion
+        });
+    });
+
+    describe('Replace registrations', () => {
+        test('Should update registered members', async () => {
+            // #region arrange
+            const { organization, group: group1, groupPrice: groupPrice1, token, member } = await initData();
+
+            const registration = await new RegistrationFactory({
+                member,
+                group: group1,
+                groupPrice: groupPrice1,
+            })
+                .create();
+
+            const group = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5,
+            }).create();
+
+            const groupPrice = group.settings.prices[0];
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [registration.id],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 5,
+                asOrganizationId: organization.id,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+
+            // update occupancy to be sure occupancy is 1
+            await group1.updateOccupancy();
+            expect(group1.settings.registeredMembers).toBe(1);
+
+            // send request and check occupancy
+            const response = await post(body, organization, token);
+
+            expect(response.body).toBeDefined();
+            expect(response.body.registrations.length).toBe(1);
+
+            const updatedGroup = await Group.getByID(group.id);
+            expect(updatedGroup!.settings.registeredMembers).toBe(1);
+            expect(updatedGroup!.settings.reservedMembers).toBe(0);
+
+            const updatedGroup1After = await Group.getByID(group1.id);
+            // occupancy should go from 1 to 0 because the registration should be replaced
+            expect(updatedGroup1After!.settings.registeredMembers).toBe(0);
+            expect(updatedGroup1After!.settings.reservedMembers).toBe(0);
+            // #endregion
+        });
+
+        test('Should set paid as organization on new registration', async () => {
+            // #region arrange
+            const { organization, group: group1, groupPrice: groupPrice1, token, member, user } = await initData();
+
+            group1.settings.allowRegistrationsByOrganization = true;
+            await group1.save();
+            const organization2 = await initOrganization();
+
+            user.permissions = UserPermissions.create({
+                organizationPermissions: new Map([
+                    [organization2.id, Permissions.create({
+                        level: PermissionLevel.Full,
+                    })],
+                    [organization.id, Permissions.create({
+                        level: PermissionLevel.Full,
+                    })],
+                ]),
+            });
+
+            await user.save();
+
+            const company = Company.create({
+                name: 'test company',
+            });
+
+            organization2.meta.companies.push(company);
+            await organization2.save();
+
+            organization.meta.companies.push(company);
+            await organization.save();
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice: groupPrice1,
+                            organizationId: organization.id,
+                            groupId: group1.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                asOrganizationId: organization2.id,
+                customer: PaymentCustomer.create({
+                    company,
+                }),
+            });
+
+            const response1 = await post(body, organization, token);
+            const registration = response1.body.registrations[0];
+            expect(registration).toBeDefined();
+
+            const group = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5,
+            }).create();
+
+            const groupPrice = group.settings.prices[0];
+
+            const body2 = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [registration.id],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 30,
+                asOrganizationId: organization.id,
+                customer: PaymentCustomer.create({
+                    company,
+                }),
+            });
+            // #endregion
+
+            // #region act and assert
+            const response = await post(body2, organization, token);
+
+            expect(response.body).toBeDefined();
+            expect(response.body.registrations.length).toBe(1);
+
+            // the payingOrganizationId should equal the id of the paying organization of the replaced registration
+            expect(response.body.registrations[0].payingOrganizationId).toEqual(organization2.id);
+            // #endregion
+        });
+
+        test('Replace registration by registration of other member should fail', async () => {
+            // #region arrange
+            const { organization, group: group1, groupPrice: groupPrice1, token, member, otherMembers: [member2] } = await initData({ otherMemberAmount: 1 });
+
+            const registration = await new RegistrationFactory({
+                member: member2,
+                group: group1,
+                groupPrice: groupPrice1,
+            })
+                .create();
+
+            const group = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5,
+            }).create();
+
+            const groupPrice = group.settings.prices[0];
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [registration.id],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 5,
+                asOrganizationId: organization.id,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Registration not found'));
+            // #endregion
+        });
+
+        test('Move registration should fail if admin of same organization', async () => {
+            // #region arrange
+            const { organization, group: group1, groupPrice: groupPrice1, token, member } = await initData();
+
+            const registration = await new RegistrationFactory({
+                member,
+                group: group1,
+                groupPrice: groupPrice1,
+            })
+                .create();
+
+            const group = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5,
+            }).create();
 
-            const updatedGroup = await Group.getByID(group1.id);
-            expect(updatedGroup!.settings.registeredMembers).toBe(1);
-            expect(updatedGroup!.settings.reservedMembers).toBe(0);
-        });
+            const groupPrice = group.settings.prices[0];
 
-        test('Should update reserved members', async () => {
-            // #region arrange
             const body = IDRegisterCheckout.create({
                 cart: IDRegisterCart.create({
                     items: [
                         IDRegisterItem.create({
                             id: uuidv4(),
-                            replaceRegistrationIds: [],
+                            replaceRegistrationIds: [registration.id],
                             options: [],
-                            groupPrice: groupPrice2,
+                            groupPrice,
                             organizationId: organization.id,
-                            groupId: group2.id,
+                            groupId: group.id,
                             memberId: member.id,
                         }),
                     ],
@@ -137,41 +1873,26 @@ describe('Endpoint.RegisterMembers', () => {
                 }),
                 administrationFee: 0,
                 freeContribution: 0,
-                paymentMethod: PaymentMethod.Payconiq,
-                redirectUrl: new URL('https://www.example.com'),
-                cancelUrl: new URL('https://www.example.com'),
-                totalPrice: 15,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 5,
                 customer: null,
             });
-
-            nock('https://api.ext.payconiq.com')
-                .post('/v3/payments')
-                .reply(200, {
-                    paymentId: 'testPaymentId',
-                    _links: {
-                        checkout: {
-                            href: 'https://www.example.com',
-                        },
-                    },
-                });
             // #endregion
 
-            // act
-            const response = await post(body);
+            // #region act and assert
 
-            // assert
-            expect(response.body).toBeDefined();
-            expect(response.body.registrations.length).toBe(1);
+            // send request and check occupancy
+            await expect(async () => await post(body, organization, token)).rejects.toThrow('Not allowed to move registrations');
 
-            const updatedGroup = await Group.getByID(group2.id);
-            expect(updatedGroup!.settings.registeredMembers).toBe(0);
-            expect(updatedGroup!.settings.reservedMembers).toBe(1);
+            // #endregion
         });
     });
 
-    describe('Register member with replace registration', () => {
+    describe('Delete registrations', () => {
         test('Should update registered members', async () => {
             // #region arrange
+            const { member, group: group1, groupPrice: groupPrice1, organization: organization1, token } = await initData();
+
             const registration = await new RegistrationFactory({
                 member,
                 group: group1,
@@ -180,7 +1901,7 @@ describe('Endpoint.RegisterMembers', () => {
                 .create();
 
             const group = await new GroupFactory({
-                organization,
+                organization: organization1,
                 price: 30,
                 stock: 5,
             }).create();
@@ -192,22 +1913,22 @@ describe('Endpoint.RegisterMembers', () => {
                     items: [
                         IDRegisterItem.create({
                             id: uuidv4(),
-                            replaceRegistrationIds: [registration.id],
+                            replaceRegistrationIds: [],
                             options: [],
                             groupPrice,
-                            organizationId: organization.id,
+                            organizationId: organization1.id,
                             groupId: group.id,
                             memberId: member.id,
                         }),
                     ],
                     balanceItems: [],
-                    deleteRegistrationIds: [],
+                    deleteRegistrationIds: [registration.id],
                 }),
                 administrationFee: 0,
                 freeContribution: 0,
                 paymentMethod: PaymentMethod.PointOfSale,
                 totalPrice: 5,
-                asOrganizationId: organization.id,
+                asOrganizationId: organization1.id,
                 customer: null,
             });
             // #endregion
@@ -219,7 +1940,7 @@ describe('Endpoint.RegisterMembers', () => {
             expect(group1.settings.registeredMembers).toBe(1);
 
             // send request and check occupancy
-            const response = await post(body);
+            const response = await post(body, organization1, token);
 
             expect(response.body).toBeDefined();
             expect(response.body.registrations.length).toBe(1);
@@ -229,7 +1950,7 @@ describe('Endpoint.RegisterMembers', () => {
             expect(updatedGroup!.settings.reservedMembers).toBe(0);
 
             const updatedGroup1After = await Group.getByID(group1.id);
-            // occupancy should go from 1 to 0 because the registration should be replaced
+            // occupancy should go from 1 to 0 because the registration should be deleted
             expect(updatedGroup1After!.settings.registeredMembers).toBe(0);
             expect(updatedGroup1After!.settings.reservedMembers).toBe(0);
             // #endregion
@@ -237,6 +1958,8 @@ describe('Endpoint.RegisterMembers', () => {
 
         test('Should throw error if with payment', async () => {
             // #region arrange
+            const { member, group: group1, groupPrice: groupPrice1, organization: organization1, token } = await initData();
+
             const registration = await new RegistrationFactory({
                 member,
                 group: group1,
@@ -245,7 +1968,7 @@ describe('Endpoint.RegisterMembers', () => {
                 .create();
 
             const group = await new GroupFactory({
-                organization,
+                organization: organization1,
                 price: 30,
                 stock: 5,
                 maxMembers: 1,
@@ -258,16 +1981,16 @@ describe('Endpoint.RegisterMembers', () => {
                     items: [
                         IDRegisterItem.create({
                             id: uuidv4(),
-                            replaceRegistrationIds: [registration.id],
+                            replaceRegistrationIds: [],
                             options: [],
                             groupPrice,
-                            organizationId: organization.id,
+                            organizationId: organization1.id,
                             groupId: group.id,
                             memberId: member.id,
                         }),
                     ],
                     balanceItems: [],
-                    deleteRegistrationIds: [],
+                    deleteRegistrationIds: [registration.id],
                 }),
                 administrationFee: 0,
                 freeContribution: 0,
@@ -285,20 +2008,19 @@ describe('Endpoint.RegisterMembers', () => {
             await group1.updateOccupancy();
             expect(group1.settings.registeredMembers).toBe(1);
 
-            await expect(async () => await post(body)).rejects.toThrow('Not allowed to move registrations');
+            await expect(async () => await post(body, organization1, token)).rejects.toThrow('Permission denied: you are not allowed to delete registrations');
             // #endregion
         });
-    });
 
-    describe('Register member with delete registration', () => {
-        test('Should update registered members', async () => {
+        test('Should deactivate registration', async () => {
             // #region arrange
+            const { member, group: group1, groupPrice: groupPrice1, organization, token } = await initData();
+
             const registration = await new RegistrationFactory({
                 member,
                 group: group1,
                 groupPrice: groupPrice1,
-            })
-                .create();
+            }).create();
 
             const group = await new GroupFactory({
                 organization,
@@ -334,45 +2056,107 @@ describe('Endpoint.RegisterMembers', () => {
             // #endregion
 
             // #region act and assert
+            await post(body, organization, token);
 
-            // update occupancy to be sure occupancy is 1
-            await group1.updateOccupancy();
-            expect(group1.settings.registeredMembers).toBe(1);
+            const updatedRegistration = await Registration.getByID(registration.id);
+            expect(updatedRegistration).toBeDefined();
+            expect(updatedRegistration!.deactivatedAt).not.toBe(null);
+            // #endregion
+        });
 
-            // send request and check occupancy
-            const response = await post(body);
+        test('Should fail if invalid cancelation fee', async () => {
+            for (const cancellationFeePercentage of [10001, -1]) {
+                // #region arrange
+                const { member, group: group1, groupPrice: groupPrice1, organization, token } = await initData();
 
-            expect(response.body).toBeDefined();
-            expect(response.body.registrations.length).toBe(1);
+                const body1 = IDRegisterCheckout.create({
+                    cart: IDRegisterCart.create({
+                        items: [
+                            IDRegisterItem.create({
+                                id: uuidv4(),
+                                replaceRegistrationIds: [],
+                                options: [],
+                                groupPrice: groupPrice1,
+                                organizationId: organization.id,
+                                groupId: group1.id,
+                                memberId: member.id,
+                            }),
+                        ],
+                        balanceItems: [],
+                        deleteRegistrationIds: [],
+                    }),
+                    administrationFee: 0,
+                    freeContribution: 0,
+                    paymentMethod: PaymentMethod.PointOfSale,
+                    totalPrice: 25,
+                    asOrganizationId: organization.id,
+                    customer: null,
+                });
 
-            const updatedGroup = await Group.getByID(group.id);
-            expect(updatedGroup!.settings.registeredMembers).toBe(1);
-            expect(updatedGroup!.settings.reservedMembers).toBe(0);
+                const group2 = await new GroupFactory({
+                    organization,
+                    price: 30,
+                    stock: 5,
+                }).create();
 
-            const updatedGroup1After = await Group.getByID(group1.id);
-            // occupancy should go from 1 to 0 because the registration should be deleted
-            expect(updatedGroup1After!.settings.registeredMembers).toBe(0);
-            expect(updatedGroup1After!.settings.reservedMembers).toBe(0);
+                const groupPrice2 = group2.settings.prices[0];
+
+                const firstResponse = await post(body1, organization, token);
+                expect(firstResponse).toBeDefined();
+                expect(firstResponse.body.registrations.length).toBe(1);
+                const registration = firstResponse.body.registrations[0];
+
+                const body2 = IDRegisterCheckout.create({
+                    cart: IDRegisterCart.create({
+                        items: [
+                            IDRegisterItem.create({
+                                id: uuidv4(),
+                                replaceRegistrationIds: [],
+                                options: [],
+                                groupPrice: groupPrice2,
+                                organizationId: organization.id,
+                                groupId: group2.id,
+                                memberId: member.id,
+                            }),
+                        ],
+                        balanceItems: [],
+                        deleteRegistrationIds: [registration.id],
+                    }),
+                    cancellationFeePercentage,
+                    administrationFee: 0,
+                    freeContribution: 0,
+                    paymentMethod: PaymentMethod.PointOfSale,
+                    totalPrice: 30,
+                    asOrganizationId: organization.id,
+                    customer: null,
+                });
+                // #endregion
+
+                // #region act and assert
+                await expect(async () => await post(body2, organization, token))
+                    .rejects
+                    .toThrow(new RegExp('Invalid cancellation fee percentage.'));
             // #endregion
+            }
         });
 
-        test('Should throw error if with payment', async () => {
+        test('Delete by member should fail if no permission to delete registration', async () => {
             // #region arrange
+            const { member, group: group1, groupPrice: groupPrice1, organization, token } = await initData();
+
             const registration = await new RegistrationFactory({
                 member,
                 group: group1,
                 groupPrice: groupPrice1,
-            })
-                .create();
+            }).create();
 
-            const group = await new GroupFactory({
+            const group2 = await new GroupFactory({
                 organization,
                 price: 30,
                 stock: 5,
-                maxMembers: 1,
             }).create();
 
-            const groupPrice = group.settings.prices[0];
+            const groupPrice = group2.settings.prices[0];
 
             const body = IDRegisterCheckout.create({
                 cart: IDRegisterCart.create({
@@ -383,7 +2167,7 @@ describe('Endpoint.RegisterMembers', () => {
                             options: [],
                             groupPrice,
                             organizationId: organization.id,
-                            groupId: group.id,
+                            groupId: group2.id,
                             memberId: member.id,
                         }),
                     ],
@@ -392,59 +2176,195 @@ describe('Endpoint.RegisterMembers', () => {
                 }),
                 administrationFee: 0,
                 freeContribution: 0,
-                paymentMethod: PaymentMethod.Payconiq,
-                redirectUrl: new URL('https://www.example.com'),
-                cancelUrl: new URL('https://www.example.com'),
+                paymentMethod: PaymentMethod.PointOfSale,
                 totalPrice: 5,
                 customer: null,
             });
             // #endregion
 
             // #region act and assert
+            await expect(async () => await post(body, organization, token))
+                .rejects
+                .toThrow(new RegExp('Permission denied: you are not allowed to delete registrations'));
+            // #endregion
+        });
 
-            // update occupancy to be sure occupancy is 1
-            await group1.updateOccupancy();
-            expect(group1.settings.registeredMembers).toBe(1);
+        test('Delete by organization should fail if no permission to delete registration', async () => {
+            // #region arrange
+            const { member, group: group1, groupPrice: groupPrice1, organization, token } = await initData({ permissionLevel: PermissionLevel.Read });
+
+            const registration = await new RegistrationFactory({
+                member,
+                group: group1,
+                groupPrice: groupPrice1,
+            }).create();
+
+            const group2 = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5,
+            }).create();
+
+            const groupPrice = group2.settings.prices[0];
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group2.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [registration.id],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 5,
+                customer: null,
+                asOrganizationId: organization.id,
+            });
+            // #endregion
 
-            await expect(async () => await post(body)).rejects.toThrow('Permission denied: you are not allowed to delete registrations');
+            // #region act and assert
+            await expect(async () => await post(body, organization, token)).rejects.toThrow(new RegExp('Je hebt geen toegangsrechten om deze inschrijving te verwijderen'));
             // #endregion
         });
-    });
 
-    it('Register member that is already registered should throw error', async () => {
-        // create existing registration
-        await new RegistrationFactory({
-            member,
-            group: group1,
-            groupPrice: groupPrice1,
-        })
-            .create();
+        test('Should fail if registration does not exist anymore', async () => {
+            // #region arrange
+            const { member, group: group1, groupPrice: groupPrice1, organization, token } = await initData();
 
-        // register again
-        const body = IDRegisterCheckout.create({
-            cart: IDRegisterCart.create({
-                items: [
-                    IDRegisterItem.create({
-                        id: uuidv4(),
-                        replaceRegistrationIds: [],
-                        options: [],
-                        groupPrice: groupPrice1,
-                        organizationId: organization.id,
-                        groupId: group1.id,
-                        memberId: member.id,
-                    }),
-                ],
-                balanceItems: [],
-                deleteRegistrationIds: [],
-            }),
-            administrationFee: 0,
-            freeContribution: 0,
-            paymentMethod: PaymentMethod.PointOfSale,
-            totalPrice: groupPrice1.price.price,
-            asOrganizationId: organization.id,
-            customer: null,
+            const registration = await new RegistrationFactory({
+                member,
+                group: group1,
+                groupPrice: groupPrice1,
+            }).create();
+
+            const group2 = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5,
+            }).create();
+
+            const groupPrice = group2.settings.prices[0];
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group2.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [registration.id],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 5,
+                customer: null,
+                asOrganizationId: organization.id,
+            });
+            // #endregion
+
+            // #region act and assert
+            await registration.delete();
+            await expect(async () => await post(body, organization, token)).rejects.toThrow(new RegExp('Registration not found'));
+            // #endregion
         });
 
-        await expect(async () => await post(body)).rejects.toThrow('Already registered');
+        test('Should fail if already deleted', async () => {
+            // #region arrange
+            const { member, group: group1, groupPrice: groupPrice1, organization, token } = await initData();
+
+            const registration = await new RegistrationFactory({
+                member,
+                group: group1,
+                groupPrice: groupPrice1,
+            }).create();
+
+            const group2 = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5,
+            }).create();
+
+            const groupPrice2 = group2.settings.prices[0];
+
+            const group3 = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5,
+            }).create();
+
+            const groupPrice3 = group3.settings.prices[0];
+
+            const body1 = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice: groupPrice2,
+                            organizationId: organization.id,
+                            groupId: group2.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [registration.id],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 5,
+                customer: null,
+                asOrganizationId: organization.id,
+            });
+
+            const body2 = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice: groupPrice3,
+                            organizationId: organization.id,
+                            groupId: group3.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [registration.id],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 5,
+                customer: null,
+                asOrganizationId: organization.id,
+            });
+            // #endregion
+
+            // #region act and assert
+            await post(body1, organization, token);
+            await expect(async () => await post(body2, organization, token)).rejects.toThrow(new RegExp('Oeps, één of meerdere inschrijvingen die je probeert te verwijderen was al verwijderd. Herlaad de pagina en probeer opnieuw'));
+            // #endregion
+        });
     });
 });