@cloudcommerce/app-discounts 2.29.9 → 2.29.11

package/lib-mjs/apply-discount.mjs

@@ -1,3 +1,4 @@
+/* eslint-disable no-await-in-loop */
 import ecomUtils from '@ecomplus/utils';
 import api from '@cloudcommerce/api';
 import {
@@ -6,38 +7,95 @@ import {
   checkOpenPromotion,
   getValidDiscountRules,
   matchDiscountRule,
-  checkCampaignProducts,
+  matchFreebieRule,
+  mapCampaignProducts,
 } from './helpers.mjs';
 
 export default async ({ params, application }) => {
-  // app configured options
-  const config = {
-    ...application.data,
-    ...application.hidden_data,
-  };
-
-  // setup response object
-  // https://apx-mods.e-com.plus/api/v1/apply_discount/response_schema.json?store_id=100
+  const config = { ...application.data, ...application.hidden_data };
+  if (config.advanced && typeof config.advanced === 'object') {
+    Object.assign(config, config.advanced);
+  }
   const response = {};
+  const discountPerSku = {};
   const respondSuccess = () => {
     if (response.available_extra_discount && !response.available_extra_discount.value) {
       delete response.available_extra_discount;
     }
+    if (response.discount_rule) {
+      if (!response.discount_rule.extra_discount?.value) {
+        delete response.discount_rule;
+      } else if (!response.discount_rule.description && config.describe_discounted_items) {
+        const discountedSkus = Object.keys(discountPerSku);
+        if (discountedSkus.length) {
+          response.discount_rule.description = `
+  Descontos por SKU:
+  ---
+  ${discountedSkus.map((sku) => `\n${sku}: ${discountPerSku[sku].toFixed(2)}`)}
+  `.substring(0, 999);
+        }
+      }
+    }
+    return response;
+  };
+
+  const checkUsageLimit = async (discountRule, label) => {
+    const { customer } = params;
+    if (!label) {
+      label = discountRule.label;
+    }
     if (
-      response.discount_rule
-      && (!response.discount_rule.extra_discount || !response.discount_rule.extra_discount.value)
+      label
+        && customer && (customer._id || customer.doc_number)
+        && (discountRule.usage_limit > 0 || discountRule.total_usage_limit > 0)
     ) {
-      delete response.discount_rule;
+      // list orders to check discount usage limits
+      const endpoint = 'orders?fields=status'
+          + `&extra_discount.app.label${(discountRule.case_insensitive ? '%=' : '=')}`
+          + encodeURIComponent(label);
+      const usageLimits = [{
+        // limit by customer
+        query: customer.doc_number
+          ? `&buyers.doc_number=${customer.doc_number}`
+          : `&buyers._id=${customer._id}`,
+        max: discountRule.usage_limit,
+      }, {
+        // total limit
+        query: '',
+        max: discountRule.total_usage_limit,
+      }];
+      for (let i = 0; i < usageLimits.length; i++) {
+        const { query, max } = usageLimits[i];
+        if (max) {
+          // send Store API request to list orders with filters
+          const { data } = await api.get(`${endpoint}${query}`);
+          const countOrders = data.result
+            .filter(({ status }) => status !== 'cancelled')
+            .length;
+          if (countOrders >= max) {
+            // limit reached
+            return false;
+          }
+        }
+      }
     }
-    return response;
+    return true;
   };
 
-  const addDiscount = (discount, flag, label, maxDiscount) => {
+  const getDiscountValue = (discount, maxDiscount) => {
     let value;
     if (typeof maxDiscount !== 'number') {
-      maxDiscount = params.amount[discount.apply_at || 'total'];
+      const applyAt = discount.apply_at || 'total';
+      maxDiscount = params.amount[applyAt];
+      if (applyAt === 'total' && response.discount_rule) {
+        maxDiscount -= response.discount_rule.extra_discount.value;
+      }
+      if (applyAt !== 'freight') {
+        // eslint-disable-next-line
+        maxDiscount -= getFreebiesPreview().value;
+      }
     }
-    if (maxDiscount) {
+    if (maxDiscount > 0) {
       // update amount discount and total
       if (discount.type === 'percentage') {
         value = maxDiscount * (discount.value / 100);
@@ -48,7 +106,11 @@ export default async ({ params, application }) => {
         value = maxDiscount;
       }
     }
+    return value !== undefined ? Number(value) : value;
+  };
 
+  const addDiscount = (discount, flag, label, maxDiscount) => {
+    const value = getDiscountValue(discount, maxDiscount);
     if (value) {
       if (response.discount_rule) {
         // accumulate discount
@@ -66,9 +128,145 @@ export default async ({ params, application }) => {
           },
         };
       }
-      return true;
+      return value;
+    }
+    return null;
+  };
+
+  const pointDiscountToSku = (discountValue, sku) => {
+    if (!discountValue || !sku) return;
+    if (!discountPerSku[sku]) discountPerSku[sku] = 0;
+    discountPerSku[sku] += discountValue;
+  };
+  const pointDiscountToEachItem = (discountValue, filteredItems) => {
+    const itemsAmount = filteredItems.reduce(
+      (amount, item) => amount + (ecomUtils.price(item) * (item.quantity || 1)),
+      0,
+    );
+    const discountMultiplier = discountValue / itemsAmount;
+    filteredItems.forEach((item) => {
+      const discountPerItem = discountMultiplier * (ecomUtils.price(item) * (item.quantity || 1));
+      return pointDiscountToSku(discountPerItem, item.sku);
+    });
+  };
+
+  const getFreebiesPreview = () => {
+    if (params.items && params.items.length) {
+      // gift products (freebies) campaings
+      if (Array.isArray(config.freebies_rules)) {
+        const validFreebiesRules = config.freebies_rules.filter((rule) => {
+          return validateDateRange(rule)
+              && validateCustomerId(rule, params)
+              && mapCampaignProducts({ product_ids: rule.check_product_ids }, params).valid
+              && Array.isArray(rule.product_ids)
+              && rule.product_ids.length
+              && matchFreebieRule(rule, params);
+        });
+        if (validFreebiesRules) {
+          const cumulativeRules = [];
+          let bestRule;
+          let discountValue = 0;
+          for (let i = 0; i < validFreebiesRules.length; i++) {
+            const rule = validFreebiesRules[i];
+            let subtotal = 0;
+            const subtotalItems = [];
+            params.items.forEach((item) => {
+              if (Array.isArray(rule.category_ids)) {
+                if (Array.isArray(item.categories)) {
+                  for (let ii = 0; ii < item.categories.length; ii++) {
+                    const category = item.categories[ii];
+                    if (rule.category_ids.indexOf(category._id) > -1) {
+                      subtotal += (item.quantity * ecomUtils.price(item));
+                      subtotalItems.push(item);
+                      break;
+                    }
+                  }
+                }
+                return;
+              }
+              subtotal += (item.quantity * ecomUtils.price(item));
+              subtotalItems.push(item);
+            });
+            if (subtotal <= 0) {
+              continue;
+            }
+            // start calculating discount
+            let value = 0;
+            let fixedSubtotal = subtotal;
+            rule.product_ids.forEach((productId) => {
+              const item = params.items.find((_item) => productId === _item.product_id);
+              if (item) {
+                const price = ecomUtils.price(item);
+                value += price;
+                if (subtotalItems.find((_item) => productId === _item.product_id)) {
+                  fixedSubtotal -= price;
+                }
+              }
+            });
+            if (rule.deduct_discounts) {
+              if (response.discount_rule) {
+                fixedSubtotal -= response.discount_rule.extra_discount.value;
+              }
+              if (params.amount.discount) {
+                fixedSubtotal -= params.amount.discount;
+              }
+            }
+            if (rule.cumulative_freebie === true && !(rule.min_subtotal > fixedSubtotal)) {
+              cumulativeRules.push({ rule, value });
+            }
+            if (!bestRule || value > discountValue || bestRule.min_subtotal < rule.min_subtotal) {
+              if (!(rule.min_subtotal > fixedSubtotal)) {
+                bestRule = rule;
+                discountValue = value;
+              } else if (!discountValue && fixedSubtotal >= rule.min_subtotal) {
+                // discount not applicable yet but additional freebies are available
+                bestRule = rule;
+              }
+            }
+          }
+
+          if (bestRule) {
+            // provide freebie products \o/
+            response.freebie_product_ids = bestRule.product_ids;
+            if (discountValue) {
+              if (bestRule.cumulative_freebie === true) {
+                cumulativeRules.forEach(({ rule, value }) => {
+                  for (let i = 0; i < response.freebie_product_ids.length; i++) {
+                    const productId = response.freebie_product_ids[i];
+                    if (rule.product_ids.includes(productId)) {
+                      // ignoring cumulative freebie rules with repeated products
+                      return;
+                    }
+                  }
+                  discountValue += value;
+                  rule.product_ids.forEach((productId) => {
+                    response.freebie_product_ids.push(productId);
+                  });
+                });
+              }
+              return {
+                value: discountValue,
+                label: bestRule.label,
+              };
+            }
+          }
+        }
+      }
+    }
+    return { value: 0 };
+  };
+
+  const addFreebies = () => {
+    const { value, label } = getFreebiesPreview();
+    if (value) {
+      const maxDiscount = Math.min(value, params.amount.total || 0);
+      addDiscount(
+        { type: 'fixed', value },
+        'FREEBIES',
+        label,
+        maxDiscount,
+      );
     }
-    return false;
   };
 
   if (params.items && params.items.length) {
@@ -76,7 +274,7 @@ export default async ({ params, application }) => {
     if (Array.isArray(config.product_kit_discounts)) {
       config.product_kit_discounts = config.product_kit_discounts.map((kitDiscount) => {
         if (!kitDiscount.product_ids) {
-          // kit with any items
+          // kit with any items (or per category)
           kitDiscount.product_ids = [];
         }
         return kitDiscount;
@@ -91,41 +289,60 @@ export default async ({ params, application }) => {
         }
         if (a.min_quantity > b.min_quantity) {
           return -1;
-        }
-        if (b.min_quantity > a.min_quantity) {
+        } if (b.min_quantity > a.min_quantity) {
           return 1;
-        }
-        if (a.discount.min_amount > b.discount.min_amount) {
+        } if (a.discount.min_amount > b.discount.min_amount) {
           return -1;
-        }
-        if (b.discount.min_amount > a.discount.min_amount) {
+        } if (b.discount.min_amount > a.discount.min_amount) {
           return 1;
         }
         return 0;
       });
-    // prevent applying duplicated kit discount for same items
+      // prevent applying duplicated kit discount for same items
     let discountedItemIds = [];
     // check buy together recommendations
     const buyTogether = [];
 
-    kitDiscounts.forEach((kitDiscount, index) => {
+    for (let index = 0; index < kitDiscounts.length; index++) {
+      const kitDiscount = kitDiscounts[index];
       if (kitDiscount) {
         const productIds = Array.isArray(kitDiscount.product_ids)
           ? kitDiscount.product_ids
           : [];
-        let kitItems = productIds.length
-          ? params.items.filter((item) => item.quantity && productIds.indexOf(item.product_id) > -1)
-          : params.items.filter((item) => item.quantity);
-        kitItems = kitItems.filter((item) => discountedItemIds.indexOf(item.product_id) === -1);
+        const categoryIds = Array.isArray(kitDiscount.category_ids)
+          ? kitDiscount.category_ids
+          : [];
+        let kitItems = [];
+        if (productIds.length) {
+          kitItems = params.items.filter((item) => productIds.indexOf(item.product_id) > -1);
+        } else if (categoryIds.length) {
+          kitItems = params.items.filter((item) => {
+            if (Array.isArray(item.categories)) {
+              for (let i = 0; i < item.categories.length; i++) {
+                const category = item.categories[i];
+                if (categoryIds.indexOf(category._id) > -1) {
+                  return true;
+                }
+              }
+            }
+            return false;
+          });
+        } else {
+          kitItems = [...params.items];
+        }
+        // eslint-disable-next-line no-loop-func
+        kitItems = kitItems.filter((item) => {
+          return item.quantity && discountedItemIds.indexOf(item.product_id) === -1;
+        });
         if (!kitItems.length) {
-          return;
+          continue;
         }
 
         const recommendBuyTogether = () => {
           if (
             params.items.length === 1
-            && productIds.length <= 4
-            && buyTogether.length < 300
+              && productIds.length <= 4
+              && buyTogether.length < 300
           ) {
             const baseProductId = params.items[0].product_id;
             if (productIds.indexOf(baseProductId) === -1) {
@@ -145,8 +362,8 @@ export default async ({ params, application }) => {
               buyTogether.push({
                 products: buyTogetherProducts,
                 discount: {
-                  type: kitDiscount.discount.type,
-                  value: kitDiscount.discount.value,
+                  type: kitDiscount.originalDiscount?.type || kitDiscount.discount.type,
+                  value: kitDiscount.originalDiscount?.value || kitDiscount.discount.value,
                 },
               });
             }
@@ -166,18 +383,25 @@ export default async ({ params, application }) => {
             if (totalQuantity < kitDiscount.min_quantity) {
               if (productIds.length > 1 && kitDiscount.check_all_items !== false) {
                 recommendBuyTogether();
-                return;
               }
-              return;
+              continue;
             }
-            if (discount.type === 'fixed' && kitDiscount.cumulative_discount !== false) {
+            if (
+              discount.type === 'fixed'
+                && kitDiscount.cumulative_discount !== false
+                && !kitDiscount.usage_limit
+            ) {
               discount.value *= Math.floor(totalQuantity / kitDiscount.min_quantity);
             }
           }
         }
 
-        if (!params.amount || !(discount.min_amount > params.amount.total)) {
+        if (
+          !params.amount
+            || !(discount.min_amount > params.amount.total - getFreebiesPreview().value)
+        ) {
           if (kitDiscount.check_all_items !== false) {
+            let isSkip = false;
             for (let i = 0; i < productIds.length; i++) {
               const productId = productIds[i];
               if (
@@ -186,99 +410,103 @@ export default async ({ params, application }) => {
               ) {
                 // product not on current cart
                 recommendBuyTogether();
-                return;
+                isSkip = true;
+                break;
+              }
+            }
+            if (categoryIds.length) {
+              for (let i = 0; i < kitItems.length; i++) {
+                const { categories } = kitItems[i];
+                let hasListedCategory = false;
+                if (categories) {
+                  for (let ii = 0; ii < categories.length; ii++) {
+                    const category = categories[ii];
+                    if (categoryIds.find((categoryId) => categoryId === category._id)) {
+                      hasListedCategory = true;
+                      continue;
+                    }
+                  }
+                }
+                if (!hasListedCategory) {
+                  recommendBuyTogether();
+                  isSkip = true;
+                  break;
+                }
               }
             }
+            if (isSkip) continue;
           }
-          // apply cumulative discount \o/
-          if (kitDiscount.same_product_quantity) {
-            kitItems.forEach((item, i) => {
-              addDiscount(
-                discount,
-                `KIT-${(index + 1)}-${i}`,
-                kitDiscount.label,
-                ecomUtils.price(item) * (item.quantity || 1),
-              );
-            });
-          } else {
-            addDiscount(discount, `KIT-${(index + 1)}`, kitDiscount.label);
+
+          try {
+            const isAvailable = await checkUsageLimit(kitDiscount);
+            if (isAvailable) {
+              // apply cumulative discount \o/
+              if (kitDiscount.same_product_quantity) {
+                kitItems.forEach((item, i) => {
+                  const discountValue = addDiscount(
+                    discount,
+                    `KIT-${(index + 1)}-${i}`,
+                    kitDiscount.label,
+                    ecomUtils.price(item) * (item.quantity || 1),
+                  );
+                  pointDiscountToSku(discountValue, item.sku);
+                });
+              } else {
+                const discountValue = addDiscount(discount, `KIT-${(index + 1)}`, kitDiscount.label);
+                pointDiscountToEachItem(discountValue, kitItems);
+              }
+              discountedItemIds = discountedItemIds.concat(kitItems.map((item) => item.product_id));
+            }
+          } catch (err) {
+            return {
+              error: 'CANT_CHECK_USAGE_LIMITS',
+              message: err.message,
+            };
           }
-          discountedItemIds = discountedItemIds.concat(kitItems.map((item) => item.product_id));
         }
       }
-    });
+    }
     if (buyTogether.length) {
       response.buy_together = buyTogether;
     }
+  }
 
-    // gift products (freebies) campaings
-    if (Array.isArray(config.freebies_rules)) {
-      const validFreebiesRules = config.freebies_rules.filter((rule) => {
-        return validateDateRange(rule)
-          && validateCustomerId(rule, params)
-          && checkCampaignProducts(rule.check_product_ids, params)
-          && Array.isArray(rule.product_ids)
-          && rule.product_ids.length;
+  // additional discount coupons for API manipualation with
+  // PATCH https://api.e-com.plus/v1/applications/<discounts_app_id>/hidden_data.json { COUPON }
+  if (!config.discount_rules) {
+    config.discount_rules = [];
+  }
+  Object.keys(config).forEach((configField) => {
+    switch (configField) {
+      case 'freebies_rules':
+      case 'product_kit_discounts':
+      case 'discount_rules':
+        return;
+      default:
+    }
+    const configObj = config[configField];
+    if (configObj && configObj.discount) {
+      config.discount_rules.push({
+        ...configObj,
+        discount_coupon: configField,
       });
-      if (validFreebiesRules) {
-        let subtotal = 0;
-        params.items.forEach((item) => {
-          subtotal += (item.quantity * ecomUtils.price(item));
-        });
-
-        let bestRule;
-        let discountValue = 0;
-        for (let i = 0; i < validFreebiesRules.length; i++) {
-          const rule = validFreebiesRules[i];
-          // start calculating discount
-          let value = 0;
-          rule.product_ids.forEach((productId) => {
-            const item = params.items.find((_item) => productId === _item.product_id);
-            if (item) {
-              value += ecomUtils.price(item);
-            }
-          });
-          const fixedSubtotal = subtotal - value;
-          if (!bestRule || value > discountValue || bestRule.min_subtotal < rule.min_subtotal) {
-            if (!(rule.min_subtotal > fixedSubtotal)) {
-              bestRule = rule;
-              discountValue = value;
-            } else if (!discountValue && subtotal >= rule.min_subtotal) {
-              // discount not applicable yet but additional freebies are available
-              bestRule = rule;
-            }
-          }
-        }
-
-        if (bestRule) {
-          // provide freebie products \o/
-          response.freebie_product_ids = bestRule.product_ids;
-          if (discountValue) {
-            addDiscount(
-              {
-                type: 'fixed',
-                value: discountValue,
-              },
-              'FREEBIES',
-              bestRule.label,
-            );
-          }
-        }
-      }
     }
-  }
+  });
 
   const discountRules = getValidDiscountRules(config.discount_rules, params);
   if (discountRules.length) {
     const { discountRule, discountMatchEnum } = matchDiscountRule(discountRules, params);
     if (discountRule) {
-      if (!checkCampaignProducts(discountRule.product_ids, params)) {
-        return {
-          available_extra_discount: response.available_extra_discount,
-          invalid_coupon_message: params.lang === 'pt_br'
-            ? 'Nenhum produto da promoção está incluído no carrinho'
-            : 'No promotion products are included in the cart',
-        };
+      const {
+        valid: isValidByItems,
+        items: filteredItems,
+      } = mapCampaignProducts(discountRule, params);
+      if (!isValidByItems) {
+        addFreebies();
+        response.invalid_coupon_message = params.lang === 'pt_br'
+          ? 'Nenhum produto da promoção está incluído no carrinho'
+          : 'No promotion products are included in the cart';
+        return respondSuccess();
       }
 
       const excludedProducts = discountRule.excluded_product_ids;
@@ -287,64 +515,104 @@ export default async ({ params, application }) => {
         for (let i = 0; i < params.items.length; i++) {
           const item = params.items[i];
           if (item.quantity && excludedProducts.includes(item.product_id)) {
-            return {
-              available_extra_discount: response.available_extra_discount,
-              invalid_coupon_message: params.lang === 'pt_br'
-                ? `Promoção é inválida para o produto ${item.name}`
-                : `Invalid promotion for product ${item.name}`,
-            };
+            addFreebies();
+            response.invalid_coupon_message = params.lang === 'pt_br'
+              ? `Promoção é inválida para o produto ${item.name}`
+              : `Invalid promotion for product ${item.name}`;
+            return respondSuccess();
           }
         }
       }
 
-      let { label } = discountRule;
       const { discount } = discountRule;
+      let { label } = discountRule;
       if (typeof label !== 'string' || !label) {
         label = params.discount_coupon || `DISCOUNT ${discountMatchEnum}`;
       }
       if (
         discount.apply_at !== 'freight'
-        && (!response.available_extra_discount || !response.available_extra_discount.value
-          || discountRule.default_discount === true || checkOpenPromotion(discountRule))
+          && (!response.available_extra_discount || !response.available_extra_discount.value
+            || discountRule.default_discount === true || checkOpenPromotion(discountRule))
       ) {
         // show current discount rule as available discount to apply
         response.available_extra_discount = {
           label: label.substring(0, 50),
+          type: discount.type,
         };
-        ['min_amount', 'type', 'value'].forEach((field) => {
+        ['min_amount', 'value'].forEach((field) => {
           if (discount[field]) {
-            response.available_extra_discount[field] = discount[field];
+            response.available_extra_discount[field] = Number(discount[field]);
           }
         });
       }
 
       // params object follows list payments request schema:
       // https://apx-mods.e-com.plus/api/v1/apply_discount/schema.json?store_id=100
+      let checkAmount;
+      if (params.amount) {
+        checkAmount = params.amount[discountRule.discount.amount_field || 'total'];
+        if (discountRule.discount.amount_field !== 'freight') {
+          checkAmount -= getFreebiesPreview().value;
+        }
+      }
       if (
         params.amount && params.amount.total > 0
-        && !(discountRule.discount.min_amount > params.amount[discountRule.discount.amount_field || 'total'])
+          && !(discountRule.discount.min_amount > checkAmount)
       ) {
         if (
           discountRule.cumulative_discount === false
-          && (response.discount_rule || params.amount.discount)
+            && (response.discount_rule || params.amount.discount)
         ) {
-          // explain discount can't be applied :(
-          // https://apx-mods.e-com.plus/api/v1/apply_discount/response_schema.json?store_id=100
-          return {
-            invalid_coupon_message: params.lang === 'pt_br'
+          if (
+            response.discount_rule?.extra_discount
+              && !params.amount.discount
+              && getDiscountValue(discount) > response.discount_rule.extra_discount.value
+          ) {
+            // replace discount with new bigger one
+            delete response.discount_rule;
+          } else {
+            // explain discount can't be applied :(
+            // https://apx-mods.e-com.plus/api/v1/apply_discount/response_schema.json?store_id=100
+            addFreebies();
+            response.invalid_coupon_message = params.lang === 'pt_br'
               ? 'A promoção não pôde ser aplicada porque este desconto não é cumulativo'
-              : 'This discount is not cumulative',
-          };
+              : 'This discount is not cumulative';
+            return respondSuccess();
+          }
         }
 
         // we have a discount to apply \o/
-        if (addDiscount(discountRule.discount, discountMatchEnum)) {
+        const discountValue = addDiscount(discountRule.discount, discountMatchEnum);
+        if (discountValue) {
+          if (filteredItems?.length) {
+            pointDiscountToEachItem(discountValue, filteredItems);
+          }
           // add discount label and description if any
           response.discount_rule.label = label;
           if (discountRule.description) {
             response.discount_rule.description = discountRule.description;
           }
           if (!checkOpenPromotion(discountRule)) {
+            if (discountRule.cumulative_discount !== false) {
+              // check for additional same-rule discount on different amount
+              const {
+                discountRule: secondDiscountRule,
+                discountMatchEnum: secondDiscountMatchEnum,
+              } = matchDiscountRule(discountRules, params, discountRule.discount.apply_at || 'total');
+              if (secondDiscountRule) {
+                let _checkAmount = params.amount[secondDiscountRule.discount.amount_field || 'total'];
+                if (secondDiscountRule.discount.amount_field !== 'freight') {
+                  _checkAmount -= getFreebiesPreview().value;
+                }
+                if (
+                  secondDiscountRule.cumulative_discount !== false
+                    && !(secondDiscountRule.discount.min_amount > _checkAmount)
+                ) {
+                  addDiscount(secondDiscountRule.discount, secondDiscountMatchEnum + '-2');
+                }
+              }
+            }
+
             // check for additional open discount
             const {
               discountRule: openDiscountRule,
@@ -352,78 +620,47 @@ export default async ({ params, application }) => {
             } = matchDiscountRule(discountRules, {});
             if (
               openDiscountRule
-              && openDiscountRule.cumulative_discount !== false
-              && openDiscountRule.discount.min_amount
+                && openDiscountRule.cumulative_discount !== false
+                && openDiscountRule.discount.min_amount
             ) {
-              let checkAmount = params.amount[openDiscountRule.discount.amount_field || 'total'];
-              if (checkAmount) {
+              let _checkAmount = params.amount[openDiscountRule.discount.amount_field || 'total'];
+              if (_checkAmount) {
                 // subtract current discount to validate cumulative open discount min amount
                 if (response.discount_rule) {
-                  checkAmount -= response.discount_rule.extra_discount.value;
+                  _checkAmount -= response.discount_rule.extra_discount.value;
                 }
-                if (openDiscountRule.discount.min_amount <= checkAmount) {
+                if (openDiscountRule.discount.amount_field !== 'freight') {
+                  _checkAmount -= getFreebiesPreview().value;
+                }
+                if (openDiscountRule.discount.min_amount <= _checkAmount) {
                   addDiscount(openDiscountRule.discount, openDiscountMatchEnum);
                 }
               }
             }
           }
 
-          const { customer } = params;
-          if (
-            customer && (customer._id || customer.doc_number)
-            && (discountRule.usage_limit > 0 || discountRule.total_usage_limit > 0)
-          ) {
-            // list orders to check discount usage limits
-            // eslint-disable-next-line prefer-template
-            const endpoint = 'orders?fields=status'
-              + `&extra_discount.app.label${(discountRule.case_insensitive ? '%=' : '=')}`
-              + encodeURIComponent(label);
-            const usageLimits = [{
-              // limit by customer
-              query: customer.doc_number
-                ? `&buyers.doc_number=${customer.doc_number}`
-                : `&buyers._id=${customer._id}`,
-              max: discountRule.usage_limit,
-            }, {
-              // total limit
-              query: '',
-              max: discountRule.total_usage_limit,
-            }];
-            for (let i = 0; i < usageLimits.length; i++) {
-              const { query, max } = usageLimits[i];
-              if (max) {
-                let countOrders;
-                try {
-                  // send Store API request to list orders with filters
-                  // eslint-disable-next-line no-await-in-loop
-                  const { data } = await api.get(`${endpoint}${query}`);
-                  countOrders = data.result
-                    .filter(({ status }) => status !== 'cancelled')
-                    .length;
-                } catch (err) {
-                  return {
-                    error: 'CANT_CHECK_USAGE_LIMITS',
-                    message: err.message,
-                  };
-                }
-
-                if (countOrders >= max) {
-                  // limit reached
-                  return {
-                    invalid_coupon_message: params.lang === 'pt_br'
-                      ? 'A promoção não pôde ser aplicada porque já atingiu o limite de usos'
-                      : 'The promotion could not be applied because it has already reached the usage limit',
-                  };
-                }
-              }
+          try {
+            const isAvailable = await checkUsageLimit(discountRule, label);
+            if (!isAvailable) {
+              delete response.discount_rule;
+              response.invalid_coupon_message = params.lang === 'pt_br'
+                ? 'A promoção não pôde ser aplicada porque já atingiu o limite de usos'
+                : 'The promotion could not be applied because it has already reached the usage limit';
             }
+            addFreebies();
+            return respondSuccess();
+          } catch (err) {
+            return {
+              error: 'CANT_CHECK_USAGE_LIMITS',
+              message: err.message,
+            };
           }
-          return respondSuccess();
         }
       }
     }
   }
 
+  addFreebies();
   // response with no error nor discount applied
   return respondSuccess();
 };

package/lib-mjs/helpers.mjs

@@ -1,3 +1,4 @@
+/* eslint-disable default-param-last, no-use-before-define */
 import ecomUtils from '@ecomplus/utils';
 
 const validateDateRange = (rule) => {
@@ -15,6 +16,19 @@ const validateDateRange = (rule) => {
 };
 
 const validateCustomerId = (rule, params) => {
+  if (
+    typeof rule.customer_ids === 'object'
+    && rule.customer_ids
+    && !Array.isArray(rule.customer_ids)
+  ) {
+    const customerIds = [];
+    Object.keys(rule.customer_ids).forEach((key) => {
+      if (rule.customer_ids[key]) {
+        customerIds.push(rule.customer_ids[key]);
+      }
+    });
+    rule.customer_ids = customerIds;
+  }
   if (
     Array.isArray(rule.customer_ids)
     && rule.customer_ids.length
@@ -26,27 +40,74 @@ const validateCustomerId = (rule, params) => {
   return true;
 };
 
+const matchFreebieRule = (rule, params = {}) => {
+  const coupon = params.discount_coupon;
+  const utm = params.utm && params.utm.campaign;
+  if (rule.domain && rule.domain !== params.domain) {
+    if (params.domain !== `${rule.domain}.skip-open`) {
+      return false;
+    }
+  }
+  if (rule.freebie_coupon && rule.freebie_utm) {
+    return coupon?.toUpperCase() === rule.freebie_coupon?.toUpperCase()
+      || (utm?.toUpperCase() === rule.freebie_utm?.toUpperCase());
+  }
+  if (rule.freebie_coupon) {
+    return coupon?.toUpperCase() === rule.freebie_coupon?.toUpperCase();
+  }
+  if (rule.freebie_utm) {
+    return (utm?.toUpperCase() === rule.freebie_utm?.toUpperCase());
+  }
+  return true;
+};
+
 const checkOpenPromotion = (rule) => {
   return !rule.discount_coupon && !rule.utm_campaign
     && (!Array.isArray(rule.customer_ids) || !rule.customer_ids.length);
 };
 
-const getValidDiscountRules = (discountRules, params, items) => {
+const getValidDiscountRules = (discountRules, params, itemsForKit) => {
   if (Array.isArray(discountRules) && discountRules.length) {
     // validate rules objects
     return discountRules.filter((rule) => {
       if (!rule || !validateCustomerId(rule, params)) {
         return false;
       }
-
-      if (Array.isArray(rule.product_ids) && Array.isArray(items)) {
+      const isKitDiscount = Array.isArray(itemsForKit)
+        && (Array.isArray(rule.product_ids) || Array.isArray(rule.category_ids));
+      if (rule.domain && rule.domain !== params.domain) {
+        if (params.domain === `${rule.domain}.skip-open`) {
+          if (!isKitDiscount && checkOpenPromotion(rule)) return false;
+        } else {
+          return false;
+        }
+      }
+      if (isKitDiscount) {
         const checkProductId = (item) => {
-          return (!rule.product_ids.length || rule.product_ids.indexOf(item.product_id) > -1);
+          if (
+            !(rule.product_ids && rule.product_ids.length)
+            && Array.isArray(rule.category_ids)
+            && rule.category_ids.length
+          ) {
+            if (Array.isArray(item.categories)) {
+              for (let i = 0; i < item.categories.length; i++) {
+                const category = item.categories[i];
+                if (rule.category_ids.indexOf(category._id) > -1) {
+                  return true;
+                }
+              }
+            }
+            return false;
+          }
+          return (
+            !(rule.product_ids && rule.product_ids.length)
+            || rule.product_ids.indexOf(item.product_id) > -1
+          );
         };
         // set/add discount value from lowest item price
         let value;
         if (rule.discount_lowest_price) {
-          items.forEach((item) => {
+          itemsForKit.forEach((item) => {
             const price = ecomUtils.price(item);
             if (price > 0 && checkProductId(item) && (!value || value > price)) {
               value = price;
@@ -54,7 +115,7 @@ const getValidDiscountRules = (discountRules, params, items) => {
           });
         } else if (rule.discount_kit_subtotal) {
           value = 0;
-          items.forEach((item) => {
+          itemsForKit.forEach((item) => {
             const price = ecomUtils.price(item);
             if (price > 0 && checkProductId(item)) {
               value += price * item.quantity;
@@ -71,6 +132,7 @@ const getValidDiscountRules = (discountRules, params, items) => {
               value = Math.min(value, rule.discount.value);
             }
           }
+          rule.originalDiscount = rule.discount;
           rule.discount = {
             ...rule.discount,
             type: 'fixed',
@@ -81,21 +143,31 @@ const getValidDiscountRules = (discountRules, params, items) => {
       if (!rule.discount || !rule.discount.value) {
         return false;
       }
-
       return validateDateRange(rule);
     });
   }
-
   // returns array anyway
   return [];
 };
 
-const matchDiscountRule = (discountRules, params = {}) => {
+const matchDiscountRule = (_discountRules, params = {}, skipApplyAt) => {
+  const validItemsDiscountRules = _discountRules.filter((rule) => {
+    return mapCampaignProducts(rule, params).valid;
+  });
+  const discountRules = validItemsDiscountRules.length
+    ? validItemsDiscountRules
+    : _discountRules;
+  const filteredRules = skipApplyAt
+    ? discountRules.filter((rule) => {
+      const applyAt = (rule.discount && rule.discount.apply_at) || 'total';
+      return applyAt !== skipApplyAt;
+    })
+    : discountRules;
   // try to match a promotion
   if (params.discount_coupon) {
     // match only by discount coupon
     return {
-      discountRule: discountRules.find((rule) => {
+      discountRule: filteredRules.find((rule) => {
         return rule.case_insensitive
           ? typeof rule.discount_coupon === 'string'
             && rule.discount_coupon.toUpperCase() === params.discount_coupon.toUpperCase()
@@ -104,10 +176,9 @@ const matchDiscountRule = (discountRules, params = {}) => {
       discountMatchEnum: 'COUPON',
     };
   }
-
   // try to match by UTM campaign first
   if (params.utm && params.utm.campaign) {
-    const discountRule = discountRules.find((rule) => {
+    const discountRule = filteredRules.find((rule) => {
       return rule.case_insensitive
         ? typeof rule.utm_campaign === 'string'
           && rule.utm_campaign.toUpperCase() === params.utm.campaign.toUpperCase()
@@ -120,11 +191,12 @@ const matchDiscountRule = (discountRules, params = {}) => {
       };
     }
   }
-
   // then try to match by customer
   if (params.customer && params.customer._id) {
-    const discountRule = discountRules.find((rule) => Array.isArray(rule.customer_ids)
-      && rule.customer_ids.indexOf(params.customer._id) > -1);
+    const discountRule = filteredRules.find((rule) => {
+      return Array.isArray(rule.customer_ids)
+      && rule.customer_ids.indexOf(params.customer._id) > -1;
+    });
     if (discountRule) {
       return {
         discountRule,
@@ -132,31 +204,59 @@ const matchDiscountRule = (discountRules, params = {}) => {
       };
     }
   }
-
+  // then try to match by domain
+  if (params.domain) {
+    const discountRule = filteredRules.find((rule) => {
+      return rule.domain === params.domain || params.domain === `${rule.domain}.skip-open`;
+    });
+    if (discountRule) {
+      return {
+        discountRule,
+        discountMatchEnum: 'DOMAIN',
+      };
+    }
+  }
   // last try to match by open promotions
   return {
-    discountRule: discountRules.find(checkOpenPromotion),
+    discountRule: filteredRules.find(checkOpenPromotion),
     discountMatchEnum: 'OPEN',
   };
 };
 
-const checkCampaignProducts = (campaignProducts, params) => {
-  if (Array.isArray(campaignProducts) && campaignProducts.length) {
-    // must check at least one campaign product on cart
-    let hasProductMatch;
-    if (params.items && params.items.length) {
-      for (let i = 0; i < campaignProducts.length; i++) {
-        if (params.items.find((item) => item.quantity && item.product_id === campaignProducts[i])) {
-          hasProductMatch = true;
-          break;
+const mapCampaignProducts = (rule, params) => {
+  if (Array.isArray(rule.product_ids) && rule.product_ids.length) {
+    const items = params.items?.filter((item) => {
+      return item.quantity && rule.product_ids.includes(item.product_id);
+    }) || [];
+    return { valid: items.length, items };
+  }
+  if (Array.isArray(rule.category_ids) && rule.category_ids.length) {
+    let discountValue = 0;
+    const items = params.items?.filter((item) => {
+      const isValidItem = item.quantity && item.categories?.some((category) => {
+        return rule.category_ids.includes(category._id);
+      });
+      if (isValidItem) {
+        const price = ecomUtils.price(item);
+        if (price > 0) {
+          discountValue += (price * item.quantity);
         }
       }
+      return isValidItem;
+    }) || [];
+    // direct "fix" rule discount value limiting by category items
+    if (rule.discount?.value) {
+      if (rule.discount.type === 'percentage') {
+        discountValue *= rule.discount.value / 100;
+      } else {
+        discountValue = Math.min(discountValue, rule.discount.value);
+      }
+      rule.discount.type = 'fixed';
+      rule.discount.value = discountValue;
     }
-    if (!hasProductMatch) {
-      return false;
-    }
+    return { valid: items.length, items };
   }
-  return true;
+  return { valid: true, items: [] };
 };
 
 export {
@@ -165,5 +265,6 @@ export {
   checkOpenPromotion,
   getValidDiscountRules,
   matchDiscountRule,
-  checkCampaignProducts,
+  matchFreebieRule,
+  mapCampaignProducts,
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloudcommerce/app-discounts",
   "type": "module",
-  "version": "2.29.9",
+  "version": "2.29.11",
   "description": "e-com.plus Cloud Commerce app for complex discount rules",
   "main": "lib/discounts.js",
   "files": [
@@ -23,10 +23,10 @@
   "homepage": "https://github.com/ecomplus/cloud-commerce/tree/main/packages/apps/discounts#readme",
   "dependencies": {
     "@ecomplus/utils": "1.5.0-rc.6",
-    "@cloudcommerce/api": "2.29.9"
+    "@cloudcommerce/api": "2.29.11"
   },
   "devDependencies": {
-    "@cloudcommerce/types": "2.29.9"
+    "@cloudcommerce/types": "2.29.11"
   },
   "scripts": {
     "build": "bash ../../../scripts/build-lib.sh"