addio-admin-sdk 1.7.103 → 1.7.104

package/dist/lib/Cart/index.js

@@ -15,6 +15,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+//#region IMPORTS
 const find_1 = __importDefault(require("lodash/find"));
 const indexOf_1 = __importDefault(require("lodash/indexOf"));
 const isNumber_1 = __importDefault(require("lodash/isNumber"));
@@ -70,10 +71,14 @@ const TransferRequest_1 = require("../TransferRequest");
 const TransferRequest_2 = require("../../Interfaces/TransferRequest");
 const inventories_1 = require("../../utils/inventories");
 const CartReservedQuantities_1 = __importDefault(require("../CartReservedQuantities"));
+//#endregion
 class Cart extends baseService_1.BaseServiceClass {
+    //#endregion
     constructor(data, collection, user, resetErrors) {
         super(data, collection, user);
+        //#region ATTRIBUTES
         this._allTaxes = [];
+        //#region SETTERS
         this.addError = (error) => {
             this._data = Object.assign(Object.assign({}, this._data), { errors: (0, uniq_1.default)([...(!!this._data.errors && Array.isArray(this._data.errors) ? this._data.errors : []), error]) });
         };
@@ -101,6 +106,12 @@ class Cart extends baseService_1.BaseServiceClass {
             }
             return this._data;
         };
+        /**
+         * Set cart as cancelled with external refund, and reset marketing props
+         * @param user - User that initiated the cancellation process
+         * @param associatedTransfers.all - Optionnal. Full list of TransferRequest obj associated to cart
+         * @param associatedTransfers.toCancel - Optionnal. Provided list of ITransferRequest data associated to cart that should be cancelled
+         */
         this.cancelCart = async (user, associatedTransfers) => {
             let userInfo;
             if (!!user) {
@@ -114,7 +125,9 @@ class Cart extends baseService_1.BaseServiceClass {
                 };
             }
             const editedCart = Object.assign(Object.assign(Object.assign(Object.assign({ status: Cart_1.CartStatusEnum.EXT_REFUND }, (!!userInfo ? { canceled_by: userInfo } : {})), (!!this._data.check_marketing_emails ? { check_marketing_emails: false } : {})), (!!this._data.check_sms_to_send ? { check_sms_to_send: false } : {})), (!!this._data.check_retarget_marketing_emails ? { check_retarget_marketing_emails: false } : {}));
+            // Space will be set in following functions if needed
             let space = undefined;
+            // Reset inventories for items
             if (!!this._data.items && !!this._data.items.length) {
                 try {
                     if (!!!space)
@@ -131,6 +144,7 @@ class Cart extends baseService_1.BaseServiceClass {
                     console.error(e);
                 }
             }
+            // Cancel associated transfer requests
             if (!!associatedTransfers && !!associatedTransfers.toCancel) {
                 try {
                     if (!!!space)
@@ -150,7 +164,7 @@ class Cart extends baseService_1.BaseServiceClass {
                 }
             }
             try {
-                await this.save(editedCart, true);
+                await this.save(editedCart, undefined, true);
                 return true;
             }
             catch (error) {
@@ -158,10 +172,69 @@ class Cart extends baseService_1.BaseServiceClass {
                 return false;
             }
         };
+        /**
+         * Set cart as cancelled for payment-pending carts
+         * @param user The data for the user who initiated the cancel operation
+         * @throws If cart contains any other saved payment type than PaymentTypeEnum.TOBERECEIVED
+         * @returns {Promise<ICart>}
+         */
+        this.cancelCartWithoutPayments = async (user) => {
+            // If cart has a payment other than "to be received", throw an error
+            const cartPaidBy = this.getAllPaidBy();
+            if (cartPaidBy.some((p) => p != Cart_1.PaymentTypeEnum.TOBERECEIVED)) {
+                console.log("Can't cancel this cart if it has payments other than to be received! Should call function cancelCart instead.");
+                throw new Error('Could not cancel cart!');
+            }
+            // Generate user info based on who initiated the cancelation
+            let userInfo;
+            if (!!user) {
+                userInfo = {
+                    user_name: `${user.firstname} ${user.lastname}`,
+                    user_email: user.email,
+                    user_id: user.id,
+                    user_external_id: user.external_id,
+                    date: new Date(),
+                    is_active: true
+                };
+            }
+            const editedCart = Object.assign(Object.assign(Object.assign(Object.assign({ id: this._data.id, status: Cart_1.CartStatusEnum.CANCELLED }, (!!userInfo ? { canceled_by: userInfo } : {})), (!!this._data.check_marketing_emails ? { check_marketing_emails: false } : {})), (!!this._data.check_sms_to_send ? { check_sms_to_send: false } : {})), (!!this._data.check_retarget_marketing_emails ? { check_retarget_marketing_emails: false } : {}));
+            // Liberate inventories for items
+            const allItems = this._data.items;
+            if (!!allItems.length) {
+                try {
+                    const space = await Space_2.default.getCurrentSpaceWithRef(this._collection.path, this._user);
+                    const spaceReservedQuantitiesOnAddToCart = space.options.checkIfOptionIsSet('inventory.reserve_on_add_to_cart');
+                    const someItemsWithReservedQuantities = allItems.some((i) => typeof i.qte_reserved == 'number');
+                    if (!!!this._data.current_store_id &&
+                        (this._data.status >= Cart_1.CartStatusEnum.CART_READY_TO_PROCESS ||
+                            (spaceReservedQuantitiesOnAddToCart && someItemsWithReservedQuantities)))
+                        throw new Error('No store associated to cart, cannot update inventory!');
+                    await space.inventory.ajust(this._data.items, 'cancelled', this._data.cart_type, {
+                        currentStoreId: this._data.current_store_id || '',
+                        onlyWeb: spaceReservedQuantitiesOnAddToCart
+                            ? !someItemsWithReservedQuantities
+                            : this._data.status < Cart_1.CartStatusEnum.CART_READY_TO_PROCESS
+                    });
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            try {
+                await this.save(editedCart, undefined, true, true);
+                return this._data;
+            }
+            catch (error) {
+                console.log('error on saving cancelled cart', error);
+                return;
+            }
+        };
         this.updateCartOnLoginFetch = async (customerData, space, orgID) => {
             try {
+                // reset discount rules
                 await this.setDiscountRules();
                 let actionsDoneOnCart = [];
+                // check item prices
                 if (!!space && !!this._data.items.length) {
                     try {
                         actionsDoneOnCart = await this.verifyCartItems(space, orgID, false);
@@ -170,6 +243,7 @@ class Cart extends baseService_1.BaseServiceClass {
                         console.log('error on verifyCartItems in /signin endpoint: ', e.toString());
                     }
                 }
+                // add/ajust customer info
                 let cartCustumerInfo = this.data().customer_info;
                 if (!!customerData.basic_info.customer_professionnal_info &&
                     !!customerData.basic_info.customer_professionnal_info.professionnal_title &&
@@ -182,6 +256,7 @@ class Cart extends baseService_1.BaseServiceClass {
                     };
                     this._data = Object.assign(Object.assign({}, this._data), newInfo);
                 }
+                // If an old cart has promise_to_purchase info saved to database, remove it when logging in
                 if (!!this._data.promise_to_purchase) {
                     const _b = this._data, { promise_to_purchase, items } = _b, rest = __rest(_b, ["promise_to_purchase", "items"]);
                     this._data = Object.assign(Object.assign({}, rest), { promise_to_purchase: null, items: items.filter((i) => !!!(0, g2_1.isEscompteSuppItem)(i.sku)) });
@@ -201,6 +276,8 @@ class Cart extends baseService_1.BaseServiceClass {
                 console.log('error on updating cart after fetch : ', e.toString());
             }
         };
+        //#endregion
+        //#region GETTERS
         this.data = () => this._data;
         this.save = async (partial, options, saveToDatabase, onlyPartial = false, noEvent) => {
             var _b;
@@ -263,12 +340,17 @@ class Cart extends baseService_1.BaseServiceClass {
         this.checkIfAmountLeftToPayOnTotal = () => {
             const currentPaidBy = this.data().paid_by;
             if (!!currentPaidBy && currentPaidBy !== Cart_1.PaymentTypeEnum.MULTIPLE) {
+                // TODO - Check what we should do for carts created before POS was online, when currentPaidBy is TOBERECEIVED
                 return currentPaidBy === Cart_1.PaymentTypeEnum.TOBERECEIVED;
             }
+            // If no payment details found, it means no payments were taken
             const paymentDetails = this.data().payment_details;
             if (!!!paymentDetails || !!!paymentDetails.length)
                 return false;
+            // Add all paymentDetails amounts and paymentDetails without toBeReceived amounts
+            // const paidAmount = sumBy(paymentDetails, 'amount')
             const paidAmountWithoutToBeReceived = (0, sumBy_1.default)(paymentDetails.filter((p) => p.method !== Cart_1.PaymentTypeEnum.TOBERECEIVED), 'amount');
+            // No amount left to pay if paidAmountNoToBeReceived is equal to total cart amount or paidAmount === 0
             return (0, round_1.default)(paidAmountWithoutToBeReceived, 2) !== (0, round_1.default)(this.data().total, 2);
         };
         this.getCustomerById = async () => {
@@ -324,6 +406,10 @@ class Cart extends baseService_1.BaseServiceClass {
                 return undefined;
             }
         };
+        /**
+         * Get the exising or create a new reservation class object
+         * @returns The Object managing the reservation for this cart
+         */
         this.getReservedQuantities = async () => {
             if (!this._data.id)
                 throw new Error(`Can't create reservation on unsaved cart`);
@@ -345,6 +431,8 @@ class Cart extends baseService_1.BaseServiceClass {
                 path: docPath
             }, this._user);
         };
+        //#endregion
+        //#region BOXES + SHIPPING
         this.canEnterPredefinedBox = (box, subtotalToRespect, weightToRespect, totalItemsToRespect, space) => {
             if (!!subtotalToRespect) {
                 if (!!!this.data().subtotal && !!space) {
@@ -407,6 +495,10 @@ class Cart extends baseService_1.BaseServiceClass {
                     : (0, dimensions_1.convertDimension)(item.shipping_info.width || 0, item.shipping_info.unit_measurments, unit) * item.qte).toFixed(2));
             });
         };
+        /**
+         * Get total cart weight by calculating each product's weigth times inventory-converted quantity
+         * @param unit The unit in which weight must be returned
+         */
         this.getTotalWeight = (unit = 'pounds') => {
             return (0, sumBy_1.default)(this.data().items, (item) => {
                 if (!!item.shipping_info.is_not_shippable)
@@ -420,6 +512,8 @@ class Cart extends baseService_1.BaseServiceClass {
                         convertedQuantities;
             });
         };
+        //#endregion
+        //#region ITEMS
         this.addItemsToCart = async (items) => {
             const itemsWithRestrictions = this.checkProductRestrictions(items);
             this._data = Object.assign(Object.assign({}, this._data), { items: itemsWithRestrictions });
@@ -457,6 +551,7 @@ class Cart extends baseService_1.BaseServiceClass {
                     console.log('proCustomerTitle: ', proCustomerTitle);
                 }
                 let customPriceList = undefined;
+                // If is GR and customer is pro customer, fetch customPriceList
                 if (!!isGR && !!!space.data().cms.hide_pro_prices && !!space.data().g2_price_fetch_active && !!proID && !!orgID) {
                     const token = (0, context_1.getSpaceToken)(space, orgID);
                     if (!!token) {
@@ -514,6 +609,8 @@ class Cart extends baseService_1.BaseServiceClass {
                             ]
                         });
                     }
+                    // -------------------------------------------------------------------------------
+                    // If the parent doesn't exist anymore
                     if (!!!parentProductsQuery.length) {
                         if (!!__1.isTestEnv)
                             console.log('parent prod does not exist for slug: ', cartItem.parent_slug);
@@ -528,12 +625,16 @@ class Cart extends baseService_1.BaseServiceClass {
                     let parentProduct = parentProductsQuery[0];
                     if (!!__1.isTestEnv)
                         console.log('parentProduct: ', parentProduct.slug);
+                    // -------------------------------------------------------------------------------
+                    // If customer is pro, check to update product declinations with price_list
                     if (!!proID && !!proCustomerTitle) {
                         parentProduct = await (0, products_1.updateProductWithInfo)(parentProduct, '', space, space.data().id, proCustomerTitle);
                     }
                     if (cartItem.parent_slug === 'installation-gazon') {
                         installationParentProduct = parentProduct;
                     }
+                    // -------------------------------------------------------------------------------
+                    // If the declination doesn't exist anymore
                     let queryDeclination = parentProduct.declinations.find((decli) => decli.sku === cartItem.sku);
                     if (!!!queryDeclination) {
                         if (!!__1.isTestEnv)
@@ -546,11 +647,15 @@ class Cart extends baseService_1.BaseServiceClass {
                         verifiedItems.push(Object.assign(Object.assign({}, cartItem), { state_after_verification: 'out_of_stock' }));
                         continue;
                     }
+                    // -------------------------------------------------------------------------------
+                    // If tier-pricing has changed
                     const queryDecliTierPricing = !!queryDeclination.tier_pricing && !!queryDeclination.tier_pricing.length
                         ? queryDeclination.tier_pricing
                         : undefined;
                     const itemTierPricing = !!cartItem.tier_pricing && !!cartItem.tier_pricing.length ? cartItem.tier_pricing : undefined;
                     let didApplyTier = false;
+                    // Check if tier-pricing does not exist on queryDeclination and exists in cartItem, remove from cartItem
+                    // Also remove discount_price if tier_pricing applied
                     if (!!itemTierPricing && !!!queryDecliTierPricing) {
                         if (!!__1.isTestEnv)
                             console.log('tier_pricing should not be in product. Removing from cartItem');
@@ -558,6 +663,7 @@ class Cart extends baseService_1.BaseServiceClass {
                             ? { discount_price: null }
                             : {})), { tier_pricing: [] });
                     }
+                    // Check to add tier-pricing to cartItem if necessary
                     if (!!!isGR || !!!proID) {
                         if (!!queryDecliTierPricing) {
                             const tierPricingToApply = (0, discount_1.getTierPricingToApply)(queryDecliTierPricing, cartItem.qte);
@@ -579,6 +685,8 @@ class Cart extends baseService_1.BaseServiceClass {
                     if (!!__1.isTestEnv) {
                         console.log('appliedTier: ', !!didApplyTier);
                     }
+                    // -------------------------------------------------------------------------------
+                    // If is GR and customer is pro customer, check customPriceList to compare prices
                     if (!!customPriceList && !!customPriceList.length) {
                         if (!!__1.isTestEnv) {
                             console.log('is pro customer, checking with G2 prices then leaving');
@@ -590,12 +698,15 @@ class Cart extends baseService_1.BaseServiceClass {
                         }
                     }
                     else {
+                        // -------------------------------------------------------------------------------
+                        // Check regular price
                         if (cartItem.regular_price.amount !== queryDeclination.regular_price.amount &&
                             !!!cartItem.regular_price.price_type) {
                             if (!!__1.isTestEnv) {
                                 console.log('regPrice is different');
                                 console.log('queryItem regPrice: ', queryDeclination.regular_price.amount, ' vs cartItem regPrice : ', cartItem.regular_price.amount);
                             }
+                            // If the regular price changed
                             actionsDone.push({
                                 sku: cartItem.sku,
                                 itemName: cartItem.name,
@@ -605,11 +716,14 @@ class Cart extends baseService_1.BaseServiceClass {
                             if (!!__1.isTestEnv)
                                 console.log('new regPrice: ', cartItem.regular_price.amount);
                         }
+                        // -------------------------------------------------------------------------------
+                        // Check discount prices
                         if (!didApplyTier) {
                             if ((!!cartItem.discount_price && !!!cartItem.discount_price.price_type) ||
                                 !!queryDeclination.discount_price) {
                                 if (!!__1.isTestEnv)
                                     console.log('checking discountPrice');
+                                // If a discount price have been added
                                 if (!!!cartItem.discount_price && !!queryDeclination.discount_price) {
                                     if (!!__1.isTestEnv)
                                         console.log('discountPrice was added');
@@ -622,6 +736,7 @@ class Cart extends baseService_1.BaseServiceClass {
                                     if (!!__1.isTestEnv)
                                         console.log('new discountPrice: ', !!cartItem.discount_price ? cartItem.discount_price.amount : 'undefined');
                                 }
+                                // If a discount price have been removed
                                 if (!!cartItem.discount_price && !!!queryDeclination.discount_price) {
                                     if (!!__1.isTestEnv)
                                         console.log('discountPrice was removed');
@@ -634,6 +749,7 @@ class Cart extends baseService_1.BaseServiceClass {
                                     if (!!__1.isTestEnv)
                                         console.log('new discountPrice: ', !!cartItem.discount_price ? cartItem.discount_price.amount : 'undefined');
                                 }
+                                // If the cart item's discount price has been updated
                                 if (!!cartItem.discount_price &&
                                     !!queryDeclination.discount_price &&
                                     cartItem.discount_price.amount !== queryDeclination.discount_price.amount &&
@@ -654,6 +770,8 @@ class Cart extends baseService_1.BaseServiceClass {
                                 }
                             }
                         }
+                        // -------------------------------------------------------------------------------
+                        // Check promo prices
                         if (!!__1.isTestEnv)
                             console.log('cartItem.promo_price: ', !!cartItem.promo_price);
                         if (!!__1.isTestEnv)
@@ -661,6 +779,7 @@ class Cart extends baseService_1.BaseServiceClass {
                         if (!!cartItem.promo_price || !!queryDeclination.promo_price) {
                             if (!!__1.isTestEnv)
                                 console.log('checking promoPrice');
+                            // If a promo price has been added
                             if (!!!cartItem.promo_price && !!queryDeclination.promo_price) {
                                 if (!!__1.isTestEnv)
                                     console.log('promoPrice was added');
@@ -673,6 +792,7 @@ class Cart extends baseService_1.BaseServiceClass {
                                 if (!!__1.isTestEnv)
                                     console.log('new promoPrice: ', !!cartItem.promo_price ? cartItem.promo_price.amount : 'undefined');
                             }
+                            // If a promo price has been removed
                             if (!!cartItem.promo_price && !!!queryDeclination.promo_price) {
                                 if (!!__1.isTestEnv)
                                     console.log('promoPrice was removed');
@@ -685,6 +805,7 @@ class Cart extends baseService_1.BaseServiceClass {
                                 if (!!__1.isTestEnv)
                                     console.log('new promoPrice: ', !!cartItem.promo_price ? cartItem.promo_price.amount : 'undefined');
                             }
+                            // If the cart item's discount price has been updated
                             if (!!cartItem.promo_price &&
                                 !!queryDeclination.promo_price &&
                                 !!!Number.isNaN((0, toNumber_1.default)(queryDeclination.promo_price.amount)) &&
@@ -705,6 +826,8 @@ class Cart extends baseService_1.BaseServiceClass {
                             }
                         }
                     }
+                    // -------------------------------------------------------------------------------
+                    // Check inventory
                     if (!!!isGR && !!!cartItem.is_service) {
                         if (!!__1.isTestEnv)
                             console.log('checking inventory');
@@ -741,9 +864,11 @@ class Cart extends baseService_1.BaseServiceClass {
                     }
                     verifiedItems.push(cartItem);
                 }
+                // Apply installation tout inclus when pro has it but cart has ventilated installation (for web)
                 if (!!proID && !!proCustomerTitle && !!customPriceList && !!customPriceList.length) {
                     let installationParent = installationParentProduct;
                     if (!!!installationParent && verifiedItems.some((i) => i.parent_slug === 'installation-gazon')) {
+                        // Fallback: fetch from indexed products when cartItem query failed in the main loop
                         const indexed = await space.indexedProducts.get({
                             query: [{ field: 'slug', operator: '==', value: 'installation-gazon' }]
                         });
@@ -775,6 +900,8 @@ class Cart extends baseService_1.BaseServiceClass {
                         !!!item.restrict_shipping.restrict_values.length)) {
                     return item;
                 }
+                // GESTION DES RESTRICTIONS SELON TYPE D'UTILISATEUR
+                // --------------------------------------------------------------------------------------------------
                 if (!!item.restrict_sale &&
                     !!item.restrict_sale.restrict_values &&
                     !!item.restrict_sale.restrict_values.length &&
@@ -791,6 +918,8 @@ class Cart extends baseService_1.BaseServiceClass {
                         item = Object.assign(Object.assign({}, item), { restrict_sale: Object.assign(Object.assign({}, item.restrict_sale), { restrict_message: '' }) });
                     }
                 }
+                // GESTION DES RESTRICTIONS SELON LA LIVRAISON
+                // --------------------------------------------------------------------------------------------------
                 if (!!item.restrict_shipping &&
                     !!item.restrict_shipping.restrict_values &&
                     !!item.restrict_shipping.restrict_values.length) {
@@ -848,6 +977,8 @@ class Cart extends baseService_1.BaseServiceClass {
             }
             return baseMsg;
         };
+        //#endregion
+        //#region TAXES
         this.setAllTaxes = async () => {
             this._allTaxes = await Tax_1.default.getAllTaxesGeneral();
             return this._allTaxes;
@@ -855,8 +986,15 @@ class Cart extends baseService_1.BaseServiceClass {
         this.setCartTaxes = (defaultTax) => {
             this._data = Object.assign(Object.assign({}, this._data), { taxes: [...this._data.taxes, defaultTax] });
         };
+        /**
+         * Calcule la "sous taxe" (ex: TPS, TVQ) d'une "tax family" (ex: QC),
+         * en vérifiant si des produits ont une famille de taxe à eux, et en enlevant le montant le cas échéant.
+         * @param taxNameFr
+         * @param taxValue
+         */
         this.getATax = (taxNameFr, taxValue, _currency = 'CAD') => {
             let taxAmount = 0;
+            // 0. On vérifie que l'adresse de livraison est bien au Canada (si au US, pas de taxes à charger)
             if ((!!this._data.shipping_address &&
                 !!this._data.shipping_address.address &&
                 ['ca', 'canada'].includes(this._data.shipping_address.address.country.toLowerCase())) ||
@@ -866,23 +1004,33 @@ class Cart extends baseService_1.BaseServiceClass {
                     : this.data().subtotal;
                 const subtotal = this.data().subtotal;
                 const subtotalWithShipping = (0, round_1.default)(this.data().subtotal + this._checkShippingAmount(), 2);
-                let customTaxableItems = this.data().items.filter((item) => !!item.tax_family_id && !item.tax_exemption);
+                // 1. On vérifie le nombre d'items au panier qui redéfinissent le tax_family_id
+                let customTaxableItems = this.data().items.filter((item) => !!item.tax_family_id && !item.tax_exemption // ne pas inclure si l'item est sans taxe
+                );
                 let notTaxableItems = this.data().items.filter((item) => !!item.tax_exemption);
                 let correspondingSubTax = undefined;
                 let amountToApplyTaxTo = 0;
+                // 2. Si le nb d'items avec tax_family_id === 0, on retourne simplement le calcul de la sous-taxe
                 if (!!!customTaxableItems.length) {
                     amountToApplyTaxTo = subtotalWithShipping;
                 }
                 else {
+                    // 3. Sinon...
                     let totalPriceAmountCustomTaxable = 0;
+                    // 3a. On parcourt tous les items avec tax_family_id, pour sortir la tax family associée
                     customTaxableItems.map((item) => {
                         let priceToTakeOut = (0, cart_2.getLowestAppliedPrice)(item).amount;
+                        // Si on trouve la sous taxe dans les taxes de l'item, on l'enregistre dans correspondingSubTax (pour avoir le taux associé)
                         const correspondingTaxes = this._allTaxes.filter((tax) => tax.id === item.tax_family_id)[0].taxes;
                         correspondingSubTax = correspondingTaxes.find((tax) => tax.label_fr === taxNameFr);
+                        // 3b. Si, parmi les sous-taxes (taxes) de la famille, on trouve le même sous-taxe label_fr que celle vérifiée présentement,
+                        //    on pousse 0, pour que le montant de l'article ne soit pas considéré dans le calcul de la sous-taxe,
                         if (!!correspondingSubTax) {
                             totalPriceAmountCustomTaxable += 0;
                         }
                         else {
+                            // 3c. Si non, on pousse le montant calculé du produit pour qu'il soit déduit du calcul de la sous-taxe
+                            //    + si on trouve la sous taxe dans les taxes du cart, on l'enregistre dans correspondingSubTax (pour avoir le taux associé)
                             const sameTaxInCart = this.data().taxes.find((tax) => tax.taxes.find((t) => taxNameFr === t.label_fr));
                             if (!!sameTaxInCart) {
                                 correspondingSubTax = sameTaxInCart.taxes.find((tax) => tax.label_fr === taxNameFr);
@@ -890,9 +1038,13 @@ class Cart extends baseService_1.BaseServiceClass {
                             totalPriceAmountCustomTaxable += priceToTakeOut * item.qte;
                         }
                     });
+                    // 3d. On calcule le ratio correspondant au montant des articles avec taxe "custom" par rapport le sous-total AVEC promotion
                     const ratioOfCustomTaxToSubtotal = (totalPriceAmountCustomTaxable * subtotal) / subtotalWithoutPromotions;
+                    // 3e. On calcule le montant de taxes par défault, en déduisant le prix "custom" du prix par défault
+                    //    + on arrondit avant de retourner
                     amountToApplyTaxTo = (0, round_1.default)(subtotalWithShipping - ratioOfCustomTaxToSubtotal, 2);
                 }
+                // 4. Si certains items de la commande sont non-taxable, les exclure du sous-total sur lequel le montant de la taxe est calculé
                 if (!!notTaxableItems.length) {
                     let totalNotTaxableItems = 0;
                     notTaxableItems.forEach((item) => {
@@ -902,6 +1054,9 @@ class Cart extends baseService_1.BaseServiceClass {
                     amountToApplyTaxTo -= totalNotTaxableItems;
                 }
                 taxAmount = (0, round_1.default)(amountToApplyTaxTo * taxValue, 2);
+                // 4. Pour enregister le montant total de cette sous-taxe dans le Cart, il faut savoir :
+                //    - à quelle famille de taxes dans le array taxes du Cart elle appartient (position 0 du array sameTaxInDefaultCart)
+                //    - à quelle sous-taxe de cette famille elle appartient (position 1 du array sameTaxInDefaultCart)
                 let sameTaxInDefaultCart = [];
                 if (!!this.data().taxes) {
                     sameTaxInDefaultCart = this.data().taxes.map((tax, key) => {
@@ -909,6 +1064,7 @@ class Cart extends baseService_1.BaseServiceClass {
                         return [key, tax.taxes.indexOf(taxToCheck)];
                     })[0];
                 }
+                // 5. On reconstruit le array de taxes du Cart avec la nouvelle valeur du "amount" au bon endroit
                 if (sameTaxInDefaultCart.indexOf(-1) === -1) {
                     this._data = Object.assign(Object.assign({}, this._data), { taxes: [
                             ...this._data.taxes.slice(0, sameTaxInDefaultCart[0]),
@@ -921,8 +1077,11 @@ class Cart extends baseService_1.BaseServiceClass {
                         ] });
                 }
             }
+            // 6. On retourne le résultat de l'affichage
             return (0, round_1.default)(taxAmount, 2);
         };
+        //#endregion
+        //#region CUSTOMERS
         this.setProCustomerInfo = async (customer) => {
             var _b, _c, _d, _e, _f, _g, _h, _j;
             const proInfo = (0, data_1.getProCustomerInfo)(customer.basic_info, customer.company_info);
@@ -955,11 +1114,14 @@ class Cart extends baseService_1.BaseServiceClass {
             }
             return this._data;
         };
+        //#endregion
+        //#region PAYMENT
         this.createPaymentIntent = async () => {
             const space = await Space_2.default.getCurrentSpaceWithRef(this._collection.path, this._user);
             const shippingServiceCredz = space.data().external_services.find((es) => !!es.is_active && es.type === 'payment');
             if (!!!shippingServiceCredz)
                 throw new Error(`Must have a payment service to use this`);
+            // this.save({ status: CartStatusEnum.CHECKOUT_PROCESSING_PAYMENT } as Partial<ICart>)
             switch (shippingServiceCredz.external_service_name) {
                 case 'stripe':
                     if (!!!shippingServiceCredz.external_service_infos.secret) {
@@ -998,6 +1160,8 @@ class Cart extends baseService_1.BaseServiceClass {
                     throw new Error(`This payment service is not handled yet`);
             }
         };
+        //#endregion
+        //#region ORDER
         this.paymentDetails = async (payment_details) => {
             return await this.save({ payment_details }, undefined, true);
         };
@@ -1008,6 +1172,34 @@ class Cart extends baseService_1.BaseServiceClass {
             let paysafe_payload = undefined;
             console.log('====================');
             console.log('in processPOSPayment');
+            // TODO - Uncomment when ready to use store credits!
+            // // Valider les store credits si utilisés comme mode de paiement
+            // let usedCredit = 0
+            // type IPaymentWithRef = IPayment & { ref: string }
+            // const foundStoreCreditPayment = !!payment_request_payload.multi_payment_methods
+            // 	? (payment_request_payload.multi_payment_methods.find(
+            // 			(p) => p.method == PaymentTypeEnum.STORE_CREDITS && !!p.ref
+            // 		) as IPaymentWithRef | undefined)
+            // 	: undefined
+            // if (foundStoreCreditPayment) {
+            // 	const creditCheck = await validateStoreCreditUsage(
+            // 		foundStoreCreditPayment.amount,
+            // 		cart.data().customer_id,
+            // 		space,
+            // 		foundStoreCreditPayment.ref!
+            // 	)
+            // 	if (!creditCheck.valid)
+            // 		return {
+            // 			error: creditCheck.error || {
+            // 				fr: 'Impossible de vérifier le crédit magasin pour la commande',
+            // 				en: 'Could not check store credit for order'
+            // 			}
+            // 		}
+            // 	usedCredit = foundStoreCreditPayment.amount
+            // }
+            // ------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+            // Apply payments to cart and create ref
+            // ------------------------------------------------------------------------------------------------------------------------------------------------------------------------
             try {
                 console.log('---------------');
                 let delay1 = (0, moment_1.default)();
@@ -1033,6 +1225,33 @@ class Cart extends baseService_1.BaseServiceClass {
                     };
                 }
                 console.log('createOrderWithSuccessfulPaymentPayload delay: ', (0, moment_1.default)().diff(delay1, 'seconds'));
+                // ------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+                // Check for store credits to update in customer data
+                // ------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+                // TODO - Uncomment when ready to use store credits!
+                // const cartData = cart.data()
+                // if (usedCredit > 0 && !!cartData.customer_id && foundStoreCreditPayment) {
+                // 	try {
+                // 		const lastUserToTakePayment = getLastUserWhoTookPayment(cartData)
+                // 		await space.customers.credits.modify(
+                // 			cartData.customer_id,
+                // 			foundStoreCreditPayment.ref,
+                // 			-usedCredit,
+                // 			`Commande #${cart.getCartRef(space).order}`,
+                // 			`POS ${lastUserToTakePayment ? lastUserToTakePayment.user_id || lastUserToTakePayment.user_name : 'Unknown'}`
+                // 		)
+                // 	} catch (err) {
+                // 		return {
+                // 			error: {
+                // 				fr: "Impossible d'ajuster les crédits magasin.",
+                // 				en: 'Could not store credits.'
+                // 			}
+                // 		}
+                // 	}
+                // }
+                // ------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+                // Check if Algolia is on -- save cart in algo
+                // ------------------------------------------------------------------------------------------------------------------------------------------------------------------------
                 if (!!indexCart) {
                     console.log('---------------');
                     let delay2 = (0, moment_1.default)();
@@ -1074,6 +1293,7 @@ class Cart extends baseService_1.BaseServiceClass {
                                 console.log('error while fetching customer: ', e.toString());
                             }
                         }
+                        // NEW FUNCTION - returns indexedCartData
                         const indexedCartData = (0, cart_1.getIndexedCartData)(cart.data(), space, {
                             setPaidAtIfUndefined: true,
                             customer: !!customer ? customer.data() : undefined,
@@ -1161,11 +1381,19 @@ class Cart extends baseService_1.BaseServiceClass {
                                         ? this.data().payment_reference
                                         : '';
             const multiPaymentMethods = !!multi_payment_methods
-                ? multi_payment_methods.map((p) => (Object.assign(Object.assign({}, p), { ref: p.ref || getPaymentRef() })))
+                ? multi_payment_methods.map((p) => (Object.assign(Object.assign({}, p), { ref: p.ref || getPaymentRef() // keep current payment ref if set for payment method, else fetch generic ref from "base" payment type
+                 })))
                 : undefined;
+            // Fetch space invoice next ref
             let newRef = !!isDev ? 123456789 : undefined;
+            // -----------------------------------------------------------------------------------------
+            // We will fetch the next avaible ref number from the api
+            // in case of issue up to 3 attemps will be done
+            // if none of these worked we raise an exception
+            // -----------------------------------------------------------------------------------------
             if (!!this._data.ref) {
                 console.log('Cart already has ref #', this._data.ref, ', skipping ref increment');
+                // if ref already in cart, set newRef with ref value so empty string is not saved in cart afterwards
                 newRef = (0, toNumber_1.default)(this._data.ref);
                 await (0, logs_1.SystemLog)({
                     clientName: `sdk-admin | Cart | ...SuccPayPayload, space: ${(0, services_1.getSpaceInitialsByID)(space.data().id)}`,
@@ -1201,7 +1429,7 @@ class Cart extends baseService_1.BaseServiceClass {
                         catch (e) {
                             console.log('Error fetching invoice number', e);
                         }
-                        await (0, tools_1.waitFor)(1000);
+                        await (0, tools_1.waitFor)(1000); // whait a second before trying again, server need to recover
                         triesLeft--;
                     }
                     if (triesLeft == 0)
@@ -1209,6 +1437,7 @@ class Cart extends baseService_1.BaseServiceClass {
                 }
                 console.log('increment space ref delay: ', (0, moment_1.default)().diff(delay1, 'seconds'));
             }
+            // Update customer last_activity prop.
             const customerId = this.data().customer_id;
             if (!!customerId) {
                 try {
@@ -1218,6 +1447,9 @@ class Cart extends baseService_1.BaseServiceClass {
                     console.log(`Could not update last_activity prop for customer: ${customerId}, ${e}`);
                 }
             }
+            // -----------------------------------------------------------------------------------------
+            // Create new partial cart data with info
+            // -----------------------------------------------------------------------------------------
             const isPOSTransactionnal = this.data().cart_type === Cart_1.CartTypeEnum.POS_TRANSACTIONNAL;
             const partialCartPaidData = Object.assign(Object.assign(Object.assign(Object.assign({ paid_by: this.getPaymentMethod({
                     paypal_payload,
@@ -1243,15 +1475,22 @@ class Cart extends baseService_1.BaseServiceClass {
                     }, logs_1.LogType.WARNING, `Cart already has ref #${this._data.ref}, but doesn't have an id??, ${this._data.id}`);
                 }
                 let delay2 = (0, moment_1.default)();
+                // -----------------------------------
+                // Save the cart and set it as "PAID"
                 const newCartId = await this.save(partialCartPaidData, undefined, saveToDatabase);
                 console.log('saving to DB delay: ', (0, moment_1.default)().diff(delay2, 'seconds'));
+                // -----------------------------------------------------------------------------------------
+                // If cart is of type POS_TRANSACTIONNAL, check if should create invoice_ref & add order to G2
+                // If so, save partial data to cart
                 if (!!isPOSTransactionnal) {
                     console.log('---------------');
                     let delay3 = (0, moment_1.default)();
+                    // a. Create invoice_ref
                     const invoiceRef = await this.setCartWithInvoiceRef(space, false, partialCartPaidData.ref);
                     console.log('setting invoice ref delay: ', (0, moment_1.default)().diff(delay3, 'seconds'));
                     console.log('---------------');
                     let delay4 = (0, moment_1.default)();
+                    // b. Add order to G2
                     const skipRef = !!this.data().is_booking || !!this.data().is_booking_beton;
                     let g2OrderRef;
                     if (!skipRef && !(0, cart_2.checkIfCartContainsType)(cart_3.CartGeneralTypeEnum.SAMPLE, this.data())) {
@@ -1262,11 +1501,15 @@ class Cart extends baseService_1.BaseServiceClass {
                     }
                     console.log('saving g2 order & setting external_value delay: ', (0, moment_1.default)().diff(delay4, 'seconds'));
                     console.log(`saving POS transactionnal cart to database: ${!!saveToDatabase}, with ref: ${partialCartPaidData.ref}, status: ${partialCartPaidData.status} and invoice ref: ${invoiceRef}${!!g2OrderRef ? ' and external_value.noCommande: ' + g2OrderRef : ''}`);
+                    // c. save to database
                     await this.save(Object.assign({ id: this.data().id || newCartId, invoice_ref: invoiceRef }, (!!g2OrderRef ? { external_values: { noCommande: g2OrderRef } } : {})), undefined, saveToDatabase, true);
                 }
+                // -----------------------------------
+                // Save inventory for cart items
                 console.log('---------------');
                 let delay5 = (0, moment_1.default)();
                 try {
+                    // Adjust cart items inventory
                     await space.inventory.ajust(this.data().items, 'paid', this.data().cart_type, {
                         currentStoreId: this.data().current_store_id || ''
                     });
@@ -1276,6 +1519,8 @@ class Cart extends baseService_1.BaseServiceClass {
                     await (0, console_1.alertAdminV2)(`Error while updating inventory`, `We are here: /src/lib/Cart/index.ts#1574. We are in space ${space.data().id}. JSON error: ${JSON.stringify(error)}`, error.toString(), space.getRef());
                 }
                 console.log('adjusting inventory delay: ', (0, moment_1.default)().diff(delay5, 'seconds'));
+                // -----------------------------------
+                // If cart has promises to purchase, check if banks used are now empty
                 if (!!this._data.promise_to_purchase) {
                     console.log('---------------');
                     let delay6 = (0, moment_1.default)();
@@ -1295,30 +1540,51 @@ class Cart extends baseService_1.BaseServiceClass {
             console.log('====================');
             return this;
         };
+        /**
+         * Sets a cart to status completed, and generates invoice_ref if necessary.
+         * @param saveToDatabase - Optional, defaults to true.
+         * @returns
+         */
         this.setCartAsCompleted = async (saveToDatabase = true, user, store) => {
             console.log('====================');
             console.log('in setCartAsCompleted');
             try {
+                // ---------------------------------------------------------
+                // 1. Fetch space
                 const space = await Space_2.default.getCurrentSpaceWithRef(this._collection.path, this._user);
                 if (!!!space)
                     throw new Error('could not init space obj');
                 console.log('---------------');
                 let delay1 = (0, moment_1.default)();
+                // ---------------------------------------------------------
+                // 2. Check if cart should not have invoice_ref generated
                 let skipRef = false;
+                // a. If booking, skip invoice_ref
                 if (!!this.data().is_booking || !!this.data().is_booking_beton)
                     skipRef = true;
+                // b. If order was generated 6 months ago or earlier, skip invoice_ref
+                // let orderPaidAtDate = !!this.data().paid_at ? formatDate(this.data().paid_at) : undefined
+                // if (!!!orderPaidAtDate || !moment().subtract(6, 'month').isBefore(moment(orderPaidAtDate))) skipRef = true
+                // ---------------------------------------------------------
+                // 3. Generate invoice ref and save to cart locally (if set, saved to database with status change)
+                //    (only if no invoice_ref in cart and should not skip ref)
                 if (!!!this.data().invoice_ref && !!!skipRef) {
                     await this.setCartWithInvoiceRef(space, false);
                 }
                 console.log('setting invoice ref delay: ', (0, moment_1.default)().diff(delay1, 'seconds'));
                 console.log('---------------');
                 let delay2 = (0, moment_1.default)();
+                // ---------------------------------------------------------
+                // 4. Check to save cart to G2 if cart isn't a booking or sample cart
+                //    Checks if G2 is set as external service in function transformAddioCartToG2Order
                 if (!skipRef && !(0, cart_2.checkIfCartContainsType)(cart_3.CartGeneralTypeEnum.SAMPLE, this.data())) {
                     await this.setG2ExternalOrderRef(space, false);
                 }
                 console.log('setting g2 ref delay: ', (0, moment_1.default)().diff(delay2, 'seconds'));
                 console.log('---------------');
                 let delay3 = (0, moment_1.default)();
+                // ---------------------------------------------------------
+                // 4. Save cart to DB with new status
                 await this.save(Object.assign({ status: Cart_1.CartStatusEnum.COMPLETED }, (!!user
                     ? {
                         completed_by: this.getCartAssignedUserData(user, store)
@@ -1333,21 +1599,25 @@ class Cart extends baseService_1.BaseServiceClass {
             }
         };
         this.saveCartModification = async (partial, oldItems, newItems, currentUser, options = {}) => {
+            // default saveToDatabase to true
             const shouldSaveToDB = typeof options.saveToDatabase == 'boolean' ? options.saveToDatabase : true;
             try {
                 const itemsForInventory = (0, cart_1.getModifiedItems)(newItems, oldItems);
                 const space = await Space_2.default.getCurrentSpaceWithRef(this._collection.path, this._user);
                 if (!!!space)
                     throw new Error('could not init space obj');
+                // If the cart is associated to a promise
                 if (!!options.usedPromise) {
                     for (const bank of options.usedPromise.banks_used) {
                         const promiseQuery = await space.promisesToPurchase.get({
                             query: [{ field: 'id', operator: '==', value: bank.promise_id }]
                         });
+                        // If the promise is closed or doesn't exist, we don't adjust it
                         if (!!!promiseQuery || !!!promiseQuery.length)
                             continue;
                         if (!!promiseQuery[0].data().ending_date)
                             continue;
+                        // If the bank is inactive, we don't adjust it
                         const bankInDB = promiseQuery[0].data().banks.find((b) => b.bank_type_id === bank.bank_type_id);
                         if (!!!bankInDB || !!!bankInDB.active)
                             continue;
@@ -1376,6 +1646,7 @@ class Cart extends baseService_1.BaseServiceClass {
                     }
                 }
                 await this.save(partial, undefined, shouldSaveToDB, true);
+                // INVENTORY MANAGEMENT
                 const data = this.data();
                 const storeIdToUse = !!data.current_store_id
                     ? data.current_store_id
@@ -1400,6 +1671,8 @@ class Cart extends baseService_1.BaseServiceClass {
                     previousItems: oldItems,
                     shouldCheckReservedQte: this.data().status === Cart_1.CartStatusEnum.CHECKOUT_PAYMENT_SUCCESS
                 });
+                // ASSOCIATED TRANSFER REQUEST MANAGEMENT
+                // Only do logic if order is not already processed
                 if (!!options.associatedTransferRequests && this.data().status === Cart_1.CartStatusEnum.CHECKOUT_PAYMENT_SUCCESS) {
                     const transfersWithItemsToUpdate = (0, cart_1.getItemsToUpdateByTransfer)(options.associatedTransferRequests, itemsForInventory.map((i) => ({
                         item: i,
@@ -1432,8 +1705,13 @@ class Cart extends baseService_1.BaseServiceClass {
             }
         };
         this.defineWhatICanBe = () => {
+            // Pre-order
+            // SDC
+            // Déterminer la règle qui permet de trouver si le cart contient des items en précommande
             return [];
         };
+        //#endregion
+        //#region DISCOUNTS RULES
         this.checkDiscountConditions = (discount) => {
             return (0, discount_1.checkPromoCodeEligibility)(this._data, discount);
         };
@@ -1475,13 +1753,14 @@ class Cart extends baseService_1.BaseServiceClass {
             }
             const cartPromo = this.getCartPromo();
             if (!!cartPromo && !!cartPromo.length) {
+                // If promo already in cart
                 if (!!cartPromo.some((i) => i.promo_code === promoCode)) {
                     this.addError(Cart_1.CartErrorEnum.PROMO_CODE_ALREADY_IN_CART);
                     return Cart_1.CartErrorEnum.PROMO_CODE_ALREADY_IN_CART;
                 }
                 if (!!cartPromo.some((i) => i.promo_code) ||
                     !!cartData.free_shipping ||
-                    (!!!discountWithSamePromoCode.is_stackable && !!cartPromo.length) ||
+                    (!!!discountWithSamePromoCode.is_stackable && !!cartPromo.length) || // si non stack et déja kkchose
                     cartPromo.some((x) => !x.stackable)) {
                     this.addError(Cart_1.CartErrorEnum.PROMO_CODE_CART_ALREADY_DISCOUNTED);
                     return Cart_1.CartErrorEnum.PROMO_CODE_CART_ALREADY_DISCOUNTED;
@@ -1566,6 +1845,7 @@ class Cart extends baseService_1.BaseServiceClass {
             }
         };
         this.setDiscountRules = async (removePaymentIncentive) => {
+            // If cart is a booking cart, discount rules are independant from "normal cart" discount rules, skip check!
             if (!!this._data.is_booking || !!this._data.is_booking_beton) {
                 if (!!__1.isTestEnv)
                     console.log('skipping discount rule check for booking cart!');
@@ -1580,13 +1860,16 @@ class Cart extends baseService_1.BaseServiceClass {
             let discountsToAdd = [];
             for (let discount of allDiscountRules) {
                 let discountData = discount.data();
+                // Remove all draft discounts
                 if (!!discountData.draft)
                     continue;
+                // Remove all payment incentive if necessary
                 if (!!removePaymentIncentive) {
                     if (!!!discountData.result.action ||
                         [IDiscountRule_1.ResultActionEnum.AMOUNT_AFTER_TAXES, IDiscountRule_1.ResultActionEnum.PERCENT_AFTER_TAXES].includes(discountData.result.action))
                         continue;
                 }
+                // If discount has been overriden don't update it
                 const cartDiscountRule = this.data().discount_rules.find((rule) => {
                     return rule.id === discountData.id;
                 });
@@ -1600,6 +1883,14 @@ class Cart extends baseService_1.BaseServiceClass {
                     ...discountsToAdd
                 ] });
         };
+        /**
+         * Check and apply tier pricing prices to items in cart based on values found in specific item. Should be called for every item in cart, and returns all cart items.
+         * @param itemToCheck - The current cart item to check
+         * @param qte - The current cart item qte
+         * @param index - The index of the item in the cart
+         * @param findWithSku - Optionnal. If item should be found by sku instead of index
+         * @param originalDecli - Optionnal. The IIndexedDeclination used to create the cart item. Used to calculate original item price before it was overidden, if necessary. Must be provided in most POS cases.
+         */
         this.checkTierPricing = (itemToCheck, qte, index, findWithSku = false, originalDecli) => {
             const currentItems = this._data.items;
             if (!!!itemToCheck)
@@ -1607,13 +1898,21 @@ class Cart extends baseService_1.BaseServiceClass {
             const item = currentItems.find((anItem) => anItem.sku === (typeof itemToCheck === 'string' ? itemToCheck : itemToCheck.sku));
             if (!!!item)
                 return currentItems;
+            // If item does not have tier_pricing
+            // update quantity and return
             if (!!!item.tier_pricing || !!!item.tier_pricing.length) {
                 this._updateQuantity(item, qte);
                 return currentItems;
             }
+            // If tier_pricing must be counted with other items in cart,
+            // return checkAttributes result
+            // --- This is why we return a full array of items instead of the item checked :
+            // --- some tier_pricing have dependencies with other items in a same cart, so that
+            // --- when a item changes quantities, the price of many items in cart might need to change
             if (item.tier_pricing.some((aTier) => !!aTier.check_attribute_value || !!aTier.check_other_items_category)) {
                 return this.checkAttributes(item, qte);
             }
+            // If price was overidden, continue to check tier-pricing, but replace discount_price.original_price instead of discount_price.amount
             const setOriginalPrice = !!item.discount_price &&
                 !!item.discount_price.overridden &&
                 typeof item.discount_price.original_amount === 'number';
@@ -1687,6 +1986,7 @@ class Cart extends baseService_1.BaseServiceClass {
                 for (const aTier of item.tier_pricing) {
                     if (isFirst && (0, toNumber_1.default)(aTier.from) > totalQte) {
                         for (const anItem of allSameCategory) {
+                            // const index = this._data.items.indexOf(anItem)
                             this._updateItems(this._data.items.map((i) => {
                                 if (i.sku !== anItem.sku)
                                     return i;
@@ -1724,6 +2024,13 @@ class Cart extends baseService_1.BaseServiceClass {
                 return Object.assign(Object.assign({}, i), { qte: qte });
             }));
         };
+        //#endregion
+        //#region TOTALS
+        /**
+         * Get default space taxes for cart. If cart outside of canada, reset taxes to empty array.
+         * @param space
+         * @param allTaxes
+         */
         this._getDefaultTaxesForCart = (space, allTaxes) => {
             const shippingAddress = this.data().shipping_address;
             const currentTaxes = this.data().taxes;
@@ -1741,6 +2048,7 @@ class Cart extends baseService_1.BaseServiceClass {
                 }
             }
             else if (!!currentTaxes.length) {
+                // Reset to empty array if address is outside of Canada
                 defaultCartTaxes = [];
             }
             return defaultCartTaxes;
@@ -1750,6 +2058,7 @@ class Cart extends baseService_1.BaseServiceClass {
             const space = await Space_2.default.getCurrentSpaceWithRef(this._collection.path, this._user);
             if (!!!space)
                 return new Error(`Can't find space`);
+            // 0. Check for general taxes array, in case it was not set correctly on cart init
             let allTaxes = this._allTaxes;
             if (!!!allTaxes || !!!allTaxes.length) {
                 try {
@@ -1770,7 +2079,9 @@ class Cart extends baseService_1.BaseServiceClass {
                     }, logs_1.LogType.ERROR, `error on fetching taxe rates from space: ${e.toString()}`);
                 }
             }
+            // 1. calcul du SUBTOTAL
             this.calculateSubtotal(space, forcedPromos);
+            // 2. gestion des taxes selon l'adresse de livraison
             const shippingAddress = this.data().shipping_address;
             const currentTaxes = this.data().taxes;
             const addressForTaxes = !!shippingAddress ? shippingAddress.address : undefined;
@@ -1787,11 +2098,13 @@ class Cart extends baseService_1.BaseServiceClass {
                             newCartTaxes = [newTaxes];
                         }
                         else {
+                            // Fetch default space taxes in last resort
                             newCartTaxes = this._getDefaultTaxesForCart(space, allTaxes);
                         }
                     }
                 }
                 else {
+                    // Fetch default space taxes in last resort
                     newCartTaxes = this._getDefaultTaxesForCart(space, allTaxes);
                 }
                 this._data = Object.assign(Object.assign({}, this._data), { taxes: newCartTaxes });
@@ -1806,6 +2119,7 @@ class Cart extends baseService_1.BaseServiceClass {
                     clientToken: (_d = process.env.NEXT_PUBLIC_LOG_SYSTEM_KEY) !== null && _d !== void 0 ? _d : ''
                 }, logs_1.LogType.ERROR, `NO TAXES IN CART EVEN IF SUBTOTAL HAS AMOUNT! Cart ref: ${this._data.ref}, id: ${this._data.id}`);
             }
+            // 3. Calcul du total
             try {
                 this.calculateTotal(true, !!currency ? currency : space.preferences.default.currency());
                 await this.save(undefined, undefined, false);
@@ -1823,6 +2137,7 @@ class Cart extends baseService_1.BaseServiceClass {
             });
         };
         this._getSubtotalToCheck = (space, feePromosTotalRemoved, removeServiceFees) => {
+            // ** NEW - Now excludes escompte supp. products from services when checking subtotal for promotions
             const serviceFeeProducts = !!!removeServiceFees
                 ? []
                 : this.data().items.filter((i) => !!i.is_service && !(0, g2_1.isEscompteSuppItem)(i.sku));
@@ -1833,9 +2148,11 @@ class Cart extends baseService_1.BaseServiceClass {
                     return (0, round_1.default)(((0, isNumber_1.default)(itemPrice) ? Number(itemPrice) : 0) * i.qte, space.data().product_preferences.decimals || 2);
                 });
             let totalRemoved = serviceFeeSubtotal;
+            // If there is a service and fees total, calculates the service and fees total after taking into account their promos
             if (!!totalRemoved) {
                 totalRemoved -= feePromosTotalRemoved;
             }
+            // Removes that calculated total from the current subtotal to get the subtotal without services and fees, in order to calculate the right promo amount
             return this._data.subtotal - totalRemoved;
         };
         this.calculateSubtotal = (space, forcedPromos) => {
@@ -1850,7 +2167,15 @@ class Cart extends baseService_1.BaseServiceClass {
                 const currentCartPromos = this.getCartPromo();
                 if (!!currentCartPromos && !!currentCartPromos.length) {
                     const oldSubtotal = this._data.subtotal;
+                    // REMOVE PAYMENT INCENTIVE PROMOS FROM ARRAY
+                    // Since this type of promos ('total_after_taxes') must be calculated and
+                    // removed from total amount AFTER shipping and taxes are calculated,
+                    // they will be dealt with later in process and must not count in "subtotalWithoutPromotions" prop
                     let cartPromos = currentCartPromos.filter((c) => c.applies_to != Cart_1.CartPromoAppliesToEnum.TOTAL_AFTER_TAXES);
+                    // REORDER PROMOS
+                    // a. if promos apply to products, bring to front of array
+                    // b. if promos contain a promo_code that applies to subtotal,
+                    //    push it to the end of the array to check that one last
                     cartPromos = (0, orderBy_1.default)(cartPromos, (p) => {
                         if (p.applies_to === Cart_1.CartPromoAppliesToEnum.PRODUCT)
                             return 1;
@@ -1891,6 +2216,7 @@ class Cart extends baseService_1.BaseServiceClass {
                             else {
                                 amountToRemove = (_b = aPromo.amount_removed) !== null && _b !== void 0 ? _b : 0;
                             }
+                            // round amountToRemove before removing from subtotal
                             amountToRemove = (0, round_1.default)(amountToRemove, 2);
                             const newSubtotal = amountUnit === IDiscountRule_1.ResultActionEnum.AMOUNT || aPromo.applies_to === Cart_1.CartPromoAppliesToEnum.PRODUCT
                                 ? this._data.subtotal - amountToRemove
@@ -1898,6 +2224,7 @@ class Cart extends baseService_1.BaseServiceClass {
                             this._data = Object.assign(Object.assign({}, this._data), { subtotalWithoutPromotions: oldSubtotal, subtotal: (0, round_1.default)(newSubtotal, 2) });
                         }
                         else if (!!aPromo && !!aPromo.free_shipping) {
+                            // ** si un item de la liste ne peut être inclu dans la promo free_shipping
                             if (!!this._data.items.some((item) => !!item.exclude_from_free_shipping)) {
                                 this.addError(Cart_1.CartErrorEnum.FREE_SHIPPING_NOT_ELIGIBLE_BECAUSE_OF_ITEM);
                                 this._data = Object.assign(Object.assign(Object.assign(Object.assign({}, this._data), (!!this._data.cart_promo_applied ? { cart_promo_applied: null } : {})), (!!this._data.cart_promos_applied && !!aPromo.discount_id
@@ -1907,6 +2234,7 @@ class Cart extends baseService_1.BaseServiceClass {
                                     : {})), { subtotalWithoutPromotions: null, free_shipping: false });
                             }
                             else {
+                                // ** si l'adresse de shipping n'est pas encore définie
                                 if (!!!this._data.shipping_address) {
                                     this._data = Object.assign(Object.assign(Object.assign(Object.assign({}, this._data), (!!this._data.cart_promo_applied ? { cart_promo_applied: null } : {})), (!!this._data.cart_promos_applied && !!aPromo.discount_id
                                         ? {
@@ -1929,6 +2257,7 @@ class Cart extends baseService_1.BaseServiceClass {
                                                         cart_promos_applied: this._data.cart_promos_applied.filter((p) => p.discount_id !== aPromo.discount_id)
                                                     }
                                                     : {})), { subtotalWithoutPromotions: null });
+                                                // return "La livraison gratuite n'est pas elligible pour votre région."
                                             }
                                         }
                                     }
@@ -1947,16 +2276,23 @@ class Cart extends baseService_1.BaseServiceClass {
             return this._data.subtotal;
         };
         this.calculateTotal = (canCartBeEmpty, currency = 'CAD') => {
+            // 1. At a minimum, total is always equivalent to the current subtotal amount
             const subtotal = (0, round_1.default)(this.data().subtotal, 2);
             let total = subtotal;
+            // 2. Check if taxes and shipping should be added to total amount
             const shouldCalculate = !!canCartBeEmpty ? this._data.items.length >= 0 : this._data.items.length >= 1;
             if (!!shouldCalculate) {
+                // A. Get shipping amount
                 const shipping = this._checkShippingAmount();
+                // B. Calculate taxes
                 const taxesAmount = (0, round_1.default)((0, sumBy_1.default)(this.data().taxes, (tax) => (0, sumBy_1.default)(tax.taxes, (t) => this.getATax(t.label_fr, t.value, currency))), 2);
+                // C. Add to total
                 total += shipping + taxesAmount;
             }
+            // 3. Check if cart contains payment incentive promos, and calculate amount from current total
             let promoAfterTaxesAmount = (0, round_1.default)((0, discount_1.getAfterTaxesPromosTotalAmount)(this._data), 2);
             total -= promoAfterTaxesAmount;
+            // 4. Round total to 2 decimals
             total = (0, round_1.default)(total, 2);
             this._data = Object.assign(Object.assign({}, this._data), { promo_after_taxes_amount: promoAfterTaxesAmount || null, total: total });
             return total;
@@ -1972,6 +2308,8 @@ class Cart extends baseService_1.BaseServiceClass {
                 return [];
             }
         };
+        //#endregion
+        //#region SHIPPING
         this._checkShippingAmount = () => {
             const cartPromo = this.getCartPromo();
             const cartHasFreeShipping = !!this._data.free_shipping || (!!cartPromo && !!cartPromo.find((p) => !!p.free_shipping));
@@ -2011,11 +2349,16 @@ class Cart extends baseService_1.BaseServiceClass {
         };
         this._getCredz = async () => {
             const space = await Space_2.default.getCurrentSpaceWithRef(this._collection.path, this._user);
+            // Shipping
+            // Get external service credentials
             const shippingServiceCredz = space.data().external_services.filter((es) => !!es.is_active && es.type === 'shipping');
+            // If no credz
             if (!!!shippingServiceCredz) {
                 const baseShippingCostDeterminedByTheOwner = space.data().transport_preferences.override_shipping_with_cost;
+                // If no base cost
                 if (baseShippingCostDeterminedByTheOwner === undefined)
                     throw new Error(`Can't use shipping, pickup only. Admin must provide base shipping cost or set external services credentials like Shipstation.`);
+                // Shipping with base cost
                 return baseShippingCostDeterminedByTheOwner;
             }
             return { shippingServiceCredz, space };
@@ -2025,6 +2368,7 @@ class Cart extends baseService_1.BaseServiceClass {
             if (typeof resCredz === 'number' || Array.isArray(resCredz))
                 return resCredz;
             const { shippingServiceCredz, space } = resCredz;
+            // Shipping with external service
             (0, console_1.workingMessage)(`Calling ${shippingServiceCredz.map((e) => e.external_service_name).join(', ')} for a quote..`);
             const shipment = new Shipment_1.default(this, shippingServiceCredz);
             try {
@@ -2089,6 +2433,10 @@ class Cart extends baseService_1.BaseServiceClass {
         };
         this.packageCartInOneBox = async (dontSaveToCart = false) => {
             const space = await Space_2.default.getCurrentSpaceWithRef(this._collection.path, this._user);
+            // if (!!!this._collection.parent) throw new Error(`Can't access space`)
+            // const spaceSnap = await this._collection.parent.get()
+            // if (!!!spaceSnap.exists || !!!spaceSnap.data()) throw new Error(`Can't access space`)
+            // const space = new Space({ ...spaceSnap.data(), id: spaceSnap.id } as ISpace, this._user, spaceSnap.ref)
             const spaceData = space.data();
             let boxes = [];
             if (!!!spaceData.transport_preferences.predefined_boxes ||
@@ -2119,15 +2467,18 @@ class Cart extends baseService_1.BaseServiceClass {
                     allItemsSplitted.push(item);
                 }
             }
+            // Begin by the biggest item
             allItemsSplitted = (0, orderBy_1.default)(allItemsSplitted, (i) => i.shipping_info.weight, 'desc');
             const itemsToBox = allItemsSplitted;
             const totalVolume = (0, sumBy_1.default)(itemsToBox, (_item) => this._calculateItemVolume(_item));
+            // let _allItemsGoIn: boolean = false
             for (const box of boxTemplates) {
                 if (totalVolume < this._calculateBoxVolume(box) * 0.9) {
                     boxes = [
                         ...boxes,
                         Object.assign(Object.assign({}, box), { item_ids: itemsToBox.map((_item) => _item.sku), occupied_volume: totalVolume / this._calculateBoxVolume(box), weight: (0, sumBy_1.default)(itemsToBox, (_item) => (0, weight_1.convertWeight)(_item.shipping_info.weight || 0, _item.shipping_info.unit_weight)) })
                     ];
+                    // _allItemsGoIn = true
                     break;
                 }
             }
@@ -2138,6 +2489,10 @@ class Cart extends baseService_1.BaseServiceClass {
         };
         this.packageCart = async (dontSaveToCart = false) => {
             const space = await Space_2.default.getCurrentSpaceWithRef(this._collection.path, this._user);
+            // if (!!!this._collection.parent) throw new Error(`Can't access space`)
+            // const spaceSnap = await this._collection.parent.get()
+            // if (!!!spaceSnap.exists || !!!spaceSnap.data()) throw new Error(`Can't access space`)
+            // const space = new Space({ ...spaceSnap.data(), id: spaceSnap.id } as ISpace, this._user, spaceSnap.ref)
             const spaceData = space.data();
             let boxes = [];
             if (!!!spaceData.transport_preferences.predefined_boxes ||
@@ -2168,16 +2523,23 @@ class Cart extends baseService_1.BaseServiceClass {
                     allItemsSplitted.push(item);
                 }
             }
+            // Begin by the biggest item
             allItemsSplitted = (0, orderBy_1.default)(allItemsSplitted, (i) => i.shipping_info.weight, 'desc');
             for (const item of allItemsSplitted) {
                 let itemBoxed = false;
+                // If boxes exists
                 if (!!boxes.length) {
                     for (const existingBox of (0, orderBy_1.default)(boxes, (b) => b.occupied_volume || 0, 'asc')) {
                         if (this._doesGoIn(item, existingBox)) {
                             boxes = [
                                 ...boxes.slice(0, (0, indexOf_1.default)(boxes, existingBox)),
                                 Object.assign(Object.assign({}, existingBox), { item_ids: [...existingBox.item_ids, item.sku], occupied_volume: existingBox.occupied_volume +
-                                        this._calculateItemVolume(item) / this._calculateBoxItemVolume(existingBox), weight: existingBox.weight + (0, weight_1.convertWeight)(item.shipping_info.weight || 0, item.shipping_info.unit_weight) }),
+                                        this._calculateItemVolume(item) / this._calculateBoxItemVolume(existingBox), 
+                                    // (existingBox.occupied_volume * this._calculateBoxItemVolume(existingBox) +
+                                    // 	this._calculateItemVolume(item)) *
+                                    // 100 /
+                                    // this._calculateBoxItemVolume(existingBox),
+                                    weight: existingBox.weight + (0, weight_1.convertWeight)(item.shipping_info.weight || 0, item.shipping_info.unit_weight) }),
                                 ...boxes.slice((0, indexOf_1.default)(boxes, existingBox) + 1)
                             ];
                             itemBoxed = true;
@@ -2187,6 +2549,9 @@ class Cart extends baseService_1.BaseServiceClass {
                 }
                 if (itemBoxed)
                     continue;
+                // If no boxes are started or item can't go in previous boxes
+                // All items starting by this one can enter a new box
+                // If allitems goes in ?
                 let _allItemsGoIn = false;
                 const itemsToBox = allItemsSplitted.slice((0, indexOf_1.default)(allItemsSplitted, item));
                 const totalVolume = (0, sumBy_1.default)(itemsToBox, (_item) => this._calculateItemVolume(_item));
@@ -2203,13 +2568,16 @@ class Cart extends baseService_1.BaseServiceClass {
                 if (_allItemsGoIn)
                     break;
                 for (const box of boxTemplates) {
+                    // Begin by the smallest
                     if (this._doesGoIn(item, Object.assign(Object.assign({}, box), { item_ids: [], occupied_volume: 0, weight: 0 }))) {
+                        // If fits, add item to a new box
                         boxes = [
                             ...boxes,
                             Object.assign(Object.assign({}, box), { item_ids: [item.sku], occupied_volume: this._calculateItemVolume(item) / this._calculateBoxVolume(box), weight: (0, weight_1.convertWeight)(item.shipping_info.weight || 0, item.shipping_info.unit_weight) })
                         ];
                         break;
                     }
+                    // Otherwise create a custom box the size of the item
                     boxes = [
                         ...boxes,
                         {
@@ -2314,6 +2682,7 @@ class Cart extends baseService_1.BaseServiceClass {
                 throw new Error(`Can't access invoices collection`);
             this.save({
                 shipping_payload: trackingInfo
+                // status: CartStatusEnum.CHECKOUT_SHIPPING
             });
         };
         this._getItems = () => this.data().items;
@@ -2543,6 +2912,7 @@ class Cart extends baseService_1.BaseServiceClass {
                 const possible = [
                     order_1.PackageTypeEnum.MY_ENVELOPE,
                     order_1.PackageTypeEnum.PACKAGE
+                    // PackageTypeEnum.PALLET
                 ];
                 if (this.getTotalWeight('pounds') <= 1)
                     possible.push(order_1.PackageTypeEnum.LETTER);
@@ -2632,6 +3002,15 @@ class Cart extends baseService_1.BaseServiceClass {
             getBoxDimension: this._getBoxDimension,
             setBoxDimension: this._setBoxDimension
         };
+        //#endregion
+        //#region PROMISES TO PURCHASE
+        /**
+         * Function updateWithPromiseToPurchasePrices
+         * @description update the cart by replacing the items with their custom price equivalent and add discount items in the cart
+         * @param escompteItems list of discount products from the dash
+         * @param customPriceList list of products with their custom pric from G2
+         * @param banksUsedForCart Optionnal. Array of banks_used applied to cart
+         */
         this.updateWithPromiseToPurchasePrices = async (escompteItems, customPriceList = undefined, banksUsedForCart) => {
             if (!!!customPriceList || typeof customPriceList == 'string')
                 throw new Error('CustomPriceList is undefined!');
@@ -2642,16 +3021,23 @@ class Cart extends baseService_1.BaseServiceClass {
                 return;
             }
             const updatedPriceProducts = this.data()
-                .items.filter((item) => !(0, g2_1.isEscompteSuppItem)(item.sku))
+                .items.filter((item) => !(0, g2_1.isEscompteSuppItem)(item.sku)) // remove discount items from the cart
                 .map((item) => {
+                // Only check customPriceList for prices if :
+                //   - banksUsedForCart is not set
+                //   - banksUsedForCart contains the associated bank id
                 const shouldCheckPriceList = !!!banksUsedForCart ||
                     (!!item.promise_to_purchase_association_ids &&
                         !!item.promise_to_purchase_association_ids.some((id) => !!banksUsedForCart.map((b) => b.bank_type_id).includes(id)));
                 return (!!shouldCheckPriceList ? (0, g2_1.checkForCustomPriceEquivalent)(item, customPriceList) : item);
             });
             const associatedEscomptes = new Array();
+            // for each item in the cart look for an associated discount item
             for (let index = 0; index < updatedPriceProducts.length; index++) {
                 const item = updatedPriceProducts[index];
+                // if item hasn't got an associated bank,
+                // or if associated bank not found in banks used for cart,
+                // don't look for an associated discount item
                 if (!!!item.promise_to_purchase_association_ids ||
                     item.promise_to_purchase_association_ids.length == 0 ||
                     (!!banksUsedForCart &&
@@ -2669,14 +3055,30 @@ class Cart extends baseService_1.BaseServiceClass {
             this._data = Object.assign(Object.assign({}, this._data), { items: [...updatedPriceProducts, ...associatedEscomptes] });
             await this.calculateTotals();
         };
+        /**
+         * Function canBePaidWithMyPromiseToPurchase
+         * @description Check if a cart can be paid with a promise to purchase
+         * @param applicableBanks the list of potential banks that could be applied for cart
+         * @param applicableBanksHistory the list of all associated history entries for applicable banks (flattened in a single array)
+         * @param customPriceList a list of custom price items
+         * @param contingency contingency (from the space)
+         * @param forceCartTypeid Optionnal. A cart type ID to use for bank to apply check, if should be forced
+         * @returns true if cart can be paid, false if it cannot
+         */
         this.canBePaidWithMyPromiseToPurchase = async (applicableBanks, applicableBanksHistory, customPriceList = undefined, contingency = 0, forcedBankTypeId) => {
             if (!!!customPriceList || typeof customPriceList == 'string')
                 throw new Error(PromiseToPurchase_2.ApplyBanksToCartErrorsEnum.CUSTOM_PRICE_LIST_UNDEFINED);
+            // NEW - used to have a check here if contingency was undefined, but it makes more sense to let the logic pass, even if no contingency exists (could be a volontary decision from user)
             await this._savePromiseToPurchaseInCart(applicableBanks, false);
+            // Calculate remaining amounts
             try {
                 const space = await Space_2.default.getCurrentSpaceWithRef(this._collection.path, this._user);
                 const remainingAmounts = await PromiseToPurchase_1.default.calculateRemainingAmounts(this, applicableBanks, applicableBanksHistory, space);
+                // If only one bank is used and said bank has no initial amount, returns empty array
+                // (so there is no overlap between "bank goes over allowed amount" and "bank is disabled in promise")
                 const potentialRemainingAmounts = this.calculatePotentialRemainingAmountsAndSetBanksUsedAmounts(remainingAmounts, applicableBanks, forcedBankTypeId);
+                // if bank to use has no initial amount, return false
+                // if payment for any of the banks goes over the remaining amount + the contingency, return false
                 if (!!!potentialRemainingAmounts.length) {
                     throw new Error(PromiseToPurchase_2.ApplyBanksToCartErrorsEnum.BANK_NOT_FOUND);
                 }
@@ -2690,14 +3092,26 @@ class Cart extends baseService_1.BaseServiceClass {
                 return e.message;
             }
         };
+        /**
+         * Function calculatePotentialRemainingAmountsAndSetBanksUsedAmounts
+         * @description Calculate the amounts that would remain in the promise's banks if we paid this cart with the promise and associates the amounts to use in the banks to the cart
+         * @param remainingAmounts remaining amounts BEFORE including this cart
+         * @param applicableBanks the list of potential banks that could be applied for cart
+         * @param promiseToPurchase the promise to purchase
+         * @returns an array of IBankUsed
+         */
         this.calculatePotentialRemainingAmountsAndSetBanksUsedAmounts = (remainingAmounts, applicableBanks, forcedBankTypeId) => {
             let accountedForItems = new Array();
             let itemsToCheck = this.data().items;
+            // allow payment only if the cart contains at least one item that is associated to only one bank
             const singleBankItems = itemsToCheck.filter((item) => !!item.promise_to_purchase_association_ids && item.promise_to_purchase_association_ids.length == 1);
             if (singleBankItems.length == 0) {
                 throw new Error(PromiseToPurchase_2.ApplyBanksToCartErrorsEnum.ONLY_ITEMS_WITH_MULTI_ASSOCIATED_BANKS);
             }
+            // manage mixed products if the cart contains any
+            // mixed product => product with no associated bank (can be deduced from any bank) or with more than one associated bank
             const multipleBankItems = itemsToCheck.filter((item) => !!!item.promise_to_purchase_association_ids || item.promise_to_purchase_association_ids.length != 1);
+            // If forcedBankTypeId is defined, only keep associated remainingAmount
             if (!!forcedBankTypeId) {
                 let bankToUse = remainingAmounts.find((bank) => bank.bank_type_id == forcedBankTypeId);
                 if (!!!bankToUse)
@@ -2725,6 +3139,9 @@ class Cart extends baseService_1.BaseServiceClass {
                     };
                 }
             }
+            // check that not all banks to use are disabled in the promise to purchase
+            // if banks to use is disabled make remainingAmounts an empty array :
+            // the cart won't use bank because no bank corresponding to the cart is enabled in the promise to purchase
             if (!!remainingAmounts.length) {
                 const banksToUse = remainingAmounts;
                 const promiseBanksToUse = banksToUse
@@ -2733,6 +3150,7 @@ class Cart extends baseService_1.BaseServiceClass {
                     return !!sameInApplicable ? sameInApplicable.bank : undefined;
                 })
                     .filter((bank) => !!bank);
+                // If all banks to apply are found in inactive promise, throw error
                 const allBanksAreInInactivePA = promiseBanksToUse.every((b) => {
                     const sameInApplicable = applicableBanks.find((ab) => ab.bank.bank_type_id === b.bank_type_id);
                     return !!sameInApplicable && !!!sameInApplicable.pa_is_active;
@@ -2740,6 +3158,7 @@ class Cart extends baseService_1.BaseServiceClass {
                 if (!!allBanksAreInInactivePA) {
                     throw new Error(PromiseToPurchase_2.ApplyBanksToCartErrorsEnum.PA_IS_INACTIVE);
                 }
+                // If all banks to apply are inactive, throw error
                 const allBanksAreInactive = promiseBanksToUse.every((b) => {
                     const sameInApplicable = applicableBanks.find((ab) => ab.bank.bank_type_id === b.bank_type_id);
                     return !!sameInApplicable && !!!sameInApplicable.bank.active;
@@ -2747,6 +3166,7 @@ class Cart extends baseService_1.BaseServiceClass {
                 if (!!allBanksAreInactive) {
                     throw new Error(PromiseToPurchase_2.ApplyBanksToCartErrorsEnum.BANK_NOT_FOUND);
                 }
+                // If the bank's pa or the bank itself is inactive, remove from remainingamounts
                 for (let bankToUse of promiseBanksToUse) {
                     const sameInApplicable = applicableBanks.find((ab) => ab.bank.bank_type_id === bankToUse.bank_type_id);
                     if (!!sameInApplicable && (!!!sameInApplicable.pa_is_active || !!!sameInApplicable.bank.active)) {
@@ -2767,7 +3187,10 @@ class Cart extends baseService_1.BaseServiceClass {
             let potentialRemainingAmounts = [];
             for (let bank of remainingAmounts) {
                 let amountToRemove = 0;
-                const { bank_type_id, amount } = bank, rest = __rest(bank, ["bank_type_id", "amount"]);
+                const { bank_type_id, amount } = bank, rest = __rest(bank
+                // If forcedBankTypeId is defined, and is same bank type than current loop check, use cart subtotal for amountToRemove
+                , ["bank_type_id", "amount"]);
+                // If forcedBankTypeId is defined, and is same bank type than current loop check, use cart subtotal for amountToRemove
                 if (!!forcedBankTypeId) {
                     amountToRemove = this.getSubtotal();
                 }
@@ -2800,7 +3223,7 @@ class Cart extends baseService_1.BaseServiceClass {
                             !!!accountedForItems.includes(item.sku));
                     });
                     amountToRemove = (0, sumBy_1.default)(itemsToAccount, (item) => {
-                        accountedForItems.push(item.sku);
+                        accountedForItems.push(item.sku); // do not account for the same items twice if it was already deduced from a bank (for items associated to more than one bank)
                         const priceToPay = this.getLowestPrice(item);
                         return priceToPay * item.qte;
                     });
@@ -2808,6 +3231,7 @@ class Cart extends baseService_1.BaseServiceClass {
                 if (amountToRemove > 0 && amount < 1)
                     throw new Error(PromiseToPurchase_2.ApplyBanksToCartErrorsEnum.EMPTY_BANK);
                 if (amountToRemove > 0) {
+                    // Update banks used array
                     banksUsed.push(Object.assign(Object.assign({}, rest), { bank_type_id: bank_type_id, amount: amountToRemove }));
                     potentialRemainingAmounts.push(Object.assign(Object.assign({}, rest), { bank_type_id: bank_type_id, amount: amount - amountToRemove }));
                 }
@@ -2833,12 +3257,24 @@ class Cart extends baseService_1.BaseServiceClass {
                     banks_used: bankAmountsUpdated
                 } });
         };
+        /**
+         * Function canBePaidWithPA
+         * @description used to determine whether the cart can be paid with the promise to purchase and to update the items of the cart with the new prices and associated discount items
+         * @param applicableBanks the list of applicable banks for cart
+         * @param customerID the customer ID associated to the cart
+         * @param customPriceList a list of custom price items
+         * @param space the space
+         * @param forcedCartType Optionnal. If provided, overrides cart type found by check cart item types.
+         * @returns the updated cart and a boolean canBePaid determining if the cart can be paid with the promise or not
+         */
         this.canBePaidWithPA = async (applicableBanks, customerID, customPriceList, space, forcedBankTypeId) => {
             const contingency = space.promisesToPurchase.getContingency();
             const escomptesItems = await space.promisesToPurchase.getEscompteItems();
+            // Get use history for applicable banks
             let applicableBanksHistory = [];
             for (let applicable of applicableBanks) {
                 const { promise_id, bank } = applicable;
+                // don't fetch history if no initial_amount
                 if (!!!bank.initial_amount)
                     continue;
                 try {
@@ -2852,6 +3288,8 @@ class Cart extends baseService_1.BaseServiceClass {
                 }
             }
             const filteredApplicableBanksHistory = (0, flatten_1.default)(applicableBanksHistory).filter((b) => !!b);
+            // set possible escomptes in cart so correct amounts are used when checking available amounts
+            // only set escomptes in cart based on potential applicableBanks where pa is active, bank is active and initial amount is set
             const possibleBanksToUse = applicableBanks
                 .filter((b) => !!b.pa_is_active && !!b.bank.active && !!b.bank.initial_amount)
                 .map((b) => ({
@@ -2862,6 +3300,8 @@ class Cart extends baseService_1.BaseServiceClass {
             }));
             await this.updateWithPromiseToPurchasePrices(escomptesItems, customPriceList, possibleBanksToUse);
             const canBePaidCheck = await this.canBePaidWithMyPromiseToPurchase(applicableBanks, filteredApplicableBanksHistory, customPriceList, contingency, forcedBankTypeId);
+            // if banks applicable length is different from banks truly applied to cart,
+            // adjust added escomptes with banks used for cart
             if (!!this._data.promise_to_purchase &&
                 applicableBanks.length !== this._data.promise_to_purchase.banks_used.length) {
                 await this.updateWithPromiseToPurchasePrices(escomptesItems, customPriceList, this._data.promise_to_purchase.banks_used);
@@ -2875,8 +3315,10 @@ class Cart extends baseService_1.BaseServiceClass {
             if (!!!promisesInCart)
                 return;
             const banksToDeactivate = {};
+            // Check for each bank if it should be deactivated
             for (let bank of promisesInCart.banks_used) {
                 try {
+                    // Fetch associated promise from DB
                     const promiseQuery = await space.promisesToPurchase.get({
                         query: [{ field: 'id', operator: '==', value: bank.promise_id }]
                     });
@@ -2886,6 +3328,7 @@ class Cart extends baseService_1.BaseServiceClass {
                     const sameBankInPromise = promise.data().banks.find((b) => b.bank_type_id === bank.bank_type_id);
                     if (!!!sameBankInPromise)
                         throw new Error('Could not find same bank in promise');
+                    // Fetch bank use history from index
                     let bankUseHistory = [];
                     try {
                         const historyQuery = await space.promisesToPurchase.getBanksUsedHistory({
@@ -2894,6 +3337,7 @@ class Cart extends baseService_1.BaseServiceClass {
                             bankTypeID: bank.bank_type_id
                         }, { hpp: 1000 });
                         if (!!historyQuery) {
+                            // Only keep history different from current cart
                             bankUseHistory = historyQuery.filter((h) => !!!h.associated_cart_ref ||
                                 h.associated_cart_ref !== this._data.ref ||
                                 (!!this._data.paid_at && h.date !== (0, moment_1.default)((0, data_1.formatDate)(this._data.paid_at)).unix()));
@@ -2912,6 +3356,8 @@ class Cart extends baseService_1.BaseServiceClass {
                             clientToken: (_c = process.env.NEXT_PUBLIC_LOG_SYSTEM_KEY) !== null && _c !== void 0 ? _c : ''
                         }, logs_1.LogType.ERROR, `Cart ref: ${this._data.ref} | Error on fetching history for banks: ${e.toString()}`);
                     }
+                    // Calculated remaining amount without most recent entry
+                    // Then remove most recent entry from remaining
                     const { remaining_amount } = (0, promiseToPurchase_1.calculatedRemainingBankAmount)(sameBankInPromise.initial_amount, bankUseHistory);
                     if (typeof remaining_amount === 'number') {
                         const remainingAmount = remaining_amount - bank.amount;
@@ -2919,6 +3365,7 @@ class Cart extends baseService_1.BaseServiceClass {
                             clientName: `sdk-admin | Cart | checkForEmptyBanks, space: ${(0, services_1.getSpaceInitialsByID)(space.data().id)}`,
                             clientToken: (_d = process.env.NEXT_PUBLIC_LOG_SYSTEM_KEY) !== null && _d !== void 0 ? _d : ''
                         }, logs_1.LogType.INFO, `Cart ref: ${this._data.ref} | Remaining amount for bank ${(0, locale_1.getPrincipalWord)(sameBankInPromise.name, space)}, for customer ${this._data.customer_id}: before ${(0, round_1.default)(remaining_amount, 2)}, after: ${(0, round_1.default)(remainingAmount, 2)}`);
+                        // If bank is now empty, set bank to be deactivated
                         if ((0, round_1.default)(remainingAmount, 2) < 1) {
                             const promiseAlreadySetInObj = banksToDeactivate[bank.promise_id];
                             banksToDeactivate[bank.promise_id] = {
@@ -2943,6 +3390,7 @@ class Cart extends baseService_1.BaseServiceClass {
                 }
             }
             try {
+                // Save promises with empty banks
                 await Promise.all(Object.values(banksToDeactivate).map(async ({ promiseObj, bankIDsWithRemainingAmounts }) => await promiseObj.disableEmptyPABanks(bankIDsWithRemainingAmounts)));
             }
             catch (e) {
@@ -2953,6 +3401,8 @@ class Cart extends baseService_1.BaseServiceClass {
                 }, logs_1.LogType.ERROR, `Cart ref: ${this._data.ref} | Error on saving promises with empty banks: ${e.toString()}`);
             }
         };
+        //#endregion
+        // #region PROCESSED CART
         this.setCartAsProcessed = async (processedAtStore, space, options) => {
             if (!!!this.data().status || this.data().status != Cart_1.CartStatusEnum.CHECKOUT_PAYMENT_SUCCESS) {
                 console.log('cannot process cart! returning');
@@ -2960,16 +3410,21 @@ class Cart extends baseService_1.BaseServiceClass {
             }
             let newData = Object.assign({}, this.data());
             let spaceShippingIsProduct = space.preferences.shipping.asProduct.get();
+            // 1. Change cart status to READY_TO_PROCESS or SHIPPING_AWAITING_OR_PICKUP_READY (if pickup of shipping is a product for space)
             newData.status =
                 !!newData.is_pickup || spaceShippingIsProduct
                     ? Cart_1.CartStatusEnum.SHIPPING_AWAITING_OR_PICKUP_READY
                     : Cart_1.CartStatusEnum.CART_READY_TO_PROCESS;
+            // 2. set current_store_id if not set
             if (!!!newData.current_store_id && !!processedAtStore) {
                 newData.current_store_id = processedAtStore.id;
             }
+            // 3. set processed_by props
             if (!!options.currentUser) {
                 newData.processed_by = this.getCartAssignedUserData(options.currentUser, processedAtStore);
             }
+            // 4. if quantities unavailable for store, set bypassed quantities property in cart items
+            //    also update reserved quantities (if defined) to total required quantity (so any transfers or checks will consider cart as "full" and new quantites will be added to available quantities for store)
             if (!!options.unavailableItemQtes) {
                 const updatedItems = newData.items.map((item) => {
                     let sameInUnavailable = options.unavailableItemQtes[item.sku];
@@ -2980,6 +3435,7 @@ class Cart extends baseService_1.BaseServiceClass {
                 });
                 newData.items = updatedItems;
             }
+            // 5. save cart, return ref
             try {
                 const saved = this.save(newData, undefined, true);
                 if (!!!saved) {
@@ -2991,8 +3447,16 @@ class Cart extends baseService_1.BaseServiceClass {
                 console.log('error on saving cart as processed: ', e.toString());
             }
         };
+        /**
+         * Change processing store for an un-completed cart that was already processed
+         * @param newProcessedAtStore - New store where cart is to be processed
+         * @param space
+         * @param options.currentUser
+         * @param options.unavailableItemQtes
+         */
         this.changeProcessingStoreForCart = async (newProcessedAtStore, space, options) => {
             let cartUpdated = false;
+            // If cart is completed or not already processed once, return
             if (!!!this.data().status ||
                 this.data().status < Cart_1.CartStatusEnum.CART_READY_TO_PROCESS ||
                 this.data().status >= Cart_1.CartStatusEnum.COMPLETED) {
@@ -3002,6 +3466,7 @@ class Cart extends baseService_1.BaseServiceClass {
             const prevStoreId = this.data().current_store_id;
             const newStoreId = newProcessedAtStore.id;
             if (!!prevStoreId && !!newStoreId) {
+                // A. Update inventory for concerned stores :
                 try {
                     await space.inventory.ajust(this.data().items, 'updatedProcessingStore', this.data().cart_type, {
                         currentStoreId: prevStoreId,
@@ -3012,14 +3477,18 @@ class Cart extends baseService_1.BaseServiceClass {
                 catch (s) {
                     console.log('error on ajusting inventory for new processing store');
                 }
+                // B. Update value for current store id in cart
                 let newPartialCart = {
                     id: this._data.id,
                     current_store_id: newStoreId
                 };
+                // C. Add updated_by entry to cart
                 if (!!options.currentUser) {
                     const updatedByData = this.getCartAssignedUserData(options.currentUser, undefined, Cart_1.UpdateTypeEnum.PROCESSING_STORE);
                     newPartialCart.updated_by = [...(this._data.updated_by || []), updatedByData];
                 }
+                // D. if quantities unavailable for store, set bypassed quantities property in cart items
+                //    also update reserved quantities (if defined) to total required quantity (so any transfers or checks will consider cart as "full" and new quantites will be added to available quantities for store)
                 if (!!options.unavailableItemQtes ||
                     this._data.items.some((i) => typeof i.qte_bypass_inventory_check == 'number')) {
                     const updatedItems = this._data.items.map((item) => {
@@ -3032,6 +3501,7 @@ class Cart extends baseService_1.BaseServiceClass {
                     });
                     newPartialCart.items = updatedItems;
                 }
+                // E. Save cart to database
                 try {
                     await this.save(newPartialCart, undefined, true, true);
                     cartUpdated = true;
@@ -3045,9 +3515,16 @@ class Cart extends baseService_1.BaseServiceClass {
             }
             return cartUpdated;
         };
+        /**
+         * Create and set new invoice_ref number in cart.
+         * @param space - Space obj.
+         * @param saveToDatabase - Optionnal. Defaults to true in save function
+         * @param newCartRef - Optionnal. If cart does not have ref saved to local object when calling function, will replace ref in data with value provided.
+         */
         this.setCartWithInvoiceRef = async (space, saveToDatabase, newCartRef) => {
             let invoiceRef = undefined;
             let newData = Object.assign(Object.assign({}, this.data()), (!!newCartRef && !!!this.data().ref ? { ref: newCartRef } : {}));
+            // 1. Check to set new invoice_ref in cart
             try {
                 invoiceRef = await space.invoices.incrementRef(newData);
                 if (!!invoiceRef) {
@@ -3061,13 +3538,21 @@ class Cart extends baseService_1.BaseServiceClass {
             }
             return invoiceRef;
         };
+        /**
+         * Save cart to external_service G2 as G2OrderSlip. Created G2 order id is then saved to cart object
+         * @param space
+         * @param saveToDatabase
+         * @param newlyCreatedCartRef
+    =	 */
         this.setG2ExternalOrderRef = async (space, saveToDatabase = true, newlyCreatedCartData) => {
             var _b, _c;
+            // Check if space has G2 service set
             const G2Service = space.services({ field: 'external_service_name', value: 'G2' });
             if (!!!G2Service || !!!G2Service.length) {
                 console.log('Space does not have G2 set as external service. Returning!');
                 return;
             }
+            // Call G2 service via API
             const cartDataToUse = Object.assign(Object.assign({}, this.data()), (newlyCreatedCartData || {}));
             let g2OrderRef;
             try {
@@ -3102,6 +3587,7 @@ class Cart extends baseService_1.BaseServiceClass {
                         if (attempt === MAX_RETRIES - 1) {
                             throw err;
                         }
+                        // Wait 500ms before next retry to not hmammer the server
                         await new Promise((res) => setTimeout(res, 500));
                     }
                 }
@@ -3119,6 +3605,7 @@ class Cart extends baseService_1.BaseServiceClass {
                     : `on save to G2 for cart ref ${this.data().ref}`;
                 const errorCode = !!g2OrderRef ? G2_1.G2OrderSaveErrors.ADDIO_SAVE_CART_ERROR : G2_1.G2OrderSaveErrors.G2_ERROR;
                 console.log(`${__1.isTestEnv ? 'TESTENV - ' : ''}G2 ORDER BUG ${errorStr}:`, e.toString());
+                // '%%' Will be used as seperator to deconstruct info from logs for daily recap
                 await (0, logs_1.SystemLog)({
                     clientName: `sdk-admin | Cart | setG2ExternalOrderRef | ${(0, services_1.getSpaceInitialsByID)(space.data().id)}`,
                     clientToken: (_c = process.env.NEXT_PUBLIC_LOG_SYSTEM_KEY) !== null && _c !== void 0 ? _c : ''
@@ -3128,6 +3615,7 @@ class Cart extends baseService_1.BaseServiceClass {
             return g2OrderRef;
         };
         this.setCartAsRefunded = async (partial, itemsToReturnInventory, storeId) => {
+            //1. Reset Inventories to available for items that were refunded
             if (!!itemsToReturnInventory && !!itemsToReturnInventory.length) {
                 try {
                     const space = await Space_2.default.getCurrentSpaceWithRef(this._collection.path, this._user);
@@ -3143,6 +3631,7 @@ class Cart extends baseService_1.BaseServiceClass {
                     console.error(e);
                 }
             }
+            // 2. save cart with info about refunded_qty for each item, then return ref
             try {
                 const saved = this.save(partial, undefined, true);
                 if (!!!saved) {