@stamhoofd/structures 2.4.0 → 2.6.0

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

@@ -1,9 +1,10 @@
 import { __decorate } from "tslib";
-import { AutoEncoder, BooleanDecoder, field, IntegerDecoder, StringDecoder } from "@simonbackx/simple-encoding";
-import { isSimpleError, isSimpleErrors, SimpleError } from "@simonbackx/simple-errors";
-import { Formatter } from "@stamhoofd/utility";
-import { GroupOption, GroupOptionMenu, GroupPrice, WaitingListType } from "../../GroupSettings";
+import { ArrayDecoder, AutoEncoder, field, IntegerDecoder, StringDecoder } from "@simonbackx/simple-encoding";
+import { isSimpleError, isSimpleErrors, SimpleError, SimpleErrors } from "@simonbackx/simple-errors";
 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);
@@ -20,8 +21,12 @@ __decorate([
     field({ decoder: IntegerDecoder })
 ], RegisterItemOption.prototype, "amount", void 0);
 export class IDRegisterItem extends AutoEncoder {
+    constructor() {
+        super(...arguments);
+        this.options = [];
+    }
     hydrate(context) {
-        return RegisterItem.fromId(this, context.family);
+        return RegisterItem.fromId(this, context);
     }
 }
 __decorate([
@@ -37,35 +42,118 @@ __decorate([
     field({ decoder: StringDecoder })
 ], IDRegisterItem.prototype, "organizationId", void 0);
 __decorate([
-    field({ decoder: BooleanDecoder })
-], IDRegisterItem.prototype, "waitingList", void 0);
+    field({ decoder: GroupPrice })
+], IDRegisterItem.prototype, "groupPrice", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(RegisterItemOption) })
+], IDRegisterItem.prototype, "options", void 0);
 export class RegisterItem {
-    static fromRegistration(registration, member) {
+    /**
+     * @deprecated
+     */
+    get waitingList() {
+        return false;
+    }
+    static fromRegistration(registration, member, organization) {
         return new RegisterItem({
             id: registration.id,
             member,
             group: registration.group,
-            waitingList: registration.waitingList
+            organization
         });
     }
     constructor(data) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         this.options = [];
-        this.waitingList = false;
         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
+         */
+        this.cartError = null;
         this.id = (_a = data.id) !== null && _a !== void 0 ? _a : uuidv4();
         this.member = data.member;
         this.group = data.group;
-        this.groupPrice = (_b = this.group.settings.prices[0]) !== null && _b !== void 0 ? _b : GroupPrice.create({});
-        this.waitingList = data.waitingList;
+        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 = (_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) {
+                if (this.options.find(o => o.optionMenu.id === optionMenu.id)) {
+                    continue;
+                }
+                this.options.push(RegisterItemOption.create({
+                    option: optionMenu.options[0],
+                    optionMenu: optionMenu,
+                    amount: 1
+                }));
+            }
+        }
+    }
+    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 || (!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;
+        }
+    }
+    clone() {
+        return new RegisterItem({
+            id: this.id,
+            member: this.member,
+            group: this.group,
+            organization: this.organization,
+            groupPrice: this.groupPrice.clone(),
+            options: this.options.map(o => o.clone())
+        });
+    }
+    copyFrom(item) {
+        this.groupPrice = item.groupPrice.clone();
+        this.options = item.options.map(o => o.clone());
+        this.calculatedPrice = item.calculatedPrice;
+    }
+    getFilteredPrices() {
+        return this.group.settings.prices.filter(p => {
+            if (p.hidden && !this.checkout.isAdminFromSameOrganization) {
+                return false;
+            }
+            return true;
+        });
+    }
+    getFilteredOptionMenus() {
+        return this.group.settings.optionMenus.filter(p => {
+            return this.getFilteredOptions(p).length > 0;
+        });
+    }
+    getFilteredOptions(menu) {
+        return menu.options.filter(p => {
+            if (p.hidden && !this.checkout.isAdminFromSameOrganization) {
+                return false;
+            }
+            return true;
+        });
     }
     convert() {
         return IDRegisterItem.create({
             id: this.id,
             memberId: this.member.member.id,
             groupId: this.group.id,
-            organizationId: this.group.organizationId,
-            waitingList: this.waitingList
+            organizationId: this.organization.id,
+            groupPrice: this.groupPrice,
+            options: this.options
         });
     }
     get memberId() {
@@ -84,36 +172,101 @@ export class RegisterItem {
     get checkout() {
         return this.family.checkout;
     }
-    static defaultFor(member, group) {
-        const item = new RegisterItem({
+    static defaultFor(member, group, organization) {
+        if (group.organizationId !== organization.id) {
+            throw new Error("Group and organization do not match in RegisterItem.defaultFor");
+        }
+        let item = new RegisterItem({
             member,
             group,
-            waitingList: false
+            organization
         });
-        item.waitingList = item.shouldUseWaitingList();
+        if (item.shouldUseWaitingList() && group.waitingList) {
+            group = group.waitingList;
+            item = RegisterItem.defaultFor(member, group, organization);
+        }
         return item;
     }
-    get organization() {
-        return this.member.organizations.find(o => o.id === this.group.organizationId);
-    }
     /**
      * Update self to the newest available data, and throw error if something failed (only after refreshing other ones)
      */
-    refresh() {
-        // todo
+    refresh(group) {
+        this.group = group;
+        const errors = new SimpleErrors();
+        if (this.group.settings.prices.length === 0) {
+            errors.addError(new SimpleError({
+                code: "product_unavailable",
+                message: "Product unavailable",
+                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 {
+            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();
+        for (const o of this.options) {
+            let index = remainingMenus.findIndex(m => m.id === o.optionMenu.id);
+            if (index == -1) {
+                // Check if it has a multiple choice one
+                index = this.group.settings.optionMenus.findIndex(m => m.id === o.optionMenu.id);
+                errors.addError(new SimpleError({
+                    code: "option_menu_unavailable",
+                    message: "Option menu unavailable",
+                    human: "Eén of meerdere keuzemogelijkheden van " + this.group.settings.name + " zijn niet meer beschikbaar"
+                }));
+                continue;
+            }
+            const menu = remainingMenus[index];
+            if (!menu.multipleChoice) {
+                // Already used: not possible to add another
+                remainingMenus.splice(index, 1)[0];
+            }
+            const option = menu.options.find(m => m.id === o.option.id);
+            if (!option) {
+                errors.addError(new SimpleError({
+                    code: "option_unavailable",
+                    message: "Option unavailable",
+                    human: "Eén of meerdere keuzemogelijkheden van " + this.group.settings.name + " zijn niet meer beschikbaar"
+                }));
+                continue;
+            }
+            // Update to latest data
+            o.optionMenu = menu;
+            o.option = option;
+        }
+        if (remainingMenus.filter(m => !m.multipleChoice).length > 0) {
+            errors.addError(new SimpleError({
+                code: "missing_menu",
+                message: "Missing menu's " + remainingMenus.filter(m => !m.multipleChoice).map(m => m.name).join(", "),
+                human: "Er zijn nieuwe keuzemogelijkheden voor " + this.group.settings.name + " waaruit je moet kiezen"
+            }));
+        }
+        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;
@@ -128,51 +281,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 => 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 => 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 && 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.settings.waitingListIfFull) {
-                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) {
@@ -182,7 +357,7 @@ export class RegisterItem {
         if (this.group.settings.waitingListType === WaitingListType.ExistingMembersFirst && !existingMember) {
             return true;
         }
-        if (this.group.settings.waitingListIfFull) {
+        if (this.group.waitingList) {
             if (this.hasReachedGroupMaximum()) {
                 return true;
             }
@@ -216,14 +391,53 @@ 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;
-        if (!this.checkout.cart.contains(this)) {
-            if (!this.checkout.cart.canAdd(this)) {
+        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");
+        }
+        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"
                 });
             }
         }
@@ -240,95 +454,107 @@ 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.settings.waitingListIfFull) {
-                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.`
+                });
+            }
+            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.`
+                });
+            }
+            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.`
+                });
+            }
+            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, family) {
-        const member = family.members.find(m => m.member.id === idRegisterItem.memberId);
+    static fromId(idRegisterItem, context) {
+        const member = context.members.find(m => m.member.id === idRegisterItem.memberId);
         if (!member) {
             throw new Error("Member not found: " + idRegisterItem.memberId);
         }
-        const organization = member.organizations.find(o => o.id === idRegisterItem.organizationId);
+        const organization = context.organizations.find(o => o.id === idRegisterItem.organizationId);
         if (!organization) {
             throw new Error("Organization not found: " + idRegisterItem.organizationId);
         }
-        const group = organization.groups.find(g => g.id === idRegisterItem.groupId);
+        const group = context.groups.find(g => g.id === idRegisterItem.groupId);
         if (!group) {
             throw new Error("Group not found: " + idRegisterItem.groupId);
         }
@@ -336,7 +562,9 @@ export class RegisterItem {
             id: idRegisterItem.id,
             member,
             group,
-            waitingList: idRegisterItem.waitingList
+            organization,
+            groupPrice: idRegisterItem.groupPrice,
+            options: idRegisterItem.options
         });
     }
     get paymentConfiguration() {
@@ -345,5 +573,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