@stamhoofd/structures 2.5.0 → 2.7.0

package/esm/dist/src/members/checkout/RegisterItem.js

@@ -1,9 +1,10 @@
 import { __decorate } from "tslib";
 import { ArrayDecoder, AutoEncoder, field, IntegerDecoder, StringDecoder } from "@simonbackx/simple-encoding";
 import { isSimpleError, isSimpleErrors, SimpleError, SimpleErrors } from "@simonbackx/simple-errors";
-import { Formatter } from "@stamhoofd/utility";
-import { GroupOption, GroupOptionMenu, GroupPrice, WaitingListType } from "../../GroupSettings";
 import { v4 as uuidv4 } from "uuid";
+import { GroupType } from "../../Group";
+import { GroupOption, GroupOptionMenu, GroupPrice, WaitingListType } from "../../GroupSettings";
+import { StockReservation } from "../../StockReservation";
 export class RegisterItemOption extends AutoEncoder {
     constructor() {
         super(...arguments);
@@ -62,9 +63,13 @@ export class RegisterItem {
         });
     }
     constructor(data) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         this.options = [];
         this.calculatedPrice = 0;
+        /**
+         * These registrations will be replaced as part of this new registration (moving or updating a registration is possible this way)
+         */
+        this.replaceRegistrations = [];
         /**
          * Show an error in the cart for recovery
          */
