@darkpos/pricing 1.0.3 → 1.0.6

package/lib/order/removeModifier.js

@@ -0,0 +1,21 @@
+module.exports = ({ modifierActions, itemActions }) =>
+  function removeModifier({ order, modifier }) {
+    if (!order || !modifier) return order;
+
+    const index = modifierActions.getModifierIndex({
+      entity: order,
+      modifier,
+    });
+    const nextOrder = { ...order };
+
+    if (index > -1) {
+      const { items, modifiers } = nextOrder;
+      if (items)
+        nextOrder.items = items.map(each =>
+          itemActions.removeModifier({ item: each, modifier: modifiers[index] })
+        );
+
+      nextOrder.modifiers.splice(index, 1);
+    }
+    return nextOrder;
+  };

package/lib/order/removeModifierByAttribute.js

@@ -0,0 +1,23 @@
+module.exports = ({ modifierActions }) =>
+  function removeModifierByAttribute({ order, attribute, applyItems = false }) {
+    if (!order || !attribute) return order;
+    if (!Array.isArray(order.modifiers)) return order;
+
+    const newOrder = { ...order };
+    newOrder.modifiers = order.modifiers.filter(
+      each => !modifierActions.hasAttribute(each, attribute)
+    );
+
+    if (applyItems && Array.isArray(order.items)) {
+      newOrder.items = order.items.map(item => {
+        if (!Array.isArray(item.modifiers)) return item;
+        return {
+          ...item,
+          modifiers: item.modifiers.filter(
+            each => !modifierActions.hasAttribute(each, attribute)
+          ),
+        };
+      });
+    }
+    return newOrder;
+  };

package/lib/order/removeModifiersWithPaymentMethods.js

@@ -0,0 +1,29 @@
+module.exports = () => {
+  const hasPaymentMethods = modifier =>
+    modifier.conditions &&
+    Array.isArray(modifier.conditions.paymentMethods) &&
+    modifier.conditions.paymentMethods.length;
+
+  return function removeModifiersWithPaymentMethods({
+    order,
+    applyItems = false,
+  }) {
+    if (!order || !Array.isArray(order.modifiers)) return order;
+
+    const newOrder = { ...order };
+    newOrder.modifiers = order.modifiers.filter(
+      each => !hasPaymentMethods(each)
+    );
+
+    if (applyItems && Array.isArray(order.items)) {
+      newOrder.items = order.items.map(item => {
+        if (!Array.isArray(item.modifiers)) return item;
+        return {
+          ...item,
+          modifiers: item.modifiers.filter(each => !hasPaymentMethods(each)),
+        };
+      });
+    }
+    return newOrder;
+  };
+};

package/lib/order/removeModifiersWithPaymentTypes.js

@@ -0,0 +1,27 @@
+module.exports = () => {
+  const hasPaymentTypes = modifier =>
+    modifier.conditions &&
+    Array.isArray(modifier.conditions.paymentTypes) &&
+    modifier.conditions.paymentTypes.length;
+
+  return function removeModifiersWithPaymentTypes({
+    order,
+    applyItems = false,
+  }) {
+    if (!order || !Array.isArray(order.modifiers)) return order;
+
+    const newOrder = { ...order };
+    newOrder.modifiers = order.modifiers.filter(each => !hasPaymentTypes(each));
+
+    if (applyItems && Array.isArray(order.items)) {
+      newOrder.items = order.items.map(item => {
+        if (!Array.isArray(item.modifiers)) return item;
+        return {
+          ...item,
+          modifiers: item.modifiers.filter(each => !hasPaymentTypes(each)),
+        };
+      });
+    }
+    return newOrder;
+  };
+};

package/lib/order/setCustomer.js

@@ -0,0 +1,50 @@
+module.exports = ({ itemActions, modifierActions, _ }) => {
+  const getTags = customer =>
+    (customer.tags || []).map(tag => tag.toLowerCase());
+
+  return function setCustomer({ order, customer, cache }) {
+    if (!order) return null;
+    // if (!customer) return { ...order, customer: null };
+
+    const { items = [] } = order;
+    const tags = customer ? getTags(customer) : ['default'];
+
+    const nextOrder = _.cloneDeep(order);
+    if (customer) {
+      nextOrder.customer = {
+        ..._.cloneDeep(customer),
+        isEmbedded: true,
+        tags,
+      };
+    } else nextOrder.customer = null;
+
+    if (!items.length) return nextOrder;
+
+    nextOrder.items = items.map(item => {
+      const originalItem = itemActions.findOriginalItem({ item, cache });
+      if (!originalItem) return item;
+
+      const newModifiers = modifierActions.getMatchTagsModifiers({
+        entity: customer,
+        modifiers: item.modifiers,
+      });
+
+      const price = itemActions.getItemPrice({
+        item,
+        customer,
+        cache,
+      });
+
+      const newItem = {
+        ...originalItem,
+        ...item,
+        modifiers: newModifiers,
+        price,
+      };
+
+      return newItem;
+    });
+
+    return nextOrder;
+  };
+};

