@stamhoofd/structures 2.7.0 → 2.9.0

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

@@ -5,6 +5,7 @@ import { v4 as uuidv4 } from "uuid";
 import { GroupType } from "../../Group";
 import { GroupOption, GroupOptionMenu, GroupPrice, WaitingListType } from "../../GroupSettings";
 import { StockReservation } from "../../StockReservation";
+import { Formatter } from "@stamhoofd/utility";
 export class RegisterItemOption extends AutoEncoder {
     constructor() {
         super(...arguments);
@@ -24,6 +25,7 @@ export class IDRegisterItem extends AutoEncoder {
     constructor() {
         super(...arguments);
         this.options = [];
+        this.replaceRegistrationIds = [];
     }
     hydrate(context) {
         return RegisterItem.fromId(this, context);
@@ -47,6 +49,9 @@ __decorate([
 __decorate([
     field({ decoder: new ArrayDecoder(RegisterItemOption) })
 ], IDRegisterItem.prototype, "options", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(StringDecoder) })
+], IDRegisterItem.prototype, "replaceRegistrationIds", void 0);
 export class RegisterItem {
     /**
      * @deprecated
@@ -59,13 +64,33 @@ export class RegisterItem {
             id: registration.id,
             member,
             group: registration.group,
+            organization,
+            groupPrice: registration.groupPrice,
+            options: registration.options
+        });
+    }
+    static defaultFor(member, group, organization) {
+        if (group.organizationId !== organization.id) {
+            throw new Error("Group and organization do not match in RegisterItem.defaultFor");
+        }
+        const item = new RegisterItem({
+            member,
+            group,
             organization
         });
+        return item;
     }
     constructor(data) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g;
         this.options = [];
+        /**
+         * Price for the new registration
+         */
         this.calculatedPrice = 0;
+        /**
+         * Refund for the replaced registrations
+         */
+        this.calculatedRefund = 0;
         /**
          * These registrations will be replaced as part of this new registration (moving or updating a registration is possible this way)
          */
@@ -77,21 +102,59 @@ export class RegisterItem {
         this.id = (_a = data.id) !== null && _a !== void 0 ? _a : uuidv4();
         this.member = data.member;
         this.group = data.group;
-        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: '' });
+        if (!data.groupPrice) {
+            const prices = this.getFilteredPrices();
+            for (const price of prices) {
+                const stock = price.getRemainingStock(this);
+                if (stock !== 0) {
+                    this.groupPrice = price;
+                    break;
+                }
+            }
+            if (!this.groupPrice) {
+                // Probably all sold out
+                // Select the first one anyway
+                this.groupPrice = (_b = prices[0]) !== null && _b !== void 0 ? _b : GroupPrice.create({ name: 'Ongeldig tarief', id: '' });
+            }
+        }
+        else {
+            this.groupPrice = data.groupPrice;
+        }
         this.organization = data.organization;
-        this.options = (_d = data.options) !== null && _d !== void 0 ? _d : [];
-        this.replaceRegistrations = (_e = data.replaceRegistrations) !== null && _e !== void 0 ? _e : [];
+        this.options = (_c = data.options) !== null && _c !== void 0 ? _c : [];
+        this.replaceRegistrations = (_d = data.replaceRegistrations) !== null && _d !== void 0 ? _d : [];
+        this.cartError = (_e = data.cartError) !== null && _e !== void 0 ? _e : null;
+        this.calculatedPrice = (_f = data.calculatedPrice) !== null && _f !== void 0 ? _f : 0;
+        this.calculatedRefund = (_g = data.calculatedRefund) !== null && _g !== void 0 ? _g : 0;
         // 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
-                }));
+                let added = false;
+                const options = this.getFilteredOptions(optionMenu);
+                for (const option of options) {
+                    const stock = option.getRemainingStock(this);
+                    if (stock === 0) {
+                        continue;
+                    }
+                    this.options.push(RegisterItemOption.create({
+                        option,
+                        optionMenu: optionMenu,
+                        amount: 1
+                    }));
+                    added = true;
+                    break;
+                }
+                if (!added && options.length > 0) {
+                    // Add the first (this one is sold out, but still required for correct error handling)
+                    this.options.push(RegisterItemOption.create({
+                        option: options[0],
+                        optionMenu: optionMenu,
+                        amount: 1
+                    }));
+                }
             }
         }
     }
