@darkpos/pricing 1.0.133 → 1.0.135

package/__TEST__/item.test.js

@@ -2501,4 +2501,74 @@ describe('Item actions', () => {
     expect(newItem.price).toBe(100);
     expect(newItem.total).toBe(115);
   });
+
+  describe('pricingService.item.getTaxes (object of tax totals)', () => {
+    test('Returns {} when item is null', () => {
+      expect(pricingService.item.getTaxes(null)).toEqual({});
+    });
+
+    test('Returns {} when modifiers is not an array', () => {
+      expect(pricingService.item.getTaxes({ modifiers: {} })).toEqual({});
+    });
+
+    test('Returns empty object when no tax modifiers exist', () => {
+      const item = {
+        modifiers: [{ name: 'env', type: 'env', _computed: { amount: 5 } }],
+      };
+
+      expect(pricingService.item.getTaxes(item)).toEqual({});
+    });
+
+    test('Returns a single tax entry with correct amount', () => {
+      const item = {
+        modifiers: [{ name: 'VAT', type: 'tax', _computed: { amount: 3 } }],
+      };
+
+      expect(pricingService.item.getTaxes(item)).toEqual({
+        VAT: 3,
+      });
+    });
+
+    test('Sums amounts for tax modifiers with the same name', () => {
+      const item = {
+        modifiers: [
+          { name: 'VAT', type: 'tax', _computed: { amount: 2 } },
+          { name: 'VAT', type: 'tax', _computed: { amount: 3 } },
+        ],
+      };
+
+      expect(pricingService.item.getTaxes(item)).toEqual({
+        VAT: 5,
+      });
+    });
+
+    test('Handles multiple different tax names', () => {
+      const item = {
+        modifiers: [
+          { name: 'VAT', type: 'tax', _computed: { amount: 1 } },
+          { name: 'Service Tax', type: 'tax', _computed: { amount: 4 } },
+        ],
+      };
+
+      expect(pricingService.item.getTaxes(item)).toEqual({
+        VAT: 1,
+        'Service Tax': 4,
+      });
+    });
+
+    test('Ignores non-tax modifiers but includes tax ones', () => {
+      const item = {
+        modifiers: [
+          { name: 'VAT', type: 'tax', _computed: { amount: 1 } },
+          { name: 'Env Fee', type: 'env', _computed: { amount: 7 } },
+          { name: 'City Tax', type: 'tax', _computed: { amount: 3 } },
+        ],
+      };
+
+      expect(pricingService.item.getTaxes(item)).toEqual({
+        VAT: 1,
+        'City Tax': 3,
+      });
+    });
+  });
 });

package/__TEST__/mocks/partially-paid/order-partially-paid.json

@@ -904,8 +904,8 @@
     "kitchen": "open",
     "delivery": "none",
     "detailed": true,
-    "fullyPaid": false,
-    "fullyPicked": true,
+    "paid": false,
+    "picked": true,
     "invoice": "partial"
   },
   "attributes": [],

package/__TEST__/order/order-payment-modifier.test.js