package/lib/order/splitByDepartments.js

@@ -0,0 +1,151 @@
+module.exports = ({
+  utils,
+  _,
+  itemActions,
+  modifierActions,
+  actions,
+  settings,
+}) => {
+  const orderSettings = _.get(settings, 'order');
+  const { date, math, helpers } = utils;
+  const noteDefaults = {
+    message: '',
+    attributes: [],
+    date: date.toISOString(),
+    user: null,
+    url: '',
+    __typename: 'Note',
+  };
+
+  const getSplitModifiers = (modifiers, totalOriginOrder, totalSplitedOrder) =>
+    modifiers.map(each => {
+      const modifier = { ...each };
+      if (modifier.type === 'fixed' && modifier.amount) {
+        const amount = totalOriginOrder
+          ? math.div(
+              math.mul(modifier.amount, totalSplitedOrder || 0),
+              totalOriginOrder
+            )
+          : 0;
+        return {
+          ...modifier,
+          _id: helpers.getObjectID(),
+          amount,
+        };
+      }
+      return modifier;
+    });
+
+  const joinItemQuantity = orders =>
+    orders.map(order => {
+      const items = order.items.reduce((arr, item) => {
+        const _items = arr;
+        const index = _items.findIndex(each => {
+          const preSubs = modifierActions.getSubscriptionModifiers(
+            each.modifiers
+          );
+          const curSubs = modifierActions.getSubscriptionModifiers(
+            item.modifiers
+          );
+          return (
+            each.itemId === item.itemId &&
+            ((!each.serial && !item.serial) || each.serial === item.serial) &&
+            ((preSubs.length < 1 && curSubs.length < 1) ||
+              (preSubs.length > 0 && curSubs.length > 0))
+          );
+        });
+        if (index !== -1)
+          _items[index] = {
+            ..._items[index],
+            quantity: _items[index].quantity + item.quantity,
+          };
+        else _items.push(item);
+        return _items;
+      }, []);
+      return { ...order, items };
+    });
+
+  const getOrder =
+    ({ order, name }) =>
+    (items, index) => {
+      let displayId = '';
+      if (orderSettings.allowSuborder)
+        displayId = `${order.displayId}-${index}`;
+      else if (index === 1) displayId = order.displayId;
+      return {
+        ...order,
+        _id: helpers.getObjectID(),
+        displayId,
+        discount: 0,
+        tax: 0,
+        parentId: orderSettings.allowSuborder ? order._id : null,
+        items,
+        modifiers: [],
+        notes: [
+          ...(order.notes || []),
+          {
+            ...noteDefaults,
+            message: `Split from ${order.displayId}, for department ${name}`,
+          },
+        ],
+      };
+    };
+
+  const getDepartmentName = item => {
+    const deps = itemActions.getDepartmentModifiers(item);
+    return (deps.length && deps[0].name) || 'other';
+  };
+
+  return function splitByDepartments(order) {
+    const { items } = order;
+    const itemsByDepartments = _.groupBy(items, getDepartmentName);
+    const orders = Object.entries(itemsByDepartments);
+    let splitOrders = [];
+
+    orders.forEach(each => {
+      const [name, newItems] = each;
+      const create = getOrder({ order, name });
+      // Assuming there is one department in the item
+      const department = itemActions.getDepartmentModifiers(newItems[0])[0];
+      const departmentName = getDepartmentName(newItems[0]);
+      const maxItems = modifierActions.getDepartmentMaxItems(department);
+
+      if (
+        department &&
+        maxItems &&
+        itemActions.getItemsTotalPieces(newItems) > maxItems
+      ) {
+        newItems.forEach(newItem => {
+          for (let j = 0; j < newItem.quantity; j += 1) {
+            const item = {
+              ...newItem,
+              quantity: 1,
+              _id: helpers.getObjectID(),
+            };
+            const totalPieces = itemActions.getItemTotalPieces(item);
+            const index = splitOrders.findIndex(
+              newOrder =>
+                newOrder.items &&
+                itemActions.getItemsTotalPieces(newOrder.items) + totalPieces <=
+                  maxItems &&
+                departmentName === getDepartmentName(newOrder.items[0])
+            );
+            if (index > -1) splitOrders[index].items.push(item);
+            else splitOrders.push(create([item], splitOrders.length + 1));
+          }
+        });
+      } else splitOrders.push(create(newItems, splitOrders.length + 1));
+    });
+
+    splitOrders = joinItemQuantity(splitOrders);
+
+    return splitOrders.map(each => {
+      const { subTotal } = actions.calculate(each);
+      const newOrder = {
+        ...each,
+        modifiers: getSplitModifiers(order.modifiers, order.subTotal, subTotal),
+      };
+      return actions.calculate(newOrder);
+    });
+  };
+};