@@ -99,40 +162,43 @@ export class RegisterItem {
         return this.member.family.checkout.cart.contains(this);
     }
     get showItemView() {
-        return this.shouldUseWaitingList() || this.replaceRegistrations.length || this.group.settings.prices.length > 1 || this.group.settings.optionMenus.length > 0 || (!this.isInCart && !this.isValid);
+        return !!this.replaceRegistrations.length || this.group.settings.prices.length !== 1 || this.group.settings.optionMenus.length > 0 || this.group.type === GroupType.WaitingList || this.group.settings.description.length > 2 || this.group.settings.prices[0].price.price > 0 || (!this.isInCart && !this.isValid);
     }
     calculatePrice() {
         this.calculatedPrice = this.groupPrice.price.forMember(this.member);
+        this.calculatedRefund = 0;
         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;
+            this.calculatedRefund += registration.price;
         }
     }
+    get totalPrice() {
+        return this.calculatedPrice - this.calculatedRefund;
+    }
     get priceBreakown() {
         let all = [];
         let replacePrice = 0;
         for (const registration of this.replaceRegistrations) {
             replacePrice += registration.price;
             all.push({
-                name: 'Terugbetaling ' + registration.group.settings.name,
+                name: this.checkout.isAdminFromSameOrganization ? 'Reeds aangerekend voor ' + registration.group.settings.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
+                price: this.calculatedPrice
             });
         }
         return [
             ...all,
             {
-                name: 'Totaal',
-                price: this.calculatedPrice
+                name: this.checkout.isAdminFromSameOrganization ? (this.totalPrice >= 0 ? 'Openstaand bedrag stijgt met' : 'Openstaand bedrag daalt met') : 'Totaal',
+                price: this.checkout.isAdminFromSameOrganization ? Math.abs(this.totalPrice) : this.totalPrice
             }
         ];
     }
@@ -144,34 +210,30 @@ export class RegisterItem {
             organization: this.organization,
             groupPrice: this.groupPrice.clone(),
             options: this.options.map(o => o.clone()),
-            replaceRegistrations: this.replaceRegistrations.map(r => r.clone())
+            replaceRegistrations: this.replaceRegistrations.map(r => r.clone()),
+            cartError: this.cartError,
+            calculatedPrice: this.calculatedPrice,
+            calculatedRefund: this.calculatedRefund
         });
     }
     copyFrom(item) {
         this.groupPrice = item.groupPrice.clone();
         this.options = item.options.map(o => o.clone());
         this.calculatedPrice = item.calculatedPrice;
+        this.calculatedRefund = item.calculatedRefund;
     }
     getFilteredPrices() {
-        return this.group.settings.prices.filter(p => {
-            if (p.hidden && !this.checkout.isAdminFromSameOrganization) {
-                return false;
-            }
-            return true;
-        });
+        const base = this.group.settings.getFilteredPrices({ admin: this.checkout.isAdminFromSameOrganization });
+        if (this.groupPrice && !base.some(b => b.id === this.groupPrice.id)) {
+            return [this.groupPrice, ...base];
+        }
+        return base;
     }
     getFilteredOptionMenus() {
-        return this.group.settings.optionMenus.filter(p => {
-            return this.getFilteredOptions(p).length > 0;
-        });
+        return this.group.settings.getFilteredOptionMenus({ admin: this.checkout.isAdminFromSameOrganization });
     }
     getFilteredOptions(menu) {
-        return menu.options.filter(p => {
-            if (p.hidden && !this.checkout.isAdminFromSameOrganization) {
-                return false;
-            }
-            return true;
-        });
+        return menu.getFilteredOptions({ admin: this.checkout.isAdminFromSameOrganization });
     }
     convert() {
         return IDRegisterItem.create({
@@ -180,7 +242,8 @@ export class RegisterItem {
             groupId: this.group.id,
             organizationId: this.organization.id,
             groupPrice: this.groupPrice,
-            options: this.options
+            options: this.options,
+            replaceRegistrationIds: this.replaceRegistrations.map(r => r.id)
         });
     }
     get memberId() {
@@ -199,21 +262,6 @@ export class RegisterItem {
     get checkout() {
         return this.family.checkout;
     }
-    static defaultFor(member, group, organization) {
-        if (group.organizationId !== organization.id) {
-            throw new Error("Group and organization do not match in RegisterItem.defaultFor");
-        }
-        const item = new RegisterItem({
-            member,
-            group,
-            organization
-        });
-        //if (item.shouldUseWaitingList() && group.waitingList) {
-        //    group = group.waitingList
-        //    item = RegisterItem.defaultFor(member, group, organization);
-        //}
-        return item;
-    }
     /**
      * Update self to the newest available data, and throw error if something failed (only after refreshing other ones)
      */
@@ -233,7 +281,8 @@ export class RegisterItem {
                 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: "Eén of meerdere tarieven van " + this.group.settings.name + " zijn niet meer beschikbaar",
+                    meta: { recoverable: true }
                 }));
             }
             else {
@@ -250,7 +299,8 @@ export class RegisterItem {
                 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"
+                    human: "Eén of meerdere keuzemogelijkheden van " + this.group.settings.name + " zijn niet meer beschikbaar",
+                    meta: { recoverable: true }
                 }));
                 continue;
             }
