@darkpos/pricing 1.0.5 → 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,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -18,25 +18,23 @@
     "access": "public"
   },
   "dependencies": {
-    "@darkpos/modifier": "1.0.1",
-    "@darkpos/utils": "1.0.6",
-    "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.8.0",
-    "eslint-config-airbnb": "^18.1.0",
-    "eslint-config-airbnb-base": "^14.1.0",
-    "eslint-config-prettier": "^6.10.1",
-    "eslint-plugin-import": "^2.20.1",
-    "eslint-plugin-jest": "^23.8.2",
-    "eslint-plugin-jsx-a11y": "^6.2.3",
-    "eslint-plugin-prettier": "^3.1.3",
-    "eslint-plugin-react": "^7.19.0",
-    "eslint-plugin-react-hooks": "^2.5.1",
-    "jest": "^25.1.0",
-    "prettier": "^1.19.1",
-    "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": "21acd4771ef10c9d65081a430d6e9cfe2c08069b"
+  "gitHead": "61d62f77f8bbbff2bfe0230bdb803d87516db17b"
 }