@darkpos/pricing 1.0.137 → 1.0.139

package/lib/index.js

@@ -9,6 +9,7 @@ const makeItemActions = require('./item');
 const makeOrderActions = require('./order');
 const makeModifierActions = require('./modifier');
 const makePaymentActions = require('./payment');
+const makeInvoiceActions = require('./invoice');
 
 const constants = require('./constants');
 
@@ -50,12 +51,22 @@ module.exports = session => {
     storeActions,
   });
 
+  const invoiceActions = makeInvoiceActions({
+    ...deps,
+    itemActions,
+    modifierActions,
+    orderActions,
+    storeActions,
+    paymentActions,
+  });
+
   return {
     item: itemActions,
     order: orderActions,
     modifier: modifierActions,
     store: storeActions,
     payment: paymentActions,
+    invoice: invoiceActions,
     constants,
   };
 };

package/lib/invoice/getStatusByItems.js

@@ -0,0 +1,22 @@
+module.exports = ({ utils, _ }) =>
+  function getStatusByItems({ items }) {
+    const { math } = utils;
+    if (!Array.isArray(items) || items.length === 0) return 'pending';
+
+    const totalPaid = items.reduce(
+      (total, item) => math.add(total, item.totalPaid),
+      0
+    );
+    const isInvoicePaid = items.every(
+      item => !!_.get(item, 'status.paid.value', false)
+    );
+    const isInvoicePartialPaid =
+      !isInvoicePaid &&
+      items.some(item => !!_.get(item, 'status.paid.value', false));
+
+    if (isInvoicePaid) return 'paid';
+    if (isInvoicePartialPaid || (!isInvoicePartialPaid && totalPaid > 0))
+      return 'partial';
+
+    return 'pending';
+  };

package/lib/invoice/getTotalByItems.js

@@ -0,0 +1,12 @@
+module.exports = ({ utils }) =>
+  function getTotalByItems({ items }) {
+    const { math } = utils;
+    if (!Array.isArray(items) || items.length === 0) return 0;
+
+    const total = items.reduce(
+      (itemsTotal, item) => math.add(itemsTotal, item.total),
+      0
+    );
+
+    return total;
+  };

package/lib/invoice/index.js

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

package/lib/item/applyPayment.js

@@ -0,0 +1,22 @@
+module.exports = () =>
+  function applyPayment({ paymentOrderItems, orderItem }) {
+    const itemOption = paymentOrderItems.find(
+      ({ orderItemId }) => String(orderItemId) === String(orderItem._id)
+    );
+
+    if (!itemOption) return orderItem;
+
+    const item = orderItem;
+
+    const paid =
+      itemOption.status && itemOption.status.paid && itemOption.status.paid;
+
+    return {
+      ...item,
+      status: {
+        ...item.status,
+        ...itemOption.status,
+        paid,
+      },
+    };
+  };

package/lib/item/calculate.js

@@ -8,8 +8,11 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       ...inputItem,
       quantity: math.max(0, Number(inputItem.quantity) || 0),
     });
-    const amountToPay =
-      typeof opts.amountToPay === 'number' ? opts.amountToPay : 0;
+    const amountToPay = actions.getAmountToPayById({
+      amountsToPay: opts.amountsToPay,
+      id: inputItem._id,
+    });
+
     const paymentMethod = opts.paymentMethod || null;
     const paymentType = opts.paymentType || null;
     const isPrepay = opts.isPrepay || false;
@@ -148,16 +151,19 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         let _modifier = modifier;
 
         if (modifierActions.isPaymentModifier(modifier)) {
+          const balance = actions.getBalanceForPaymentModifier({
+            item,
+            computedPrice,
+            modifier,
+          });
+
           _modifier = modifierActions.calculatePaymentModifier({
             paymentModifier: modifier,
             amountToPay:
               accumulatedAmount < 0 && amountToPay > 0
                 ? math.add(amountToPay, math.abs(accumulatedAmount))
                 : amountToPay,
-            itemBalance:
-              typeof item.totalPaid === 'number' && item.totalPaid > 0
-                ? actions.getItemsBalance({ items: [item] })
-                : math.sub(computedPrice, item.totalPaid),
+            itemBalance: math.max(0, balance),
             paymentId,
           });
         }
@@ -255,7 +261,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       modifiers: [...modifiersToNotCompute, ...modifiers],
       subTotals,
       total,
