@darkpos/pricing 1.0.4 → 1.0.7

package/.eslintrc

@@ -7,18 +7,16 @@
   "plugins": ["prettier", "jest"],
   "rules": {
     "no-debugger": 0,
-    "import/no-extraneous-dependencies": 0,
     "no-underscore-dangle": 0,
-    "import/no-dynamic-require": 0,
     "no-console": 0,
     "global-require": 0,
-    "prettier/prettier": [
-      "error",
-      {
-        "trailingComma": "es5",
-        "singleQuote": true,
-        "printWidth": 100
-      }
-    ]
+    "prettier/prettier": ["error", {
+      "singleQuote": true,
+      "trailingComma": "es5",
+      "bracketSpacing": true,
+      "bracketSameLine": false,
+      "arrowParens": "avoid",
+      "parser": "flow"
+    }]
   }
 }

package/README.md

@@ -7,9 +7,113 @@
 ### Usage
 
 ```
-const pricing = require('dark-pricing');
-const { modifier, item, order } = pricing;
+const usePricing = require('@darkpos/pricing');
 
-const order = {};
-order.calculateOrder(order);
+const options = {
+    ...localization,
+};
+
+const pricingService = usePricing(options);
+
+//
+const newOrder = pricingService.order.calculate(oldOrder);
+```
+
+Sample of a calculated Item:
+
+```
+const item = {
+    name: 'shirt',
+    price: 2,
+    modifiers: [
+    {
+        action: 'add',
+        type: 'fixed',
+        amount: 1
+        attributes: [hidden]
+        category: 'fee',
+        properties: {
+            sort: 1,
+            included: true,
+        },
+        computed: {
+            amount: 1
+        }
+    }                            ----> subTotal: 3
+    {
+        action: 'add',
+        type: 'percentage',
+        amount: 20
+        category: 'tax',
+        properties: {
+            direct: false,
+            sort: 2,
+            included: true
+        }
+        computed: {
+         amount: 0.60
+        }
+    }                          
+    {
+        action: 'add',
+        type: 'percentage',
+        amount: 30
+        category: 'tax',
+        properties: {
+            direct: false,
+            sort: 2,
+            included: true
+        }
+        computed: {
+         amount: 0.90
+        }
+    }
+                                 ----> subTotal: 4.50
+    {
+        action: 'subtract',
+        type: 'fixed',
+        amount: 1
+        category: 'discount'
+        properties: {
+            direct: false,
+            sort: 3,
+            included: false
+        }
+        computed: {
+         amount: -1
+        }
+    }],
+    subTotals: {
+        tax: (included: false)                                ---> 0.60
+        discount: (included: false)                           --->-1.00
+        fee:                                                ---> 0.00 
+        _included: (included: true)                         ---> 1
+        _xincluded                                          ---> -0.40
+        _direct: sum(modifiers with direct: true)           ---> 1.60 *
+        _xdirect: (direct: false)                           ---> -1
+        _simple: price * quantity                           ---> 2.00 *
+        _actual: _simple  + _included                       ---> 3.00
+    }
+    total: _actual + _xincluded                             ---> 2.60
+}
+
+const order = {
+    items: [item],
+    modifiers: [{
+        action: 'subtract',
+        type: 'fixed',
+        amount: 1
+        attributes: [hidden]
+        group: 'discount'
+    }],
+    subTotal: sum of _actuals                   ---> 3.00
+    ---
+    subTotals: {
+        tax: sum of subTotals.tax                ---> 0.60
+        fee: sum of subTotals.fee                ---> 0.00
+        discount: sum of subTotals.discount      --->-1.00
+    }
+    ---
+    total: sum of above                          ---> 2.60
+}
 ```

package/__TEST__/item.test.js

@@ -1,54 +1,285 @@
-const itemActions = require("../lib/item/actions");
+const usePricing = require('../index');
 
