@darkpos/pricing 1.0.43 → 1.0.44

package/lib/modifier/validate.js

@@ -0,0 +1,14 @@
+module.exports = ({ actions }) => {
+  function validate(modifier, opts) {
+    if (!modifier) return modifier;
+
+    return {
+      ...modifier,
+      conditions: {
+        ...(modifier.conditions || {}),
+        valid: !!actions.areConditionsMet(modifier, opts),
+      },
+    };
+  }
+  return validate;
+};

package/lib/modifier/validateDateDaysDiff.js

@@ -0,0 +1,30 @@
+module.exports = () =>
+  function validateDateDaysDiff(
+    startRequestDate,
+    endRequestDate,
+    conditionNumber,
+    operand
+  ) {
+    if (!conditionNumber && !operand) return true;
+    if (!startRequestDate || !endRequestDate) return false;
+    const diff = Math.abs(
+      new Date(endRequestDate) - new Date(startRequestDate)
+    );
+    const diffDays = Math.ceil(diff / (1000 * 60 * 60 * 24));
+    switch (operand) {
+      case '$eq':
+        return diffDays === conditionNumber;
+      case '$ne':
+        return diffDays !== conditionNumber;
+      case '$gt':
+        return diffDays > conditionNumber;
+      case '$gte':
+        return diffDays >= conditionNumber;
+      case '$lt':
+        return diffDays < conditionNumber;
+      case '$lte':
+        return diffDays <= conditionNumber;
+      default:
+        return false;
+    }
+  };

package/lib/modifier/validateInArr.js

@@ -0,0 +1,12 @@
+module.exports = ({ _ }) =>
+  function validateInArr(item, requiredArr, operand) {
+    if (_.isEmpty(requiredArr) && !operand) return true;
+    switch (operand) {
+      case '$in':
+        return requiredArr.some(each => item === each);
+      case '$nin':
+        return requiredArr.every(each => item !== each);
+      default:
+        return false;
+    }
+  };

package/lib/modifier/validateNumberCondition.js

@@ -0,0 +1,20 @@
+module.exports = () =>
+  function validateNumberCondition(itemNumber, conditionNumber, operand) {
+    if (!conditionNumber && !operand) return true;
+    switch (operand) {
+      case '$eq':
+        return Number(conditionNumber) === itemNumber;
+      case '$ne':
+        return Number(conditionNumber) !== itemNumber;
+      case '$gt':
+        return Number(conditionNumber) < itemNumber;
+      case '$gte':
+        return Number(conditionNumber) <= itemNumber;
+      case '$lt':
+        return Number(conditionNumber) > itemNumber;
+      case '$lte':
+        return Number(conditionNumber) >= itemNumber;
+      default:
+        return false;
+    }
+  };

package/lib/modifier/validateRequiredModifiers.js

@@ -0,0 +1,16 @@
+module.exports = ({ actions, _ }) =>
+  function validateRequiredModifiers(modifiers, requiredModifiers, operand) {
+    if (_.isEmpty(requiredModifiers) && !operand) return true;
+    switch (operand) {
+      case '$in':
+        return requiredModifiers.some(each =>
+          actions.contains(modifiers, each)
+        );
+      case '$nin':
+        return requiredModifiers.every(
+          each => !actions.contains(modifiers, each)
+        );
+      default:
+        return false;
+    }
+  };

package/lib/order/addItemModifier.js

@@ -27,31 +27,71 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     return false;
   };
 