-      status: actions.getUpdatedStatus({ status: item.status, total }),
+      ...(item.status || {}),
     };
   };
 

package/lib/item/getAmountToPayById.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function getAmountToPayById({ amountsToPay, id }) {
+    if (!amountsToPay) return 0;
+
+    return amountsToPay[id] || 0;
+  };

package/lib/item/getBalanceForPaymentModifier.js

@@ -0,0 +1,30 @@
+module.exports = ({ utils, actions, modifierActions }) => {
+  const { math } = utils;
+  return function getBalanceForPaymentModifier({
+    item,
+    computedPrice,
+    modifier,
+  }) {
+    let balance =
+      typeof item.totalPaid === 'number' && item.totalPaid > 0
+        ? actions.getItemsBalance({ items: [item] })
+        : math.sub(computedPrice, item.totalPaid);
+
+    const modifiersAmount = item.modifiers.reduce((amount, mod) => {
+      if (
+        modifierActions.isCalculatedPaymentModifier(mod) &&
+        mod.locked &&
+        modifier.modifierId === mod.modifierId
+      ) {
+        return math.add(amount, mod._computed.amount);
+      }
+      return amount;
+    }, 0);
+
+    if (modifiersAmount > 0) {
+      balance = math.sub(balance, modifiersAmount);
+    }
+
+    return balance;
+  };
+};

package/lib/item/getPaidStatus.js

@@ -0,0 +1,29 @@
+module.exports = ({ actions, settings }) =>
+  function getPaidStatus({
+    status,
+    total: totalParam,
+    totalPaid: totalPaidParam,
+  }) {
+    const localStatus = status || {};
+
+    const total = totalParam || 0;
+    const totalPaid = totalPaidParam || 0;
+
+    if (
+      actions.isPaid({ item: { status: localStatus } }) &&
+      total !== 0 &&
+      total > totalPaid
+    ) {
+      return undefined;
+    }
+
+    if (!settings || !settings.order || !settings.order.autoMarkAsPaid) {
+      return localStatus.paid;
+    }
+
+    if (!actions.isPaid({ item: { status: localStatus } }) && total === 0) {
+      return { value: true, date: new Date() };
+    }
+
+    return localStatus.paid;
+  };

package/lib/item/index.js

@@ -59,7 +59,7 @@ const getSubtotal = require('./getSubtotal');
 const isSomeTagsMatch = require('./isSomeTagsMatch');
 const getTotals = require('./getTotals');
 const patchItem = require('./patchItem');
-const getUpdatedStatus = require('./getUpdatedStatus');
+const getPaidStatus = require('./getPaidStatus');
 const isOverwrittenPrice = require('./isOverwrittenPrice');
 const isOverwrittenQuantity = require('./isOverwrittenQuantity');
 const overrideNotes = require('./overrideNotes');
@@ -74,10 +74,14 @@ const isSerialLengthValid = require('./isSerialLengthValid');
 const getSerialStatus = require('./getSerialStatus');
 const removeDepartmentModifiers = require('./removeDepartmentModifiers');
 const isRemoveParentItem = require('./isRemoveParentItem');
+const isMergeWithParentItem = require('./isMergeWithParentItem');
 const hasRelatedItems = require('./hasRelatedItems');
 const getAddModifiers = require('./getAddModifiers');
 const hasAddModifiers = require('./hasAddModifiers');
 const getTaxes = require('./getTaxes');
