@stamhoofd/structures 2.83.4 → 2.84.0

package/dist/src/members/checkout/RegisterCart.test.js

@@ -0,0 +1,1384 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const BundleDiscountGroupPriceSettings_js_1 = require("../../BundleDiscountGroupPriceSettings.js");
+const Group_js_1 = require("../../Group.js");
+const GroupPriceDiscount_js_1 = require("../../GroupPriceDiscount.js");
+const GroupSettings_js_1 = require("../../GroupSettings.js");
+const Organization_js_1 = require("../../Organization.js");
+const Platform_js_1 = require("../../Platform.js");
+const ReduceablePrice_js_1 = require("../../ReduceablePrice.js");
+const RegistrationPeriod_js_1 = require("../../RegistrationPeriod.js");
+const TranslatedString_js_1 = require("../../TranslatedString.js");
+const MemberDetails_js_1 = require("../MemberDetails.js");
+const PlatformMember_js_1 = require("../PlatformMember.js");
+const RegisterItem_js_1 = require("./RegisterItem.js");
+const MemberWithRegistrationsBlob_js_1 = require("../MemberWithRegistrationsBlob.js");
+// Should be last because of circular dependencies
+const BundleDiscount_js_1 = require("../../BundleDiscount.js");
+const Registration_js_1 = require("../Registration.js");
+const AppliedRegistrationDiscount_js_1 = require("../../AppliedRegistrationDiscount.js");
+const RegistrationWithPlatformMember_js_1 = require("./RegistrationWithPlatformMember.js");
+const GenericBalance_js_1 = require("../../GenericBalance.js");
+// Helper functions to reduce code duplication
+function createTestPeriod() {
+    const period = RegistrationPeriod_js_1.RegistrationPeriod.create({});
+    const organizationRegistrationPeriod = RegistrationPeriod_js_1.OrganizationRegistrationPeriod.create({
+        period,
+    });
+    const organization = Organization_js_1.Organization.create({
+        period: organizationRegistrationPeriod,
+    });
+    return { period, organizationRegistrationPeriod, organization };
+}
+function createTestGroups(organization, period, prices = [5000, 4000], names) {
+    return prices.map((price, index) => {
+        return Group_js_1.Group.create({
+            organizationId: organization.id,
+            periodId: period.id,
+            settings: GroupSettings_js_1.GroupSettings.create({
+                name: names ? new TranslatedString_js_1.TranslatedString(names[index]) : undefined,
+                prices: [
+                    GroupSettings_js_1.GroupPrice.create({
+                        price: ReduceablePrice_js_1.ReduceablePrice.create({
+                            price,
+                        }),
+                    }),
+                ],
+            }),
+        });
+    });
+}
+function createBundleDiscount({ name = 'Bundle discount', countWholeFamily = true, countPerGroup = false, discounts = [
+    { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+    { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+], } = {}) {
+    return BundleDiscount_js_1.BundleDiscount.create({
+        name: new TranslatedString_js_1.TranslatedString(name),
+        countWholeFamily,
+        countPerGroup,
+        discounts: discounts.map(d => {
+            var _a;
+            return GroupPriceDiscount_js_1.GroupPriceDiscount.create({
+                value: ReduceablePrice_js_1.ReduceablePrice.create({
+                    price: d.value,
+                    reducedPrice: (_a = d.reducedValue) !== null && _a !== void 0 ? _a : null,
+                }),
+                type: d.type,
+            });
+        }),
+    });
+}
+function createTestFamily(memberCount = 3) {
+    const members = Array(memberCount).fill(null).map((_, i) => {
+        const names = ['John', 'Jane', 'Jack'];
+        return MemberWithRegistrationsBlob_js_1.MemberWithRegistrationsBlob.create({
+            details: MemberDetails_js_1.MemberDetails.create({
+                firstName: names[i] || `Member${i + 1}`,
+                lastName: 'Doe',
+            }),
+        });
+    });
+    const blob = MemberWithRegistrationsBlob_js_1.MembersBlob.create({
+        members,
+    });
+    return PlatformMember_js_1.PlatformFamily.create(blob, { platform: Platform_js_1.Platform.create({}) });
+}
+function setupDiscountTest({ memberCount = 3, groupPrices = [5000, 4000], groupNames, bundleDiscount, } = {}) {
+    const { period, organizationRegistrationPeriod, organization } = createTestPeriod();
+    const groups = createTestGroups(organization, period, groupPrices, groupNames);
+    organizationRegistrationPeriod.groups = groups;
+    const discount = bundleDiscount || createBundleDiscount();
+    organizationRegistrationPeriod.settings.bundleDiscounts.push(discount);
+    // Setup bundle discounts on all groups
+    groups.forEach((group) => {
+        group.settings.prices[0].bundleDiscounts.set(discount.id, BundleDiscountGroupPriceSettings_js_1.BundleDiscountGroupPriceSettings.create({
+            name: discount.name,
+        }));
+    });
+    const family = createTestFamily(memberCount);
+    return {
+        period,
+        organizationRegistrationPeriod,
+        organization,
+        groups,
+        discount,
+        family,
+    };
+}
+function addHistoricRegistration(member, group, organization, appliedDiscounts = new Map()) {
+    const registration = Registration_js_1.Registration.create({
+        group: group,
+        groupPrice: group.settings.prices[0],
+        memberId: member.id,
+        organizationId: group.organizationId,
+        registeredAt: new Date('2023-01-01'),
+        startDate: new Date('2023-01-01'),
+        price: group.settings.prices[0].price.price,
+        balances: [
+            GenericBalance_js_1.GenericBalance.create({
+                organizationId: organization.id,
+                amountPaid: 0,
+                amountOpen: group.settings.prices[0].price.price - [...appliedDiscounts.values()].reduce((acc, d) => acc + d.amount, 0),
+                amountPending: 0,
+            }),
+        ],
+        discounts: appliedDiscounts,
+    });
+    member.member.registrations.push(registration);
+    member.family.insertOrganization(organization);
+    return registration;
+}
+describe('Unit.RegisterCart', () => {
+    describe('Bundle Discounts', () => {
+        it('A fixed discount is granted for the second and third registration in a bundle', () => {
+            const { organization, groups, family } = setupDiscountTest({
+                bundleDiscount: createBundleDiscount({
+                    name: 'Bundle discount',
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB, memberC] = family.members;
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemA);
+            cart.add(itemB);
+            cart.add(itemC);
+            cart.calculatePrices();
+            // Check price for item A is 50.00
+            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemA.calculatedRefund).toEqual(0);
+            expect(itemA.calculatedPriceDueLater).toEqual(0);
+            // Check price for items B and C
+            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemB.calculatedRefund).toEqual(0);
+            expect(itemB.calculatedPriceDueLater).toEqual(0);
+            expect(itemC.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedRefund).toEqual(0);
+            expect(itemC.calculatedPriceDueLater).toEqual(0);
+            // Check calculated discount is 10_00 + 15_00 = 25_00
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(2500);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(2500);
+            expect(cart.price).toEqual(5000 + 4000 + 4000);
+            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 2500);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 13000,
+                }),
+                {
+                    name: 'Bundle discount',
+                    price: -2500,
+                },
+                expect.objectContaining({
+                    price: 13000 - 2500,
+                }),
+            ]);
+        });
+        test('A percentage discount is granted for the second and third registration in a bundle', () => {
+            const { organization, groups, family } = setupDiscountTest({
+                bundleDiscount: createBundleDiscount({
+                    name: 'Bundle discount',
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB, memberC] = family.members;
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemA);
+            cart.add(itemB);
+            cart.add(itemC);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedPrice).toEqual(4000);
+            // 15% will be applied to 50 euro (max), and 10% to one of the 40 euros
+            // Check calculated discount is 50_00 * 0.15 + 40_00 * 0.10 = 7_50 + 4_00 = 11_50
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(1150);
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(1150);
+            expect(cart.price).toEqual(5000 + 4000 + 4000);
+            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 1150);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 13000,
+                }),
+                {
+                    name: 'Bundle discount',
+                    price: -1150,
+                },
+                expect.objectContaining({
+                    price: 13000 - 1150,
+                }),
+            ]);
+        });
+        test('Historic registrations are included in the calculation', () => {
+            const { organization, groups, family } = setupDiscountTest({
+                bundleDiscount: createBundleDiscount({
+                    name: 'Bundle discount',
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB, memberC] = family.members;
+            // Member A is already registered for group A in the past
+            addHistoricRegistration(memberA, groupA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemB);
+            cart.add(itemC);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedPrice).toEqual(4000);
+            // 15% will be applied to 50 euro (max), and 10% to one of the 40 euros
+            // Check calculated discount is 50_00 * 0.15 + 40_00 * 0.10 = 7_50 + 4_00 = 11_50
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(1150);
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(1150);
+            expect(cart.price).toEqual(4000 + 4000);
+            expect(checkout.totalPrice).toEqual(4000 + 4000 - 1150);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 8000,
+                }),
+                {
+                    name: 'Bundle discount',
+                    price: -1150,
+                },
+                expect.objectContaining({
+                    price: 8000 - 1150,
+                }),
+            ]);
+        });
+        test('Deleting a registration also removes the attached discount', () => {
+            // We have two family members with existing registrations.
+            // One of those registrations received a discount earlier.
+            // But since we are adding a new registration in our cart, a more optimal discount
+            // would be if that registration would get the newly higher discount instead
+            // (because it is percentage based)
+            const { organization, groups, family, discount } = setupDiscountTest({
+                memberCount: 2,
+                bundleDiscount: createBundleDiscount({
+                    name: 'Multiple family members discount',
+                    countWholeFamily: true,
+                    countPerGroup: false,
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+                groupPrices: [10000, 4000],
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB] = family.members;
+            const registrationA = addHistoricRegistration(memberA, groupA, organization);
+            const registrationB = addHistoricRegistration(memberB, groupB, organization, new Map([
+                [
+                    discount.id,
+                    AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
+                        name: discount.name,
+                        amount: 1000, // 10% discount on 100_00 = 10_00
+                    }),
+                ],
+            ]));
+            // If we delete registration B, the discount won't be visible in the cart because it is included in the registration
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.removeRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
+                registration: registrationB,
+                member: memberB,
+            }));
+            cart.calculatePrices();
+            expect(cart.bundleDiscounts).toHaveLength(0);
+            expect(checkout.totalPrice).toEqual(-3000);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: -4000 + 1000,
+                }),
+                expect.objectContaining({
+                    price: -4000 + 1000,
+                }),
+            ]);
+            // Now readd the registration
+            cart.unremoveRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
+                registration: registrationB,
+                member: memberB,
+            }));
+            // Remove registration A, this should show the discount because it is a side effect of deleting the registration
+            cart.removeRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
+                registration: registrationA,
+                member: memberA,
+            }));
+            cart.calculatePrices();
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(0);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(1000); // The previous discount
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(-1000);
+            expect(checkout.totalPrice).toEqual(-9000);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: -10000, // Reeds aangerekend
+                }),
+                {
+                    name: '766a39be-a4af-4a04-baf0-1f064d2fed16 (Multiple family members discount)',
+                    price: 1000,
+                },
+                expect.objectContaining({
+                    price: -9000,
+                }),
+            ]);
+        });
+        test('Deleting a registration with cancellation fees', () => {
+            // We have two family members with existing registrations.
+            // One of those registrations received a discount earlier.
+            // But since we are adding a new registration in our cart, a more optimal discount
+            // would be if that registration would get the newly higher discount instead
+            // (because it is percentage based)
+            const { organization, groups, family, discount } = setupDiscountTest({
+                memberCount: 2,
+                bundleDiscount: createBundleDiscount({
+                    name: 'Multiple family members discount',
+                    countWholeFamily: true,
+                    countPerGroup: false,
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+                groupPrices: [10000, 4000],
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB] = family.members;
+            const registrationA = addHistoricRegistration(memberA, groupA, organization);
+            const registrationB = addHistoricRegistration(memberB, groupB, organization, new Map([
+                [
+                    discount.id,
+                    AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
+                        name: discount.name,
+                        amount: 1000, // 10% discount on 100_00 = 10_00
+                    }),
+                ],
+            ]));
+            // If we delete registration B, the discount won't be visible in the cart because it is included in the registration
+            const checkout = family.checkout;
+            checkout.cancellationFeePercentage = 5000;
+            const cart = checkout.cart;
+            cart.removeRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
+                registration: registrationB,
+                member: memberB,
+            }));
+            cart.calculatePrices();
+            expect(cart.bundleDiscounts).toHaveLength(0);
+            expect(checkout.totalPrice).toEqual(-1500);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: -4000 + 1000, // Already charged amount
+                }),
+                // Cancellation fee = 50% of the balance total, 30_00 = 15_00
+                expect.objectContaining({
+                    price: 1500,
+                }),
+                expect.objectContaining({
+                    price: -1500,
+                }),
+            ]);
+            // Now readd the registration
+            cart.unremoveRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
+                registration: registrationB,
+                member: memberB,
+            }));
+            // Remove registration A, this should show the discount because it is a side effect of deleting the registration
+            cart.removeRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
+                registration: registrationA,
+                member: memberA,
+            }));
+            cart.calculatePrices();
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(0);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(1000); // The previous discount
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(-1000);
+            expect(checkout.totalPrice).toEqual(-4000);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: -10000, // Already charged for registration A that is being deleted
+                }),
+                // Cancellation fee = 50% of the balance total, 100_00 = 50_00
+                expect.objectContaining({
+                    price: 5000,
+                }),
+                {
+                    // Side effect in registration B
+                    name: '766a39be-a4af-4a04-baf0-1f064d2fed16 (Multiple family members discount)',
+                    price: 1000,
+                },
+                expect.objectContaining({
+                    price: -4000,
+                }),
+            ]);
+        });
+        test('Replacing a registration without discount also removes the attached discount in another registration if the new registration in not elegible', () => {
+            // Create a family with two members, each with a registration
+            // Add a discount to one of the registrations (like it should have been calculated at the time)
+            // Next, move one of the registrations to a different group that does not have the discount
+            // The previously given discount should be added as an extra price on the cart as an adjustment for the discount that should have been given
+            const { organization, groups, family, discount } = setupDiscountTest({
+                memberCount: 2,
+                bundleDiscount: createBundleDiscount({
+                    name: 'Multiple family members discount',
+                    countWholeFamily: true,
+                    countPerGroup: false,
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+                groupPrices: [10000, 4000],
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB] = family.members;
+            const registrationA = addHistoricRegistration(memberA, groupA, organization);
+            addHistoricRegistration(memberB, groupB, organization, new Map([
+                [
+                    discount.id,
+                    AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
+                        name: discount.name,
+                        amount: 1000, // 10% discount on 100_00 = 10_00
+                    }),
+                ],
+            ]));
+            const groupCPrice = GroupSettings_js_1.GroupPrice.create({
+                price: ReduceablePrice_js_1.ReduceablePrice.create({
+                    price: 5000,
+                }),
+            });
+            const groupC = Group_js_1.Group.create({
+                organizationId: organization.id,
+                periodId: organization.period.id,
+                settings: GroupSettings_js_1.GroupSettings.create({
+                    name: new TranslatedString_js_1.TranslatedString('Group C'),
+                    prices: [
+                        groupCPrice,
+                    ],
+                }),
+            });
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupC, organization);
+            itemA.replaceRegistrations = [
+                new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
+                    registration: registrationA,
+                    member: memberA,
+                }),
+            ];
+            cart.add(itemA);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemA.calculatedRefund).toEqual(10000);
+            expect(itemA.calculatedPriceDueLater).toEqual(0);
+            // Check discount should be given back
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(0);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(1000); // The previous discount
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(-1000);
+            expect(checkout.totalPrice).toEqual(5000 - 10000 + 1000);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    // Subtotal (normal price)
+                    price: 5000,
+                }),
+                expect.objectContaining({
+                    // Refund for the previous registration
+                    price: -10000,
+                }),
+                {
+                    name: '766a39be-a4af-4a04-baf0-1f064d2fed16 (Multiple family members discount)',
+                    price: 1000,
+                },
+                expect.objectContaining({
+                    price: -5000 + 1000,
+                }),
+            ]);
+            // Now, what if groupC does have a higher discount instead of no discount?
+            groupCPrice.bundleDiscounts.set(discount.id, BundleDiscountGroupPriceSettings_js_1.BundleDiscountGroupPriceSettings.create({
+                name: discount.name,
+                customDiscounts: [
+                    // Custom discount for this price
+                    GroupPriceDiscount_js_1.GroupPriceDiscount.create({
+                        value: ReduceablePrice_js_1.ReduceablePrice.create({
+                            price: 2500,
+                        }),
+                        type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed,
+                    }),
+                ],
+            }));
+            // Recalculate
+            cart.calculatePrices();
+            // Check discount should be given back
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(2500);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(1000); // The previous discount
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(1500);
+            expect(checkout.totalPrice).toEqual(5000 - 10000 - 1500);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    // Subtotal (normal price)
+                    price: 5000,
+                }),
+                expect.objectContaining({
+                    // Refund for the previous registration
+                    price: -10000,
+                }),
+                {
+                    name: 'Multiple family members discount',
+                    price: -1500,
+                },
+                expect.objectContaining({
+                    price: -5000 - 1500,
+                }),
+            ]);
+        });
+        test('Replacing a registration with discount also removes the attached discount registration if the new registration in not elegible', () => {
+            const { organization, groups, family, discount } = setupDiscountTest({
+                memberCount: 2,
+                bundleDiscount: createBundleDiscount({
+                    name: 'Multiple family members discount',
+                    countWholeFamily: true,
+                    countPerGroup: false,
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+                groupPrices: [10000, 4000],
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB] = family.members;
+            const registrationA = addHistoricRegistration(memberA, groupA, organization, new Map([
+                [
+                    discount.id,
+                    AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
+                        name: discount.name,
+                        amount: 1000, // 10% discount on 100_00 = 10_00
+                    }),
+                ],
+            ]));
+            addHistoricRegistration(memberB, groupB, organization);
+            const groupCPrice = GroupSettings_js_1.GroupPrice.create({
+                price: ReduceablePrice_js_1.ReduceablePrice.create({
+                    price: 5000,
+                }),
+            });
+            const groupC = Group_js_1.Group.create({
+                organizationId: organization.id,
+                periodId: organization.period.id,
+                settings: GroupSettings_js_1.GroupSettings.create({
+                    name: new TranslatedString_js_1.TranslatedString('Group C'),
+                    prices: [
+                        groupCPrice,
+                    ],
+                }),
+            });
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupC, organization);
+            itemA.replaceRegistrations = [
+                new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
+                    registration: registrationA,
+                    member: memberA,
+                }),
+            ];
+            cart.add(itemA);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemA.calculatedRefund).toEqual(9000);
+            expect(itemA.calculatedPriceDueLater).toEqual(0);
+            // No discounts anymore
+            expect(cart.bundleDiscounts).toHaveLength(0);
+            expect(checkout.totalPrice).toEqual(5000 - 9000);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    // Subtotal (normal price)
+                    price: 5000,
+                }),
+                expect.objectContaining({
+                    // Refund for the previous registration, without the discount that was granted
+                    price: -9000,
+                }),
+                expect.objectContaining({
+                    price: 5000 - 9000,
+                }),
+            ]);
+            // Now, what if groupC does have a higher discount instead of no discount?
+            groupCPrice.bundleDiscounts.set(discount.id, BundleDiscountGroupPriceSettings_js_1.BundleDiscountGroupPriceSettings.create({
+                name: discount.name,
+                customDiscounts: [
+                    // Custom discount for this price
+                    GroupPriceDiscount_js_1.GroupPriceDiscount.create({
+                        value: ReduceablePrice_js_1.ReduceablePrice.create({
+                            price: 2500,
+                        }),
+                        type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed,
+                    }),
+                ],
+            }));
+            // Recalculate
+            cart.calculatePrices();
+            // Check discount should be given back
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(2500);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0); // Not included here, because the registration will be removed including the applied discount
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(2500);
+            expect(checkout.totalPrice).toEqual(5000 - 9000 - 2500);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    // Subtotal (normal price)
+                    price: 5000,
+                }),
+                expect.objectContaining({
+                    // Refund for the previous registration
+                    price: -9000,
+                }),
+                {
+                    name: 'Multiple family members discount',
+                    price: -2500,
+                },
+                expect.objectContaining({
+                    price: 5000 - 9000 - 2500,
+                }),
+            ]);
+        });
+        test('The last discount is repeated', () => {
+            // Create a family with 3 members. Add 3 items to the cart.
+            // The bundle discount only defined one discount, but that should be repated for the second and third item
+            const { organization, groups, family, discount } = setupDiscountTest({
+                memberCount: 3,
+                groupPrices: [5000, 4000],
+                groupNames: ['Group A', 'Group B'],
+                bundleDiscount: createBundleDiscount({
+                    name: 'Bundle discount',
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB, memberC] = family.members;
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemA);
+            cart.add(itemB);
+            cart.add(itemC);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemA.calculatedRefund).toEqual(0);
+            expect(itemA.calculatedPriceDueLater).toEqual(0);
+            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemB.calculatedRefund).toEqual(0);
+            expect(itemB.calculatedPriceDueLater).toEqual(0);
+            expect(itemC.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedRefund).toEqual(0);
+            expect(itemC.calculatedPriceDueLater).toEqual(0);
+            // Check calculated discount is 50_00 * 0.10 + 40_00 * 0.10 = 5_00 + 4_00 = 9_00
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(900);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(900);
+            expect(cart.price).toEqual(5000 + 4000 + 4000);
+            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 900);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 13000,
+                }),
+                {
+                    name: 'Bundle discount',
+                    price: -900,
+                },
+                expect.objectContaining({
+                    price: 13000 - 900,
+                }),
+            ]);
+        });
+        test('The highest possible discount is granted', () => {
+            const { organization, groups, family, discount } = setupDiscountTest({
+                memberCount: 3,
+                groupPrices: [5000, 4000],
+                groupNames: ['Group A', 'Group B'],
+                bundleDiscount: createBundleDiscount({
+                    name: 'Bundle discount',
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB, memberC] = family.members;
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
+            // Change group B to give 20 euro for the second item, and 0 for the third item
+            groupB.settings.prices[0].bundleDiscounts.set(discount.id, BundleDiscountGroupPriceSettings_js_1.BundleDiscountGroupPriceSettings.create({
+                name: discount.name,
+                customDiscounts: [
+                    GroupPriceDiscount_js_1.GroupPriceDiscount.create({
+                        value: ReduceablePrice_js_1.ReduceablePrice.create({
+                            price: 2000,
+                        }),
+                        type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed,
+                    }),
+                    GroupPriceDiscount_js_1.GroupPriceDiscount.create({
+                        value: ReduceablePrice_js_1.ReduceablePrice.create({
+                            price: 0,
+                        }),
+                        type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed,
+                    }),
+                ],
+            }));
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemA);
+            cart.add(itemB);
+            cart.add(itemC);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemA.calculatedRefund).toEqual(0);
+            expect(itemA.calculatedPriceDueLater).toEqual(0);
+            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemB.calculatedRefund).toEqual(0);
+            expect(itemB.calculatedPriceDueLater).toEqual(0);
+            expect(itemC.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedRefund).toEqual(0);
+            expect(itemC.calculatedPriceDueLater).toEqual(0);
+            // Check calculated discount is 50_00 * 0.10 + 20_00 fixed + 0 = 5_00 + 20_00 + 0 = 25_00
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(2500);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(2500);
+            expect(cart.price).toEqual(5000 + 4000 + 4000);
+            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 2500);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 13000,
+                }),
+                {
+                    name: 'Bundle discount',
+                    price: -2500,
+                },
+                expect.objectContaining({
+                    price: 13000 - 2500,
+                }),
+            ]);
+        });
+        test('Multiple bundles can be combined', () => {
+            // Situation: Camp A costs 100 euro
+            // Camp B costs 150 euro
+            // Camp A and/or campB gives a discount of 10, 20, 30... (all camp discount)
+            // On top of that there is an extra discount if you combine multiple expensive camps (camp B) of 5 euro, 10 ...
+            const { organization, groups, family, organizationRegistrationPeriod } = setupDiscountTest({
+                memberCount: 5,
+                groupPrices: [10000, 15000],
+                groupNames: ['Camp A', 'Camp B'],
+                bundleDiscount: createBundleDiscount({
+                    name: 'All camp discount',
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+                    ],
+                }),
+            });
+            const [campA, campB] = groups;
+            const [memberA, memberB, memberC, memberD, memberE] = family.members;
+            const expensiveCampDiscount = createBundleDiscount({
+                name: 'Expensive camp discount',
+                discounts: [
+                    { value: 500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+                ],
+            });
+            // Add discount to organizationRegistrationPeriod
+            organizationRegistrationPeriod.settings.bundleDiscounts.push(expensiveCampDiscount);
+            // Add camp B to the expensive camp discount
+            campB.settings.prices[0].bundleDiscounts.set(expensiveCampDiscount.id, BundleDiscountGroupPriceSettings_js_1.BundleDiscountGroupPriceSettings.create({
+                name: expensiveCampDiscount.name,
+            }));
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, campA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, campB, organization); // +10_00 discount
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, campB, organization); // +10_00 discount and +5_00 discount
+            const itemD = RegisterItem_js_1.RegisterItem.defaultFor(memberD, campA, organization); // +10_00 discount
+            const itemE = RegisterItem_js_1.RegisterItem.defaultFor(memberE, campB, organization); // +10_00 discount and +5_00 discount
+            cart.add(itemA);
+            cart.add(itemB);
+            cart.add(itemC);
+            cart.add(itemD);
+            cart.add(itemE);
+            cart.calculatePrices();
+            expect(cart.bundleDiscounts).toHaveLength(2);
+            expect(cart.bundleDiscounts.map((d) => {
+                return {
+                    name: d.name,
+                    total: d.total,
+                    netTotal: d.netTotal,
+                };
+            })).toEqual([
+                {
+                    name: 'All camp discount',
+                    total: 1000 * 4,
+                    netTotal: 1000 * 4,
+                },
+                {
+                    name: 'Expensive camp discount',
+                    total: 500 * 2,
+                    netTotal: 500 * 2,
+                },
+            ]);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 10000 * 2 + 15000 * 3,
+                }),
+                {
+                    name: 'All camp discount',
+                    price: -1000 * 4,
+                },
+                {
+                    name: 'Expensive camp discount',
+                    price: -500 * 2,
+                },
+                expect.objectContaining({
+                    price: 10000 * 2 + 15000 * 3 - 1000 * 4 - 500 * 2,
+                }),
+            ]);
+        });
+        test('Previous discounts can be altered if a better optimum is found later', () => {
+            // We have two family members with existing registrations.
+            // One of those registrations received a discount earlier.
+            // But since we are adding a new registration in our cart, a more optimal discount
+            // would be if that registration would get the newly higher discount instead
+            // (because it is percentage based)
+            const { organization, groups, family, discount } = setupDiscountTest({
+                memberCount: 2,
+                bundleDiscount: createBundleDiscount({
+                    name: 'Multiple family members discount',
+                    countWholeFamily: true,
+                    countPerGroup: false,
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+                groupPrices: [10000, 4000],
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB] = family.members;
+            const registrationA = addHistoricRegistration(memberA, groupA, organization);
+            const registrationB = addHistoricRegistration(memberB, groupB, organization);
+            registrationA.discounts.set(discount.id, AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
+                name: discount.name,
+                amount: 1000, // 10% discount on 100_00 = 10_00
+            }));
+            // Now create itemC
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupB, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemC);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemC.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedRefund).toEqual(0);
+            expect(itemC.calculatedPriceDueLater).toEqual(0);
+            // Check calculated discount is 100_00 * 0.15 + 40_00 * 0.10 = 15_00 + 4_00 = 19_00
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(1900);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(1000); // The previous discount
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(900);
+            expect(cart.price).toEqual(4000);
+            expect(checkout.totalPrice).toEqual(4000 - 900);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 4000,
+                }),
+                {
+                    name: 'Multiple family members discount',
+                    price: -900,
+                },
+                expect.objectContaining({
+                    price: 4000 - 900,
+                }),
+            ]);
+        });
+        test('The repeating behaviour can be stopped by setting the last discount to zero', () => {
+            // Create a family with 3 members. Add 3 items to the cart.
+            // The bundle discount only defined one discount, but that should be repated for the second and third item
+            const { organization, groups, family, discount } = setupDiscountTest({
+                memberCount: 3,
+                groupPrices: [5000, 4000],
+                groupNames: ['Group A', 'Group B'],
+                bundleDiscount: createBundleDiscount({
+                    name: 'Bundle discount',
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                        { value: 0, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage }, // This should stop the repeating behaviour
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB, memberC] = family.members;
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemA);
+            cart.add(itemB);
+            cart.add(itemC);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemA.calculatedRefund).toEqual(0);
+            expect(itemA.calculatedPriceDueLater).toEqual(0);
+            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemB.calculatedRefund).toEqual(0);
+            expect(itemB.calculatedPriceDueLater).toEqual(0);
+            expect(itemC.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedRefund).toEqual(0);
+            expect(itemC.calculatedPriceDueLater).toEqual(0);
+            // Check calculated discount is 50_00 * 0.10 = 5_00
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(500);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(500);
+            expect(cart.price).toEqual(5000 + 4000 + 4000);
+            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 500);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 13000,
+                }),
+                {
+                    name: 'Bundle discount',
+                    price: -500,
+                },
+                expect.objectContaining({
+                    price: 13000 - 500,
+                }),
+            ]);
+        });
+        test('Gives different discount for members with reduced price', () => {
+            // Create familuy with 3 members.
+            // One member has a reduced price.
+            // The other two members have a normal price.
+            // Create a 50%, 100% discount for the reduced price in a bundle discount (so it should be free in a family with 3 members)
+            const { organization, groups, family } = setupDiscountTest({
+                memberCount: 3,
+                groupPrices: [5000, 4000],
+                groupNames: ['Group A', 'Group B'],
+                bundleDiscount: createBundleDiscount({
+                    name: 'Bundle discount',
+                    discounts: [
+                        { value: 500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage, reducedValue: 5000 },
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage, reducedValue: 10000 },
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB, memberC] = family.members;
+            // Make sure the last member has a reduced price
+            memberC.member.details.requiresFinancialSupport = MemberDetails_js_1.BooleanStatus.create({ value: true });
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemA);
+            cart.add(itemB);
+            cart.add(itemC);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedPrice).toEqual(4000);
+            // Check calculated discount is 40_00 * 1 + 50_00 * 5% = 40_00 + 2_50 = 42_50
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(4250);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(4250);
+            expect(cart.price).toEqual(5000 + 4000 + 4000);
+            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 4250);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 13000,
+                }),
+                {
+                    name: 'Bundle discount',
+                    price: -4250,
+                },
+                expect.objectContaining({
+                    price: 13000 - 4250,
+                }),
+            ]);
+            // Remove requires financial support, then recalculate
+            memberC.member.details.requiresFinancialSupport = MemberDetails_js_1.BooleanStatus.create({ value: false });
+            cart.calculatePrices();
+            // 10% on 50_00 + 5% on 40_00 = 5_00 + 2_00 = 7_00
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 13000,
+                }),
+                {
+                    name: 'Bundle discount',
+                    price: -700,
+                },
+                expect.objectContaining({
+                    price: 13000 - 700,
+                }),
+            ]);
+        });
+        test('Bundles without countWholeFamily only count per unique member', () => {
+            // Register member A for both group A and group B
+            // while member B is only registered for group A
+            // Only member A should get the discount for either A or B (if the order matters)
+            const { organization, groups, family } = setupDiscountTest({
+                memberCount: 2,
+                bundleDiscount: createBundleDiscount({
+                    name: 'Multiple lessons discount',
+                    countWholeFamily: false,
+                    countPerGroup: false,
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB] = family.members;
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupB, organization);
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupA, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemA);
+            cart.add(itemB);
+            cart.add(itemC);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedPrice).toEqual(5000);
+            // Check calculated discount is 50_00 * 0.10 = 5_00
+            expect(cart.bundleDiscounts.map(c => c.netTotal)).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(500);
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(500);
+            expect(cart.price).toEqual(5000 + 4000 + 5000);
+            expect(checkout.totalPrice).toEqual(5000 + 4000 + 5000 - 500);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 5000 + 4000 + 5000,
+                }),
+                {
+                    name: 'Multiple lessons discount (John)',
+                    price: -500,
+                },
+                expect.objectContaining({
+                    price: 5000 + 4000 + 5000 - 500,
+                }),
+            ]);
+            // Add a historic registration for member B, so it also gets a discount
+            addHistoricRegistration(memberB, groupB, organization);
+            cart.calculatePrices();
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 5000 + 4000 + 5000, // no change
+                }),
+                {
+                    name: 'Multiple lessons discount (John)',
+                    price: -500,
+                },
+                {
+                    name: 'Multiple lessons discount (Jane)',
+                    price: -500,
+                },
+                expect.objectContaining({
+                    price: 5000 + 4000 + 5000 - 500 - 500,
+                }),
+            ]);
+        });
+        test('Bundles with countPerGroup only count per unique group', () => {
+            const { organization, groups, family, discount } = setupDiscountTest({
+                memberCount: 2,
+                groupNames: ['Group A', 'Group B'],
+                bundleDiscount: createBundleDiscount({
+                    name: 'Multiple family members discount',
+                    countWholeFamily: true,
+                    countPerGroup: true,
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB] = family.members;
+            // Both members register for the different groups, does not give the discount
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemA);
+            cart.add(itemB);
+            cart.calculatePrices();
+            // No discount should be applied yet (need at least 2 different groups)
+            expect(cart.bundleDiscounts).toHaveLength(0);
+            expect(checkout.totalPrice).toEqual(5000 + 4000);
+            // Now register one member for group B as well
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupB, organization);
+            cart.add(itemC);
+            cart.calculatePrices();
+            // Now we should get a discount
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(400); // 10% of 40_00 (not 50_00)
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(400);
+            expect(cart.price).toEqual(5000 + 4000 + 4000);
+            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 400);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 5000 + 4000 + 4000,
+                }),
+                {
+                    name: 'Multiple family members discount (Group B)',
+                    price: -400,
+                },
+                expect.objectContaining({
+                    price: 5000 + 4000 + 4000 - 400,
+                }),
+            ]);
+            // Change calculation to count across groups
+            discount.countPerGroup = false;
+            cart.calculatePrices();
+            // Now we should get a discount for both groups
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 5000 + 4000 + 4000,
+                }),
+                {
+                    name: 'Multiple family members discount',
+                    price: -900,
+                },
+                expect.objectContaining({
+                    price: 5000 + 4000 + 4000 - 900,
+                }),
+            ]);
+        });
+        test('countPerGroup = true is ignored if countWholeFamily is false', () => {
+            const { organization, groups, family, discount } = setupDiscountTest({
+                memberCount: 2,
+                groupNames: ['Group A', 'Group B'],
+                bundleDiscount: createBundleDiscount({
+                    name: 'Multiple lessons discount',
+                    countWholeFamily: false, // This means only count per unique member
+                    countPerGroup: true, // This should be ignored since countWholeFamily is false
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB] = family.members;
+            // Register member A for both group A and B
+            // Register member B for group A
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupB, organization);
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupA, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemA);
+            cart.add(itemB);
+            cart.add(itemC);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedPrice).toEqual(5000);
+            // Check calculated discount - should only apply to member A (who has multiple registrations)
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(500); // 10% of 50_00 (we always apply discounts to highest price first)
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(500);
+            expect(cart.price).toEqual(5000 + 4000 + 5000);
+            expect(checkout.totalPrice).toEqual(5000 + 4000 + 5000 - 500);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 5000 + 4000 + 5000,
+                }),
+                {
+                    name: 'Multiple lessons discount (John)',
+                    price: -500,
+                },
+                expect.objectContaining({
+                    price: 5000 + 4000 + 5000 - 500,
+                }),
+            ]);
+            // Now explicitly turn on countPerGroup and set countWholeFamily to true
+            // to verify it behaves differently (proving that countPerGroup was indeed ignored before)
+            discount.countWholeFamily = true;
+            discount.countPerGroup = true;
+            cart.calculatePrices();
+            // Now we should get a discount for group A (since two members are registered for it)
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 5000 + 4000 + 5000,
+                }),
+                {
+                    name: 'Multiple lessons discount (Group A)',
+                    price: -500, // 10% of the second 50_00
+                },
+                expect.objectContaining({
+                    price: 5000 + 4000 + 5000 - 500,
+                }),
+            ]);
+        });
+        test('Past discounts are only altered if a related registration is added or removed', () => {
+            // Create two historic registrations that didn't get an existing discount (= error)
+            // now, add a new registration to the cart that is not applicable to the discount - the old discount should not be altered
+            const { organization, groups, family, period, discount } = setupDiscountTest({
+                memberCount: 2,
+                groupPrices: [5000, 4000],
+                groupNames: ['Group A', 'Group B'],
+                bundleDiscount: createBundleDiscount({
+                    name: 'Multiple family members discount',
+                    countWholeFamily: true,
+                    countPerGroup: false,
+                    discounts: [
+                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB] = family.members;
+            const registrationA = addHistoricRegistration(memberA, groupA, organization);
+            const registrationB = addHistoricRegistration(memberB, groupB, organization);
+            // Create a new group that is not applicable to the discount
+            const [groupC] = createTestGroups(organization, period, [3000], ['Group C']);
+            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupC, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemC);
+            cart.calculatePrices();
+            expect(itemC.calculatedPrice).toEqual(3000);
+            expect(cart.bundleDiscounts).toHaveLength(0);
+            expect(checkout.totalPrice).toEqual(3000);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 3000,
+                }),
+            ]);
+            // Now also register memberB for group A and add it to the cart
+            const itemD = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupA, organization);
+            cart.add(itemD);
+            cart.calculatePrices();
+            // Check price for items
+            expect(itemD.calculatedPrice).toEqual(5000);
+            expect(itemC.calculatedPrice).toEqual(3000);
+            // Check calculated discount: should also take old registrations into account
+            // 50_00 * 10% + 50_00 * 10% = 5_00 + 5_00 = 10_00
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(1000);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(1000);
+            expect(cart.price).toEqual(5000 + 3000);
+            expect(checkout.totalPrice).toEqual(5000 + 3000 - 1000);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 5000 + 3000,
+                }),
+                {
+                    name: 'Multiple family members discount',
+                    price: -1000,
+                },
+                expect.objectContaining({
+                    price: 5000 + 3000 - 1000,
+                }),
+            ]);
+        });
+        test('Fixed discounts are limited to the group price', () => {
+            const { organization, groups, family, discount } = setupDiscountTest({
+                memberCount: 2,
+                groupNames: ['Group A', 'Group B'],
+                bundleDiscount: createBundleDiscount({
+                    name: 'Multiple family members discount',
+                    countWholeFamily: true,
+                    countPerGroup: false,
+                    discounts: [
+                        { value: 100000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+                    ],
+                }),
+            });
+            const [groupA, groupB] = groups;
+            const [memberA, memberB] = family.members;
+            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
+            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
+            // Add to a single cart
+            const checkout = family.checkout;
+            const cart = checkout.cart;
+            cart.add(itemA);
+            cart.add(itemB);
+            cart.calculatePrices();
+            expect(cart.bundleDiscounts).toHaveLength(1);
+            expect(cart.bundleDiscounts[0].total).toEqual(5000);
+            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(5000);
+            expect(cart.price).toEqual(5000 + 4000);
+            expect(checkout.totalPrice).toEqual(4000);
+            expect(checkout.priceBreakown).toEqual([
+                expect.objectContaining({
+                    price: 5000 + 4000,
+                }),
+                {
+                    name: 'Multiple family members discount',
+                    price: -5000,
+                },
+                expect.objectContaining({
+                    price: 4000,
+                }),
+            ]);
+        });
+        test.todo('Can handle bundle discounts for a future period');
+        test.todo('Families should be calculated correctly for admins');
+        test.todo('The price per item can never be negative');
+    });
+});
+//# sourceMappingURL=RegisterCart.test.js.map