-  const validateItemPiecesCondition = (itemPieces, minPieces) => {
-    if (!minPieces) return true;
-    return minPieces <= itemPieces;
-  };
-
-  const validateItemQtyCondition = (itemQuantity, minQuantity) => {
-    if (!minQuantity) return true;
-    return minQuantity <= itemQuantity;
-  };
-
-  const validateRequiredModifiers = (modifiers, requiredModifiers) => {
-    if (_.isEmpty(modifiers) || _.isEmpty(requiredModifiers)) return true;
-    return requiredModifiers.every(each =>
-      modifierActions.contains(modifiers, each)
-    );
-  };
-
   const areConditionsMet = (item, conditions) => {
-    if (!conditions) return true;
-
-    return (
-      validateItemPiecesCondition(item.pieces, conditions.minItemPieces) &&
-      validateItemQtyCondition(item.quantity, conditions.minItemQuantity) &&
-      validateRequiredModifiers(item.modifiers, conditions.modifiers)
+    const conditionsBag = [];
+    if (!conditions || !conditions.rules) return conditionsBag;
+    // Find conditions with itemPieces as key
+    const itemPiecesConditions = conditions.rules.filter(
+      each => each.key === 'itemPieces'
     );
+    if (itemPiecesConditions.length > 0) {
+      itemPiecesConditions.forEach(each => {
+        if (
+          !modifierActions.validateNumberCondition(
+            item.pieces,
+            each.value,
+            each.operand
+          )
+        ) {
+          conditionsBag.push({
+            name: `${each.operand}.itemPieces`,
+            value: each.value,
+            current: item.pieces,
+          });
+        }
+      });
+    }
+    const itemQtyConditions = conditions.rules.filter(
+      each => each.key === 'itemQuantity'
+    );
+    if (itemQtyConditions.length > 0) {
+      itemQtyConditions.forEach(each => {
+        if (
+          !modifierActions.validateNumberCondition(
+            item.quantity,
+            each.value,
+            each.operand
+          )
+        ) {
+          conditionsBag.push({
+            name: `${each.operand}.itemQuantity`,
+            value: each.value,
+            current: item.quantity,
+          });
+        }
+      });
+    }
+    const requiredModifiersConditions = conditions.rules.filter(
+      each => each.key === 'modifiers'
+    );
+    if (requiredModifiersConditions.length > 0) {
+      requiredModifiersConditions.forEach(each => {
+        if (
+          !modifierActions.validateRequiredModifiers(
+            item.modifiers,
+            each.value,
+            each.operand
+          )
+        ) {
+          conditionsBag.push({
+            name: `${each.operand}.modifiers`,
+            value: each.value,
+            current: item.modifiers,
+          });
+        }
+      });
+    }
+    return conditionsBag;
   };
 
   const addModifier = ({
@@ -63,19 +103,21 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
       items: [],
       itemModifiers: [],
     },
+    onConditionsNotMet,
   }) => {
     const modifier = _modifier; // to avoid no param reassign lint rule
     let item = { ...itemProp };
     const compute = getComputeModField(modifier);
     if (hasBehaivoralFields(modifier)) return item;
-    // check conditions
-    if (!areConditionsMet(item, modifier.conditions)) return item;
+    const conditionsBag = areConditionsMet(item, modifier.conditions);
     const isAmountOverride = modifierActions.isAmountOverride(modifier);
     const isPriceOverride = modifierActions.isPriceOverride(modifier);
-
-    // change modifier compute based on onverride and creates a clone of  the modifier
+    // is the modifier suggestion required
+    if (conditionsBag.length > 0 && !modifierActions.isRequired(modifier)) {
+      if (onConditionsNotMet) onConditionsNotMet(conditionsBag);
+      return item;
+    }
     const modifierToAdd = modifierActions.mutateModifier(modifier);
-
     const modifierIndex = item.modifiers.findIndex(
       ieach => ieach.modifierId === modifier._id
     );
@@ -122,6 +164,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     modifier,
     itemIndex,
     cache,
+    onConditionsNotMet,
   }) {
     let order = _.cloneDeep(orderProp);
     if (!order || itemIndex < 0 || !modifier) return order;
@@ -166,6 +209,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
       modifier,
       cache,
       customer,
+      onConditionsNotMet,
     });
 
     // Recursive Rules:

package/lib/order/calculate.js

@@ -3,18 +3,23 @@
  * return calculated Order
  */
 module.exports = ({ _, actions, itemActions, modifierActions }) =>
-  function calculateorder(inputOrder) {
+  function calculateorder(inputOrder, opts = {}) {
     if (!inputOrder) return inputOrder;
     const order = _.cloneDeep(inputOrder);
     const { items = [], orders = [] } = order;
-
     if (!items.length) {
       if (!orders.length)
         return { ...order, subTotals: {}, subTotal: 0, total: 0 };
 
       return { ...order, ...actions.getTotals(order.orders) };
     }
-
+    const startRequestDate = order.start ? order.start.requestDate : null;
+    const endRequestDate = order.end ? order.end.requestDate : null;
+    const options = {
+      ...opts,
+      startRequestDate,
+      endRequestDate,
+    };
     const sortedOrderModifiers = modifierActions.sort(
       modifierActions.removeLocked(order.modifiers)
     );
@@ -23,7 +28,7 @@ module.exports = ({ _, actions, itemActions, modifierActions }) =>
       itemActions.removeModifiers({ item, modifiers: sortedOrderModifiers })
     );
 
-    itemsWNIM = itemActions.calculate(itemsWNIM);
+    itemsWNIM = itemActions.calculate(itemsWNIM, options);
 
     const newOrder = {
       ...order,
@@ -55,11 +60,11 @@ module.exports = ({ _, actions, itemActions, modifierActions }) =>
         } else {
           tempItems = itemsWIM;
         }
-        tempItems = itemActions.calculate(tempItems);
+        tempItems = itemActions.calculate(tempItems, options);
       }
 
       if (isCredit) {
-        const calculatedItemWIM = itemActions.calculate(itemsWIM);
+        const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
         computedTotal = itemActions.getTotals(calculatedItemWIM).total;
       }
 
@@ -92,7 +97,7 @@ module.exports = ({ _, actions, itemActions, modifierActions }) =>
       prvSort = sort;
     }
 