@@ -559,45 +559,45 @@ describe('Order actions', () => {
     expect(itemBalance).toEqual(1.25);
 
     // paying with a paymenttype that doesn match the payment modifiers
-    const fullyPaidOrderWithCredit = pricingService.order.calculate(testOrder, {
+    const paidOrderWithCredit = pricingService.order.calculate(testOrder, {
       paymentType: 'credit',
       amountToPay: 1.25,
       lockPaymentModifiers: true,
     });
-    fullyPaidOrderWithCredit.items[0].totalPaid += 1.25;
-    fullyPaidOrderWithCredit.totalPaid += 1.25;
+    paidOrderWithCredit.items[0].totalPaid += 1.25;
+    paidOrderWithCredit.totalPaid += 1.25;
 
     const orderBalanceWithCredit = pricingService.order.getOrdersBalance({
-      orders: [fullyPaidOrderWithCredit],
+      orders: [paidOrderWithCredit],
     });
     const itemBalanceWithCredit = pricingService.item.getItemsBalance({
-      items: fullyPaidOrderWithCredit.items,
+      items: paidOrderWithCredit.items,
     });
 
-    expect(fullyPaidOrderWithCredit).toHaveProperty('total', 11.59);
-    expect(fullyPaidOrderWithCredit).toHaveProperty('subTotal', 13.5);
-    expect(fullyPaidOrderWithCredit).toHaveProperty('subTotals', {
+    expect(paidOrderWithCredit).toHaveProperty('total', 11.59);
+    expect(paidOrderWithCredit).toHaveProperty('subTotal', 13.5);
+    expect(paidOrderWithCredit).toHaveProperty('subTotals', {
       discount: -2.585,
       fee: 0.675,
     });
 
-    expect(fullyPaidOrderWithCredit.items[0].modifiers).toHaveLength(3);
+    expect(paidOrderWithCredit.items[0].modifiers).toHaveLength(3);
 
-    expect(fullyPaidOrderWithCredit.items[0].modifiers[0]._computed).toEqual(
+    expect(paidOrderWithCredit.items[0].modifiers[0]._computed).toEqual(
       expect.objectContaining({
         amount: 0,
         description: 'CASH 20% DISCOUNT',
       })
     );
 
-    expect(fullyPaidOrderWithCredit.items[0].modifiers[1]._computed).toEqual(
+    expect(paidOrderWithCredit.items[0].modifiers[1]._computed).toEqual(
       expect.objectContaining({
         amount: 0.675,
         description: '5% FEE ($0.68)',
       })
     );
 
-    expect(fullyPaidOrderWithCredit.items[0].modifiers[2]._computed).toEqual(
+    expect(paidOrderWithCredit.items[0].modifiers[2]._computed).toEqual(
       expect.objectContaining({
         amount: -2.585,
         description: '$2.59 discount (-$2.59)',
@@ -608,52 +608,52 @@ describe('Order actions', () => {
     expect(itemBalanceWithCredit).toEqual(0);
 
     // paying with a paymenttype that doesn match the payment modifiers
-    const fullyPaidOrderWithCash = pricingService.order.calculate(testOrder, {
+    const paidOrderWithCash = pricingService.order.calculate(testOrder, {
       paymentType: 'cash',
       amountToPay: 1,
       lockPaymentModifiers: true,
     });
-    fullyPaidOrderWithCash.items[0].totalPaid += 1;
-    fullyPaidOrderWithCash.totalPaid += 1;
+    paidOrderWithCash.items[0].totalPaid += 1;
+    paidOrderWithCash.totalPaid += 1;
 
     const orderBalanceWithCash = pricingService.order.getOrdersBalance({
-      orders: [fullyPaidOrderWithCash],
+      orders: [paidOrderWithCash],
     });
     const itemBalanceWithCash = pricingService.item.getItemsBalance({
-      items: fullyPaidOrderWithCash.items,
+      items: paidOrderWithCash.items,
     });
 
-    expect(fullyPaidOrderWithCash).toHaveProperty('total', 11.34);
-    expect(fullyPaidOrderWithCash).toHaveProperty('subTotal', 13.5);
-    expect(fullyPaidOrderWithCash).toHaveProperty('subTotals', {
+    expect(paidOrderWithCash).toHaveProperty('total', 11.34);
+    expect(paidOrderWithCash).toHaveProperty('subTotal', 13.5);
+    expect(paidOrderWithCash).toHaveProperty('subTotals', {
       discount: -2.835,
       fee: 0.675,
     });
 
-    expect(fullyPaidOrderWithCash.items[0].modifiers).toHaveLength(4);
+    expect(paidOrderWithCash.items[0].modifiers).toHaveLength(4);
 
-    expect(fullyPaidOrderWithCash.items[0].modifiers[0]._computed).toEqual(
+    expect(paidOrderWithCash.items[0].modifiers[0]._computed).toEqual(
       expect.objectContaining({
         amount: 0,
         description: 'CASH 20% DISCOUNT',
       })
     );
 
-    expect(fullyPaidOrderWithCash.items[0].modifiers[1]._computed).toEqual(
+    expect(paidOrderWithCash.items[0].modifiers[1]._computed).toEqual(
       expect.objectContaining({
         amount: 0.675,
         description: '5% FEE ($0.68)',
       })
     );
 
-    expect(fullyPaidOrderWithCash.items[0].modifiers[2]._computed).toEqual(
+    expect(paidOrderWithCash.items[0].modifiers[2]._computed).toEqual(
       expect.objectContaining({
         amount: -0.25,
         description: '$0.25 discount (-$0.25)',
       })
     );
 
-    expect(fullyPaidOrderWithCash.items[0].modifiers[3]._computed).toEqual(
+    expect(paidOrderWithCash.items[0].modifiers[3]._computed).toEqual(
       expect.objectContaining({
         amount: -2.585,
         description: '$2.59 discount (-$2.59)',

package/__TEST__/order/order.test.js

@@ -3743,7 +3743,7 @@ describe('Order actions', () => {
     const newOrder = pricing.order.calculate(order);
 
     expect(newOrder).toHaveProperty('total', 0);
-    expect(newOrder.status).toMatchObject({ fullyPaid: true });
+    expect(newOrder.status).toMatchObject({ paid: true });
     expect(newOrder.items[0].total).toBe(0);
     expect(newOrder.items[0].status).toMatchObject({
       paid: {
@@ -3770,11 +3770,11 @@ describe('Order actions', () => {
     const pricing = usePricing({
       store: { _settings: { order: { autoMarkAsPaid: true } } },
     });
-    const order = { items: [orderItem], status: { fullyPaid: true } };
+    const order = { items: [orderItem], status: { paid: true } };
     const newOrder = pricing.order.calculate(order);
 
     expect(newOrder).toHaveProperty('total', 25);
-    expect(newOrder.status).toMatchObject({ fullyPaid: false });
+    expect(newOrder.status).toMatchObject({ paid: false });
     expect(newOrder.items[0].total).toBe(25);
     expect(newOrder.items[0].status).toMatchObject({
       paid: undefined,
@@ -3783,7 +3783,7 @@ describe('Order actions', () => {
     const newOrder2 = pricingService.order.calculate(order);
 
     expect(newOrder2).toHaveProperty('total', 25);
-    expect(newOrder2.status).toMatchObject({ fullyPaid: true });
+    expect(newOrder2.status).toMatchObject({ paid: true });
     expect(newOrder2.items[0].total).toBe(25);
     expect(newOrder2.items[0].status).toMatchObject({ paid: { value: true } });
   });
@@ -3933,4 +3933,135 @@ describe('Order actions', () => {
     expect(parentCount).toBe(1);
     expect(result).toEqual(items);
   });
+
+  test('Should remove notes with no message, file, or url', () => {
+    const order = {
+      notes: [
+        { message: '', file: '', url: '' }, // empty
+        { message: 'Hello', file: '', url: '' }, // valid
+        { message: '', file: 'a.pdf', url: '' }, // valid
+        { message: '', file: '', url: 'http://x.com' }, // valid
+      ],
+    };
+
+    const { removeEmptyNotes } = pricingService.order;
+    const result = removeEmptyNotes(order);
+
+    expect(result.notes.length).toBe(3);
+    expect(result.notes).toEqual([
+      { message: 'Hello', file: '', url: '' },
+      { message: '', file: 'a.pdf', url: '' },
+      { message: '', file: '', url: 'http://x.com' },
+    ]);
+  });
+
+  test('Should return order unchanged if notes is missing or not an array', () => {
+    const { removeEmptyNotes } = pricingService.order;
+
+    const order1 = {};
+    const order2 = { notes: null };
+    const order3 = { notes: 'invalid' };
+
+    expect(removeEmptyNotes(order1)).toEqual(order1);
+    expect(removeEmptyNotes(order2)).toEqual(order2);
+    expect(removeEmptyNotes(order3)).toEqual(order3);
+  });
+
+  describe('pricingService.order.getTaxes – real integration', () => {
+    test('Returns {} when order is null', () => {
+      expect(pricingService.order.getTaxes(null)).toEqual({});
+    });
+
+    test('Returns {} when order.items is not an array', () => {
+      expect(pricingService.order.getTaxes({ items: null })).toEqual({});
+    });
+
+    test('Returns {} when order has no items', () => {
+      expect(pricingService.order.getTaxes({ items: [] })).toEqual({});
+    });
+
+    test('Aggregates taxes from a single item', () => {
+      const order = {
+        items: [
+          {
+            modifiers: [{ name: 'VAT', type: 'tax', _computed: { amount: 3 } }],
+          },
+        ],
+      };
+
+      const result = pricingService.order.getTaxes(order);
+
+      expect(result).toEqual({
+        VAT: 3,
+      });
+    });
+
+    test('Sums taxes from multiple items with the same tax name', () => {
+      const order = {
+        items: [
+          {
+            modifiers: [{ name: 'VAT', type: 'tax', _computed: { amount: 2 } }],
+          },
+          {
+            modifiers: [{ name: 'VAT', type: 'tax', _computed: { amount: 1 } }],
+          },
+        ],
+      };
+
+      const result = pricingService.order.getTaxes(order);
+
+      expect(result).toEqual({
+        VAT: 3,
+      });
+    });
+
+    test('Handles multiple different tax names across items', () => {
+      const order = {
+        items: [
+          {
+            modifiers: [{ name: 'VAT', type: 'tax', _computed: { amount: 1 } }],
+          },
+          {
+            modifiers: [
+              { name: 'ServiceTax', type: 'tax', _computed: { amount: 4 } },
+            ],
+          },
+          {
+            modifiers: [{ name: 'VAT', type: 'tax', _computed: { amount: 2 } }],
+          },
+        ],
+      };
+
+      const result = pricingService.order.getTaxes(order);
+
+      expect(result).toEqual({
+        VAT: 3, // 1 + 2
+        ServiceTax: 4,
+      });
+    });
+
+    test('Skips non-tax modifiers completely', () => {
+      const order = {
+        items: [
+          {
+            modifiers: [
+              { name: 'Fee', type: 'fee', _computed: { amount: 10 } },
+              { name: 'VAT', type: 'tax', _computed: { amount: 2 } },
+            ],
+          },
+          {
+            modifiers: [
+              { name: 'Other', type: 'env', _computed: { amount: 5 } },
+            ],
+          },
+        ],
+      };
+
+      const result = pricingService.order.getTaxes(order);
+
+      expect(result).toEqual({
+        VAT: 2,
+      });
+    });
+  });
 });

package/__TEST__/order/pickEndDate.test.js

@@ -5,7 +5,7 @@ const getDefaultSettings = schedules => ({
   store: {
     _settings: {
       schedule: {
-        close: [
+        closed: [
           {
             date: '2024-09-03',
           },

package/__TEST__/order/unpick.order.test.js

@@ -14,9 +14,9 @@ describe('Order actions - unpick order', () => {
       quantity: 2,
       status: { picked: { value: true, date: new Date() } },
     };
-    const order = { items: [orderItem], status: { fullyPicked: true } };
+    const order = { items: [orderItem], status: { picked: true } };
     const newOrder = pricingService.order.unpickOrder(order);
-    expect(newOrder.status.fullyPicked).toBe(false);
+    expect(newOrder.status.picked).toBe(false);
     newOrder.items.map(item =>
       expect(item.status.picked).toStrictEqual({ value: false, date: '' })
     );
@@ -28,7 +28,7 @@ describe('Order actions - unpick order', () => {
       status: { picked: { value: true, date: new Date() } },
     };
     const order = {
-      status: { fullyPicked: true },
+      status: { picked: true },
       items: [
         orderItem,
         orderItem,
@@ -43,7 +43,7 @@ describe('Order actions - unpick order', () => {
       ],
     };
     const newOrder = pricingService.order.unpickOrder(order);
-    expect(newOrder.status.fullyPicked).toBe(false);
+    expect(newOrder.status.picked).toBe(false);
     newOrder.items.map(item =>
       expect(item.status.picked).toStrictEqual({ value: false, date: '' })
     );
@@ -61,10 +61,10 @@ describe('Order actions - unpick order', () => {
     };
     const order = {
       items: [orderItem, orderItemNotPicked],
-      status: { fullyPicked: true },
+      status: { picked: true },
     };
     const newOrder = pricingService.order.unpickOrder(order);
-    expect(newOrder.status.fullyPicked).toBe(false);
+    expect(newOrder.status.picked).toBe(false);
     newOrder.items.map(item =>
       expect(item.status.picked).toStrictEqual({ value: false, date: '' })
     );
@@ -77,18 +77,18 @@ describe('Order actions - unpick order', () => {
       status: { picked: { value: true, date: new Date() } },
     };
 
-    const subOrder = { items: [orderItem], status: { fullyPicked: true } };
+    const subOrder = { items: [orderItem], status: { picked: true } };
     const order = {
       items: [orderItem],
       orders: [subOrder],
-      status: { fullyPicked: true },
+      status: { picked: true },
     };
     const newOrder = pricingService.order.unpickOrder(order);
     newOrder.items.map(item =>
       expect(item.status.picked).toStrictEqual({ value: false, date: '' })
     );
     newOrder.orders.map(_order => {
-      expect(_order.status.fullyPicked).toBe(false);
+      expect(_order.status.picked).toBe(false);
       return _order.items.map(item =>
         expect(item.status.picked).toStrictEqual({ value: false, date: '' })
       );

package/lib/constants/Status/index.js

@@ -2,13 +2,13 @@ const Order = Object.freeze({
   OPEN: 'open',
   HOLD: 'hold',
   VOID: 'void',
-  CLOSED: 'close',
+  CLOSED: 'closed',
 });
 
 const Invoice = Object.freeze({
   PARTIAL: 'partial',
   PENDING: 'pending',
-  CLOSED: 'close',
+  CLOSED: 'closed',
 });
 
 const Kitchen = Object.freeze({

package/lib/item/adjustCreditModifiersDifference.js

@@ -5,7 +5,7 @@ module.exports = ({ utils, actions, modifierActions }) => {
     const selectedSubItemIndex = subItems.findIndex(
       subItem =>
         modifierActions.hasCreditModifier(subItem.modifiers) &&
-        !actions.isFullyPaid(subItem) &&
+        !actions.isPaid(subItem) &&
         subItem.total > difference
     );
 

package/lib/item/adjustFixedModifiersDifference.js

@@ -5,7 +5,7 @@ module.exports = ({ utils, actions, modifierActions, _ }) => {
     const selectedSubItemIndex = subItems.findIndex(
       subItem =>
         modifierActions.hasFixedModifier(subItem.modifiers) &&
-        !actions.isFullyPaid(subItem) &&
+        !actions.isPaid(subItem) &&
         subItem.total > difference
     );
 

package/lib/item/getTaxes.js

@@ -0,0 +1,18 @@
+module.exports = ({ modifierActions, utils }) => {
+  const { math } = utils;
+
+  return function getTaxes(item) {
+    if (!item || !Array.isArray(item.modifiers)) return {};
+
+    const taxes = {};
+
+    item.modifiers.forEach(mod => {
+      if (!modifierActions.isTax(mod)) return;
+
+      const prevVal = taxes[mod.name] || 0;
+      taxes[mod.name] = math.add(prevVal, mod._computed.amount);
+    });
+
+    return taxes;
+  };
+};

package/lib/item/getUpdatedStatus.js

@@ -5,14 +5,11 @@ module.exports = ({ actions, settings }) =>
 
     const localStatus = status || {};
 
-    if (actions.isFullyPaid({ item: { status: localStatus } }) && total !== 0) {
+    if (actions.isPaid({ item: { status: localStatus } }) && total !== 0) {
       return { ...localStatus, paid: undefined };
     }
 
-    if (
-      !actions.isFullyPaid({ item: { status: localStatus } }) &&
-      total === 0
-    ) {
+    if (!actions.isPaid({ item: { status: localStatus } }) && total === 0) {
       return { ...localStatus, paid: { value: true, date: new Date() } };
     }
 

package/lib/item/index.js

@@ -29,7 +29,7 @@ const isRepairOnly = require('./isRepairOnly');
 const hasCreateSubscription = require('./hasCreateSubscription');
 const getItemModifiers = require('./getItemModifiers');
 const getItemsBalance = require('./getItemsBalance');
-const isFullyPaid = require('./isFullyPaid');
+const isPaid = require('./isPaid');
 const getTotalPrice = require('./getTotalPrice');
 const getItems = require('./getItems');
 const getAmounts = require('./getAmounts');
@@ -77,6 +77,7 @@ const isRemoveParentItem = require('./isRemoveParentItem');
 const hasRelatedItems = require('./hasRelatedItems');
 const getAddModifiers = require('./getAddModifiers');
 const hasAddModifiers = require('./hasAddModifiers');
+const getTaxes = require('./getTaxes');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -118,7 +119,7 @@ const itemActions = (deps = {}) => {
     hasCreateSubscription: hasCreateSubscription(innerDeps),
     getItemModifiers: getItemModifiers(innerDeps),
     getItemsBalance: getItemsBalance(innerDeps),
-    isFullyPaid: isFullyPaid(innerDeps),
+    isPaid: isPaid(innerDeps),
     getTotalPrice: getTotalPrice(innerDeps),
     getItems: getItems(innerDeps),
     getAmounts: getAmounts(innerDeps),
@@ -167,6 +168,7 @@ const itemActions = (deps = {}) => {
     hasRelatedItems: hasRelatedItems(innerDeps),
     getAddModifiers: getAddModifiers(innerDeps),
     hasAddModifiers: hasAddModifiers(innerDeps),
+    getTaxes: getTaxes(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/{isFullyPaid.js → isPaid.js}

@@ -1,5 +1,5 @@
 module.exports = () =>
-  function isFullyPaid({ item }) {
+  function isPaid({ item }) {
     if (!item) return false;
 
     return item.status && item.status.paid && item.status.paid.value;

package/lib/modifier/index.js

@@ -182,6 +182,7 @@ const getCountPerCustomer = require('./getCountPerCustomer');
 const getAmountMultiplier = require('./getAmountMultiplier');
 const isAmountMultiplier = require('./isAmountMultiplier');
 const isRemoveParentItem = require('./isRemoveParentItem');
+const isTax = require('./isTax');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -376,6 +377,7 @@ const modifierActions = (deps = {}) => {
     getAmountMultiplier: getAmountMultiplier(innerDeps),
     isAmountMultiplier: isAmountMultiplier(innerDeps),
     isRemoveParentItem: isRemoveParentItem(innerDeps),
+    isTax: isTax(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isTax.js

@@ -0,0 +1,6 @@
+module.exports = ({ constants }) => {
+  const { Modifier } = constants;
+  return function isTax(modifier) {
+    return modifier && modifier.type === Modifier.Types.TAX;
+  };
+};

package/lib/order/calculate.js

@@ -123,7 +123,7 @@ module.exports = ({
 
       const itemIndex = calculatedItems.findIndex(
         item =>
-          !itemActions.isFullyPaid(item) &&
+          !itemActions.isPaid(item) &&
           item.modifiers.some(
             mod =>
               modifierActions.isPercentage(mod) ||

package/lib/order/createSubOrder.js

@@ -26,8 +26,8 @@ module.exports = ({ actions, settings, _ }) => {
         order: 'open',
         delivery: status.delivery || false,
         detailed: status.detailed || false,
-        fullyPaid: false,
-        fullyPicked: false,
+        paid: false,
+        picked: false,
       },
       items,
     });

package/lib/order/getTaxes.js

@@ -0,0 +1,20 @@
+module.exports = ({ itemActions, utils }) => {
+  const { math } = utils;
+
+  return function getTaxes(order) {
+    if (!order || !Array.isArray(order.items)) return {};
+
+    const taxes = {};
+
+    order.items.forEach(item => {
+      const itemTaxes = itemActions.getTaxes(item);
+
+      Object.keys(itemTaxes).forEach(taxName => {
+        const prev = taxes[taxName] || 0;
+        taxes[taxName] = math.add(prev, itemTaxes[taxName]);
+      });
+    });
+
+    return taxes;
+  };
+};

package/lib/order/getUpdatedStatus.js

@@ -5,18 +5,12 @@ module.exports = ({ actions, settings }) =>
 
     const localStatus = status || {};
 
-    if (
-      actions.isFullyPaid({ order: { status: localStatus } }) &&
-      total !== 0
-    ) {
-      return { ...localStatus, fullyPaid: false };
+    if (actions.isPaid({ order: { status: localStatus } }) && total !== 0) {
+      return { ...localStatus, paid: false };
     }
 
-    if (
-      !actions.isFullyPaid({ order: { status: localStatus } }) &&
-      total === 0
-    ) {
-      return { ...localStatus, fullyPaid: true };
+    if (!actions.isPaid({ order: { status: localStatus } }) && total === 0) {
+      return { ...localStatus, paid: true };
     }
 
     return localStatus;

package/lib/order/index.js

@@ -89,12 +89,14 @@ const resetItem = require('./resetItem');
 const splitItems = require('./splitItems');
 const getNewItems = require('./getNewItems');
 const mapSubOrders = require('./mapSubOrders');
-const isFullyPaid = require('./isFullyPaid');
+const isPaid = require('./isPaid');
 const getUpdatedStatus = require('./getUpdatedStatus');
 const setPieces = require('./setPieces');
 const copyItemToParents = require('./copyItemToParents');
 const getItemsWithParents = require('./getItemsWithParents');
 const addModifiersToParentItem = require('./addModifiersToParentItem');
+const removeEmptyNotes = require('./removeEmptyNotes');
+const getTaxes = require('./getTaxes');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -195,12 +197,14 @@ const orderActions = (deps = {}) => {
     splitItems: splitItems(innerDeps),
     getNewItems: getNewItems(innerDeps),
     mapSubOrders: mapSubOrders(innerDeps),
-    isFullyPaid: isFullyPaid(innerDeps),
+    isPaid: isPaid(innerDeps),
     getUpdatedStatus: getUpdatedStatus(innerDeps),
     setPieces: setPieces(innerDeps),
     copyItemToParents: copyItemToParents(innerDeps),
     getItemsWithParents: getItemsWithParents(innerDeps),
     addModifiersToParentItem: addModifiersToParentItem(innerDeps),
+    removeEmptyNotes: removeEmptyNotes(innerDeps),
+    getTaxes: getTaxes(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/isPaid.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function isPaid({ order }) {
+    if (!order) return false;
+
+    return order.status && order.status.paid;
+  };

package/lib/order/removeEmptyNotes.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function removeEmptyNotes(order) {
+    if (!order || !Array.isArray(order.notes)) return order;
+
+    return {
+      ...order,
+      notes: order.notes.filter(
+        note => !!note.message || !!note.file || !!note.url
+      ),
+    };
+  };

package/lib/order/unpick.js

@@ -6,8 +6,8 @@ module.exports = ({ itemActions }) =>
       const orderItems = [...(order.items || [])].map(item =>
         itemActions.unpickItem(item)
       );
-      if (nextOrder.status && nextOrder.status.fullyPicked) {
-        nextOrder.status.fullyPicked = false;
+      if (nextOrder.status && nextOrder.status.picked) {
+        nextOrder.status.picked = false;
       }
       nextOrder.items = orderItems;
     }
@@ -17,8 +17,8 @@ module.exports = ({ itemActions }) =>
           ..._order,
           items: _order.items.map(item => itemActions.unpickItem(item)),
         };
-        if (nextsubOrder.status && nextsubOrder.status.fullyPicked) {
-          nextsubOrder.status.fullyPicked = false;
+        if (nextsubOrder.status && nextsubOrder.status.picked) {
+          nextsubOrder.status.picked = false;
         }
         return nextsubOrder;
       });

package/lib/store/pickEndDate.js

@@ -35,9 +35,9 @@ module.exports = ({ settings, _, moment }) => {
 
   const getClosedDays = () => {
     const schedule = _.get(settings, 'schedule', {});
-    const { close = [] } = schedule;
-    if (!Array.isArray(close)) return [];
-    return close;
+    const { closed = [] } = schedule;
+    if (!Array.isArray(closed)) return [];
+    return closed;
   };
 
   const MAX_ADD_DAYS = 365;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.133",
+  "version": "1.0.135",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -52,5 +52,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "1cec04f4a6fc32238922712068994984b62ab92d"
+  "gitHead": "2ccf91f622bdc8de4548a2670d4a7293d335367e"
 }

package/lib/order/isFullyPaid.js

@@ -1,6 +0,0 @@
-module.exports = () =>
-  function isFullyPaid({ order }) {
-    if (!order) return false;
-
-    return order.status && order.status.fullyPaid;
-  };