@@ -264,7 +314,8 @@ export class RegisterItem {
                 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"
+                    human: "Eén of meerdere keuzemogelijkheden van " + this.group.settings.name + " zijn niet meer beschikbaar",
+                    meta: { recoverable: true }
                 }));
                 continue;
             }
@@ -276,13 +327,17 @@ export class RegisterItem {
             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"
+                human: "Er zijn nieuwe keuzemogelijkheden voor " + this.group.settings.name + " waaruit je moet kiezen",
+                meta: { recoverable: true }
             }));
         }
         errors.throwIfNotEmpty();
     }
+    willReplace(registrationId) {
+        return this.replaceRegistrations.some(rr => rr.id === registrationId);
+    }
     isAlreadyRegistered() {
-        return !!this.member.member.registrations.find(r => r.groupId === this.group.id && r.registeredAt !== null && r.deactivatedAt === null);
+        return !!this.member.member.registrations.find(r => !this.willReplace(r.id) && r.groupId === this.group.id && r.registeredAt !== null && r.deactivatedAt === null);
     }
     hasReachedCategoryMaximum() {
         if (this.group.type !== GroupType.Membership) {
@@ -292,7 +347,7 @@ export class RegisterItem {
         for (const parent of parents) {
             if (parent.settings.maximumRegistrations !== null) {
                 const count = this.member.patchedMember.registrations.filter(r => {
-                    if (r.registeredAt !== null && r.deactivatedAt === null && parent.groupIds.includes(r.groupId)) {
+                    if (!this.willReplace(r.id) && r.registeredAt !== null && r.deactivatedAt === null && parent.groupIds.includes(r.groupId)) {
                         return true;
                     }
                     return false;
@@ -313,7 +368,7 @@ export class RegisterItem {
     doesMeetRequireGroupIds() {
         if (this.group.settings.requireGroupIds.length > 0) {
             const hasGroup = this.member.member.registrations.find(r => {
-                return r.registeredAt !== null && r.deactivatedAt === null && this.group.settings.requireGroupIds.includes(r.groupId);
+                return !this.willReplace(r.id) && 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;
@@ -321,7 +376,7 @@ export class RegisterItem {
         }
         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);
+                return !this.willReplace(r.id) && 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;
@@ -332,7 +387,7 @@ export class RegisterItem {
     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;
+                return !this.willReplace(r.id) && 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;
@@ -376,36 +431,57 @@ export class RegisterItem {
         }
         return descriptions.filter(d => !!d).join("\n");
     }
-    shouldUseWaitingList() {
-        if (this.group.settings.waitingListType === WaitingListType.All) {
-            return true;
-        }
-        const existingMember = this.isExistingMemberOrFamily();
-        if (this.group.settings.waitingListType === WaitingListType.ExistingMembersFirst && !existingMember) {
+    hasReachedGroupMaximum() {
+        const available = this.group.settings.getRemainingStock(this);
+        if (available !== null && available <= 0) {
             return true;
         }
-        if (this.group.waitingList) {
-            if (this.hasReachedGroupMaximum()) {
+        // If all prices are sold out -> also reached maximum
+        const prices = this.getFilteredPrices();
+        if (prices.length > 0) {
+            let allPricesSoldOut = true;
+            for (const price of prices) {
+                const remaining = price.getRemainingStock(this);
+                if (remaining === null || remaining > 0) {
+                    allPricesSoldOut = false;
+                    break;
+                }
+            }
+            if (allPricesSoldOut) {
                 return true;
             }
         }
-        return false;
-    }
-    hasReachedGroupMaximum() {
-        const available = this.group.settings.availableMembers;
-        if (available !== null) {
-            const count = this.checkout.cart.items.filter(item => item.group.id === this.group.id && item.member.member.id !== this.member.member.id && !item.waitingList).length;
-            if (count >= available) {
-                // Check if we have a reserved spot
-                const now = new Date();
-                const reserved = this.member.member.registrations.find(r => r.groupId === this.group.id && r.reservedUntil && r.reservedUntil > now && !r.waitingList && r.registeredAt === null && r.cycle === this.group.cycle);
-                if (!reserved) {
+        // If non-multiple choice option menu's are sold out -> also reached maximum
+        const optionMenus = this.getFilteredOptionMenus();
+        for (const menu of optionMenus) {
+            if (!menu.multipleChoice) {
+                let allOptionsSoldOut = true;
+                for (const option of menu.options) {
+                    const remaining = option.getRemainingStock(this);
+                    if (remaining === null || remaining > 0) {
+                        allOptionsSoldOut = false;
+                        break;
+                    }
+                }
+                if (allOptionsSoldOut) {
                     return true;
                 }
             }
         }
         return false;
     }
+    get validationErrorForWaitingList() {
+        try {
+            this.validate({ forWaitingList: true });
+        }
+        catch (e) {
+            if (isSimpleError(e) || isSimpleErrors(e)) {
+                return e.getHuman();
+            }
+            throw e;
+        }
+        return null;
+    }
     get validationError() {
         try {
             this.validate();
@@ -442,14 +518,28 @@ export class RegisterItem {
     }
     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 (checkout.asOrganizationId && !admin && !this.group.settings.allowRegistrationsByOrganization) {
+        if (this.checkout.singleOrganization && this.checkout.singleOrganization.id !== this.organization.id) {
+            throw new SimpleError({
+                code: "multiple_organizations",
+                message: "Cannot add items of multiple organizations to the checkout",
+                human: `Reken eerst jouw huidige winkelmandje af. Inschrijvingen voor ${this.group.settings.name} moeten aan een andere organisatie betaald worden en kan je daardoor niet samen afrekenen.`,
+                meta: { recoverable: true }
+            });
+        }
+        if ((options === null || options === void 0 ? void 0 : options.forWaitingList) && !this.group.waitingList) {
+            throw new SimpleError({
+                code: "missing_waiting_list",
+                message: "No waiting list",
+                human: `Je kan niet inschrijven voor de wachtlijst`
+            });
+        }
+        if (checkout.asOrganizationId && !checkout.isAdminFromSameOrganization && !this.group.settings.allowRegistrationsByOrganization) {
             throw new SimpleError({
                 code: "as_organization_disabled",
                 message: "allowRegistrationsByOrganization disabled",
@@ -458,7 +548,7 @@ export class RegisterItem {
         }
         for (const registration of this.replaceRegistrations) {
             // todo: check if you are allowed to move
-            if (registration.member.id !== this.member.id) {
+            if (registration.memberId !== this.member.id) {
                 throw new SimpleError({
                     code: "invalid_move",
                     message: "Invalid member in replaceRegistration",
@@ -474,6 +564,14 @@ export class RegisterItem {
                     field: "replaceRegistrations"
                 });
             }
+            if (!admin) {
+                throw new SimpleError({
+                    code: "invalid_move",
+                    message: "Not allowed to move registrations",
+                    human: "Enkel beheerders kunnen inschrijvingen verplaatsen.",
+                    field: "replaceRegistrations"
+                });
+            }
         }
         // Already registered
         if (this.isAlreadyRegistered()) {
@@ -496,19 +594,21 @@ export class RegisterItem {
             return;
         }
         if (!admin) {
-            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.`
-                });
+            if (!(options === null || options === void 0 ? void 0 : options.forWaitingList)) {
+                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) {
@@ -561,22 +661,73 @@ export class RegisterItem {
                     });
                 }
             }
-            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 }
-                });
+            const reachedMaximum = this.hasReachedGroupMaximum();
+            if (!(options === null || options === void 0 ? void 0 : options.forWaitingList)) {
+                // More detailed error messages
+                if (this.group.settings.waitingListType === WaitingListType.All) {
+                    throw new SimpleError({
+                        code: "waiting_list_required",
+                        message: "Waiting list required",
+                        human: `Iedereen moet zich eerst op de wachtlijst inschrijven`,
+                        meta: { recoverable: true }
+                    });
+                }
+                if (this.group.settings.waitingListType === WaitingListType.ExistingMembersFirst && !existingMember) {
+                    throw new SimpleError({
+                        code: "waiting_list_required",
+                        message: "Waiting list required",
+                        human: `Nieuwe leden moeten zich eerst op de wachtlijst inschrijven`,
+                        meta: { recoverable: true }
+                    });
+                }
+                if (this.group.waitingList) {
+                    if (reachedMaximum) {
+                        throw new SimpleError({
+                            code: "waiting_list_required",
+                            message: "Waiting list required",
+                            human: `De inschrijvingen voor ${this.group.settings.name} zijn volzet. Je kan wel nog inschrijven voor de wachtlijst`,
+                            meta: { recoverable: true }
+                        });
+                    }
+                }
             }
-            if (this.hasReachedGroupMaximum()) {
+            if (reachedMaximum && !this.group.waitingList) {
+                // Reached maximum without waiting lists
                 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. `,
+                    human: `De inschrijvingen voor ${this.group.settings.name} zijn volzet`,
                     meta: { recoverable: true }
                 });
             }
+            // Only check individual stock if we haven't reached the maximum - otherwise it won't suggest to use the waiting list
+            if (!reachedMaximum) {
+                // Check individual stock
+                if (this.groupPrice.getRemainingStock(this) === 0) {
+                    throw new SimpleError({
+                        code: "stock_empty",
+                        message: "Stock empty",
+                        human: `Het tarief ${this.groupPrice.name} is uitverkocht`,
+                        meta: { recoverable: true }
+                    });
+                }
+                for (const option of this.options) {
+                    const remaining = option.option.getRemainingStock(this);
+                    if (remaining !== null && remaining < option.amount) {
+                        throw new SimpleError({
+                            code: "stock_empty",
+                            message: "Stock empty",
+                            human: remaining === 0 ? `De keuzemogelijkheid ${option.option.name} is uitverkocht` : `Er zijn nog maar ${Formatter.pluralText(remaining, 'stuk', 'stuks')} beschikbaar van ${option.option.name}`,
+                            meta: { recoverable: true }
+                        });
+                    }
+                }
+            }
+            if (options === null || options === void 0 ? void 0 : options.forWaitingList) {
+                // Also check waiting list itself
+                const item = RegisterItem.defaultFor(this.member, this.group.waitingList, this.organization);
+                item.validate({ warnings: options === null || options === void 0 ? void 0 : options.warnings });
+            }
         }
     }
     static fromId(idRegisterItem, context) {
@@ -592,27 +743,33 @@ export class RegisterItem {
         if (!group) {
             throw new Error("Group not found: " + idRegisterItem.groupId);
         }
+        const replaceRegistrations = [];
+        for (const registrationId of idRegisterItem.replaceRegistrationIds) {
+            const registration = member.patchedMember.registrations.find(r => r.id === registrationId);
+            if (!registration) {
+                throw new Error("Registration not found: " + registrationId);
+            }
+            replaceRegistrations.push(registration);
+        }
         return new RegisterItem({
             id: idRegisterItem.id,
             member,
             group,
             organization,
             groupPrice: idRegisterItem.groupPrice,
-            options: idRegisterItem.options
+            options: idRegisterItem.options,
+            replaceRegistrations
         });
     }
-    get paymentConfiguration() {
-        if (this.calculatedPrice === 0) {
-            return null;
-        }
-        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 deleteRegistrations = [
+            ...this.checkout.cart.deleteRegistrations.filter(r => r.groupId === this.group.id),
+            ...this.replaceRegistrations.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
@@ -620,10 +777,10 @@ export class RegisterItem {
         );
     }
     /**
-     * Stock that will be taken by this item
+     * Stock that will be taken or removed by this item
      */
     getPendingStockReservations() {
-        return [
+        const base = [
             // Global level stock reservations (stored in each group)
             StockReservation.create({
                 objectId: this.group.id,
@@ -646,6 +803,8 @@ export class RegisterItem {
                 ]
             })
         ];
+        const freed = this.replaceRegistrations.flatMap(r => r.stockReservations);
+        return StockReservation.removed(base, freed);
     }
 }
 //# sourceMappingURL=RegisterItem.js.map