package/lib/order/toggleModifier.js

@@ -0,0 +1,9 @@
+module.exports = ({ actions, modifierActions }) =>
+  function toggleModifier({ order, modifier }) {
+    if (!order || !modifier) return order;
+
+    if (modifierActions.hasModifier({ entity: order, modifier })) {
+      return actions.removeModifier({ order, modifier });
+    }
+    return actions.addModifier({ order, modifier });
+  };

package/lib/order/updateItem.js

@@ -0,0 +1,8 @@
+module.exports = ({ _ }) =>
+  function updateItem({ order, itemIndex, item }) {
+    const updatedOrder = _.cloneDeep(order);
+    if (!order || !order.items || order.items.length < itemIndex)
+      return updatedOrder;
+    updatedOrder.items[itemIndex] = item;
+    return updatedOrder;
+  };

package/lib/order/updateItemQuantity.js

@@ -0,0 +1,35 @@
+module.exports = ({ actions, settings, _ }) => {
+  const orderSettings = _.get(settings, 'order');
+  return function updateItemQuantity({
+    order,
+    quantity,
+    itemIndex,
+    reset,
+    cache,
+  }) {
+    const item = actions.getSelectedItem({ order, itemIndex });
+    const isBefore = orderSettings.useKeypadOnItemAdd === 'before';
+
+    if ((!isBefore && item) || (item && item.isPending)) {
+      const updatedQuantity = reset
+        ? quantity
+        : parseInt(`${item.quantity}${quantity}`, 10);
+      return actions.addItem({
+        order,
+        item,
+        itemIndex,
+        cache,
+        overridenQuantity: updatedQuantity,
+      });
+    }
+    if (isBefore) {
+      return actions.addItem({
+        order,
+        item: { isPending: true },
+        cache,
+        overridenQuantity: quantity,
+      });
+    }
+    return order;
+  };
+};

package/lib/order/void.js

@@ -0,0 +1,11 @@
+module.exports = ({ constants }) =>
+  function voidOrder(order) {
+    if (!order) return order;
+    return {
+      ...order,
+      status: {
+        ...(order.status || {}),
+        order: constants.status.Order.VOID,
+      },
+    };
+  };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.3",
-  "description": "Pricing calculation",
+  "version": "1.0.6",
+  "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
   "homepage": "https://gitlab.com/darkpos/packages/dark#readme",
@@ -9,35 +9,32 @@
     "type": "git",
     "url": "git+https://gitlab.com/darkpos/packages/dark"
   },
-  "main": "./lib/index.js",
+  "main": "index.js",
   "scripts": {
-    "test": "jest --runInBand --detectOpenHandles --logHeapUsage --verbose --forceExit ./__TEST__"
+    "test": "jest --runInBand --detectOpenHandles --logHeapUsage --verbose --forceExit ./__TEST__",
+    "lint": "eslint --quiet --fix lib/"
   },
   "publishConfig": {
     "access": "public"
   },
-  "directories": {
-    "lib": "lib"
-  },
-  "files": [
-    "lib"
-  ],
   "dependencies": {
-    "bson-objectid": "^1.3.0",
-    "decimal.js": "^10.2.0",
-    "lodash": "^4.17.15"
+    "@darkpos/modifier": "1.0.2",
+    "@darkpos/utils": "1.0.7",
+    "lodash": "^4.17.21",
+    "moment-timezone": "^0.5.34"
   },
   "devDependencies": {
-    "eslint": "^6.3.0",
-    "eslint-config-airbnb": "^18.0.1",
-    "eslint-config-airbnb-base": "^14.0.0",
-    "eslint-config-prettier": "^6.2.0",
-    "eslint-plugin-jest": "^22.17.0",
-    "eslint-plugin-prettier": "^3.1.0",
-    "jest": "^25.1.0",
-    "prettier": "^1.18.2",
-    "supertest": "^4.0.2",
+    "eslint": "^8.2.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jest": "^26.5.3",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^28.1.1",
+    "prettier": "^2.7.0",
+    "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "e25675947c015b6eb69a49e918ed778ee41ecc85"
+  "gitHead": "61d62f77f8bbbff2bfe0230bdb803d87516db17b"
 }

