@stamhoofd/structures 2.118.1 → 2.120.0

package/esm/dist/src/webshops/CartItem.js

@@ -1,816 +0,0 @@
-import { __decorate } from "tslib";
-import { ArrayDecoder, AutoEncoder, field, IntegerDecoder, MapDecoder, StringDecoder } from '@simonbackx/simple-encoding';
-import { isSimpleError, isSimpleErrors, SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
-import { DataValidator, Formatter } from '@stamhoofd/utility';
-import { v4 as uuidv4 } from 'uuid';
-import { CartReservedSeat, ReservedSeat } from '../SeatingPlan.js';
-import { CartStockHelper } from './CartStockHelper.js';
-import { ProductDiscountSettings } from './Discount.js';
-import { Option, OptionMenu, Product, ProductPrice, ProductType } from './Product.js';
-import { WebshopFieldAnswer } from './WebshopField.js';
-import { UitpasNumberAndPrice } from './UitpasNumberAndPrice.js';
-import { upgradePriceFrom2To4DecimalPlaces } from '../upgradePriceFrom2To4DecimalPlaces.js';
-export class CartItemPrice extends AutoEncoder {
-    constructor() {
-        super(...arguments);
-        this.price = 0;
-        this.fixedDiscount = 0;
-        this.percentageDiscount = 0;
-    }
-    get discountedPrice() {
-        let price = this.price;
-        price = Math.min(price, Math.max(0, 100 * Math.round(price * (10000 - this.percentageDiscount) / 1000000))); // Min is required to support negative prices: prices should never increase after applyign discounts
-        price = Math.min(price, Math.max(0, price - this.fixedDiscount)); // Min is required to support negative prices: prices should never increase after applyign discounts
-        return price;
-    }
-}
-__decorate([
-    field({ decoder: IntegerDecoder }),
-    field({ ...upgradePriceFrom2To4DecimalPlaces })
-], CartItemPrice.prototype, "price", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder }),
-    field({ ...upgradePriceFrom2To4DecimalPlaces })
-], CartItemPrice.prototype, "fixedDiscount", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder })
-], CartItemPrice.prototype, "percentageDiscount", void 0);
-export class CartItemOption extends AutoEncoder {
-}
-__decorate([
-    field({ decoder: Option })
-], CartItemOption.prototype, "option", void 0);
-__decorate([
-    field({ decoder: OptionMenu })
-], CartItemOption.prototype, "optionMenu", void 0);
-export class CartItem extends AutoEncoder {
-    constructor() {
-        super(...arguments);
-        this.options = [];
-        this.fieldAnswers = [];
-        this.seats = [];
-        this.amount = 1;
-        /**
-         * Discounts that are actually applied
-         */
-        this.discounts = [];
-        /**
-         * When an order is correctly placed, we store the reserved amount in the stock here.
-         * We need this to check the stock changes when an order is edited after placement.
-         */
-        this.reservedAmount = 0;
-        /**
-         * Holds a list of what we reserved a stock for (which produce prices and which options specifically so we don't reserve the same thing multiple times or revert when it wasn't reserved earlier)
-         */
-        this.reservedOptions = new Map();
-        /**
-         * Holds a list of what we reserved a stock for (which produce prices and which options specifically so we don't reserve the same thing multiple times or revert when it wasn't reserved earlier)
-         */
-        this.reservedPrices = new Map();
-        /**
-         * When the seats are successfully reserved, we store them here
-         * This makes editing seats possible because we know we can still use these seats even if they are blocked normally
-         */
-        this.reservedSeats = [];
-        /**
-         * @deprecated
-         * Saved unitPrice (migration needed)
-         */
-        this.unitPrice = null;
-        /**
-         * Detailed list of prices
-         */
-        this.calculatedPrices = [];
-        /**
-         * In case this product is a UiTPAS social tarrif,
-         * we hold a list of UiTPAS numbers (length is equal to amount)
-         * and the price of the social tarrif for this uitpas number.
-         *
-         * In case this is not a UiTPAS social tarrif, this will be an empty array.
-         */
-        this.uitpasNumbers = [];
-        /**
-         * Show an error in the cart for recovery
-         */
-        this.cartError = null;
-    }
-    /**
-     * @deprecated
-     */
-    get price() {
-        return this.unitPrice ? (this.unitPrice * this.amount) : null;
-    }
-    getReservedAmountPrice(priceId) {
-        return this.reservedPrices.get(priceId) || 0;
-    }
-    getReservedAmountOption(optionId) {
-        return this.reservedOptions.get(optionId) || 0;
-    }
-    static createDefault(product, cart, webshop, data) {
-        // Return the first that still has stock or the first if none has stock
-        const options = [];
-        // Fill in all default options here
-        for (const optionMenu of product.optionMenus) {
-            if (optionMenu.multipleChoice) {
-                continue;
-            }
-            if (!optionMenu.autoSelectFirst) {
-                continue;
-            }
-            let cartItemOption = null;
-            // Add first option with remaining stock
-            for (const option of optionMenu.options) {
-                const stock = CartStockHelper.getOptionStock({ product, option, oldItem: null, cart, webshop, admin: data.admin });
-                if (!stock || stock.remaining === null || stock.remaining > 0) {
-                    cartItemOption = CartItemOption.create({
-                        option,
-                        optionMenu,
-                    });
-                    break;
-                }
-            }
-            // Add (default if no stock for all)
-            options.push(cartItemOption !== null && cartItemOption !== void 0 ? cartItemOption : CartItemOption.create({
-                option: optionMenu.options[0],
-                optionMenu,
-            }));
-        }
-        const prices = product.filteredPrices(data);
-        let chosenPrice = null;
-        for (const productPrice of prices) {
-            const stock = CartStockHelper.getPriceStock({ product, productPrice, oldItem: null, cart, webshop, admin: data.admin });
-            if (!stock || stock.remaining === null || stock.remaining > 0) {
-                chosenPrice = productPrice;
-                break;
-            }
-        }
-        // Default
-        return CartItem.create({
-            product: product,
-            productPrice: chosenPrice !== null && chosenPrice !== void 0 ? chosenPrice : product.filteredPrices(data)[0],
-            options,
-        });
-    }
-    static create(object) {
-        const c = super.create(object);
-        // Fill in all default options here
-        for (const optionMenu of c.product.optionMenus) {
-            if (optionMenu.multipleChoice) {
-                continue;
-            }
-            if (!optionMenu.autoSelectFirst) {
-                continue;
-            }
-            if (c.options.find(o => o.optionMenu.id === optionMenu.id)) {
-                continue;
-            }
-            c.options.push(CartItemOption.create({
-                option: optionMenu.options[0],
-                optionMenu: optionMenu,
-            }));
-        }
-        return c;
-    }
-    /**
-     * Unique identifier to check if two cart items are the same
-     */
-    get code() {
-        return this.codeWithoutFields + '.' + this.fieldAnswers.map(a => a.field.id + '-' + Formatter.slug(a.answer)).join('.');
-    }
-    get codeWithoutFields() {
-        return this.product.id + '.' + this.productPrice.id + '.' + this.options.map(o => o.option.id).join('.');
-    }
-    /**
-     * Return total amount of same product in the given cart. Always includes the current item, even when it isn't in the cart. Doesn't count it twice
-     */
-    getTotalAmount(cart) {
-        return cart.items.reduce((c, item) => {
-            if (item.product.id !== this.product.id) {
-                return c;
-            }
-            if (item.id === this.id) {
-                return c;
-            }
-            return c + item.amount;
-        }, 0) + this.amount;
-    }
-    /**
-     * Note: this resets any discounts that are applied to the cart item
-     */
-    calculatePrices(cart) {
-        const prices = [];
-        const unitPrice = this.calculateUnitPrice(cart);
-        for (let i = 0; i < this.amount; i++) {
-            let p;
-            if (i < this.uitpasNumbers.length && this.product.uitpasEvent) {
-                p = this.calculateOptionsPrice(cart, this.uitpasNumbers[i].price);
-            }
-            else {
-                p = unitPrice;
-            }
-            if (i < this.seats.length) {
-                // Seats
-                const seatPrice = p + this.seats[i].price;
-                prices.push(CartItemPrice.create({
-                    price: seatPrice,
-                }));
-            }
-            else {
-                // Others (non seats)
-                prices.push(CartItemPrice.create({
-                    price: p,
-                }));
-            }
-        }
-        this.calculatedPrices = prices;
-    }
-    calculateUnitPrice(cart) {
-        const amount = this.getTotalAmount(cart);
-        let price = this.productPrice.price;
-        if (this.productPrice.discountPrice !== null && amount >= this.productPrice.discountAmount) {
-            price = this.productPrice.discountPrice;
-        }
-        this.unitPrice = this.calculateOptionsPrice(cart, price);
-        return this.unitPrice;
-    }
-    calculateOptionsPrice(cart, priceBeforeOptions) {
-        let price = priceBeforeOptions;
-        for (const option of this.options) {
-            price += option.option.price;
-        }
-        if (this.productPrice.price >= 0) {
-            price = Math.max(0, price);
-        } // Allow negative
-        return price;
-    }
-    /**
-     * @deprecated
-     * Use this method if you need temporary prices in case it is not yet calculated
-     */
-    getUnitPrice(cart) {
-        if (this.unitPrice) {
-            return this.unitPrice;
-        }
-        return this.calculateUnitPrice(cart);
-    }
-    getPriceWithDiscounts() {
-        return this.calculatedPrices.reduce((a, b) => a + b.discountedPrice, 0);
-    }
-    getPriceWithoutDiscounts() {
-        return this.calculatedPrices.reduce((a, b) => a + b.price, 0);
-    }
-    /**
-     * @deprecated: use other systems
-     * Prices that are only applicable to some amount, but not all (e.g. seat extra prices)
-     */
-    getPartialExtraPrice(cart) {
-        const unitPrice = this.getUnitPrice(cart);
-        const expectedPrice = unitPrice * this.amount;
-        const actualPrice = this.getPriceWithoutDiscounts();
-        return actualPrice - expectedPrice;
-    }
-    /**
-     * @deprecated use getPriceWithDiscounts instead for clarity
-     */
-    getPrice() {
-        return this.getPriceWithDiscounts();
-    }
-    getUnitPriceCombinationsWithoutDiscount() {
-        const priceCombinations = new Map();
-        for (const calculatedPrice of this.calculatedPrices) {
-            const price = calculatedPrice.price;
-            priceCombinations.set(price, (priceCombinations.get(price) || 0) + 1);
-        }
-        return priceCombinations;
-    }
-    getUnitPriceCombinationsWithDiscount() {
-        const priceCombinations = new Map();
-        for (const calculatedPrice of this.calculatedPrices) {
-            const price = calculatedPrice.discountedPrice;
-            priceCombinations.set(price, (priceCombinations.get(price) || 0) + 1);
-        }
-        return priceCombinations;
-    }
-    get formattedAmount() {
-        if (!this.product.allowMultiple) {
-            return '';
-        }
-        return Formatter.integer(this.amount);
-    }
-    /**
-     * Without discounts
-     */
-    getFormattedPriceWithoutDiscount() {
-        // Group by seats
-        const priceCombinations = this.getUnitPriceCombinationsWithoutDiscount();
-        return this.priceCombinationToString(priceCombinations);
-    }
-    getFormattedPriceWithDiscount() {
-        const price = this.getPriceWithDiscounts();
-        if (price === this.getPriceWithoutDiscounts()) {
-            return null;
-        }
-        const priceCombinations = this.getUnitPriceCombinationsWithDiscount();
-        return this.priceCombinationToString(priceCombinations);
-    }
-    getDiffName() {
-        return this.product.name;
-    }
-    getDiffValue() {
-        return this.formattedAmount + 'x ' + this.description;
-    }
-    priceCombinationToString(priceCombinations) {
-        // Sort by price
-        const sorted = [...priceCombinations.entries()].map(([price, amount]) => ({ price, amount })).sort((a, b) => b.price - a.price);
-        // Format
-        const parts = [];
-        for (const { price, amount } of sorted) {
-            if (parts.length > 0 || price < 0) {
-                if (price >= 0) {
-                    parts.push('+');
-                }
-                else {
-                    parts.push('-');
-                }
-            }
-            if (!this.product.allowMultiple && amount === 1) {
-                parts.push(Formatter.price(Math.abs(price)));
-                continue;
-            }
-            if (price === 0) {
-                if (sorted.length === 1) {
-                    parts.push($t(`99e41cea-bce3-4329-8b17-e3487c4534ac`));
-                }
-                else {
-                    parts.push(amount + ' ' + $t(`50af1227-4f3d-46bb-a832-b62c4e3bc6ab`));
-                }
-            }
-            else {
-                if (sorted.length === 1 || amount === 1) {
-                    if (amount > 1) {
-                        parts.push(Formatter.price(Math.abs(price)) + ' ' + $t(`4edf400a-ac16-4442-8561-e66ed2f785b5`));
-                    }
-                    else {
-                        parts.push(Formatter.price(Math.abs(price)));
-                    }
-                }
-                else {
-                    parts.push(amount + ' × ' + Formatter.price(Math.abs(price)));
-                }
-            }
-        }
-        return parts.join(' ');
-    }
-    /**
-     * Used for statistics
-     */
-    get descriptionWithoutFields() {
-        const descriptions = [];
-        if (this.product.prices.length > 1) {
-            descriptions.push(this.productPrice.name);
-        }
-        for (const option of this.options) {
-            descriptions.push(option.option.name);
-        }
-        if ((this.product.type === ProductType.Ticket || this.product.type === ProductType.Voucher) && this.product.dateRange) {
-            descriptions.unshift(Formatter.capitalizeFirstLetter(this.product.dateRange.toString()));
-        }
-        return descriptions.filter(d => !!d).join('\n');
-    }
-    get descriptionWithoutDate() {
-        const descriptions = [];
-        if (this.product.prices.length > 1) {
-            descriptions.push(this.productPrice.name);
-        }
-        for (const option of this.options) {
-            descriptions.push(option.option.name);
-        }
-        for (const a of this.fieldAnswers) {
-            if (!a.answer) {
-                continue;
-            }
-            descriptions.push(a.field.name + ': ' + a.answer);
-        }
-        return descriptions.filter(d => !!d).join('\n');
-    }
-    get description() {
-        const descriptions = [this.descriptionWithoutDate];
-        if ((this.product.type === ProductType.Ticket || this.product.type === ProductType.Voucher) && this.product.dateRange) {
-            descriptions.unshift(Formatter.capitalizeFirstLetter(this.product.dateRange.toString()));
-        }
-        if (this.seats.length) {
-            descriptions.push((this.seats.length === 1 ? $t(`8435edb8-619e-4ddf-b5c8-4d1a2bc44acc`) : $t(`2a3d1996-17cd-4ef7-827b-63f2f9b5b84a`)) + ': '
-                + this.seats.slice().sort(ReservedSeat.sort).map(s => s.getShortName(this.product)).join(', '));
-        }
-        if (this.uitpasNumbers.length) {
-            if (this.uitpasNumbers.length === 1) {
-                descriptions.push($t('e330f60b-d331-49a2-a437-cddc31a878de') + ': ' + DataValidator.formatUitpasNumber(this.uitpasNumbers[0].uitpasNumber));
-            }
-            else {
-                descriptions.push($t('83eca88a-9820-4b6e-8849-9d59ec3e4a3b') + ': ' + this.uitpasNumbers.map(item => DataValidator.formatUitpasNumber(item.uitpasNumber)).join(', '));
-            }
-        }
-        return descriptions.filter(d => !!d).join('\n');
-    }
-    validateAnswers() {
-        const newAnswers = [];
-        for (const field of this.product.customFields) {
-            const answer = this.fieldAnswers.find(a => a.field.id === field.id);
-            try {
-                if (!answer) {
-                    const a = WebshopFieldAnswer.create({ field, answer: '' });
-                    a.validate();
-                    newAnswers.push(a);
-                }
-                else {
-                    answer.field = field;
-                    answer.validate();
-                    newAnswers.push(answer);
-                }
-            }
-            catch (e) {
-                if (isSimpleError(e) || isSimpleErrors(e)) {
-                    e.addNamespace('fieldAnswers.' + field.id);
-                }
-                throw e;
-            }
-        }
-        this.fieldAnswers = newAnswers;
-    }
-    /**
-     * Update self to the newest available data, and throw error if something failed (only after refreshing other ones)
-     */
-    refresh(webshop) {
-        const errors = new SimpleErrors();
-        const product = webshop.products.find(p => p.id === this.product.id);
-        if (!product) {
-            errors.addError(new SimpleError({
-                code: 'product_unavailable',
-                message: 'Product unavailable',
-                human: $t(`b3468d2d-269d-4330-9bb7-580920d2d080`, { product: this.product.name }),
-            }));
-        }
-        else {
-            this.product = product;
-            const productPrice = product.prices.find(p => p.id === this.productPrice.id);
-            if (!productPrice) {
-                if ((this.productPrice.name.length === 0 || this.product.prices.length <= 1) && product.prices.length > 1) {
-                    errors.addError(new SimpleError({
-                        code: 'product_price_unavailable',
-                        message: 'Product price unavailable',
-                        human: $t(`349ac252-348b-42ae-aa9c-708a25db03f6`, { product: this.product.name }),
-                    }));
-                }
-                else {
-                    errors.addError(new SimpleError({
-                        code: 'product_price_unavailable',
-                        message: 'Product price unavailable',
-                        human: $t(`c3862722-84b2-4eca-b8cd-dd3f2a9f95c7`, { price: this.productPrice.name, product: this.product.name }),
-                    }));
-                }
-            }
-            else {
-                // Only set product if we did find our product price
-                this.productPrice = productPrice;
-            }
-            // Check all options
-            const remainingMenus = this.product.optionMenus.slice();
-            for (const o of this.options) {
-                const index = remainingMenus.findIndex(m => m.id === o.optionMenu.id);
-                if (index === -1) {
-                    // Check if it has a multiple choice one
-                    errors.addError(new SimpleError({
-                        code: 'option_menu_unavailable',
-                        message: 'Option menu unavailable',
-                        human: $t(`609af825-3468-407d-a033-170d75b51075`, { product: this.product.name }),
-                    }));
-                    continue;
-                }
-                const menu = remainingMenus[index];
-                if (!menu.multipleChoice) {
-                    // Already used: not possible to add another
-                    remainingMenus.splice(index, 1);
-                }
-                const option = menu.options.find(m => m.id === o.option.id);
-                if (!option) {
-                    errors.addError(new SimpleError({
-                        code: 'option_unavailable',
-                        message: 'Option unavailable',
-                        human: $t(`609af825-3468-407d-a033-170d75b51075`, { product: this.product.name }),
-                    }));
-                    continue;
-                }
-                // Update to latest data
-                o.optionMenu = menu;
-                o.option = option;
-            }
-            if (remainingMenus.filter(m => !m.multipleChoice).length > 0) {
-                for (const remaining of remainingMenus) {
-                    errors.addError(new SimpleError({
-                        code: 'missing_menu',
-                        message: 'Missing menu',
-                        human: $t(`60021a05-e01f-4fda-b12e-8aa8046a2f07`, { option_menu_name: remaining.name }),
-                        field: 'optionMenus.' + remaining.id,
-                        meta: { recoverable: true },
-                    }));
-                }
-            }
-        }
-        try {
-            this.validateAnswers();
-        }
-        catch (e) {
-            if (isSimpleError(e) || isSimpleErrors(e)) {
-                errors.addError(e);
-            }
-            else {
-                throw e;
-            }
-        }
-        errors.throwIfNotEmpty();
-    }
-    getFixedStockDefinitions(oldItem, cart, webshop, admin) {
-        return CartStockHelper.getFixedStockDefinitions({ oldItem, cart, product: this.product, webshop, admin, amount: this.amount });
-    }
-    /**
-     * Return all the stock definitions for this cart item with the currently selected options
-     * = calculate how much you can order with these options
-     */
-    getAvailableStock(oldItem, cart, webshop, admin) {
-        return CartStockHelper.getAvailableStock({ oldItem, cart, product: this.product, webshop, admin, amount: this.amount, productPrice: this.productPrice, options: this.options });
-    }
-    getMaximumRemaining(oldItem, cart, webshop, admin) {
-        return CartStockHelper.getRemaining(this.getAvailableStock(oldItem, cart, webshop, admin));
-    }
-    validateUitpasNumbers() {
-        if (!this.productPrice.uitpasBaseProductPriceId) {
-            if (this.uitpasNumbers.length > 0) {
-                throw new SimpleError({
-                    code: 'uitpas_numbers_not_allowed',
-                    message: 'UiTPAS numbers not allowed for this product',
-                    human: $t('43c308e7-301b-46f0-abed-ae855fa49bed'),
-                    field: 'cart.items.uitpasNumbers',
-                });
-            }
-            return;
-        }
-        const uitpasNumbers = this.uitpasNumbers.map(p => p.uitpasNumber);
-        uitpasNumbers.forEach((num, i) => {
-            if (num === '') {
-                throw new SimpleError({
-                    code: 'empty_uitpas_number',
-                    message: 'Empty uitpas number',
-                    human: $t('37ba6753-ea29-4166-94dc-43538a5e7356'),
-                    field: 'uitpasNumbers.' + i.toString(),
-                });
-            }
-        });
-        const errors = uitpasNumbers.filter(num => !DataValidator.isUitpasNumberValid(num)).map((value, i) => new SimpleError({
-            code: 'invalid_uitpas_number',
-            message: 'Invalid uitpas number',
-            human: $t('13e018ab-25db-4743-9267-f0724862dac9'),
-            field: 'uitpasNumbers.' + i.toString(),
-        }));
-        if (errors.length > 0) {
-            throw new SimpleErrors(...errors);
-        }
-        // verify the amount of UiTPAS numbers
-        if (uitpasNumbers.length !== this.amount) {
-            throw new SimpleError({
-                code: 'amount_of_uitpas_numbers_mismatch',
-                message: 'The number of UiTPAS numbers and items with UiTPAS social tariff does not match',
-                human: $t('6140c642-69b2-43d6-80ba-2af4915c5837'),
-                field: 'cart.items.uitpasNumbers',
-            });
-        }
-        // verify the UiTPAS numbers are unique (within the item)
-        if (uitpasNumbers.length !== Formatter.uniqueArray(uitpasNumbers).length) {
-            throw new SimpleError({
-                code: 'duplicate_uitpas_numbers',
-                message: 'Duplicate uitpas numbers used',
-                human: $t('d9ec27f3-dafa-41e8-bcfb-9da564a4a675'),
-                field: 'cart.items.uitpasNumbers',
-            });
-        }
-    }
-    /**
-     * Update self to the newest available data and throw if it was not able to recover
-     */
-    validate(webshop, cart, { refresh, admin, validateSeats } = { refresh: true, admin: false, validateSeats: true }) {
-        this.cartError = null;
-        if (admin === undefined) {
-            admin = false;
-        }
-        if (refresh === undefined) {
-            refresh = true;
-        }
-        if (validateSeats === undefined) {
-            validateSeats = true;
-        }
-        if (refresh) {
-            this.refresh(webshop);
-        }
-        const product = this.product;
-        if (!product.allowMultiple) {
-            this.amount = 1;
-        }
-        // Check stock
-        if (!admin) {
-            if (!product.isEnabled && this.amount > this.reservedAmount) {
-                throw new SimpleError({
-                    code: 'product_unavailable',
-                    message: 'Product unavailable',
-                    human: $t(`b3468d2d-269d-4330-9bb7-580920d2d080`, { product: this.product.name }),
-                });
-            }
-            if (this.productPrice.hidden) {
-                throw new SimpleError({
-                    code: 'product_price_unavailable',
-                    message: 'Product price unavailable',
-                    human: $t(`325ccc3a-41a6-462e-81db-2efb0235e3eb`, { price: this.productPrice.name }),
-                });
-            }
-            if (product.isSoldOut && this.amount > this.reservedAmount) {
-                throw new SimpleError({
-                    code: 'product_unavailable',
-                    message: 'Product unavailable',
-                    human: $t(`7701d42d-eef3-419b-b1fb-85443d117554`, { product: this.product.name }),
-                });
-            }
-            const remaining = this.getAvailableStock(this, cart, webshop, admin);
-            const minimumRemaining = CartStockHelper.getRemaining(remaining);
-            if (minimumRemaining !== null && minimumRemaining < this.amount) {
-                // Search for appropriate message in stock definitions
-                const stockDefinition = remaining.find(r => r.remaining === minimumRemaining);
-                throw new SimpleError({
-                    code: 'product_unavailable',
-                    message: 'Product unavailable',
-                    human: (stockDefinition === null || stockDefinition === void 0 ? void 0 : stockDefinition.text) || $t(`ade1f338-f45e-4384-9520-9d20cfe5311e`, { count: minimumRemaining.toString(), product: this.product.name }),
-                    meta: { recoverable: minimumRemaining > 0 },
-                });
-            }
-        }
-        if (this.product.seatingPlanId && validateSeats) {
-            const seatingPlan = webshop.meta.seatingPlans.find(s => s.id === this.product.seatingPlanId);
-            if (!seatingPlan) {
-                throw new SimpleError({
-                    code: 'seating_plan_unavailable',
-                    message: 'Invalid seating plan',
-                    human: $t(`6f4d58c7-25d2-407e-901a-f3c03a7e0ab3`, { product: this.product.name }),
-                });
-            }
-            // Check seats taken already?
-            const reservedSeats = this.product.reservedSeats;
-            // Remove invalid seats
-            const invalidSeats = this.seats.filter((s) => {
-                const valid = seatingPlan.isValidSeat(s, reservedSeats, this.reservedSeats);
-                if (valid) {
-                    return false;
-                }
-                else {
-                    if (!admin && seatingPlan.isAdminSeat(s)) {
-                        return false;
-                    }
-                    return true;
-                }
-            });
-            if (invalidSeats.length) {
-                throw new SimpleError({
-                    code: 'seats_unavailable',
-                    message: 'Seats unavailable',
-                    human: $t(`2fd43e7b-2c16-4695-bdb4-f3095952d36d`) + ' ' + invalidSeats.map(s => s.getNameString(webshop, this.product)).join(', '),
-                    meta: { recoverable: true },
-                });
-            }
-            // Seating validation
-            if (this.seats.length !== this.amount) {
-                if (this.seats.length > this.amount) {
-                    // We need to handle this, because this can be caused by a stock limit
-                    throw new SimpleError({
-                        code: 'invalid_seats',
-                        message: 'Invalid seats',
-                        human: $t(`5d8d7f45-85ae-44d0-b8ac-b7db850003ba`, { seats: Formatter.pluralText(this.amount, $t(`886ea5ba-4715-43a2-88b6-4715df3cfa2c`), $t(`a76b6d3c-05a1-4c71-9f88-077261a4e595`)) }),
-                        meta: { recoverable: true },
-                    });
-                }
-                throw new SimpleError({
-                    code: 'invalid_seats',
-                    message: 'Invalid seats',
-                    human: $t(`2858b401-42b8-4a95-8bd1-d67addbda5e1`, { seats: Formatter.pluralText(this.amount - this.seats.length, $t(`886ea5ba-4715-43a2-88b6-4715df3cfa2c`), $t(`a76b6d3c-05a1-4c71-9f88-077261a4e595`)) }),
-                    meta: { recoverable: true },
-                });
-            }
-            // Check other cart items have same seats
-            const otherItems = cart.items.filter(i => i.product.id === this.product.id && i.id !== this.id);
-            for (const item of otherItems) {
-                for (const seat of item.seats) {
-                    if (this.seats.find(s => s.equals(seat))) {
-                        throw new SimpleError({
-                            code: 'seats_unavailable',
-                            message: 'Seats unavailable',
-                            human: $t(`794b3f34-9dd2-4097-af25-af094431fba0`) + ' ' + seat.getNameString(webshop, this.product),
-                        });
-                    }
-                }
-            }
-            // Adjust seats automatically if enabled
-            if (seatingPlan.requireOptimalReservation && !admin) {
-                const otherSeats = cart.items.filter(i => i.product.id === this.product.id && i.id !== this.id).flatMap(i => i.seats);
-                const adjusted = seatingPlan.adjustSeatsForBetterFit(this.seats, [...reservedSeats, ...otherSeats], this.reservedSeats);
-                if (adjusted) {
-                    this.seats = adjusted.map(a => CartReservedSeat.create(a));
-                }
-                // Edge case: if seats are not optimal across multiple items, we can't fix it
-                const adjusted2 = seatingPlan.adjustSeatsForBetterFit([...this.seats, ...otherSeats], reservedSeats, this.reservedSeats);
-                if (adjusted2) {
-                    // Not able to correct this across multiple items
-                    throw new SimpleError({
-                        code: 'select_connected_seats',
-                        message: 'Select connected seats',
-                        human: $t(`a751a023-570b-46ad-8aaa-7b0c4412cbe8`),
-                        meta: { recoverable: true },
-                    });
-                }
-            }
-            // Update prices
-            for (const seat of this.seats) {
-                seat.calculatePrice(seatingPlan);
-            }
-        }
-        this.validateUitpasNumbers();
-        // Update prices
-        // should now happen in the checkout so discounts are in sync
-        // this.calculateUnitPrice(cart)
-    }
-}
-__decorate([
-    field({ decoder: StringDecoder, defaultValue: () => uuidv4(), version: 106, upgrade: function () {
-            // Warning: this id will always be too long for storage in a normal database record.
-            // But that is not a problem, since only new orders will use tickets that need this field
-            return this.code;
-        } })
-], CartItem.prototype, "id", void 0);
-__decorate([
-    field({ decoder: Product })
-], CartItem.prototype, "product", void 0);
-__decorate([
-    field({ decoder: ProductPrice })
-], CartItem.prototype, "productPrice", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(CartItemOption) })
-], CartItem.prototype, "options", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(WebshopFieldAnswer), version: 94 })
-], CartItem.prototype, "fieldAnswers", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(CartReservedSeat), version: 212 })
-], CartItem.prototype, "seats", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder })
-], CartItem.prototype, "amount", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(ProductDiscountSettings), version: 237, optional: true })
-], CartItem.prototype, "discounts", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder, version: 115 })
-], CartItem.prototype, "reservedAmount", void 0);
-__decorate([
-    field({ decoder: new MapDecoder(StringDecoder, IntegerDecoder), version: 224 })
-], CartItem.prototype, "reservedOptions", void 0);
-__decorate([
-    field({ decoder: new MapDecoder(StringDecoder, IntegerDecoder), version: 224 })
-], CartItem.prototype, "reservedPrices", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(CartReservedSeat), version: 213 })
-], CartItem.prototype, "reservedSeats", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder, nullable: true, version: 107 }),
-    field({ ...upgradePriceFrom2To4DecimalPlaces, nullable: true })
-], CartItem.prototype, "unitPrice", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(CartItemPrice), version: 236, upgrade: function () {
-            var _a;
-            const prices = [];
-            const unitPrice = (_a = this.unitPrice) !== null && _a !== void 0 ? _a : 0;
-            for (const seat of this.seats) {
-                const seatPrice = unitPrice + seat.price;
-                prices.push(CartItemPrice.create({
-                    price: seatPrice,
-                }));
-            }
-            // Others (non seats)
-            const remaining = this.amount - this.seats.length;
-            if (remaining > 0) {
-                for (let index = 0; index < remaining; index++) {
-                    prices.push(CartItemPrice.create({
-                        price: unitPrice,
-                    }));
-                }
-            }
-            return prices;
-        } })
-], CartItem.prototype, "calculatedPrices", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(UitpasNumberAndPrice), version: 377 })
-], CartItem.prototype, "uitpasNumbers", void 0);
-//# sourceMappingURL=CartItem.js.map