-    const calculatedItemWIM = itemActions.calculate(itemsWIM);
+    const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
 
     return {
       ...order,

package/lib/order/index.js

@@ -72,7 +72,6 @@ const getItemIndex = require('./getItemIndex');
 const getRelatedItems = require('./getRelatedItems');
 const getItemByItemId = require('./getItemByItemId');
 const getScheduleByCustomer = require('./getScheduleByCustomer');
-const pickEndDate = require('./pickEndDate');
 const getAppliedCredit = require('./getAppliedCredit');
 const addCreditModifier = require('./addCreditModifier');
 const adjustCreditModifiersDifference = require('./adjustCreditModifiersDifference');
@@ -172,7 +171,6 @@ const orderActions = (deps = {}) => {
     getItemIndex: getItemIndex(innerDeps),
     getRelatedItems: getRelatedItems(innerDeps),
     getScheduleByCustomer: getScheduleByCustomer(innerDeps),
-    pickEndDate: pickEndDate(innerDeps),
     getAppliedCredit: getAppliedCredit(innerDeps),
     addCreditModifier: addCreditModifier(innerDeps),
     adjustCreditModifiersDifference: adjustCreditModifiersDifference(innerDeps),

package/lib/order/removeModifiersWithPaymentMethods.js

@@ -1,8 +1,7 @@
 module.exports = () => {
   const hasPaymentMethods = modifier =>
     modifier.conditions &&
-    Array.isArray(modifier.conditions.paymentMethods) &&
-    modifier.conditions.paymentMethods.length;
+    modifier.conditions.some(condition => condition.key === 'paymentMethods');
 
   return function removeModifiersWithPaymentMethods({
     order,

package/lib/order/removeModifiersWithPaymentTypes.js

@@ -1,8 +1,7 @@
 module.exports = () => {
   const hasPaymentTypes = modifier =>
     modifier.conditions &&
-    Array.isArray(modifier.conditions.paymentTypes) &&
-    modifier.conditions.paymentTypes.length;
+    modifier.conditions.some(condition => condition.key === 'paymentMethods');
 
   return function removeModifiersWithPaymentTypes({
     order,

package/lib/store/getRecommendedEndDate.js

@@ -0,0 +1,13 @@
+module.exports = ({ actions, settings }) =>
+  function getRecommendedEndDate() {
+    const defaultSchedule =
+      settings.order &&
+      settings.order.endDate &&
+      settings.order.endDate.default;
+
+    return defaultSchedule
+      ? actions.pickEndDate({
+          ...defaultSchedule,
+        })
+      : null;
+  };

package/lib/store/index.js

@@ -0,0 +1,25 @@
+//
+const pickEndDate = require('./pickEndDate');
+const getRecommendedEndDate = require('./getRecommendedEndDate');
+
+const storeActions = (deps = {}) => {
+  const actions = {};
+
+  const innerDeps = {
+    ...deps,
+    actions,
+  };
+
+  const freezedActions = Object.freeze({
+    pickEndDate: pickEndDate(innerDeps),
+    getRecommendedEndDate: getRecommendedEndDate(innerDeps),
+  });
+
+  Object.keys(freezedActions).forEach(actionName => {
+    actions[actionName] = freezedActions[actionName];
+  });
+
+  return freezedActions;
+};
+
+module.exports = storeActions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.43",
+  "version": "1.0.44",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -13,7 +13,7 @@
   "scripts": {
     "test": "jest --runInBand --detectOpenHandles --logHeapUsage --verbose --forceExit ./__TEST__",
     "test:me": "jest --runInBand --detectOpenHandles --logHeapUsage --verbose --forceExit",
-    "lint": "eslint --quiet --fix lib/"
+    "lint": "eslint --quiet --fix lib/ __TEST__/"
   },
   "publishConfig": {
     "access": "public"
@@ -36,5 +36,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "60a1eef3eb458c750cda95b701904c8ea7e68157"
+  "gitHead": "9237aef8561cbdf9c29150a0915cf55ff54f3c80"
 }

package/lib/modifier/findByPaymentMethod.js

@@ -1,10 +0,0 @@
-module.exports = ({ actions }) =>
-  function findByPaymentMethod({ modifiers, paymentMethod = '' }) {
-    if (!Array.isArray(modifiers) || !paymentMethod) return null;
-
-    return modifiers.find(
-      each =>
-        actions.isPaymentMethodModifier(each) &&
-        each.conditions.paymentMethods.includes(paymentMethod)
-    );
-  };

package/lib/modifier/findByPaymentType.js

@@ -1,10 +0,0 @@
-module.exports = ({ actions }) =>
-  function findByPaymentType({ modifiers, paymentType = '' }) {
-    if (!Array.isArray(modifiers) || !paymentType) return null;
-
-    return modifiers.find(
-      each =>
-        actions.isPaymentTypeModifier(each) &&
-        each.conditions.paymentTypes.includes(paymentType)
-    );
-  };