-describe("Item actions", () => {
-  test("Get calculated Item", () => {
+const pricingService = usePricing();
+
+describe('Item actions', () => {
+  test('Get calculated Item: included: false && direct: false', () => {
     const modifiers = [
-      { amount: 20, type: "percentage", action: "add" },
-      { amount: 20, type: "percentage", action: "subtract" },
-      { amount: 2, type: "fixed", action: "subtract" }
+      {
+        compute: {
+          amount: 20,
+          type: 'percentage',
+          action: 'add',
+        },
+        name: 'modifier1',
+        type: 'discount',
+        direct: false,
+        included: false,
+      },
+      {
+        compute: {
+          amount: 20,
+          type: 'percentage',
+          action: 'subtract',
+        },
+        name: 'modifier2',
+        type: 'discount',
+        direct: false,
+        included: false,
+      },
+      {
+        compute: {
+          amount: 2,
+          type: 'fixed',
+          action: 'subtract',
+        },
+        name: 'modifier3',
+        type: 'discount',
+        direct: false,
+        included: false,
+      },
     ];
     const orderItem = { price: 30, quantity: 2, modifiers };
-    const newItem = itemActions.calculateItem(orderItem);
-    expect(newItem).toHaveProperty("total", 56);
-    expect(newItem).toHaveProperty("subTotal", 60);
+    const newItem = pricingService.item.calculate(orderItem);
+    expect(newItem).toHaveProperty('total', 56);
+    expect(newItem).toHaveProperty('subTotals', {
+      discount: -4,
+      _included: 0,
+      _xincluded: -4,
+      _direct: 0,
+      _xdirect: -4,
+      _simple: 60,
+      _actual: 60,
+    });
   });
-  test("Get calculated Item with distributed Modifiers", () => {
+  test('Get calculated Item: included: false && direct: true', () => {
     const modifiers = [
       {
-        amount: 20,
-        type: "percentage",
-        action: "add",
-        attributes: ["distributed"]
+        compute: { amount: 2, type: 'fixed', action: 'subtract' },
+        type: 'discount',
+        name: 'modifier1',
+        direct: true,
+        included: false,
+      },
+      {
+        compute: {
+          amount: 20,
+          type: 'percentage',
+          action: 'subtract',
+        },
+        name: 'modifier2',
+        type: 'discount',
+        direct: true,
+        included: false,
+      },
+      {
+        compute: {
+          amount: 2,
+          type: 'fixed',
+          action: 'add',
+        },
+        name: 'modifier3',
+        type: 'tax',
+        direct: true,
+        included: false,
       },
-      { amount: 20, type: "percentage", action: "subtract" },
-      { amount: 2, type: "fixed", action: "subtract" }
     ];
     const orderItem = { price: 30, quantity: 2, modifiers };
-    const newItem = itemActions.calculateItem(orderItem);
-    expect(newItem).toHaveProperty("total", 56);
-    expect(newItem).toHaveProperty("subTotal", 60);
-    expect(newItem).toHaveProperty("distributed", 12);
+    const newItem = pricingService.item.calculate(orderItem);
+    expect(newItem).toHaveProperty('total', 48);
+    expect(newItem).toHaveProperty('subTotals', {
+      discount: -16,
+      tax: 4,
+      _included: 0,
+      _xincluded: -12,
+      _direct: -12,
+      _xdirect: 0,
+      _simple: 60,
+      _actual: 60,
+    });
   });
-  test("Get calculated Item with discount Modifiers", () => {
+  test('Get calculated Item: included: true && direct: true', () => {
     const modifiers = [
       {
-        amount: 20,
-        type: "percentage",
-        action: "add",
-        attributes: ["discount"]
+        compute: {
+          amount: 2,
+          type: 'fixed',
+          action: 'subtract',
+        },
+        name: 'modifier1',
+        type: 'discount',
+        direct: true,
+        included: true,
       },
       {
-        amount: 20,
-        type: "percentage",
-        action: "subtract",
-        attributes: ["discount"]
+        compute: {
+          amount: 20,
+          type: 'percentage',
+          action: 'subtract',
+        },
+        name: 'modifier2',
+        type: 'discount',
+        direct: true,
+        included: true,
+      },
+      {
+        compute: {
+          amount: 2,
+          type: 'fixed',
+          action: 'add',
+        },
+        name: 'modifier3',
+        type: 'upcharge',
+        direct: true,
+        included: true,
       },
-      { amount: 2, type: "fixed", action: "subtract", attributes: ["discount"] }
     ];
     const orderItem = { price: 30, quantity: 2, modifiers };
-    const newItem = itemActions.calculateItem(orderItem);
-    expect(newItem).toHaveProperty("total", 56);
-    expect(newItem).toHaveProperty("subTotal", 60);
-    expect(newItem).toHaveProperty("discount", -4);
+    const newItem = pricingService.item.calculate(orderItem);
+    expect(newItem).toHaveProperty('total', 48);
+    expect(newItem).toHaveProperty('subTotals', {
+      _included: -12,
+      _xincluded: 0,
+      _direct: -12,
+      _xdirect: 0,
+      _simple: 60,
+      _actual: 48,
+    });
+  });
+  test('Get calculated Item: included: true, sample 1', () => {
+    const modifiers = [
+      {
+        compute: {
+          amount: 2,
+          type: 'fixed',
+          action: 'add',
+        },
+        name: 'modifier1',
+        type: 'upcharge',
+        included: true,
+        direct: true,
+      },
+    ];
+    const orderItem = { price: 2, quantity: 1, modifiers };
+    const newItem = pricingService.item.calculate(orderItem);
+    expect(newItem).toHaveProperty('total', 4);
+    expect(newItem).toHaveProperty('subTotals', {
+      _included: 2,
+      _xincluded: 0,
+      _direct: 2,
+      _xdirect: 0,
+      _simple: 2,
+      _actual: 4,
+    });
+  });
+  test('Get calculated Item: included: true, sample 2', () => {
+    const modifiers = [
+      {
+        compute: { amount: 2, type: 'fixed', action: 'add' },
+        name: 'modifier1',
+        type: 'upcharge',
+        included: true,
+        direct: true,
+        properties: {
+          sort: 1,
+        },
+      },
+      {
+        compute: {
+          amount: 10,
+          type: 'percentage',
+          action: 'add',
+        },
+        name: 'modifier2',
+        type: 'tax',
+        properties: {
+          sort: 2,
+        },
+        included: true,
+        direct: true,
+      },
+    ];
+    const orderItem = { price: 2, quantity: 1, modifiers };
+    const newItem = pricingService.item.calculate(orderItem);
+    expect(newItem).toHaveProperty('total', 4.4);
+    expect(newItem).toHaveProperty('subTotals', {
+      _included: 2.4,
+      _xincluded: 0,
+      _direct: 2.4,
+      _xdirect: 0,
+      _simple: 2,
+      _actual: 4.4,
+    });
+  });
+  test('Get calculated Item: included: true, sample 3', () => {
+    const modifiers = [
+      {
+        compute: {
+          amount: 2,
+          type: 'fixed',
+          action: 'subtract',
+        },
+        name: 'modifier1',
+        type: 'discount',
+        properties: {
+          sort: 1,
+        },
+        included: true,
+        direct: true,
+      },
+      {
+        compute: {
+          amount: 2,
+          type: 'fixed',
+          action: 'add',
+        },
+        name: 'modifier1',
+        type: 'upcharge',
+        included: true,
+        direct: true,
+        properties: {
+          sort: 1,
+        },
+      },
+      {
+        compute: {
+          amount: 10,
+          type: 'percentage',
+          action: 'add',
+        },
+        name: 'modifier2',
+        type: 'tax',
+        properties: {
+          sort: 2,
+        },
+        included: true,
+        direct: true,
+      },
+      {
+        compute: {
+          amount: 6,
+          type: 'percentage',
+          action: 'add',
+        },
+        name: 'modifier3',
+        type: 'tax',
+        properties: {
+          sort: 2,
+        },
+        included: true,
+        direct: true,
+      },
+    ];
+    const orderItem = { price: 2, quantity: 1, modifiers };
+    const newItem = pricingService.item.calculate(orderItem);
+    expect(newItem).toHaveProperty('total', 2.32);
+    expect(newItem).toHaveProperty('subTotals', {
+      _xdirect: 0,
+      _simple: 2,
+      _actual: 2.32,
+      _direct: 0.32,
+      _included: 0.32,
+      _xincluded: 0,
+    });
   });
 });

package/__TEST__/modifier/calculate.test.js

@@ -0,0 +1,73 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('Calculate Function', () => {
+  test('calculate with fix amount and add action', () => {
+    const modifier = {
+      compute: {
+        type: 'fixed',
+        action: 'add',
+        amount: 10,
+      },
+      name: 'someModifier',
+    };
+    const orderItem = { price: 30, quantity: 1 };
+    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    expect(computedModifier._computed).toMatchObject({
+      amount: 10,
+      description: 'someModifier ($10.00)',
+    });
+  });
+
+  test('calculate with fix amount and subtract action', () => {
+    const modifier = {
+      compute: {
+        type: 'fixed',
+        action: 'subtract',
+        amount: 10,
+      },
+      name: 'someModifier',
+    };
+    const orderItem = { price: 30, quantity: 1 };
+    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    expect(computedModifier._computed).toMatchObject({
+      amount: -10,
+      description: 'someModifier (-$10.00)',
+    });
+  });
+
+  test('calculate with percentage amount and subtract action', () => {
+    const modifier = {
+      compute: {
+        amount: 20,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: 'someModifier',
+    };
+    const orderItem = { price: 30, quantity: 1 };
+    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    expect(computedModifier._computed).toMatchObject({
+      amount: -6,
+      description: 'someModifier (-$6.00)',
+    });
+  });
+
+  test('calculate with percentage amount and add action', () => {
+    const modifier = {
+      compute: {
+        amount: 20,
+        type: 'percentage',
+        action: 'add',
+      },
+      name: 'someModifier',
+    };
+    const orderItem = { price: 30, quantity: 1 };
+    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    expect(computedModifier._computed).toMatchObject({
+      amount: 6,
+      description: 'someModifier ($6.00)',
+    });
+  });
+});

package/__TEST__/modifier/getAvailablePromotionsOrSubscriptions.test.js

@@ -0,0 +1,81 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('GetAvailablePromotionsOrSubscriptions Function', () => {
+  test('usecases', () => {
+    const today = new Date();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions()
+    ).toStrictEqual([]);
+
+    const modifier = { attributes: ['promotion'] };
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    modifier.properties = {
+      promotion: { numberOfUsesLimit: 4, numberOfUses: 3 },
+    };
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    modifier.properties.promotion.numberOfUses = 4;
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([]);
+
+    modifier.properties.promotion.numberOfUses = 5;
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([]);
+
+    modifier.properties = {
+      promotion: { dateLimit: { from: today.toISOString(), to: '' } },
+    };
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    const tomorrow = new Date(today);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    modifier.properties.promotion.dateLimit.from = tomorrow.toISOString();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([]);
+
+    const yesterday = new Date(today);
+    yesterday.setDate(yesterday.getDate() - 1);
+    modifier.properties.promotion.dateLimit.from = yesterday.toISOString();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    modifier.properties.promotion.dateLimit.to = yesterday.toISOString();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([]);
+
+    modifier.properties.promotion.dateLimit.to = today.toISOString();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    modifier.properties.promotion.dateLimit.to = tomorrow.toISOString();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    modifier.attributes = ['subscription'];
+    modifier.properties.subscription = modifier.properties.promotion;
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    delete modifier.properties;
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([]);
+  });
+});