@darkpos/pricing 1.0.103 → 1.0.105

package/__TEST__/order/conditionsNotMet.test.js

@@ -1259,4 +1259,369 @@ describe('Conditions not met for the item', () => {
 
     expect(result.modifiers.length).toBe(0);
   });
+
+  test('Should mark modifier as valid if customerTotalSales === 0', () => {
+    const modifier = {
+      _id: '6819114c06c23d37c1f19412',
+      name: 'first order discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'customerTotalSales',
+            value: 0,
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 25,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [],
+    };
+
+    let order = {
+      items: [item],
+      customer: {
+        _id: '123456789',
+        stats: {
+          totalSales: 0,
+          totalVisits: 0,
+        },
+      },
+    };
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    const calculatedOrder = pricingService.order.calculate(order);
+
+    expect(calculatedOrder.total).toBe(7.5);
+    expect(calculatedOrder.items[0].total).toBe(7.5);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].properties.customerId).toBe(
+      '123456789'
+    );
+  });
+
+  test('Should mark modifier as not valid if customerTotalSales !== 0', () => {
+    const modifier = {
+      _id: '6819114c06c23d37c1f19412',
+      name: 'first order discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'customerTotalSales',
+            value: 0,
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 25,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [],
+    };
+
+    let order = {
+      items: [item],
+      customer: {
+        _id: '123456789',
+        stats: {
+          totalSales: 15,
+          totalVisits: 0,
+        },
+      },
+    };
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    const calculatedOrder = pricingService.order.calculate(order);
+
+    expect(calculatedOrder.total).toBe(10);
+    expect(calculatedOrder.items[0].total).toBe(10);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(false);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(undefined);
+  });
+
+  test('Should mark modifier as valid if customerTotalVisits === 0', () => {
+    const modifier = {
+      _id: '6819114c06c23d37c1f19412',
+      name: 'first order discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'customerTotalVisits',
+            value: 0,
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 25,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [],
+    };
+
+    let order = {
+      items: [item],
+      customer: {
+        _id: '123456789',
+        stats: {
+          totalSales: 0,
+          totalVisits: 0,
+        },
+      },
+    };
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    const calculatedOrder = pricingService.order.calculate(order);
+
+    expect(calculatedOrder.total).toBe(7.5);
+    expect(calculatedOrder.items[0].total).toBe(7.5);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].properties.customerId).toBe(
+      '123456789'
+    );
+  });
+
+  test('Should mark modifier as not valid if customerTotalVisits !== 0', () => {
+    const modifier = {
+      _id: '6819114c06c23d37c1f19412',
+      name: 'first order discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'customerTotalVisits',
+            value: 0,
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 25,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [],
+    };
+
+    let order = {
+      items: [item],
+      customer: {
+        _id: '123456789',
+        stats: {
+          totalSales: 0,
+          totalVisits: 15,
+        },
+      },
+    };
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    const calculatedOrder = pricingService.order.calculate(order);
+
+    expect(calculatedOrder.total).toBe(10);
+    expect(calculatedOrder.items[0].total).toBe(10);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(false);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(undefined);
+  });
+
+  test('Should mark modifier as not valid if there is no customer', () => {
+    const modifier = {
+      _id: '6819114c06c23d37c1f19412',
+      name: 'first order discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'customerTotalVisits',
+            value: 0,
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 25,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [],
+    };
+
+    let order = {
+      items: [item],
+    };
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    const calculatedOrder = pricingService.order.calculate(order);
+
+    expect(calculatedOrder.total).toBe(10);
+    expect(calculatedOrder.items[0].total).toBe(10);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(false);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(undefined);
+    expect(calculatedOrder.items[0].modifiers[0].properties).toBe(undefined);
+  });
+
+  test('Should mark modifier as valid if there is a customer, no matter is stats is undefined', () => {
+    const modifier = {
+      _id: '6819114c06c23d37c1f19412',
+      name: 'first order discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'customerTotalVisits',
+            value: 0,
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 25,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [],
+    };
+
+    let order = {
+      items: [item],
+      customer: {
+        _id: 'abcd1234',
+      },
+    };
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    let calculatedOrder = pricingService.order.calculate(order);
+
+    expect(calculatedOrder.total).toBe(7.5);
+    expect(calculatedOrder.items[0].total).toBe(7.5);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].properties.customerId).toBe(
+      'abcd1234'
+    );
+
+    calculatedOrder = pricingService.order.calculate({
+      ...calculatedOrder,
+      customer: {
+        _id: '11122555',
+        stats: {
+          totalVisits: 15,
+        },
+      },
+    });
+
+    expect(calculatedOrder.total).toBe(10);
+    expect(calculatedOrder.items[0].total).toBe(10);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(false);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(false);
+    expect(calculatedOrder.items[0].modifiers[0].properties.customerId).toBe(
+      undefined
+    );
+  });
 });