package/lib/item/actions.js

@@ -1,135 +0,0 @@
-const modifierConstants = require('../modifier/constants');
-const modifierActions = require('../modifier/actions');
-const { math, defaultPrices } = require('../utils');
-
-/**
- * Remove order modifiers from items
- */
-const _removeOrderModifiers = items =>
-  items.map(item => ({
-    ...item,
-    modifiers: (item.modifiers || []).filter(
-      modifier => !modifierActions._hasAttribute(modifier, modifierConstants.attributes.distributed)
-    ),
-  }));
-
-/**
- * Get items with order modifier
- */
-const _getOrderModifiers = (items = []) =>
-  items
-    .reduce((modifiers, item) => [...modifiers, ...(item.modifiers || [])], [])
-    .filter(modifier =>
-      modifierActions._hasAttribute(modifier, modifierConstants.attributes.order)
-    );
-
-/**
- * Get Total prices of items
- */
-const _itemsPricing = (items = []) =>
-  items.reduce(
-    (prices, item) => ({
-      tax: math.add(prices.tax, item.tax),
-      subTotal: math.add(prices.subTotal, item.subTotal),
-      discount: math.add(prices.discount, item.discount),
-      distributed: math.add(prices.distributed, item.distributed),
-      total: math.add(prices.total, item.total),
-      fee: math.add(prices.fee, item.fee),
-    }),
-    defaultPrices
-  );
-
-/**
- * add order modifier to items
- */
-const _addOrderModifier = (order, items, modifier) => {
-  if (!modifierActions._hasAttribute(modifier, modifierConstants.attributes.distributed))
-    return items;
-
-  const itemsModifiers = {};
-  // get distributed price in order level
-  const modifierPrices = modifierActions.pricing(modifier, {
-    price: order.total,
-    quantity: 1,
-  });
-  const orderModifierTotal = math.abs(modifierPrices.distributed);
-
-  const totalDistributed = items.reduce((acc, item) => {
-    const distributedMod = modifierActions._createDistributedModifier(order, item, modifier);
-    itemsModifiers[item._id] = distributedMod;
-    return math.add(acc, math.mul(distributedMod.amount, item.quantity));
-  }, 0);
-
-  // check validation
-  if (math.abs(totalDistributed) !== math.abs(orderModifierTotal)) {
-    const difference = math.sub(orderModifierTotal, totalDistributed);
-    // console.log('difference => ', difference);
-    const selectedItem = items.find(item => math.sub(item.total, difference) > 0);
-
-    const distributedMod = itemsModifiers[selectedItem._id];
-    itemsModifiers[selectedItem._id] = {
-      ...distributedMod,
-      amount: math.add(distributedMod.amount, math.div(difference, selectedItem.quantity)),
-    };
-  }
-
-  return itemsModifiers;
-};
-
-/**
- * Get prices of an item
- */
-const pricing = item => {
-  const { modifiers = [] } = item;
-  const price = parseFloat(item.price);
-  const quantity = parseInt(item.quantity, 10);
-  const subTotal = math.mul(price, quantity);
-
-  if (modifiers.length) {
-    const modifiersPrices = modifierActions.pricingModifiers(modifiers, {
-      price,
-      quantity,
-    });
-    const total = math.add(subTotal, modifiersPrices.total);
-    return { ...modifiersPrices, price, total, subTotal };
-  }
-
-  return { ...defaultPrices, price, total: subTotal, subTotal };
-};
-
-/**
- * Get a calculated item
- */
-const calculateItem = item => {
-  const descriptions = [];
-  const modifiers = (item.modifiers || []).map(mod => {
-    const description = modifierActions._getDescription(mod);
-    descriptions.push(description);
-    return { ...mod, description };
-  });
-  //
-  const prices = pricing(item);
-
-  return {
-    ...item,
-    modifiers,
-    ...prices,
-    description: descriptions.join(', '),
-  };
-};
-
-/**
- * Get calculated items
- */
-const calculateItems = (items = []) => items.map(item => calculateItem(item));
-
-//
-module.exports = {
-  calculateItem,
-  calculateItems,
-  pricing,
-  _getOrderModifiers,
-  _removeOrderModifiers,
-  _addOrderModifier,
-  _itemsPricing,
-};