+const getAmountToPayById = require('./getAmountToPayById');
+const applyPayment = require('./applyPayment');
+const getBalanceForPaymentModifier = require('./getBalanceForPaymentModifier');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -150,7 +154,7 @@ const itemActions = (deps = {}) => {
     isSomeTagsMatch: isSomeTagsMatch(innerDeps),
     getTotals: getTotals(innerDeps),
     patchItem: patchItem(innerDeps),
-    getUpdatedStatus: getUpdatedStatus(innerDeps),
+    getPaidStatus: getPaidStatus(innerDeps),
     isOverwrittenPrice: isOverwrittenPrice(innerDeps),
     isOverwrittenQuantity: isOverwrittenQuantity(innerDeps),
     overrideNotes: overrideNotes(innerDeps),
@@ -165,10 +169,14 @@ const itemActions = (deps = {}) => {
     getSerialStatus: getSerialStatus(innerDeps),
     removeDepartmentModifiers: removeDepartmentModifiers(innerDeps),
     isRemoveParentItem: isRemoveParentItem(innerDeps),
+    isMergeWithParentItem: isMergeWithParentItem(innerDeps),
     hasRelatedItems: hasRelatedItems(innerDeps),
     getAddModifiers: getAddModifiers(innerDeps),
     hasAddModifiers: hasAddModifiers(innerDeps),
     getTaxes: getTaxes(innerDeps),
+    getAmountToPayById: getAmountToPayById(innerDeps),
+    applyPayment: applyPayment(innerDeps),
+    getBalanceForPaymentModifier: getBalanceForPaymentModifier(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/isMergeWithParentItem.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isMergeWithParentItem(item) {
+    return !!(item && item.properties && item.properties.mergeWithParentItem);
+  };

package/lib/item/patchItem.js

@@ -5,7 +5,9 @@ module.exports = ({ actions, modifierActions }) =>
     const localItem = { ...item };
 
     const modifierIndex = item.modifiers.findIndex(
-      mod => modifierActions.isPercentage(mod) || !modifierActions.isDirect(mod)
+      mod =>
+        modifierActions.isValid(mod) &&
+        (modifierActions.isPercentage(mod) || !modifierActions.isDirect(mod))
     );
 
     localItem.modifiers[modifierIndex] = modifierActions.patchModifier({

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 isMergeWithParentItem = require('./isMergeWithParentItem');
 const isTax = require('./isTax');
 
 const modifierActions = (deps = {}) => {
@@ -377,6 +378,7 @@ const modifierActions = (deps = {}) => {
     getAmountMultiplier: getAmountMultiplier(innerDeps),
     isAmountMultiplier: isAmountMultiplier(innerDeps),
     isRemoveParentItem: isRemoveParentItem(innerDeps),
+    isMergeWithParentItem: isMergeWithParentItem(innerDeps),
     isTax: isTax(innerDeps),
   });
 

package/lib/modifier/isMergeWithParentItem.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isMergeWithParentItem(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.group &&
+      modifier.properties.group.mergeWithParentItem
+    );
+  };

package/lib/modifier/patchModifier.js

@@ -9,6 +9,10 @@ module.exports = ({ utils, actions }) =>
       difference
     );
 
+    modifier.properties = {
+      ...(modifier.properties || {}),
+    };
+
     modifier._computed.description = actions.createDescription({
       modifier: {
         ...modifier,

package/lib/order/addItem.js

@@ -253,7 +253,7 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       nextItemIndex,
     });
 
-    if (reArrangedOrder && newIndex) {
+    if (reArrangedOrder && newIndex >= 0) {
       nextOrder = { ...reArrangedOrder };
       nextItemIndex = newIndex;
     }
@@ -262,7 +262,7 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
 
     if (combined && pendingItemIndex > -1 && idx !== itemIndex) {
       const idxToRemove = actions.getPendingItemIndex(nextOrder);
-      nextOrder.items.splice(idxToRemove, 1);
+      if (idxToRemove > -1) nextOrder.items.splice(idxToRemove, 1);
     }
 
     nextOrder = actions.addModifiersToParentItem({
@@ -270,10 +270,29 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       relatedItem: orderItem,
     });
 
+    const relatedItemFromOrder =
+      actions.getSelectedItem({ order: nextOrder, itemIndex: nextItemIndex }) ||
+      nextItem ||
+      orderItem;
+
+    let newItem = relatedItemFromOrder;
+
+    if (itemActions.isMergeWithParentItem(relatedItemFromOrder)) {
+      const result = actions.mergeRelatedItemWithParentItem({
+        order: nextOrder,
+        relatedItem: relatedItemFromOrder,
+        originalItem: item,
+      });
+      nextOrder = result.order;
+      newItem = result.parent;
+    }
+
     return {
       updatedOrder: nextOrder,
-      itemIndex: nextItemIndex,
-      item: nextItem,
+      item: newItem,
+      itemIndex: nextOrder.items.findIndex(
+        eachItem => eachItem._id === newItem._id
+      ),
     };
   };
 };

package/lib/order/calculate.js

@@ -126,8 +126,9 @@ module.exports = ({
           !itemActions.isPaid(item) &&
           item.modifiers.some(
             mod =>
-              modifierActions.isPercentage(mod) ||
-              !modifierActions.isDirect(mod)
+              modifierActions.isValid(mod) &&
+              (modifierActions.isPercentage(mod) ||
+                !modifierActions.isDirect(mod))
           )
       );
 
@@ -153,13 +154,56 @@ module.exports = ({
     const pieceCount = calculatedItems.length
       ? itemActions.getItemsTotalPieces(calculatedItems)
       : order.properties.pieceCount;
+
+    calculatedItems = calculatedItems.map(calcItem => {
+      let itemTotalPaid = calcItem.totalPaid;
+
+      const amountToPay = itemActions.getAmountToPayById({
+        amountsToPay: opts.amountsToPay,
+        id: calcItem._id,
+      });
+      if (amountToPay) {
+        itemTotalPaid = utils.math.add(itemTotalPaid, amountToPay);
+      }
+      return {
+        ...calcItem,
+        totalPaid: itemTotalPaid,
+        status: {
+          ...calcItem.status,
+          paid: itemActions.getPaidStatus({
+            status: calcItem.status,
+            total: calcItem.total,
+            totalPaid: itemTotalPaid,
+          }),
+        },
+      };
+    });
+
+    const totalPaid = itemActions.getItemsTotalPaid({
+      orderItems: calculatedItems,
+    });
+
+    const picked = actions.getPickedStatus({ items: calculatedItems });
+    const paid = actions.getPaidStatus({
+      items: calculatedItems,
+      status: order.status,
+      total,
+      totalPaid,
+    });
+
     return {
       ...order,
       subTotals,
       subTotal,
       total,
       items: calculatedItems,
-      status: actions.getUpdatedStatus({ status: order.status, total }),
+      status: {
+        ...(order.status || {}),
+        picked,
+        paid,
+        order: picked && paid ? 'closed' : 'open',
+      },
+      totalPaid,
       properties: {
         ...(order.properties || {}),
         pieceCount,

package/lib/order/calculateWithPayment.js

@@ -0,0 +1,36 @@
+module.exports = ({ actions, itemActions }) =>
+  function calculateWithPayment({
+    order,
+    paymentOrderItems,
+    paymentMethod,
+    paymentType,
+    isPrepay,
+    paymentId,
+  }) {
+    const amountsToPay = paymentOrderItems
+      .filter(each => order.items.find(item => each.orderItemId === item._id))
+      .reduce(
+        (prevVal, val) => ({
+          ...prevVal,
+          [val.orderItemId]: val.amount,
+        }),
+        {}
+      );
+
+    return actions.calculate(
+      {
+        ...order,
+        items: order.items.map(orderItem =>
+          itemActions.applyPayment({ paymentOrderItems, orderItem })
+        ),
+      },
+      {
+        paymentMethod,
+        paymentType,
+        isPrepay,
+        amountsToPay,
+        lockPaymentModifiers: true,
+        paymentId,
+      }
+    );
+  };

package/lib/order/getPaidStatus.js

@@ -0,0 +1,35 @@
+module.exports = ({ actions, settings, _ }) =>
+  function getPaidStatus({
+    items,
+    status,
+    total: totalParam,
+    totalPaid: totalPaidParam,
+  }) {
+    const localStatus = status || {};
+
+    const total = totalParam || 0;
+    const totalPaid = totalPaidParam || 0;
+
+    const areAllItemsPaid = items.every(
+      item => !!_.get(item, 'status.paid.value', false)
+    );
+
+    if (areAllItemsPaid) return true;
+
+    if (
+      actions.isPaid({ order: { status: localStatus } }) &&
+      total !== 0 &&
+      total > totalPaid
+    ) {
+      return false;
+    }
+
+    if (!settings || !settings.order || !settings.order.autoMarkAsPaid)
+      return !!localStatus.paid;
+
+    if (!actions.isPaid({ order: { status: localStatus } }) && total === 0) {
+      return true;
+    }
+
+    return !!localStatus.paid;
+  };

package/lib/order/getPickedStatus.js

@@ -0,0 +1,4 @@
+module.exports = ({ _ }) =>
+  function getPickedStatus({ items }) {
+    return items.every(item => !!_.get(item, 'status.picked.value', false));
+  };

package/lib/order/index.js

@@ -90,13 +90,16 @@ const splitItems = require('./splitItems');
 const getNewItems = require('./getNewItems');
 const mapSubOrders = require('./mapSubOrders');
 const isPaid = require('./isPaid');
-const getUpdatedStatus = require('./getUpdatedStatus');
+const getPaidStatus = require('./getPaidStatus');
 const setPieces = require('./setPieces');
 const copyItemToParents = require('./copyItemToParents');
 const getItemsWithParents = require('./getItemsWithParents');
 const addModifiersToParentItem = require('./addModifiersToParentItem');
+const mergeRelatedItemWithParentItem = require('./mergeRelatedItemWithParentItem');
 const removeEmptyNotes = require('./removeEmptyNotes');
 const getTaxes = require('./getTaxes');
+const getPickedStatus = require('./getPickedStatus');
+const calculateWithPayment = require('./calculateWithPayment');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -198,13 +201,16 @@ const orderActions = (deps = {}) => {
     getNewItems: getNewItems(innerDeps),
     mapSubOrders: mapSubOrders(innerDeps),
     isPaid: isPaid(innerDeps),
-    getUpdatedStatus: getUpdatedStatus(innerDeps),
+    getPaidStatus: getPaidStatus(innerDeps),
     setPieces: setPieces(innerDeps),
     copyItemToParents: copyItemToParents(innerDeps),
     getItemsWithParents: getItemsWithParents(innerDeps),
     addModifiersToParentItem: addModifiersToParentItem(innerDeps),
+    mergeRelatedItemWithParentItem: mergeRelatedItemWithParentItem(innerDeps),
     removeEmptyNotes: removeEmptyNotes(innerDeps),
     getTaxes: getTaxes(innerDeps),
+    getPickedStatus: getPickedStatus(innerDeps),
+    calculateWithPayment: calculateWithPayment(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/mergeRelatedItemWithParentItem.js

@@ -0,0 +1,94 @@
+module.exports = ({ actions, itemActions, utils }) => {
+  const { math } = utils;
+
+  return function mergeRelatedItemWithParentItem({
+    order,
+    relatedItem,
+    originalItem,
+  }) {
+    if (
+      !order ||
+      !itemActions.isRelatedItem(relatedItem) ||
+      (!itemActions.isMergeWithParentItem(originalItem) &&
+        !itemActions.isMergeWithParentItem(relatedItem))
+    ) {
+      return order;
+    }
+
+    if (!Array.isArray(order.items)) return order;
+
+    const nextOrder = { ...order };
+
+    const parentItem = itemActions.getParentItem(nextOrder.items, relatedItem);
+    if (!parentItem) return nextOrder;
+
+    const parentIndex = actions.getItemIndex({
+      order: nextOrder,
+      item: parentItem,
+    });
+    if (parentIndex < 0) return nextOrder;
+
+    const relatedIndex = actions.getItemIndex({
+      order: nextOrder,
+      item: relatedItem,
+    });
+    if (relatedIndex < 0) return nextOrder;
+
+    let updatedParent = parentItem;
+
+    if (relatedItem && relatedItem.name) {
+      if (!updatedParent.name) updatedParent.name = relatedItem.name;
+      else if (!updatedParent.name.includes(relatedItem.name)) {
+        updatedParent.name = `${updatedParent.name} - ${relatedItem.name}`;
+      }
+    }
+
+    if (typeof relatedItem.price === 'number') {
+      updatedParent.price = math.add(
+        updatedParent.price || 0,
+        relatedItem.price
+      );
+    }
+
+    nextOrder.items = [...nextOrder.items];
+    nextOrder.items[parentIndex] = updatedParent;
+
+    const relatedModifiers = Array.isArray(relatedItem.modifiers)
+      ? relatedItem.modifiers
+      : [];
+
+    if (relatedModifiers.length) {
+      const parentModifierIds = (updatedParent.modifiers || [])
+        .map(mod => mod.modifierId || mod._id)
+        .filter(Boolean);
+
+      const modifiersToAdd = relatedModifiers.filter(mod => {
+        const modId = mod.modifierId || mod._id;
+        return modId && !parentModifierIds.includes(modId);
+      });
+
+      if (modifiersToAdd.length) {
+        const orderWithModifiers = modifiersToAdd.reduce(
+          (acc, modifier) =>
+            actions.addItemModifier({
+              itemIndex: parentIndex,
+              order: acc,
+              modifier,
+              originalItem: updatedParent,
+            }),
+          nextOrder
+        );
+        nextOrder.items = orderWithModifiers.items;
+      }
+    }
+
+    updatedParent =
+      actions.getSelectedItem({ order: nextOrder, itemIndex: parentIndex }) ||
+      updatedParent;
+
+    nextOrder.items[parentIndex] = updatedParent;
+    nextOrder.items.splice(relatedIndex, 1);
+
+    return { order: nextOrder, parent: updatedParent };
+  };
+};