package/lib/item/calculate.js

@@ -12,6 +12,8 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
     const isPrepay = opts.isPrepay || false;
     const startRequestDate = opts.startRequestDate || null;
     const endRequestDate = opts.endRequestDate || null;
+    const customer = opts.customer || null;
+
     const lockPaymentModifiers = !!opts.lockPaymentModifiers;
     const allItems = Array.isArray(opts.items) ? opts.items : [];
 
@@ -43,16 +45,21 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
     subTotals._simple = math.mul(price, quantity);
 
     const modifiers = [];
-    const { modifiers: itemModifiersPrev = [] } =
+    let { modifiers: itemModifiersPrev = [] } =
       actions.removeModifiersByQuantity(item);
 
+    itemModifiersPrev = modifierActions.unlockCustomerStatsModifiers({
+      modifiers: itemModifiersPrev,
+      customer,
+    });
+
     const itemModifiers = [...itemModifiersPrev].filter(
       mod =>
         !modifierActions.isCalculatedPaymentModifier(mod) ||
         modifierActions.isLocked(mod)
     );
 
-    const validatedModifiers = actions.validateModifiers({
+    let validatedModifiers = actions.validateModifiers({
       item,
       itemModifiers,
       startRequestDate,
@@ -61,6 +68,12 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       paymentMethod,
       paymentType,
       isPrepay,
+      customer,
+    });
+
+    validatedModifiers = modifierActions.lockCustomerStatsModifiers({
+      modifiers: validatedModifiers,
+      customer,
     });
 
     const modifiersToCompute = validatedModifiers.filter(

package/lib/item/validateModifiers.js

@@ -8,6 +8,7 @@ module.exports = ({ modifierActions }) =>
     paymentMethod,
     paymentType,
     isPrepay,
+    customer,
   }) {
     const validatedModifiers = [];
     const firstValidatedModifiers = itemModifiers.map(each =>
@@ -19,6 +20,7 @@ module.exports = ({ modifierActions }) =>
         paymentMethod,
         paymentType,
         isPrepay,
+        customer,
       })
     );
 

package/lib/modifier/areConditionsMet.js