@@ -72,12 +77,10 @@ export class RegisterItem {
         this.id = (_a = data.id) !== null && _a !== void 0 ? _a : uuidv4();
         this.member = data.member;
         this.group = data.group;
-        if (this.group.settings.prices.length === 0) {
-            throw new Error("Group has no prices");
-        }
-        this.groupPrice = (_b = data.groupPrice) !== null && _b !== void 0 ? _b : this.group.settings.prices[0];
+        this.groupPrice = (_c = (_b = data.groupPrice) !== null && _b !== void 0 ? _b : this.group.settings.prices[0]) !== null && _c !== void 0 ? _c : GroupPrice.create({ name: 'Ongeldig tarief', id: '' });
         this.organization = data.organization;
-        this.options = (_c = data.options) !== null && _c !== void 0 ? _c : [];
+        this.options = (_d = data.options) !== null && _d !== void 0 ? _d : [];
+        this.replaceRegistrations = (_e = data.replaceRegistrations) !== null && _e !== void 0 ? _e : [];
         // Select all defaults
         for (const optionMenu of this.group.settings.optionMenus) {
             if (!optionMenu.multipleChoice) {
@@ -92,14 +95,46 @@ export class RegisterItem {
             }
         }
     }
+    get isInCart() {
+        return this.member.family.checkout.cart.contains(this);
+    }
     get showItemView() {
-        return this.shouldUseWaitingList() || this.group.settings.prices.length > 1 || this.group.settings.optionMenus.length > 0;
+        return this.shouldUseWaitingList() || this.replaceRegistrations.length || this.group.settings.prices.length > 1 || this.group.settings.optionMenus.length > 0 || (!this.isInCart && !this.isValid);
     }
     calculatePrice() {
         this.calculatedPrice = this.groupPrice.price.forMember(this.member);
         for (const option of this.options) {
             this.calculatedPrice += option.option.price.forMember(this.member) * option.amount;
         }
+        for (const registration of this.replaceRegistrations) {
+            this.calculatedPrice -= registration.price;
+        }
+    }
+    get priceBreakown() {
+        let all = [];
+        let replacePrice = 0;
+        for (const registration of this.replaceRegistrations) {
+            replacePrice += registration.price;
+            all.push({
+                name: 'Terugbetaling ' + registration.group.settings.name,
+                price: -registration.price
+            });
+        }
+        const subtotal = this.calculatedPrice + replacePrice;
+        all = all.filter(a => a.price !== 0);
+        if (all.length > 0) {
+            all.unshift({
+                name: 'Subtotaal',
+                price: subtotal
+            });
+        }
+        return [
+            ...all,
+            {
+                name: 'Totaal',
+                price: this.calculatedPrice
+            }
+        ];
     }
     clone() {
         return new RegisterItem({
@@ -108,7 +143,8 @@ export class RegisterItem {
             group: this.group,
             organization: this.organization,
             groupPrice: this.groupPrice.clone(),
-            options: this.options.map(o => o.clone())
+            options: this.options.map(o => o.clone()),
+            replaceRegistrations: this.replaceRegistrations.map(r => r.clone())
         });
     }
     copyFrom(item) {
@@ -116,22 +152,22 @@ export class RegisterItem {
         this.options = item.options.map(o => o.clone());
         this.calculatedPrice = item.calculatedPrice;
     }
-    getFilteredPrices(options) {
+    getFilteredPrices() {
         return this.group.settings.prices.filter(p => {
-            if (p.hidden && !options.admin) {
+            if (p.hidden && !this.checkout.isAdminFromSameOrganization) {
                 return false;
             }
             return true;
         });
     }
-    getFilteredOptionMenus(options) {
+    getFilteredOptionMenus() {
         return this.group.settings.optionMenus.filter(p => {
-            return this.getFilteredOptions(p, options).length > 0;
+            return this.getFilteredOptions(p).length > 0;
         });
     }
-    getFilteredOptions(menu, options) {
+    getFilteredOptions(menu) {
         return menu.options.filter(p => {
-            if (p.hidden && !options.admin) {
+            if (p.hidden && !this.checkout.isAdminFromSameOrganization) {
                 return false;
             }
             return true;
@@ -172,6 +208,10 @@ export class RegisterItem {
             group,
             organization
         });
+        //if (item.shouldUseWaitingList() && group.waitingList) {
+        //    group = group.waitingList
+        //    item = RegisterItem.defaultFor(member, group, organization);
+        //}
         return item;
     }
     /**
@@ -180,16 +220,25 @@ export class RegisterItem {
     refresh(group) {
         this.group = group;
         const errors = new SimpleErrors();
-        const groupPrice = this.group.settings.prices.find(p => p.id === this.groupPrice.id);
-        if (!groupPrice) {
+        if (this.group.settings.prices.length === 0) {
             errors.addError(new SimpleError({
                 code: "product_unavailable",
                 message: "Product unavailable",
-                human: "Eén of meerdere tarieven van " + this.group.settings.name + " zijn niet meer beschikbaar"
+                human: "Er is iets fout met de tariefinstellingen van " + this.group.settings.name + ", waardoor je nu niet kan inschrijven. Neem contact op met een beheerder en vraag de tariefinstellingen na te kijken."
             }));
         }
         else {
-            this.groupPrice = groupPrice;
+            const groupPrice = this.group.settings.prices.find(p => p.id === this.groupPrice.id);
+            if (!groupPrice) {
+                errors.addError(new SimpleError({
+                    code: "product_unavailable",
+                    message: "Product unavailable",
+                    human: "Eén of meerdere tarieven van " + this.group.settings.name + " zijn niet meer beschikbaar"
+                }));
+            }
+            else {
+                this.groupPrice = groupPrice;
+            }
         }
         // Check all options
         const remainingMenus = this.group.settings.optionMenus.slice();
@@ -233,17 +282,18 @@ export class RegisterItem {
         errors.throwIfNotEmpty();
     }
     isAlreadyRegistered() {
-        return !!this.member.member.registrations.find(r => r.groupId === this.group.id && (this.waitingList || r.registeredAt !== null) && r.deactivatedAt === null && r.waitingList === this.waitingList && r.cycle === this.group.cycle);
+        return !!this.member.member.registrations.find(r => r.groupId === this.group.id && r.registeredAt !== null && r.deactivatedAt === null);
     }
     hasReachedCategoryMaximum() {
+        if (this.group.type !== GroupType.Membership) {
+            return false;
+        }
         const parents = this.group.getParentCategories(this.organization.period.settings.categories, false);
         for (const parent of parents) {
             if (parent.settings.maximumRegistrations !== null) {
-                const count = this.member.member.registrations.filter(r => {
-                    if (r.registeredAt !== null && !r.waitingList && r.deactivatedAt === null && parent.groupIds.includes(r.groupId)) {
-                        // Check cycle (only count current periods, not previous periods)
-                        const g = this.organization.groups.find(gg => gg.id === r.groupId);
-                        return g && g.cycle === r.cycle;
+                const count = this.member.patchedMember.registrations.filter(r => {
+                    if (r.registeredAt !== null && r.deactivatedAt === null && parent.groupIds.includes(r.groupId)) {
+                        return true;
                     }
                     return false;
                 }).length;
@@ -258,51 +308,73 @@ export class RegisterItem {
         return false;
     }
     isInvited() {
-        return !!this.member.member.registrations.find(r => r.groupId === this.group.id && r.waitingList && r.canRegister && r.cycle === this.group.cycle);
+        return !!this.member.member.registrations.find(r => r.groupId === this.group.id && r.registeredAt === null && r.canRegister);
     }
     doesMeetRequireGroupIds() {
         if (this.group.settings.requireGroupIds.length > 0) {
             const hasGroup = this.member.member.registrations.find(r => {
-                const registrationGroup = this.organization.groups.find(g => g.id === r.groupId);
-                if (!registrationGroup) {
-                    return false;
-                }
-                return this.group.settings.requireGroupIds.includes(r.groupId) && r.registeredAt !== null && r.deactivatedAt === null && !r.waitingList && r.cycle === registrationGroup.cycle;
+                return r.registeredAt !== null && r.deactivatedAt === null && this.group.settings.requireGroupIds.includes(r.groupId);
             });
-            if (!hasGroup && !this.checkout.cart.items.find(item => this.group.settings.requireGroupIds.includes(item.group.id) && item.member.member.id === this.member.member.id && !item.waitingList)) {
+            if (!hasGroup && !this.checkout.cart.items.find(item => item.member.id === this.member.id && this.group.settings.requireGroupIds.includes(item.group.id))) {
+                return false;
+            }
+        }
+        if (this.group.settings.requireDefaultAgeGroupIds.length > 0) {
+            const hasGroup = this.member.member.registrations.find(r => {
+                return r.registeredAt !== null && r.deactivatedAt === null && r.group.defaultAgeGroupId && this.group.settings.requireDefaultAgeGroupIds.includes(r.group.defaultAgeGroupId);
+            });
+            if (!hasGroup && !this.checkout.cart.items.find(item => item.member.id === this.member.id && item.group.defaultAgeGroupId && this.group.settings.requireDefaultAgeGroupIds.includes(item.group.defaultAgeGroupId))) {
                 return false;
             }
         }
         return true;
     }
-    isExistingMemberOrFamily() {
-        return this.member.isExistingMember(this.group.organizationId) || (this.group.settings.priorityForFamily && !!this.family.members.find(f => f.isExistingMember(this.group.organizationId)));
+    doesMeetRequireOrganizationIds() {
+        if (this.group.settings.requireOrganizationIds.length > 0) {
+            const hasGroup = this.member.member.registrations.find(r => {
+                return r.group.type === GroupType.Membership && this.group.settings.requireOrganizationIds.includes(r.organizationId) && r.registeredAt !== null && r.deactivatedAt === null;
+            });
+            if (!hasGroup && !this.checkout.cart.items.find(item => item.member.id === this.member.id && this.group.settings.requireOrganizationIds.includes(item.organization.id))) {
+                return false;
+            }
+        }
+        return true;
     }
-    get rowLabel() {
-        if (this.isInvited()) {
-            return 'Uitnodiging';
+    doesMeetRequireOrganizationTags() {
+        if (this.group.settings.requireOrganizationTags.length > 0) {
+            const hasOrganization = this.member.filterOrganizations({ currentPeriod: true, types: [GroupType.Membership] }).find(organization => {
+                return organization.meta.matchTags(this.group.settings.requireOrganizationTags);
+            });
+            if (!hasOrganization && !this.checkout.cart.items.find(item => item.member.id === this.member.id && item.organization.meta.matchTags(this.group.settings.requireOrganizationTags))) {
+                return false;
+            }
         }
-        return null;
+        return true;
     }
-    get infoDescription() {
-        if (this.isInvited()) {
-            return 'Je bent uitgenodigd om in te schrijven voor deze groep';
+    doesMeetRequirePlatformMembershipOn() {
+        if (this.group.settings.requirePlatformMembershipOn !== null) {
+            const requirePlatformMembershipOn = this.group.settings.requirePlatformMembershipOn;
+            return !!this.member.patchedMember.platformMemberships.find(m => m.isActive(requirePlatformMembershipOn));
         }
-        if (this.waitingList) {
-            if (this.group.settings.waitingListType === WaitingListType.All) {
-                return 'Je kan enkel inschrijven voor de wachtlijst';
-            }
-            const existingMember = this.isExistingMemberOrFamily();
-            if (this.group.settings.waitingListType === WaitingListType.ExistingMembersFirst && !existingMember) {
-                return 'Nieuwe leden kunnen enkel inschrijven voor de wachtlijst';
-            }
-            if (this.group.waitingList) {
-                if (this.hasReachedGroupMaximum()) {
-                    return 'De inschrijvingen zijn volzet, je kan enkel inschrijven voor de wachtlijst';
-                }
+        return true;
+    }
+    isExistingMemberOrFamily() {
+        return this.member.isExistingMember(this.group.organizationId) || (this.group.settings.priorityForFamily && !!this.family.members.find(f => f.isExistingMember(this.group.organizationId)));
+    }
+    get description() {
+        const descriptions = [];
+        if (this.replaceRegistrations.length > 0) {
+            for (const registration of this.replaceRegistrations) {
+                descriptions.push("Verplaatsen vanaf " + registration.group.settings.name);
             }
         }
-        return null;
+        if (this.getFilteredPrices().length > 1) {
+            descriptions.push(this.groupPrice.name);
+        }
+        for (const option of this.options) {
+            descriptions.push(option.optionMenu.name + ': ' + option.option.name + (option.option.allowAmount ? ` x ${option.amount}` : ""));
+        }
+        return descriptions.filter(d => !!d).join("\n");
     }
     shouldUseWaitingList() {
         if (this.group.settings.waitingListType === WaitingListType.All) {
@@ -346,19 +418,60 @@ export class RegisterItem {
         }
         return null;
     }
-    validate() {
+    get validationWarning() {
+        if (this.validationError) {
+            return null;
+        }
+        if (!this.member.family.checkout.isAdminFromSameOrganization) {
+            // Warnings are only for admins
+            return null;
+        }
+        try {
+            this.validate({ warnings: true });
+        }
+        catch (e) {
+            if (isSimpleError(e) || isSimpleErrors(e)) {
+                return e.getHuman();
+            }
+            throw e;
+        }
+        return null;
+    }
+    get isValid() {
+        return this.validationError === null;
+    }
+    validate(options) {
         var _a;
         this.cartError = null;
         this.refresh(this.group);
+        const checkout = this.member.family.checkout;
+        const admin = checkout.isAdminFromSameOrganization && !(options === null || options === void 0 ? void 0 : options.warnings);
         if (this.group.organizationId !== this.organization.id) {
             throw new Error("Group and organization do not match in RegisterItem.validate");
         }
-        if (!this.checkout.cart.contains(this)) {
-            if (!this.checkout.cart.canAdd(this)) {
+        if (checkout.asOrganizationId && !admin && !this.group.settings.allowRegistrationsByOrganization) {
+            throw new SimpleError({
+                code: "as_organization_disabled",
+                message: "allowRegistrationsByOrganization disabled",
+                human: "Inschrijvingen door organisaties zijn niet toegestaan voor " + this.group.settings.name,
+            });
+        }
+        for (const registration of this.replaceRegistrations) {
+            // todo: check if you are allowed to move
+            if (registration.member.id !== this.member.id) {
                 throw new SimpleError({
-                    code: "already_registered",
-                    message: "Already registered",
-                    human: `Reken jouw winkelmandje eerst af. Het is niet mogelijk om deze inschrijving samen af te rekenen omdat het inschrijvingsgeld aan een andere partij betaald moet worden.`
+                    code: "invalid_move",
+                    message: "Invalid member in replaceRegistration",
+                    human: "Je wilt een inschrijving verplaatsen van een ander lid in ruil voor een ander lid. Dit is niet toegestaan.",
+                    field: "replaceRegistrations"
+                });
+            }
+            if (registration.group.organizationId !== this.organization.id) {
+                throw new SimpleError({
+                    code: "invalid_move",
+                    message: "Invalid organization in replaceRegistration",
+                    human: "Je wilt een inschrijving verplaatsen van een andere organisatie. Dit is niet toegestaan.",
+                    field: "replaceRegistrations"
                 });
             }
         }
@@ -375,83 +488,95 @@ export class RegisterItem {
             throw new SimpleError({
                 code: "maximum_reached",
                 message: "Maximum reached",
-                human: `Je kan niet meer inschrijven voor ${this.group.settings.name} omdat je al ingeschreven bent of aan het inschrijven bent voor een groep die je niet kan combineren.`
+                human: `Je kan niet meer inschrijven voor ${this.group.settings.name} omdat ${this.member.patchedMember.name} al ingeschreven is voor een groep die je niet kan combineren.`
             });
         }
         // Check if we have an invite (doesn't matter if registrations are closed)
         if (this.isInvited()) {
             return;
         }
-        if (this.group.notYetOpen) {
-            throw new SimpleError({
-                code: "not_yet_open",
-                message: "Not yet open",
-                human: `De inschrijvingen voor ${this.group.settings.name} zijn nog niet geopend.`
-            });
-        }
-        if (this.group.closed) {
-            throw new SimpleError({
-                code: "closed",
-                message: "Closed",
-                human: `De inschrijvingen voor ${this.group.settings.name} zijn gesloten.`
-            });
-        }
-        // Check if it fits
-        if (this.member.member.details) {
-            if (!this.member.member.details.doesMatchGroup(this.group)) {
-                const error = this.member.member.details.getMatchingError(this.group);
+        if (!admin) {
+            if (this.group.notYetOpen) {
                 throw new SimpleError({
-                    code: "not_matching",
-                    message: "Not matching",
-                    human: (_a = error === null || error === void 0 ? void 0 : error.description) !== null && _a !== void 0 ? _a : "Je voldoet niet aan de voorwaarden om in te schrijven voor deze groep."
+                    code: "not_yet_open",
+                    message: "Not yet open",
+                    human: `De inschrijvingen voor ${this.group.settings.name} zijn nog niet geopend.`
                 });
             }
-        }
-        // Check if registrations are limited
-        if (!this.doesMeetRequireGroupIds()) {
-            throw new SimpleError({
-                code: "not_matching",
-                message: "Not matching",
-                human: "Inschrijving bij " + Formatter.joinLast(this.group.settings.requireGroupIds.map(id => { var _a, _b; return (_b = (_a = this.organization.groups.find(g => g.id === id)) === null || _a === void 0 ? void 0 : _a.settings.name) !== null && _b !== void 0 ? _b : "Onbekend"; }), ", ", " of ") + " is verplicht voor je kan inschrijven voor " + this.group.settings.name,
-            });
-        }
-        const existingMember = this.isExistingMemberOrFamily();
-        // Pre registrations?
-        if (this.group.activePreRegistrationDate) {
-            if (!existingMember) {
+            if (this.group.closed) {
                 throw new SimpleError({
-                    code: "pre_registrations",
-                    message: "Pre registrations",
-                    human: "Momenteel zijn de voorinschrijvingen nog bezig voor " + this.group.settings.name + ". Dit is enkel voor bestaande leden" + (this.group.settings.priorityForFamily ? " en hun broers/zussen" : "") + "."
+                    code: "closed",
+                    message: "Closed",
+                    human: `De inschrijvingen voor ${this.group.settings.name} zijn gesloten.`
                 });
             }
-        }
-        if (!this.waitingList && this.shouldUseWaitingList()) {
-            throw new SimpleError({
-                code: "waiting_list_required",
-                message: "Waiting list required",
-                human: `${this.member.member.firstName} kan momenteel enkel voor de wachtlijst van ${this.group.settings.name} inschrijven.`
-            });
-        }
-        if (!this.waitingList) {
-            if (!this.group.waitingList) {
-                if (this.hasReachedGroupMaximum()) {
+            // Check if it fits
+            if (this.member.member.details) {
+                if (!this.member.member.details.doesMatchGroup(this.group)) {
+                    const error = this.member.member.details.getMatchingError(this.group);
                     throw new SimpleError({
-                        code: "maximum_reached",
-                        message: "Maximum reached",
-                        human: `De inschrijvingen voor ${this.group.settings.name} zijn volzet. Je kan wel nog inschrijven voor de wachtlijst.`
+                        code: "not_matching",
+                        message: "Not matching: memberDetails",
+                        human: (_a = error === null || error === void 0 ? void 0 : error.description) !== null && _a !== void 0 ? _a : `${this.member.patchedMember.name} voldoet niet aan de voorwaarden om in te schrijven voor deze groep.`
                     });
                 }
             }
-            else {
-                if (this.hasReachedGroupMaximum()) {
+            // Check if registrations are limited
+            if (!this.doesMeetRequireGroupIds()) {
+                throw new SimpleError({
+                    code: "not_matching",
+                    message: "Not matching: requireGroupIds",
+                    human: `${this.member.patchedMember.name} voldoet niet aan de voorwaarden om in te schrijven voor deze groep (verplichte inschrijving bij leeftijdsgroep).`
+                });
+            }
+            if (!this.doesMeetRequireOrganizationIds()) {
+                throw new SimpleError({
+                    code: "not_matching",
+                    message: "Not matching: requireOrganizationIds",
+                    human: `${this.member.patchedMember.name} kan pas inschrijven met een geldige actieve inschrijving  (verplichte inschrijving bij lokale groep).`
+                });
+            }
+            if (!this.doesMeetRequireOrganizationTags()) {
+                throw new SimpleError({
+                    code: "not_matching",
+                    message: "Not matching: requireOrganizationIds",
+                    human: `${this.member.patchedMember.name} kan pas inschrijven met een geldige actieve inschrijving  (verplichte inschrijving in regio).`
+                });
+            }
+            if (!this.doesMeetRequirePlatformMembershipOn()) {
+                throw new SimpleError({
+                    code: "not_matching",
+                    message: "Not matching: requirePlatformMembershipOn",
+                    human: `${this.member.patchedMember.name} kan pas inschrijven met een geldige aansluiting (en dus verzekering) bij de koepel`
+                });
+            }
+            const existingMember = this.isExistingMemberOrFamily();
+            // Pre registrations?
+            if (this.group.activePreRegistrationDate) {
+                if (!existingMember) {
                     throw new SimpleError({
-                        code: "maximum_reached",
-                        message: "Maximum reached",
-                        human: `De inschrijvingen voor ${this.group.settings.name} zijn volzet.`
+                        code: "pre_registrations",
+                        message: "Pre registrations",
+                        human: "Momenteel zijn de voorinschrijvingen nog bezig voor " + this.group.settings.name + ". Dit is enkel voor bestaande leden" + (this.group.settings.priorityForFamily ? " en hun broers/zussen" : "") + "."
                     });
                 }
             }
+            if (this.shouldUseWaitingList()) {
+                throw new SimpleError({
+                    code: "waiting_list_required",
+                    message: "Waiting list required",
+                    human: `${this.member.member.firstName} kan momenteel enkel voor de wachtlijst van ${this.group.settings.name} inschrijven.`,
+                    meta: { recoverable: true }
+                });
+            }
+            if (this.hasReachedGroupMaximum()) {
+                throw new SimpleError({
+                    code: "maximum_reached",
+                    message: "Maximum reached",
+                    human: this.group.waitingList ? `De inschrijvingen voor ${this.group.settings.name} zijn volzet. Je kan wel nog inschrijven voor de wachtlijst.` : `De inschrijvingen voor ${this.group.settings.name} zijn volzet. `,
+                    meta: { recoverable: true }
+                });
+            }
         }
     }
     static fromId(idRegisterItem, context) {
@@ -482,5 +607,45 @@ export class RegisterItem {
         }
         return this.organization.meta.registrationPaymentConfiguration;
     }
+    /**
+     * Returns the stock that will be taken (or freed if negative) by all the register items before this item
+     * and with the removed registrations freed up, so this can be negative
+     */
+    getCartPendingStockReservations() {
+        const deleteRegistrations = this.checkout.cart.deleteRegistrations.filter(r => r.groupId === this.group.id);
+        const cartIndex = this.checkout.cart.items.findIndex(i => i.id === this.id);
+        const itemsBefore = this.checkout.cart.items.slice(0, cartIndex === -1 ? undefined : cartIndex);
+        return StockReservation.removed(itemsBefore.flatMap(i => i.getPendingStockReservations()), // these will be removed
+        deleteRegistrations.flatMap(r => r.stockReservations) // these will be freed up
+        );
+    }
+    /**
+     * Stock that will be taken by this item
+     */
+    getPendingStockReservations() {
+        return [
+            // Global level stock reservations (stored in each group)
+            StockReservation.create({
+                objectId: this.group.id,
+                objectType: 'Group',
+                amount: 1,
+                children: [
+                    // Group level stock reservatiosn (stored in the group)
+                    StockReservation.create({
+                        objectId: this.groupPrice.id,
+                        objectType: 'GroupPrice',
+                        amount: 1
+                    }),
+                    ...this.options.map(o => {
+                        return StockReservation.create({
+                            objectId: o.option.id,
+                            objectType: 'GroupOption',
+                            amount: o.amount
+                        });
+                    })
+                ]
+            })
+        ];
+    }
 }
 //# sourceMappingURL=RegisterItem.js.map