@stamhoofd/backend 2.75.0 → 2.75.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.75.0",
+    "version": "2.75.1",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -37,14 +37,14 @@
         "@simonbackx/simple-encoding": "2.20.0",
         "@simonbackx/simple-endpoints": "1.19.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.75.0",
-        "@stamhoofd/backend-middleware": "2.75.0",
-        "@stamhoofd/email": "2.75.0",
-        "@stamhoofd/models": "2.75.0",
-        "@stamhoofd/queues": "2.75.0",
-        "@stamhoofd/sql": "2.75.0",
-        "@stamhoofd/structures": "2.75.0",
-        "@stamhoofd/utility": "2.75.0",
+        "@stamhoofd/backend-i18n": "2.75.1",
+        "@stamhoofd/backend-middleware": "2.75.1",
+        "@stamhoofd/email": "2.75.1",
+        "@stamhoofd/models": "2.75.1",
+        "@stamhoofd/queues": "2.75.1",
+        "@stamhoofd/sql": "2.75.1",
+        "@stamhoofd/structures": "2.75.1",
+        "@stamhoofd/utility": "2.75.1",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -64,5 +64,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "4710a9386f9f489356e04518622cc83c5faa2bf1"
+    "gitHead": "4c6a7f14c62e4832885325d02c5aaeeccf27568b"
 }

package/src/endpoints/auth/OpenIDConnectStartEndpoint.ts

@@ -30,11 +30,6 @@ export class OpenIDConnectStartEndpoint extends Endpoint<Params, Query, Body, Re
         // Check webshop and/or organization
         await Context.setUserOrganizationScope();
         await Context.optionalAuthenticate({ allowWithoutAccount: false });
-        console.log('Full start connect body;', await request.request.body);
-
-        if (Context.user) {
-            console.log('User:', Context.user);
-        }
         const service = await SSOService.fromContext(request.body.provider);
         return await service.validateAndStartAuthCodeFlow(request.body);
     }

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

@@ -1,7 +1,7 @@
 import { Request } from '@simonbackx/simple-endpoints';
 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, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, OrganizationPackages, PayconiqAccount, PaymentCustomer, PaymentMethod, PermissionLevel, Permissions, STPackageStatus, STPackageType, UserPermissions, Version } from '@stamhoofd/structures';