@@ -1,4 +1,15 @@
 module.exports = ({ actions, utils }) => {
+  const getCustomerStat = (customer, key) => {
+    if (
+      !customer ||
+      !customer.stats ||
+      typeof customer.stats[key] !== 'number'
+    ) {
+      return 0;
+    }
+    return customer.stats[key];
+  };
+
   const modifierConditionPass = (
     modifier,
     {
@@ -9,6 +20,7 @@ module.exports = ({ actions, utils }) => {
       paymentMethod,
       paymentType,
       isPrepay,
+      customer,
     }
   ) =>
     modifier.conditions && Array.isArray(modifier.conditions.rules)
@@ -83,6 +95,20 @@ module.exports = ({ actions, utils }) => {
                 condition.value,
                 condition.operand
               );
+            case 'customerTotalVisits':
+              if (!actions.isValidCustomer(customer)) return false;
+              return actions.validateNumberCondition(
+                getCustomerStat(customer, 'totalVisits'),
+                condition.value,
+                condition.operand
+              );
+            case 'customerTotalSales':
+              if (!actions.isValidCustomer(customer)) return false;
+              return actions.validateNumberCondition(
+                getCustomerStat(customer, 'totalSales'),
+                condition.value,
+                condition.operand
+              );
             case 'modifiers':
               return actions.validateRequiredModifiers(
                 item.modifiers,
@@ -124,6 +150,7 @@ module.exports = ({ actions, utils }) => {
       paymentMethod,
       paymentType,
       isPrepay,
+      customer,
     } = opts;
     return (
       modifier &&
@@ -135,6 +162,7 @@ module.exports = ({ actions, utils }) => {
         paymentMethod,
         paymentType,
         isPrepay,
+        customer,
       })
     );
   }

package/lib/modifier/index.js

@@ -167,6 +167,12 @@ const isNotesOverride = require('./isNotesOverride');
 const isOverrideSubtotal = require('./isOverrideSubtotal');
 const validatePaymentCondition = require('./validatePaymentCondition');
 const createManualModifier = require('./createManualModifier');
+const isCustomerStatsModifier = require('./isCustomerStatsModifier');
+const isTotalSalesModifier = require('./isTotalSalesModifier');
+const isTotalVisitsModifier = require('./isTotalVisitsModifier');
+const isValidCustomer = require('./isValidCustomer');
+const lockCustomerStatsModifiers = require('./lockCustomerStatsModifiers');
+const unlockCustomerStatsModifiers = require('./unlockCustomerStatsModifiers');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -347,6 +353,12 @@ const modifierActions = (deps = {}) => {
     isOverrideSubtotal: isOverrideSubtotal(innerDeps),
     validatePaymentCondition: validatePaymentCondition(innerDeps),
     createManualModifier: createManualModifier(innerDeps),
+    isCustomerStatsModifier: isCustomerStatsModifier(innerDeps),
+    isTotalSalesModifier: isTotalSalesModifier(innerDeps),
+    isTotalVisitsModifier: isTotalVisitsModifier(innerDeps),
+    isValidCustomer: isValidCustomer(innerDeps),
+    lockCustomerStatsModifiers: lockCustomerStatsModifiers(innerDeps),
+    unlockCustomerStatsModifiers: unlockCustomerStatsModifiers(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isCustomerStatsModifier.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function isCustomerStatModifier(modifier) {
+    return (
+      actions.isTotalSalesModifier(modifier) ||
+      actions.isTotalVisitsModifier(modifier)
+    );
+  };

package/lib/modifier/isTotalSalesModifier.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function isPaymentTypeModifier(modifier) {
+    return !!(
+      modifier &&
+      modifier.conditions &&
+      Array.isArray(modifier.conditions.rules) &&
+      modifier.conditions.rules.some(
+        condition => condition.key === 'customerTotalSales'
+      )
+    );
+  };

package/lib/modifier/isTotalVisitsModifier.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function isTotalVisitsModifier(modifier) {
+    return !!(
+      modifier &&
+      modifier.conditions &&
+      Array.isArray(modifier.conditions.rules) &&
+      modifier.conditions.rules.some(
+        condition => condition.key === 'customerTotalVisits'
+      )
+    );
+  };

package/lib/modifier/isValidCustomer.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isValid(customer) {
+    return customer && typeof customer !== 'string' && customer._id;
+  };

package/lib/modifier/lockCustomerStatsModifiers.js

@@ -0,0 +1,22 @@
+module.exports = ({ actions }) =>
+  function lockCustomerStatsModifiers({ modifiers, customer }) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.map(valMod => {
+      if (
+        actions.isValidCustomer(customer) &&
+        actions.isCustomerStatsModifier(valMod) &&
+        actions.isValid(valMod)
+      ) {
+        return {
+          ...valMod,
+          locked: true,
+          properties: {
+            ...(valMod.properties || {}),
+            customerId: customer._id,
+          },
+        };
+      }
+
+      return valMod;
+    });
+  };

package/lib/modifier/unlockCustomerStatsModifiers.js

@@ -0,0 +1,23 @@
+module.exports = ({ actions }) =>
+  function unlockCustomerStatsModifiers({ modifiers, customer }) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.map(valMod => {
+      if (
+        actions.isValidCustomer(customer) &&
+        actions.isCustomerStatsModifier(valMod) &&
+        actions.isLocked(valMod) &&
+        valMod.properties.customerId !== customer._id
+      ) {
+        return {
+          ...valMod,
+          locked: false,
+          properties: {
+            ...(valMod.properties || {}),
+            customerId: undefined,
+          },
+        };
+      }
+
+      return valMod;
+    });
+  };

package/lib/order/calculate.js

@@ -13,7 +13,7 @@ module.exports = ({
   function calculateorder(inputOrder, opts = {}) {
     if (!inputOrder) return inputOrder;
     const order = _.cloneDeep(inputOrder);
-    const { items = [], orders = [] } = order;
+    const { items = [], orders = [], customer } = order;
     if (!items.length) {
       if (!orders.length)
         return { ...order, subTotals: {}, subTotal: 0, total: 0 };
@@ -22,10 +22,12 @@ module.exports = ({
     }
     const startRequestDate = order.start ? order.start.requestDate : null;
     const endRequestDate = order.end ? order.end.requestDate : null;
+
     const options = {
       ...opts,
       startRequestDate,
       endRequestDate,
+      customer,
     };
     const sortedOrderModifiers = modifierActions.sort(order.modifiers || []);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.103",
+  "version": "1.0.105",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -54,5 +54,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "032bea629a5c32d78886daca4d2382b847b5d075"
+  "gitHead": "09c5c7462144195081cfc13eb82f55f4530a77aa"
 }