addio-admin-sdk 1.7.144 → 1.7.145

package/dist/lib/Inventory/index.js

@@ -1,493 +1,493 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const isEqual_1 = __importDefault(require("lodash/isEqual"));
-const toNumber_1 = __importDefault(require("lodash/toNumber"));
-const DatabaseService_1 = __importDefault(require("../../services/database/DatabaseService"));
-const baseService_1 = require("../baseService");
-const TransferRequest_1 = require("../../Interfaces/TransferRequest");
-const IInventoryItem_1 = require("../../Interfaces/Product/IInventoryItem");
-const Cart_1 = require("../../Interfaces/Cart");
-const console_1 = require("../../utils/console");
-const string_1 = require("../../utils/string");
-const inventories_1 = require("../../utils/inventories");
-class Inventory extends baseService_1.BaseServiceClass {
-    constructor(data, collection, user) {
-        super(data, collection, user);
-        this.save = async (newInventoryData, options, saveToDatabase = true, update, merge) => {
-            if (!!!this.data().sku)
-                return false;
-            const exists = await DatabaseService_1.default.getDocuments(this._collection.path, {
-                query: [{ field: 'sku', operator: '==', value: this.data().sku }]
-            });
-            if (!!!exists.length) {
-                return await super.save(Object.assign(Object.assign({}, (newInventoryData ? newInventoryData : this.data())), { id: (0, string_1.string_to_slug)(this.data().sku) }), options, saveToDatabase, update, merge);
-            }
-            else {
-                try {
-                    const doc = exists[0];
-                    const newData = Object.assign(Object.assign({}, this.data()), (!!newInventoryData ? newInventoryData : {}));
-                    await super.save(Object.assign(Object.assign(Object.assign({}, newData), { last_update_by: this.user() }), (!!!newData.id && !!doc ? { id: doc.id } : {})), options, saveToDatabase, update, merge);
-                }
-                catch (err) {
-                    console.log('err', err);
-                    return false;
-                }
-                return true;
-            }
-        };
-        this.delete = async () => {
-            try {
-                await DatabaseService_1.default.deleteDocument(this._collection.path, (0, string_1.string_to_slug)(this.data().sku));
-                return true;
-            }
-            catch (err) {
-                console.log(err);
-                return false;
-            }
-        };
-        this.getHistoryInventory = async () => {
-            if (!!!this._collection || DatabaseService_1.default.getPathParent(this._collection.path) == '/') {
-                throw new Error('Collection should be defined and have a parent.');
-            }
-            try {
-                const historyQuery = await DatabaseService_1.default.getDocuments(DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'inventory_history'), {
-                    query: [
-                        {
-                            field: 'sku',
-                            operator: 'in',
-                            value: [this.data().sku, this.data().sku.toLowerCase(), this.data().sku.toUpperCase()]
-                        }
-                    ],
-                    orderBy: 'at',
-                    order: 'desc',
-                    limit: 50
-                });
-                return historyQuery.map((d) => (Object.assign(Object.assign({}, d.data), { id: d.id })));
-            }
-            catch (err) {
-                (0, console_1.errorMessage)(`Could not get inventory history${err.message}`);
-                return [];
-            }
-        };
-        this.setQuantitiesWithInventoryItemByStore = async (inventory) => {
-            return await this.save({
-                inventories: this.data().inventories.map((_inventory) => {
-                    if (_inventory.store_id.toLowerCase() !== (inventory.store_id || '').toLowerCase())
-                        return _inventory;
-                    return Object.assign(Object.assign({}, _inventory), { qty: Object.assign(Object.assign({}, _inventory.qty), inventory.qty) });
-                })
-            }, undefined, true, true);
-        };
-        this.setQuantitiesWithWebInventoryItemByStore = async (inventory, webQty) => {
-            let isDiff = false;
-            if (!!!this._data.web_inventory ||
-                !!!this._data.web_inventory.available ||
-                this._data.web_inventory.available !== webQty)
-                isDiff = true;
-            for (const inv of this._data.inventories) {
-                if (!!inventory.find((i) => (i.store_id || '').toLowerCase() === inv.store_id.toLowerCase() && !(0, isEqual_1.default)(i.qty, inv.qty)))
-                    isDiff = true;
-            }
-            if (!isDiff) {
-                console.log('Inventory didnt change, not saving : ', this._data.sku);
-                return;
-            }
-            return await this.save({
-                inventories: this.data().inventories.map((_inventory) => {
-                    const newInv = inventory.find((i) => _inventory.store_id.toLowerCase() === (i.store_id || '').toLowerCase());
-                    if (!!!newInv)
-                        return _inventory;
-                    return Object.assign(Object.assign({}, _inventory), { qty: Object.assign(Object.assign({}, _inventory.qty), newInv.qty) });
-                }),
-                web_inventory: Object.assign(Object.assign(Object.assign({}, (0, IInventoryItem_1.getDefaultInventoryQuantities)()), (this.data().web_inventory || {})), { available: webQty })
-            }, undefined, true, true);
-        };
-        this._modifyQuantitiesByStore = async (storeId, type, operation, amount = 0, cartType, saveToDatabase = true, updateWeb) => {
-            var _a;
-            if (!!!operation)
-                return 'Must include operation type';
-            let isWeb = false;
-            let newQuantity = undefined;
-            const inventories = this._data.inventories.map((storeInventory) => {
-                if (storeInventory.store_id !== storeId)
-                    return storeInventory;
-                const currentQte = (0, toNumber_1.default)(storeInventory.qty[type] || 0);
-                if (storeInventory.can_sell_online || (!!cartType && cartType !== Cart_1.CartTypeEnum.POS_TRANSACTIONNAL))
-                    isWeb = true;
-                newQuantity =
-                    operation === IInventoryItem_1.inventoryOperationEnum.ADD ? currentQte + (0, toNumber_1.default)(amount) : currentQte - (0, toNumber_1.default)(amount);
-                return Object.assign(Object.assign({}, storeInventory), { qty: Object.assign(Object.assign({}, storeInventory.qty), { [type]: newQuantity }) });
-            });
-            const willRemoveQuantities = (operation == IInventoryItem_1.inventoryOperationEnum.ADD && amount < 0) ||
-                (operation == IInventoryItem_1.inventoryOperationEnum.REMOVE && amount > 0);
-            this._data = Object.assign(Object.assign(Object.assign({}, this._data), { inventories: inventories }), (!!isWeb && typeof newQuantity === 'number' && !!updateWeb
-                ? {
-                    web_inventory: Object.assign(Object.assign({}, ((_a = this._data.web_inventory) !== null && _a !== void 0 ? _a : (0, IInventoryItem_1.getDefaultInventoryQuantities)())), { 
-                        // NEW : If web inventory is updated with store, add props to stop inventory
-                        //       from adjusting to high negative values if operation will REMOVE quantities
-                        [type]: this._getNewWebQuantity(type, operation, amount, willRemoveQuantities) })
-                }
-                : {}));
-            if (!!saveToDatabase) {
-                await this.save({}, undefined, saveToDatabase);
-            }
-        };
-        this._modifyQuantitiesOnlyWeb = async (type, operation, amount = 0, saveToDatabase) => {
-            var _a;
-            if (!!!operation)
-                return 'Must include operation type';
-            let newQuantity = this._getNewWebQuantity(type, operation, amount);
-            await this.save({
-                web_inventory: Object.assign(Object.assign({}, ((_a = this._data.web_inventory) !== null && _a !== void 0 ? _a : (0, IInventoryItem_1.getDefaultInventoryQuantities)())), { [type]: newQuantity })
-            }, undefined, saveToDatabase);
-        };
-        /**
-         * Returns calculated new value for web inventory
-         * @param type - The inventory type to calculate
-         * @param operation - If quantities should be added or removed
-         * @param amount - The quantity to adjust
-         * @param ignoreNewNegativeValues - Optionnal. If true, will replace calculated qte with 0 if current qte was positive, and keep current value if it was already negative and is 'available' inventory (since only available web quantites could be negative).
-         */
-        this._getNewWebQuantity = (type, operation, amount, ignoreNewNegativeValues) => {
-            var _a, _b;
-            const webInventory = (_a = this._data.web_inventory) !== null && _a !== void 0 ? _a : (0, IInventoryItem_1.getDefaultInventoryQuantities)();
-            const currentQte = (0, toNumber_1.default)((_b = webInventory[type]) !== null && _b !== void 0 ? _b : 0);
-            let newValue = operation === IInventoryItem_1.inventoryOperationEnum.ADD
-                ? (0, toNumber_1.default)(currentQte) + (0, toNumber_1.default)(amount)
-                : (0, toNumber_1.default)(currentQte) - (0, toNumber_1.default)(amount);
-            if (ignoreNewNegativeValues && newValue < 0)
-                newValue = currentQte < 0 && type == 'available' ? currentQte : 0;
-            return newValue;
-        };
-        this._orderCompleted = async (storeId, qte, cartType) => {
-            // If order was completed, we need to ajust :
-            //    - both PROCESSING and COMPLETED quantities
-            //    - for WEB and STORE inventories
-            await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false, true);
-            await this._modifyQuantitiesByStore(storeId, 'completed', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true, true);
-        };
-        this.handleOrderDelivered = async (storeId, qte, cartType) => {
-            await this._orderCompleted(storeId, qte, cartType);
-            return this.data();
-        };
-        this.handleOrderPickedupInStore = async (storeId, qte, cartType) => {
-            await this._orderCompleted(storeId, qte, cartType);
-            return this.data();
-        };
-        this.handleOrderProcessedForShipping = async (storeId, qte, cartType) => {
-            await this._orderCompleted(storeId, qte, cartType);
-            return this.data();
-        };
-        this.handleNewQuantities = async (storeId, qte, cartType, saveToDatabase) => {
-            const shouldSaveToDB = typeof saveToDatabase != 'undefined' ? saveToDatabase : true;
-            // If quantities added, we need to ajust :
-            //    - AVAILABLE quantities
-            //    - for WEB and STORE inventories
-            await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, shouldSaveToDB, true);
-            return this._data;
-        };
-        this.handleUpdateWebInventory = async (qte) => {
-            // After inventory is updated through CSV import, we need to adjust :
-            //    - AVAILABLE quantities
-            //    - for WEB inventory
-            await this._modifyQuantitiesOnlyWeb('available', IInventoryItem_1.inventoryOperationEnum.ADD, qte, true);
-        };
-        this.handleProductSold = async (storeId, qte, cartType, web = false) => {
-            // If product was sold and is a web transaction, we need to ajust :
-            //    - both AVAILABLE and PROCESSING quantities
-            //    - for only WEB inventory
-            if (!!web) {
-                await this._modifyQuantitiesOnlyWeb('available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, false);
-                await this._modifyQuantitiesOnlyWeb('processing', IInventoryItem_1.inventoryOperationEnum.ADD, qte);
-                return this.data();
-            }
-            // If product was sold and is a POS transaction (!!!web), we need to ajust :
-            //    - both AVAILABLE and COMPLETED quantities
-            //    - for WEB and STORE inventory
-            //    - only if storeId is defined
-            if (!!storeId) {
-                await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false, true);
-                await this._modifyQuantitiesByStore(storeId, 'completed', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true, true);
-            }
-            else {
-                console.log('no storeId provided!');
-            }
-            return this.data();
-        };
-        /**
-         * Update inventory on cart item modified (POS modify cart process).
-         * @param storeId The store associated to the order. If cart still at status 5, might be undefined (unless quantities already reserved for order)
-         * @param qte The quantities to ajust
-         * @param cartType The associated cart's type
-         * @param options.onlyWeb Optionnal. If only web inventory should be ajusted
-         * @param options.reservedQteDiff Optionnal. Reserved quantities difference for given cart item. Expressed in sell_unit (must be converted to inventory_unit)
-         * @returns {Promise<IInventoryItem>}
-         */
-        this.handleProductModified = async (storeId, qte, cartType, options = {}) => {
-            var _a;
-            // Save store inventory if not only web and storeId is provided
-            if (!!!options.onlyWeb && !!storeId) {
-                // If quantities were already reserved for order, should only update inventory according to reserved quantity difference
-                let qteToUse = (_a = options.reservedQteDiff) !== null && _a !== void 0 ? _a : qte;
-                await this._modifyQuantitiesByStore(storeId, 'available', qteToUse < 0 ? IInventoryItem_1.inventoryOperationEnum.ADD : IInventoryItem_1.inventoryOperationEnum.REMOVE, qteToUse < 0 ? qteToUse * -1 : qteToUse, cartType, false, // save to database (will be done later on web update)
-                false // save web (will be done later)
-                );
-                await this._modifyQuantitiesByStore(storeId, 'processing', qteToUse < 0 ? IInventoryItem_1.inventoryOperationEnum.REMOVE : IInventoryItem_1.inventoryOperationEnum.ADD, qteToUse < 0 ? qteToUse * -1 : qteToUse, cartType, false, // save to database (will be done later on web update)
-                false // save web (will be done laters
-                );
-            }
-            // Always update web quantities with total modified quantities
-            await this._modifyQuantitiesOnlyWeb('available', qte < 0 ? IInventoryItem_1.inventoryOperationEnum.ADD : IInventoryItem_1.inventoryOperationEnum.REMOVE, qte < 0 ? qte * -1 : qte, false);
-            await this._modifyQuantitiesOnlyWeb('processing', qte < 0 ? IInventoryItem_1.inventoryOperationEnum.REMOVE : IInventoryItem_1.inventoryOperationEnum.ADD, qte < 0 ? qte * -1 : qte, true // save to database done here for all updates to inventories and web_inventory
-            );
-            return this.data();
-        };
-        /**
-         * Update inventory for a specific item if order was cancelled or refunded.
-         * @param toStoreId The store where quantities will be ADDED
-         * @param fromStoreId The store where quantities will vbe REMOVED
-         * @param qte The quantity to ajust
-         * @param operationType If cart was cancelled or refunded
-         * @param cartType If cart is web, POS, or Pickup Now
-         * @param options.deleteItem Optionnal. If item should not be returned to the stores inventory (broken, misplaced, old batch, etc...)
-         * @param options.onlyWeb Optionnal. If inventory should only be updated for web inventory (and not for stores). Mostly depends on the cart's status when cancelled.
-         * @param options.orderAssociatedTransfers Optionnal. Array of TransferRequest objects associated to cart. Used when cart is cancelled
-         * @param options.saveToDatabase Optionnal. Mostly used for dev purpuses (and for unit testing). Otherwise, save is done logically at the end of the update process
-         * @param options.reservedQte Optionnal. Quantity reserved in processing inventory for cart item as of now. Expressed in sell_unit (must be converted to inventory_unit)
-         * @param options.otherUnits Optionnal. Other units for corresponding cart item. If not defined, will use those found in InventoryItem data
-         */
-        this.handleOrderCancelled = async (toStoreId, fromStoreId, qte, operationType, cartType, options = {}) => {
-            const otherUnitsToUse = options.otherUnits || this._data.other_units;
-            // If order was cancelled, we need to ajust :
-            //    - PROCESSING quantities always, and AVAILABLE quantities only if item should return in stock
-            //    - for WEB inventory, and STORE inventory if onlyWeb is false, or order has associated transfers
-            // If order was refunded, we need to ajust :
-            //    - Take quantities from COMPLETED and put them back in AVAILABLE
-            //    - for WEB and STORE inventory, in this case onlyWeb is always false
-            // ----------------------------------------------------------
-            // #region CHECK FOR QUANTITIES TO AJUST IN STORE
-            let qteToUseForStoreUpdate = !!!options.onlyWeb ? qte : 0;
-            if (!!options.orderAssociatedTransfers && operationType == 'cancelled' && !!options.onlyWeb) {
-                // A. Calculate initial quantites asked for transfer
-                let initialQuantitiesInTransfers = 0;
-                let receivedQuantitesInTransfers = 0;
-                for (let transfer of options.orderAssociatedTransfers) {
-                    // Skip transfers that were split at creation, to fetch only initial quantities
-                    if (!!!transfer.data().original_transfer_id) {
-                        initialQuantitiesInTransfers += transfer.getOriginalRequestedQuantity(this._data.sku);
-                    }
-                    // Get quantities received from transfers with status RECEIVED or RECEIVED_PARTIAL
-                    if ([TransferRequest_1.TransferRequestStatusEnum.RECEIVED, TransferRequest_1.TransferRequestStatusEnum.RECEIVED_PARTIAL].includes(transfer.data().status)) {
-                        const sameProd = transfer.data().products.find((p) => p.sku == this._data.sku);
-                        if (!!sameProd)
-                            receivedQuantitesInTransfers += sameProd.qte_received || 0;
-                    }
-                }
-                // B. Set currently in processing quantities to ...
-                // ...reserved quantities (if defined)
-                if (typeof options.reservedQte != 'undefined') {
-                    qteToUseForStoreUpdate = (0, inventories_1.getConvertedUnitQuantity)(otherUnitsToUse, options.reservedQte, 'inventory_unit');
-                }
-                else {
-                    // ...the difference between total qte for item in cart and quantities initially set for transfer requests
-                    qteToUseForStoreUpdate = qte - initialQuantitiesInTransfers;
-                    if (qteToUseForStoreUpdate < 0)
-                        qteToUseForStoreUpdate = 0;
-                    // ... and add quantities received from transfers to processing quantites
-                    qteToUseForStoreUpdate += receivedQuantitesInTransfers;
-                }
-            }
-            if (qteToUseForStoreUpdate != 0) {
-                await this._modifyQuantitiesByStore(fromStoreId, operationType === 'refunded' ? 'completed' : 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qteToUseForStoreUpdate, cartType, typeof options.saveToDatabase == 'boolean' ? options.saveToDatabase : !!options.deleteItem // save to database
-                );
-                if (!!!options.deleteItem) {
-                    await this._modifyQuantitiesByStore(toStoreId, 'available', IInventoryItem_1.inventoryOperationEnum.ADD, qteToUseForStoreUpdate, cartType, typeof options.saveToDatabase == 'boolean' ? options.saveToDatabase : true // save to database
-                    );
-                }
-            }
-            // #endregion
-            // ----------------------------------------------------------
-            // #region AJUST WEB QUANTITIES
-            if (!!!options.deleteItem) {
-                await this._modifyQuantitiesOnlyWeb('available', IInventoryItem_1.inventoryOperationEnum.ADD, qte, false);
-            }
-            await this._modifyQuantitiesOnlyWeb(operationType === 'refunded' ? 'completed' : 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, typeof options.saveToDatabase == 'boolean' ? options.saveToDatabase : true);
-            // #endregion
-            return this._data;
-        };
-        this.handleOrderReadyForProcessing = async (storeId, qte, cartType) => {
-            // If order is ready for processing, we need to ajust :
-            //    - both AVAILABLE and PROCESSING quantities
-            //    - for only STORE inventory
-            await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, false, false);
-            await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, true, false);
-            return this.data();
-        };
-        this.handleOrderInDelivery = async (storeId, qte, cartType) => {
-            // If order is in delivery, we need to ajust :
-            //    - both PROCESSING and IN_TRANSIT quantities
-            //    - for only STORE inventory
-            await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false);
-            await this._modifyQuantitiesByStore(storeId, 'in_transit', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType);
-            return this.data();
-        };
-        this.handleChangedProcessingStore = async (oldStoreId, newStoreId, qte, cartType) => {
-            // If processing store was updated :
-            //    - for old processing store :
-            //       - remove qties from processing, add to available
-            //    - for new processing store :
-            //       - remove qties from available, add to processing
-            //    - in both cases, only for store inventory (no changes to web inventory)
-            await this._modifyQuantitiesByStore(oldStoreId, 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false);
-            await this._modifyQuantitiesByStore(oldStoreId, 'available', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, false);
-            await this._modifyQuantitiesByStore(newStoreId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false);
-            await this._modifyQuantitiesByStore(newStoreId, 'processing', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true);
-            return this.data();
-        };
-        this.handleTransferInTransit = async (storeId, qte, cartType, forOrder) => {
-            // If transfer is now in transit, we need to ajust :
-            //    - both AVAILABLE and IN_TRANSIT quantities
-            //    - for STORE inventory always
-            //    - for WEB inventory if transfer was not created though an order
-            await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false, !forOrder);
-            await this._modifyQuantitiesByStore(storeId, 'in_transit', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true, !forOrder);
-            return this.data();
-        };
-        /**
-         * Adjust store quantities
-         * @param storeFromId Origin store id
-         * @param storeToId Target store id
-         * @param qte Total quantity received
-         * @param cartType Cart type, GR only?
-         * @param options.forOrder True if associated to an order
-         * @param options.maxProcessingQte Quantity to place in processing, extra will go in available
-         * @param options.skipWebUpdateForAvailable If web inventory update should be skipped for available quantities (for when transfer is received for a already processed cart)
-         * @returns the new inventory item data
-         */
-        this.handleTransferReceived = async (storeFromId, storeToId, qte, cartType, options) => {
-            // FROM STORE
-            // If order transfer was received, we need to ajust :
-            //    - only IN_TRANSIT quantities
-            //    - for only STORE inventory
-            //    - of the storeFromID
-            await this._modifyQuantitiesByStore(storeFromId, 'in_transit', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false, // don't save to database here, will be done on next steps
-            !options.forOrder);
-            // TO STORE
-            // If order transfer was received, we need to ajust :
-            //    - if transfer is associated to order :
-            //          - only IN_TRANSIT quantities
-            //          - only for STORE inventory
-            //
-            //    - else :
-            //          - only AVAILABLE quantities
-            //          - for STORE inventory always, and WEB inventory
-            if (options.maxProcessingQte && options.forOrder) {
-                qte -= options.maxProcessingQte;
-                await this._modifyQuantitiesByStore(storeToId, 'processing', IInventoryItem_1.inventoryOperationEnum.ADD, options.maxProcessingQte, cartType, qte <= 0, // save to database only if logic will not enter next check
-                !options.forOrder);
-            }
-            if (qte > 0) {
-                await this._modifyQuantitiesByStore(storeToId, 'available', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true, // always save to database here
-                !options.skipWebUpdateForAvailable // only update web inventory if property not set to skip operation
-                );
-            }
-            return this.data();
-        };
-        /**
-         * Cancel value in transit - Adjust the in transit negatively without adjusting any other quantity.
-         * @param storeId The store to apply the change
-         * @param qte The quantity to remove
-         * @param cartType Cart type, GR only?
-         * @param forOrder True if associated to an order
-         * @returns updated data
-         */
-        this.handleCancelInTransit = async (storeId, qte, cartType, forOrder) => {
-            await this._modifyQuantitiesByStore(storeId, 'in_transit', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, true, !forOrder);
-            return this.data();
-        };
-        this.handlePOSCartFastComplete = async (storeId, qte, cartType, quantitiesAlreadyReserved = 0) => {
-            // If order was triggered by POS Fast complete (button in order interface dashboard), we need to ajust :
-            //    - both PROCESSING and COMPLETE quantities
-            //    - for only WEB inventory
-            //    - if store can sell online
-            const fromStoreIsWeb = this.data().inventories.find((inventory) => inventory.store_id === storeId).can_sell_online;
-            if (!!fromStoreIsWeb) {
-                await this._modifyQuantitiesOnlyWeb('processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, false);
-                await this._modifyQuantitiesOnlyWeb('completed', IInventoryItem_1.inventoryOperationEnum.ADD, qte, false);
-            }
-            const quantitiesNotReserved = qte - quantitiesAlreadyReserved;
-            // AND, we need to ajust :
-            //    - potentially AVAILABLE quantities with quantitiesNotReserved (if quantitiesNotReserved != 0)
-            //    - potentially PROCESSING quantities with quantitiesAlreadyReserved (if quantitiesAlreadyReserved != 0)
-            //    - always COMPLETE quantities with full qte from item
-            //    - for only STORE inventory
-            if (quantitiesNotReserved != 0) {
-                await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, quantitiesNotReserved, cartType, false, false);
-            }
-            if (quantitiesAlreadyReserved != 0) {
-                await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, quantitiesAlreadyReserved, cartType, false, false);
-            }
-            await this._modifyQuantitiesByStore(storeId, 'completed', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true, false);
-            return this.data();
-        };
-        this.handleChangeCanSellOnline = async (storeId, qte, newCanSellOnline, saveToDatabase) => {
-            const storeInventoryIndex = this.data().inventories.findIndex((i) => i.store_id === storeId);
-            if (storeInventoryIndex === -1)
-                return;
-            const currentWebInventory = this.data().web_inventory;
-            const currentAvailable = !!currentWebInventory && !!currentWebInventory.available ? currentWebInventory.available : 0;
-            const partial = {
-                web_inventory: Object.assign(Object.assign(Object.assign({}, (0, IInventoryItem_1.getDefaultInventoryQuantities)()), (!!this.data().web_inventory ? this.data().web_inventory : {})), { available: !!newCanSellOnline ? currentAvailable + qte : currentAvailable - qte }),
-                inventories: [
-                    ...this.data().inventories.slice(0, storeInventoryIndex),
-                    Object.assign(Object.assign({}, this.data().inventories[storeInventoryIndex]), { can_sell_online: newCanSellOnline }),
-                    ...this.data().inventories.slice(storeInventoryIndex + 1)
-                ]
-            };
-            if (!!saveToDatabase) {
-                await this.save(partial);
-            }
-            else {
-                this._data = Object.assign(Object.assign({}, this.data()), partial);
-            }
-            return this.data();
-        };
-        /**
-         * Reserve a quantity from the available web inventory and store if provided
-         * @param qty The quantity to reserve
-         * @param storeId The store id to use for reservation, undefined if web only
-         * @returns the new inventory data
-         */
-        this.handleReserveInventory = async (qty, storeId) => {
-            if (!!storeId) {
-                await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qty, Cart_1.CartTypeEnum.POS, false, true);
-                await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.ADD, qty, Cart_1.CartTypeEnum.POS, true, true);
-                return this.data();
-            }
-            await this._modifyQuantitiesOnlyWeb('available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qty, false);
-            await this._modifyQuantitiesOnlyWeb('processing', IInventoryItem_1.inventoryOperationEnum.ADD, qty);
-            return this.data();
-        };
-        /**
-         * Release a quantity from the processing web inventory and store if provided
-         * @param qty The quantity to release
-         * @param storeId The store id to use for reservation, undefined if web only
-         * @returns the new inventory data
-         */
-        this.handleUnreserveInventory = async (qty, storeId) => {
-            if (!!storeId) {
-                await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qty, Cart_1.CartTypeEnum.POS, false, true);
-                await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.ADD, qty, Cart_1.CartTypeEnum.POS, true, true);
-                return this.data();
-            }
-            await this._modifyQuantitiesOnlyWeb('processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qty, false);
-            await this._modifyQuantitiesOnlyWeb('available', IInventoryItem_1.inventoryOperationEnum.ADD, qty);
-            return this.data();
-        };
-    }
-}
-exports.default = Inventory;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const toNumber_1 = __importDefault(require("lodash/toNumber"));
+const DatabaseService_1 = __importDefault(require("../../services/database/DatabaseService"));
+const baseService_1 = require("../baseService");
+const TransferRequest_1 = require("../../Interfaces/TransferRequest");
+const IInventoryItem_1 = require("../../Interfaces/Product/IInventoryItem");
+const Cart_1 = require("../../Interfaces/Cart");
+const console_1 = require("../../utils/console");
+const string_1 = require("../../utils/string");
+const inventories_1 = require("../../utils/inventories");
+class Inventory extends baseService_1.BaseServiceClass {
+    constructor(data, collection, user) {
+        super(data, collection, user);
+        this.save = async (newInventoryData, options, saveToDatabase = true, update, merge) => {
+            if (!!!this.data().sku)
+                return false;
+            const exists = await DatabaseService_1.default.getDocuments(this._collection.path, {
+                query: [{ field: 'sku', operator: '==', value: this.data().sku }]
+            });
+            if (!!!exists.length) {
+                return await super.save(Object.assign(Object.assign({}, (newInventoryData ? newInventoryData : this.data())), { id: (0, string_1.string_to_slug)(this.data().sku) }), options, saveToDatabase, update, merge);
+            }
+            else {
+                try {
+                    const doc = exists[0];
+                    const newData = Object.assign(Object.assign({}, this.data()), (!!newInventoryData ? newInventoryData : {}));
+                    await super.save(Object.assign(Object.assign(Object.assign({}, newData), { last_update_by: this.user() }), (!!!newData.id && !!doc ? { id: doc.id } : {})), options, saveToDatabase, update, merge);
+                }
+                catch (err) {
+                    console.log('err', err);
+                    return false;
+                }
+                return true;
+            }
+        };
+        this.delete = async () => {
+            try {
+                await DatabaseService_1.default.deleteDocument(this._collection.path, (0, string_1.string_to_slug)(this.data().sku));
+                return true;
+            }
+            catch (err) {
+                console.log(err);
+                return false;
+            }
+        };
+        this.getHistoryInventory = async () => {
+            if (!!!this._collection || DatabaseService_1.default.getPathParent(this._collection.path) == '/') {
+                throw new Error('Collection should be defined and have a parent.');
+            }
+            try {
+                const historyQuery = await DatabaseService_1.default.getDocuments(DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'inventory_history'), {
+                    query: [
+                        {
+                            field: 'sku',
+                            operator: 'in',
+                            value: [this.data().sku, this.data().sku.toLowerCase(), this.data().sku.toUpperCase()]
+                        }
+                    ],
+                    orderBy: 'at',
+                    order: 'desc',
+                    limit: 50
+                });
+                return historyQuery.map((d) => (Object.assign(Object.assign({}, d.data), { id: d.id })));
+            }
+            catch (err) {
+                (0, console_1.errorMessage)(`Could not get inventory history${err.message}`);
+                return [];
+            }
+        };
+        this.setQuantitiesWithInventoryItemByStore = async (inventory) => {
+            return await this.save({
+                inventories: this.data().inventories.map((_inventory) => {
+                    if (_inventory.store_id.toLowerCase() !== (inventory.store_id || '').toLowerCase())
+                        return _inventory;
+                    return Object.assign(Object.assign({}, _inventory), { qty: Object.assign(Object.assign({}, _inventory.qty), inventory.qty) });
+                })
+            }, undefined, true, true);
+        };
+        this.setQuantitiesWithWebInventoryItemByStore = async (inventory, webQty) => {
+            let isDiff = false;
+            if (!!!this._data.web_inventory ||
+                !!!this._data.web_inventory.available ||
+                this._data.web_inventory.available !== webQty)
+                isDiff = true;
+            for (const inv of this._data.inventories) {
+                if (!!inventory.find((i) => (i.store_id || '').toLowerCase() === inv.store_id.toLowerCase() && !(0, isEqual_1.default)(i.qty, inv.qty)))
+                    isDiff = true;
+            }
+            if (!isDiff) {
+                console.log('Inventory didnt change, not saving : ', this._data.sku);
+                return;
+            }
+            return await this.save({
+                inventories: this.data().inventories.map((_inventory) => {
+                    const newInv = inventory.find((i) => _inventory.store_id.toLowerCase() === (i.store_id || '').toLowerCase());
+                    if (!!!newInv)
+                        return _inventory;
+                    return Object.assign(Object.assign({}, _inventory), { qty: Object.assign(Object.assign({}, _inventory.qty), newInv.qty) });
+                }),
+                web_inventory: Object.assign(Object.assign(Object.assign({}, (0, IInventoryItem_1.getDefaultInventoryQuantities)()), (this.data().web_inventory || {})), { available: webQty })
+            }, undefined, true, true);
+        };
+        this._modifyQuantitiesByStore = async (storeId, type, operation, amount = 0, cartType, saveToDatabase = true, updateWeb) => {
+            var _a;
+            if (!!!operation)
+                return 'Must include operation type';
+            let isWeb = false;
+            let newQuantity = undefined;
+            const inventories = this._data.inventories.map((storeInventory) => {
+                if (storeInventory.store_id !== storeId)
+                    return storeInventory;
+                const currentQte = (0, toNumber_1.default)(storeInventory.qty[type] || 0);
+                if (storeInventory.can_sell_online || (!!cartType && cartType !== Cart_1.CartTypeEnum.POS_TRANSACTIONNAL))
+                    isWeb = true;
+                newQuantity =
+                    operation === IInventoryItem_1.inventoryOperationEnum.ADD ? currentQte + (0, toNumber_1.default)(amount) : currentQte - (0, toNumber_1.default)(amount);
+                return Object.assign(Object.assign({}, storeInventory), { qty: Object.assign(Object.assign({}, storeInventory.qty), { [type]: newQuantity }) });
+            });
+            const willRemoveQuantities = (operation == IInventoryItem_1.inventoryOperationEnum.ADD && amount < 0) ||
+                (operation == IInventoryItem_1.inventoryOperationEnum.REMOVE && amount > 0);
+            this._data = Object.assign(Object.assign(Object.assign({}, this._data), { inventories: inventories }), (!!isWeb && typeof newQuantity === 'number' && !!updateWeb
+                ? {
+                    web_inventory: Object.assign(Object.assign({}, ((_a = this._data.web_inventory) !== null && _a !== void 0 ? _a : (0, IInventoryItem_1.getDefaultInventoryQuantities)())), { 
+                        // NEW : If web inventory is updated with store, add props to stop inventory
+                        //       from adjusting to high negative values if operation will REMOVE quantities
+                        [type]: this._getNewWebQuantity(type, operation, amount, willRemoveQuantities) })
+                }
+                : {}));
+            if (!!saveToDatabase) {
+                await this.save({}, undefined, saveToDatabase);
+            }
+        };
+        this._modifyQuantitiesOnlyWeb = async (type, operation, amount = 0, saveToDatabase) => {
+            var _a;
+            if (!!!operation)
+                return 'Must include operation type';
+            let newQuantity = this._getNewWebQuantity(type, operation, amount);
+            await this.save({
+                web_inventory: Object.assign(Object.assign({}, ((_a = this._data.web_inventory) !== null && _a !== void 0 ? _a : (0, IInventoryItem_1.getDefaultInventoryQuantities)())), { [type]: newQuantity })
+            }, undefined, saveToDatabase);
+        };
+        /**
+         * Returns calculated new value for web inventory
+         * @param type - The inventory type to calculate
+         * @param operation - If quantities should be added or removed
+         * @param amount - The quantity to adjust
+         * @param ignoreNewNegativeValues - Optionnal. If true, will replace calculated qte with 0 if current qte was positive, and keep current value if it was already negative and is 'available' inventory (since only available web quantites could be negative).
+         */
+        this._getNewWebQuantity = (type, operation, amount, ignoreNewNegativeValues) => {
+            var _a, _b;
+            const webInventory = (_a = this._data.web_inventory) !== null && _a !== void 0 ? _a : (0, IInventoryItem_1.getDefaultInventoryQuantities)();
+            const currentQte = (0, toNumber_1.default)((_b = webInventory[type]) !== null && _b !== void 0 ? _b : 0);
+            let newValue = operation === IInventoryItem_1.inventoryOperationEnum.ADD
+                ? (0, toNumber_1.default)(currentQte) + (0, toNumber_1.default)(amount)
+                : (0, toNumber_1.default)(currentQte) - (0, toNumber_1.default)(amount);
+            if (ignoreNewNegativeValues && newValue < 0)
+                newValue = currentQte < 0 && type == 'available' ? currentQte : 0;
+            return newValue;
+        };
+        this._orderCompleted = async (storeId, qte, cartType) => {
+            // If order was completed, we need to ajust :
+            //    - both PROCESSING and COMPLETED quantities
+            //    - for WEB and STORE inventories
+            await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false, true);
+            await this._modifyQuantitiesByStore(storeId, 'completed', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true, true);
+        };
+        this.handleOrderDelivered = async (storeId, qte, cartType) => {
+            await this._orderCompleted(storeId, qte, cartType);
+            return this.data();
+        };
+        this.handleOrderPickedupInStore = async (storeId, qte, cartType) => {
+            await this._orderCompleted(storeId, qte, cartType);
+            return this.data();
+        };
+        this.handleOrderProcessedForShipping = async (storeId, qte, cartType) => {
+            await this._orderCompleted(storeId, qte, cartType);
+            return this.data();
+        };
+        this.handleNewQuantities = async (storeId, qte, cartType, saveToDatabase) => {
+            const shouldSaveToDB = typeof saveToDatabase != 'undefined' ? saveToDatabase : true;
+            // If quantities added, we need to ajust :
+            //    - AVAILABLE quantities
+            //    - for WEB and STORE inventories
+            await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, shouldSaveToDB, true);
+            return this._data;
+        };
+        this.handleUpdateWebInventory = async (qte) => {
+            // After inventory is updated through CSV import, we need to adjust :
+            //    - AVAILABLE quantities
+            //    - for WEB inventory
+            await this._modifyQuantitiesOnlyWeb('available', IInventoryItem_1.inventoryOperationEnum.ADD, qte, true);
+        };
+        this.handleProductSold = async (storeId, qte, cartType, web = false) => {
+            // If product was sold and is a web transaction, we need to ajust :
+            //    - both AVAILABLE and PROCESSING quantities
+            //    - for only WEB inventory
+            if (!!web) {
+                await this._modifyQuantitiesOnlyWeb('available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, false);
+                await this._modifyQuantitiesOnlyWeb('processing', IInventoryItem_1.inventoryOperationEnum.ADD, qte);
+                return this.data();
+            }
+            // If product was sold and is a POS transaction (!!!web), we need to ajust :
+            //    - both AVAILABLE and COMPLETED quantities
+            //    - for WEB and STORE inventory
+            //    - only if storeId is defined
+            if (!!storeId) {
+                await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false, true);
+                await this._modifyQuantitiesByStore(storeId, 'completed', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true, true);
+            }
+            else {
+                console.log('no storeId provided!');
+            }
+            return this.data();
+        };
+        /**
+         * Update inventory on cart item modified (POS modify cart process).
+         * @param storeId The store associated to the order. If cart still at status 5, might be undefined (unless quantities already reserved for order)
+         * @param qte The quantities to ajust
+         * @param cartType The associated cart's type
+         * @param options.onlyWeb Optionnal. If only web inventory should be ajusted
+         * @param options.reservedQteDiff Optionnal. Reserved quantities difference for given cart item. Expressed in sell_unit (must be converted to inventory_unit)
+         * @returns {Promise<IInventoryItem>}
+         */
+        this.handleProductModified = async (storeId, qte, cartType, options = {}) => {
+            var _a;
+            // Save store inventory if not only web and storeId is provided
+            if (!!!options.onlyWeb && !!storeId) {
+                // If quantities were already reserved for order, should only update inventory according to reserved quantity difference
+                let qteToUse = (_a = options.reservedQteDiff) !== null && _a !== void 0 ? _a : qte;
+                await this._modifyQuantitiesByStore(storeId, 'available', qteToUse < 0 ? IInventoryItem_1.inventoryOperationEnum.ADD : IInventoryItem_1.inventoryOperationEnum.REMOVE, qteToUse < 0 ? qteToUse * -1 : qteToUse, cartType, false, // save to database (will be done later on web update)
+                false // save web (will be done later)
+                );
+                await this._modifyQuantitiesByStore(storeId, 'processing', qteToUse < 0 ? IInventoryItem_1.inventoryOperationEnum.REMOVE : IInventoryItem_1.inventoryOperationEnum.ADD, qteToUse < 0 ? qteToUse * -1 : qteToUse, cartType, false, // save to database (will be done later on web update)
+                false // save web (will be done laters
+                );
+            }
+            // Always update web quantities with total modified quantities
+            await this._modifyQuantitiesOnlyWeb('available', qte < 0 ? IInventoryItem_1.inventoryOperationEnum.ADD : IInventoryItem_1.inventoryOperationEnum.REMOVE, qte < 0 ? qte * -1 : qte, false);
+            await this._modifyQuantitiesOnlyWeb('processing', qte < 0 ? IInventoryItem_1.inventoryOperationEnum.REMOVE : IInventoryItem_1.inventoryOperationEnum.ADD, qte < 0 ? qte * -1 : qte, true // save to database done here for all updates to inventories and web_inventory
+            );
+            return this.data();
+        };
+        /**
+         * Update inventory for a specific item if order was cancelled or refunded.
+         * @param toStoreId The store where quantities will be ADDED
+         * @param fromStoreId The store where quantities will vbe REMOVED
+         * @param qte The quantity to ajust
+         * @param operationType If cart was cancelled or refunded
+         * @param cartType If cart is web, POS, or Pickup Now
+         * @param options.deleteItem Optionnal. If item should not be returned to the stores inventory (broken, misplaced, old batch, etc...)
+         * @param options.onlyWeb Optionnal. If inventory should only be updated for web inventory (and not for stores). Mostly depends on the cart's status when cancelled.
+         * @param options.orderAssociatedTransfers Optionnal. Array of TransferRequest objects associated to cart. Used when cart is cancelled
+         * @param options.saveToDatabase Optionnal. Mostly used for dev purpuses (and for unit testing). Otherwise, save is done logically at the end of the update process
+         * @param options.reservedQte Optionnal. Quantity reserved in processing inventory for cart item as of now. Expressed in sell_unit (must be converted to inventory_unit)
+         * @param options.otherUnits Optionnal. Other units for corresponding cart item. If not defined, will use those found in InventoryItem data
+         */
+        this.handleOrderCancelled = async (toStoreId, fromStoreId, qte, operationType, cartType, options = {}) => {
+            const otherUnitsToUse = options.otherUnits || this._data.other_units;
+            // If order was cancelled, we need to ajust :
+            //    - PROCESSING quantities always, and AVAILABLE quantities only if item should return in stock
+            //    - for WEB inventory, and STORE inventory if onlyWeb is false, or order has associated transfers
+            // If order was refunded, we need to ajust :
+            //    - Take quantities from COMPLETED and put them back in AVAILABLE
+            //    - for WEB and STORE inventory, in this case onlyWeb is always false
+            // ----------------------------------------------------------
+            // #region CHECK FOR QUANTITIES TO AJUST IN STORE
+            let qteToUseForStoreUpdate = !!!options.onlyWeb ? qte : 0;
+            if (!!options.orderAssociatedTransfers && operationType == 'cancelled' && !!options.onlyWeb) {
+                // A. Calculate initial quantites asked for transfer
+                let initialQuantitiesInTransfers = 0;
+                let receivedQuantitesInTransfers = 0;
+                for (let transfer of options.orderAssociatedTransfers) {
+                    // Skip transfers that were split at creation, to fetch only initial quantities
+                    if (!!!transfer.data().original_transfer_id) {
+                        initialQuantitiesInTransfers += transfer.getOriginalRequestedQuantity(this._data.sku);
+                    }
+                    // Get quantities received from transfers with status RECEIVED or RECEIVED_PARTIAL
+                    if ([TransferRequest_1.TransferRequestStatusEnum.RECEIVED, TransferRequest_1.TransferRequestStatusEnum.RECEIVED_PARTIAL].includes(transfer.data().status)) {
+                        const sameProd = transfer.data().products.find((p) => p.sku == this._data.sku);
+                        if (!!sameProd)
+                            receivedQuantitesInTransfers += sameProd.qte_received || 0;
+                    }
+                }
+                // B. Set currently in processing quantities to ...
+                // ...reserved quantities (if defined)
+                if (typeof options.reservedQte != 'undefined') {
+                    qteToUseForStoreUpdate = (0, inventories_1.getConvertedUnitQuantity)(otherUnitsToUse, options.reservedQte, 'inventory_unit');
+                }
+                else {
+                    // ...the difference between total qte for item in cart and quantities initially set for transfer requests
+                    qteToUseForStoreUpdate = qte - initialQuantitiesInTransfers;
+                    if (qteToUseForStoreUpdate < 0)
+                        qteToUseForStoreUpdate = 0;
+                    // ... and add quantities received from transfers to processing quantites
+                    qteToUseForStoreUpdate += receivedQuantitesInTransfers;
+                }
+            }
+            if (qteToUseForStoreUpdate != 0) {
+                await this._modifyQuantitiesByStore(fromStoreId, operationType === 'refunded' ? 'completed' : 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qteToUseForStoreUpdate, cartType, typeof options.saveToDatabase == 'boolean' ? options.saveToDatabase : !!options.deleteItem // save to database
+                );
+                if (!!!options.deleteItem) {
+                    await this._modifyQuantitiesByStore(toStoreId, 'available', IInventoryItem_1.inventoryOperationEnum.ADD, qteToUseForStoreUpdate, cartType, typeof options.saveToDatabase == 'boolean' ? options.saveToDatabase : true // save to database
+                    );
+                }
+            }
+            // #endregion
+            // ----------------------------------------------------------
+            // #region AJUST WEB QUANTITIES
+            if (!!!options.deleteItem) {
+                await this._modifyQuantitiesOnlyWeb('available', IInventoryItem_1.inventoryOperationEnum.ADD, qte, false);
+            }
+            await this._modifyQuantitiesOnlyWeb(operationType === 'refunded' ? 'completed' : 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, typeof options.saveToDatabase == 'boolean' ? options.saveToDatabase : true);
+            // #endregion
+            return this._data;
+        };
+        this.handleOrderReadyForProcessing = async (storeId, qte, cartType) => {
+            // If order is ready for processing, we need to ajust :
+            //    - both AVAILABLE and PROCESSING quantities
+            //    - for only STORE inventory
+            await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, false, false);
+            await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, true, false);
+            return this.data();
+        };
+        this.handleOrderInDelivery = async (storeId, qte, cartType) => {
+            // If order is in delivery, we need to ajust :
+            //    - both PROCESSING and IN_TRANSIT quantities
+            //    - for only STORE inventory
+            await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false);
+            await this._modifyQuantitiesByStore(storeId, 'in_transit', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType);
+            return this.data();
+        };
+        this.handleChangedProcessingStore = async (oldStoreId, newStoreId, qte, cartType) => {
+            // If processing store was updated :
+            //    - for old processing store :
+            //       - remove qties from processing, add to available
+            //    - for new processing store :
+            //       - remove qties from available, add to processing
+            //    - in both cases, only for store inventory (no changes to web inventory)
+            await this._modifyQuantitiesByStore(oldStoreId, 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false);
+            await this._modifyQuantitiesByStore(oldStoreId, 'available', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, false);
+            await this._modifyQuantitiesByStore(newStoreId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false);
+            await this._modifyQuantitiesByStore(newStoreId, 'processing', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true);
+            return this.data();
+        };
+        this.handleTransferInTransit = async (storeId, qte, cartType, forOrder) => {
+            // If transfer is now in transit, we need to ajust :
+            //    - both AVAILABLE and IN_TRANSIT quantities
+            //    - for STORE inventory always
+            //    - for WEB inventory if transfer was not created though an order
+            await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false, !forOrder);
+            await this._modifyQuantitiesByStore(storeId, 'in_transit', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true, !forOrder);
+            return this.data();
+        };
+        /**
+         * Adjust store quantities
+         * @param storeFromId Origin store id
+         * @param storeToId Target store id
+         * @param qte Total quantity received
+         * @param cartType Cart type, GR only?
+         * @param options.forOrder True if associated to an order
+         * @param options.maxProcessingQte Quantity to place in processing, extra will go in available
+         * @param options.skipWebUpdateForAvailable If web inventory update should be skipped for available quantities (for when transfer is received for a already processed cart)
+         * @returns the new inventory item data
+         */
+        this.handleTransferReceived = async (storeFromId, storeToId, qte, cartType, options) => {
+            // FROM STORE
+            // If order transfer was received, we need to ajust :
+            //    - only IN_TRANSIT quantities
+            //    - for only STORE inventory
+            //    - of the storeFromID
+            await this._modifyQuantitiesByStore(storeFromId, 'in_transit', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, false, // don't save to database here, will be done on next steps
+            !options.forOrder);
+            // TO STORE
+            // If order transfer was received, we need to ajust :
+            //    - if transfer is associated to order :
+            //          - only IN_TRANSIT quantities
+            //          - only for STORE inventory
+            //
+            //    - else :
+            //          - only AVAILABLE quantities
+            //          - for STORE inventory always, and WEB inventory
+            if (options.maxProcessingQte && options.forOrder) {
+                qte -= options.maxProcessingQte;
+                await this._modifyQuantitiesByStore(storeToId, 'processing', IInventoryItem_1.inventoryOperationEnum.ADD, options.maxProcessingQte, cartType, qte <= 0, // save to database only if logic will not enter next check
+                !options.forOrder);
+            }
+            if (qte > 0) {
+                await this._modifyQuantitiesByStore(storeToId, 'available', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true, // always save to database here
+                !options.skipWebUpdateForAvailable // only update web inventory if property not set to skip operation
+                );
+            }
+            return this.data();
+        };
+        /**
+         * Cancel value in transit - Adjust the in transit negatively without adjusting any other quantity.
+         * @param storeId The store to apply the change
+         * @param qte The quantity to remove
+         * @param cartType Cart type, GR only?
+         * @param forOrder True if associated to an order
+         * @returns updated data
+         */
+        this.handleCancelInTransit = async (storeId, qte, cartType, forOrder) => {
+            await this._modifyQuantitiesByStore(storeId, 'in_transit', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, cartType, true, !forOrder);
+            return this.data();
+        };
+        this.handlePOSCartFastComplete = async (storeId, qte, cartType, quantitiesAlreadyReserved = 0) => {
+            // If order was triggered by POS Fast complete (button in order interface dashboard), we need to ajust :
+            //    - both PROCESSING and COMPLETE quantities
+            //    - for only WEB inventory
+            //    - if store can sell online
+            const fromStoreIsWeb = this.data().inventories.find((inventory) => inventory.store_id === storeId).can_sell_online;
+            if (!!fromStoreIsWeb) {
+                await this._modifyQuantitiesOnlyWeb('processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qte, false);
+                await this._modifyQuantitiesOnlyWeb('completed', IInventoryItem_1.inventoryOperationEnum.ADD, qte, false);
+            }
+            const quantitiesNotReserved = qte - quantitiesAlreadyReserved;
+            // AND, we need to ajust :
+            //    - potentially AVAILABLE quantities with quantitiesNotReserved (if quantitiesNotReserved != 0)
+            //    - potentially PROCESSING quantities with quantitiesAlreadyReserved (if quantitiesAlreadyReserved != 0)
+            //    - always COMPLETE quantities with full qte from item
+            //    - for only STORE inventory
+            if (quantitiesNotReserved != 0) {
+                await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, quantitiesNotReserved, cartType, false, false);
+            }
+            if (quantitiesAlreadyReserved != 0) {
+                await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, quantitiesAlreadyReserved, cartType, false, false);
+            }
+            await this._modifyQuantitiesByStore(storeId, 'completed', IInventoryItem_1.inventoryOperationEnum.ADD, qte, cartType, true, false);
+            return this.data();
+        };
+        this.handleChangeCanSellOnline = async (storeId, qte, newCanSellOnline, saveToDatabase) => {
+            const storeInventoryIndex = this.data().inventories.findIndex((i) => i.store_id === storeId);
+            if (storeInventoryIndex === -1)
+                return;
+            const currentWebInventory = this.data().web_inventory;
+            const currentAvailable = !!currentWebInventory && !!currentWebInventory.available ? currentWebInventory.available : 0;
+            const partial = {
+                web_inventory: Object.assign(Object.assign(Object.assign({}, (0, IInventoryItem_1.getDefaultInventoryQuantities)()), (!!this.data().web_inventory ? this.data().web_inventory : {})), { available: !!newCanSellOnline ? currentAvailable + qte : currentAvailable - qte }),
+                inventories: [
+                    ...this.data().inventories.slice(0, storeInventoryIndex),
+                    Object.assign(Object.assign({}, this.data().inventories[storeInventoryIndex]), { can_sell_online: newCanSellOnline }),
+                    ...this.data().inventories.slice(storeInventoryIndex + 1)
+                ]
+            };
+            if (!!saveToDatabase) {
+                await this.save(partial);
+            }
+            else {
+                this._data = Object.assign(Object.assign({}, this.data()), partial);
+            }
+            return this.data();
+        };
+        /**
+         * Reserve a quantity from the available web inventory and store if provided
+         * @param qty The quantity to reserve
+         * @param storeId The store id to use for reservation, undefined if web only
+         * @returns the new inventory data
+         */
+        this.handleReserveInventory = async (qty, storeId) => {
+            if (!!storeId) {
+                await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qty, Cart_1.CartTypeEnum.POS, false, true);
+                await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.ADD, qty, Cart_1.CartTypeEnum.POS, true, true);
+                return this.data();
+            }
+            await this._modifyQuantitiesOnlyWeb('available', IInventoryItem_1.inventoryOperationEnum.REMOVE, qty, false);
+            await this._modifyQuantitiesOnlyWeb('processing', IInventoryItem_1.inventoryOperationEnum.ADD, qty);
+            return this.data();
+        };
+        /**
+         * Release a quantity from the processing web inventory and store if provided
+         * @param qty The quantity to release
+         * @param storeId The store id to use for reservation, undefined if web only
+         * @returns the new inventory data
+         */
+        this.handleUnreserveInventory = async (qty, storeId) => {
+            if (!!storeId) {
+                await this._modifyQuantitiesByStore(storeId, 'processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qty, Cart_1.CartTypeEnum.POS, false, true);
+                await this._modifyQuantitiesByStore(storeId, 'available', IInventoryItem_1.inventoryOperationEnum.ADD, qty, Cart_1.CartTypeEnum.POS, true, true);
+                return this.data();
+            }
+            await this._modifyQuantitiesOnlyWeb('processing', IInventoryItem_1.inventoryOperationEnum.REMOVE, qty, false);
+            await this._modifyQuantitiesOnlyWeb('available', IInventoryItem_1.inventoryOperationEnum.ADD, qty);
+            return this.data();
+        };
+    }
+}
+exports.default = Inventory;
 //# sourceMappingURL=index.js.map