+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';
@@ -1011,6 +1011,334 @@ describe('Endpoint.RegisterMembers', () => {
                 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', () => {

package/src/services/FileSignService.ts

@@ -87,24 +87,14 @@ export class FileSignService {
 
             file.signature = jws;
         };
-    }
-
-    static async fillSignedUrl(file: File, duration = 60 * 60) {
-        if (!file.isPrivate) {
-            if (file.signedUrl) {
-                console.error('Warning: public file has a signed url');
-                // this will not be encoded because of the file encode implementation
-            }
-            return;
-        }
 
-        // Only created signed urls for files that were generated by our own server
-        if (!await file.verify()) {
-            console.error('Failed to verify file:', file.id);
-            return;
-        }
+        File.getWithSignedUrl = async (file: File) => {
+            return this.withSignedUrl(file);
+        };
+    }
 
-        console.log('Signing file:', file.id);
+    static async withSignedUrl(file: File, duration = 60 * 60) {
+        console.log('Generating signed url:', file.id);
 
         if (file.signedUrl) {
             console.error('Warning: file already signed');
@@ -126,13 +116,13 @@ export class FileSignService {
         }
         catch (e) {
             console.error('Failed to sign file:', e);
-            return file;
+            return null;
         }
     }
 
     static async fillSignedUrlsForStruct(data: any) {
         if (data instanceof File) {
-            return await this.fillSignedUrl(data);
+            return (await data.withSignedUrl()) ?? undefined; // never return null if it fails because we'll want to use the original file in that case
         }
 
         if (Array.isArray(data)) {

package/src/services/SSOService.ts

@@ -81,7 +81,7 @@ export class SSOService {
         const platform = await Platform.getShared();
 
         const service = new SSOService({ provider, platform, organization, user: Context.user });
-        service.validate();
+        service.validateConfiguration();
 
         return service;
     }
@@ -138,11 +138,13 @@ export class SSOService {
         return loginConfiguration;
     }
 
-    validate() {
+    validateConfiguration() {
         // Validate configuration exists
         const _ = this.configuration;
         const __ = this.loginConfiguration;
+    }
 
+    validateUser() {
         if (this.user) {
             this.validateEmail(this.user.email);
         }
@@ -317,6 +319,9 @@ export class SSOService {
         const code_challenge = generators.codeChallenge(code_verifier);
         const expires = new Date(Date.now() + 1000 * 60 * 15);
 
+        // Validate user id
+        this.validateUser();
+
         const session: SSOSessionContext = {
             expires,
             code_verifier,

package/tests/e2e/register.test.ts

@@ -1,6 +1,6 @@
 import { Request } from '@simonbackx/simple-endpoints';
-import { BalanceItemFactory, GroupFactory, MemberFactory, MemberWithRegistrations, Organization, OrganizationFactory, OrganizationRegistrationPeriod, Platform, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
-import { AdministrationFeeSettings, BalanceItemCartItem, BalanceItemType, DefaultAgeGroup, FreeContributionSettings, GroupOption, GroupOptionMenu, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, PaymentMethod, PermissionLevel, Permissions, PlatformMembershipType, PlatformMembershipTypeConfig, ReceivableBalanceType, ReduceablePrice, RegisterItemOption, Version } from '@stamhoofd/structures';
+import { BalanceItemFactory, GroupFactory, MemberFactory, MemberWithRegistrations, Organization, OrganizationFactory, OrganizationRegistrationPeriod, Platform, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
+import { AdministrationFeeSettings, BalanceItemCartItem, BalanceItemStatus, BalanceItemType, BooleanStatus, DefaultAgeGroup, FreeContributionSettings, GroupOption, GroupOptionMenu, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, PaymentMethod, PermissionLevel, Permissions, PlatformMembershipType, PlatformMembershipTypeConfig, ReceivableBalanceType, ReduceablePrice, RegisterItemOption, Version } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from 'uuid';
 import { GetMemberFamilyEndpoint } from '../../src/endpoints/global/members/GetMemberFamilyEndpoint';
 import { RegisterMembersEndpoint } from '../../src/endpoints/global/registration/RegisterMembersEndpoint';
@@ -87,6 +87,7 @@ describe('E2E.Register', () => {
         const group = await new GroupFactory({
             organization,
             price: 25,
+            reducedPrice: 21,
             stock: 5,
         })
             .create();
@@ -152,10 +153,6 @@ describe('E2E.Register', () => {
             // #endregion
         });
 
-        // todo: test max option + allowAmount
-        // todo: test stock?
-        // todo: test reduced price?
-
         test('Should create balance items for options', async () => {
             // #region arrange
             const { organization, group, groupPrice, token, member } = await initData();
@@ -492,19 +489,195 @@ describe('E2E.Register', () => {
             ]));
             // #endregion
         });
+
+        test('Should apply reduced price if member requires financial support', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+            member.details.requiresFinancialSupport = BooleanStatus.create({
+                value: true,
+            });
+
+            await member.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: 21,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            const balanceBefore = await getBalance(member.id, organization, token);
+            expect(balanceBefore).toBeDefined();
+            expect(balanceBefore.body.length).toBe(0);
+
+            await register(body, organization, token);
+
+            const balance = await getBalance(member.id, organization, token);
+            expect(balance).toBeDefined();
+            expect(balance.body.length).toBe(1);
+            expect(balance.body[0].price).toBe(21);
+            expect(balance.body[0].pricePaid).toBe(0);
+            // #endregion
+        });
+
+        test('Should apply reduced price for options if member requires financial support', async () => {
+            // #region arrange
+            const { organization, group, groupPrice, token, member } = await initData();
+            member.details.requiresFinancialSupport = BooleanStatus.create({
+                value: true,
+            });
+
+            await member.save();
+
+            const option1 = GroupOption.create({
+                name: 'option 1',
+                price: ReduceablePrice.create({
+                    price: 5,
+                    reducedPrice: 3,
+                }),
+            });
+
+            const option2 = GroupOption.create({
+                name: 'option 2',
+                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: 32,
+                customer: null,
+            });
+            // #endregion
+
+            // #region act and assert
+            const balanceBefore = await getBalance(member.id, organization, token);
+            expect(balanceBefore).toBeDefined();
+            expect(balanceBefore.body.length).toBe(0);
+
+            await register(body, organization, token);
+
+            const balance = await getBalance(member.id, organization, token);
+            expect(balance).toBeDefined();
+            expect(balance.body.length).toBe(3);
+            expect.arrayContaining([
+                expect.objectContaining({
+                    price: 6,
+                    pricePaid: 0,
+                    status: BalanceItemStatus.Due,
+                }),
+                expect.objectContaining({
+                    price: 5,
+                    pricePaid: 0,
+                    status: BalanceItemStatus.Due,
+                }),
+                expect.objectContaining({
+                    price: 25,
+                    pricePaid: 0,
+                    status: BalanceItemStatus.Due,
+                }),
+            ]);
+            // #endregion
+        });
     });
 
     describe('Delete registrations', () => {
-        // todo: should include call to other endpoints?
-        test.skip('Should create negative balance items', async () => {
+        test('Should cancel balance item for deleted 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();
+            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,
+                customer: null,
+                asOrganizationId: organization.id,
+            });
+
+            const response1 = await register(body1, organization, token);
+            expect(response1.body).toBeDefined();
+            expect(response1.body.registrations.length).toBe(1);
+
+            const registrationToDelete = response1.body.registrations[0];
 
             const group = await new GroupFactory({
                 organization,
@@ -514,7 +687,7 @@ describe('E2E.Register', () => {
 
             const groupPrice = group.settings.prices[0];
 
-            const body = IDRegisterCheckout.create({
+            const body2 = IDRegisterCheckout.create({
                 cart: IDRegisterCart.create({
                     items: [
                         IDRegisterItem.create({
@@ -527,31 +700,293 @@ describe('E2E.Register', () => {
                             memberId: member.id,
                         }),
                     ],
-                    balanceItems: [],
-                    deleteRegistrationIds: [registration.id],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [registrationToDelete.id],
                 }),
                 administrationFee: 0,
                 freeContribution: 0,
                 paymentMethod: PaymentMethod.PointOfSale,
-                totalPrice: 5,
-                asOrganizationId: organization.id,
+                totalPrice: 30,
                 customer: null,
+                asOrganizationId: organization.id,
             });
             // #endregion
 
             // #region act and assert
-            const response = await register(body, organization, token);
+            const balanceBefore = await getBalance(member.id, organization, token);
+            expect(balanceBefore).toBeDefined();
+            expect(balanceBefore.body.length).toBe(1);
+            expect(balanceBefore.body[0].price).toBe(25);
+            expect(balanceBefore.body[0].pricePaid).toBe(0);
+
+            await register(body2, organization, token);
+
+            const balance = await getBalance(member.id, organization, token);
+            expect(balance).toBeDefined();
+            expect(balance.body.length).toBe(2);
 
-            throw new Error('not implemented');
+            expect.arrayContaining([
+                expect.objectContaining({
+                    price: 25,
+                    pricePaid: 0,
+                    status: BalanceItemStatus.Canceled,
+                }),
+                expect.objectContaining({
+                    price: 30,
+                    pricePaid: 0,
+                    status: BalanceItemStatus.Due,
+                }),
+            ]);
             // #endregion
         });
 
-        test.skip('Should apply cancelation fee', async () => {
-            throw new Error('Not implemented');
+        test('Should cancel all related balance item for deleted registration', async () => {
+            // #region arrange
+            const { member, group: group1, groupPrice: groupPrice1, organization, token } = await initData();
+
+            const option1 = GroupOption.create({
+                name: 'option 1',
+                price: ReduceablePrice.create({
+                    price: 5,
+                    reducedPrice: 3,
+                }),
+            });
+
+            const option2 = GroupOption.create({
+                name: 'option 2',
+                price: ReduceablePrice.create({
+                    price: 3,
+                    reducedPrice: 1,
+                }),
+            });
+
+            const optionMenu = GroupOptionMenu.create({
+                name: 'option menu 1',
+                multipleChoice: true,
+                options: [option1, option2],
+            });
+
+            group1.settings.optionMenus = [
+                optionMenu,
+            ];
+
+            await group1.save();
+
+            const body1 = 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: groupPrice1,
+                            organizationId: organization.id,
+                            groupId: group1.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 50,
+                customer: null,
+                asOrganizationId: organization.id,
+            });
+
+            const response1 = await register(body1, organization, token);
+            expect(response1.body).toBeDefined();
+            expect(response1.body.registrations.length).toBe(1);
+
+            const registrationToDelete = response1.body.registrations[0];
+
+            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: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [registrationToDelete.id],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 30,
+                customer: null,
+                asOrganizationId: organization.id,
+            });
+            // #endregion
+
+            // #region act and assert
+            const balanceBefore = await getBalance(member.id, organization, token);
+            expect(balanceBefore).toBeDefined();
+            expect(balanceBefore.body.length).toBe(3);
+
+            await register(body2, organization, token);
+
+            const balance = await getBalance(member.id, organization, token);
+            expect(balance).toBeDefined();
+            expect(balance.body.length).toBe(4);
+
+            expect.arrayContaining([
+                expect.objectContaining({
+                    price: 10,
+                    pricePaid: 0,
+                    status: BalanceItemStatus.Canceled,
+                }),
+                expect.objectContaining({
+                    price: 15,
+                    pricePaid: 0,
+                    status: BalanceItemStatus.Canceled,
+                }),
+                expect.objectContaining({
+                    price: 25,
+                    pricePaid: 0,
+                    status: BalanceItemStatus.Canceled,
+                }),
+                expect.objectContaining({
+                    price: 30,
+                    pricePaid: 0,
+                    status: BalanceItemStatus.Due,
+                }),
+            ]);
+            // #endregion
         });
 
-        test.skip('Should fail if invalid cancelation fee', async () => {
-            throw new Error('Not implemented');
+        test('Should apply cancelation fee', async () => {
+            // #region arrange
+            const { member, group: group1, groupPrice: groupPrice1, organization, token } = await initData();
+
+            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,
+                customer: null,
+                asOrganizationId: organization.id,
+            });
+
+            const response1 = await register(body1, organization, token);
+            expect(response1.body).toBeDefined();
+            expect(response1.body.registrations.length).toBe(1);
+
+            const registrationToDelete = response1.body.registrations[0];
+
+            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: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id,
+                        }),
+                    ],
+                    balanceItems: [
+                    ],
+                    deleteRegistrationIds: [registrationToDelete.id],
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 30,
+                customer: null,
+                asOrganizationId: organization.id,
+                cancellationFeePercentage: 2000,
+            });
+            // #endregion
+
+            // #region act and assert
+            const balanceBefore = await getBalance(member.id, organization, token);
+            expect(balanceBefore).toBeDefined();
+            expect(balanceBefore.body.length).toBe(1);
+            expect(balanceBefore.body[0].price).toBe(25);
+            expect(balanceBefore.body[0].pricePaid).toBe(0);
+
+            await register(body2, organization, token);
+
+            const balance = await getBalance(member.id, organization, token);
+            expect(balance).toBeDefined();
+            expect(balance.body.length).toBe(3);
+
+            expect.arrayContaining([
+                expect.objectContaining({
+                    price: 25,
+                    pricePaid: 0,
+                    status: BalanceItemStatus.Canceled,
+                }),
+                expect.objectContaining({
+                    price: 30,
+                    pricePaid: 0,
+                    status: BalanceItemStatus.Due,
+                }),
+                expect.objectContaining({
+                    price: 5,
+                    pricePaid: 0,
+                    type: BalanceItemType.CancellationFee,
+                    status: BalanceItemStatus.Due,
+                }),
+            ]);
+            // #endregion
         });
     });