@darkpos/pricing 1.0.4 → 1.0.7

package/lib/order/pickEndDate.js

@@ -0,0 +1,70 @@
+module.exports = ({ settings, _, moment }) => {
+  const timezone = _.get(settings, 'localization.timezone', 'America/New_York');
+  const isInSchedule = (each, date) => {
+    const isoWeekday = moment(date).tz(timezone).isoWeekday();
+    let check = false;
+    if (each.day !== undefined && each.day !== null)
+      check = String(each.day) === String(isoWeekday === 7 ? 0 : isoWeekday);
+
+    if (each.date)
+      check =
+        moment(date).startOf('day').tz(timezone).format('YYYYMMDD') ===
+        moment(each.date).startOf('day').tz(timezone).format('YYYYMMDD');
+    return check;
+  };
+
+  const checkStoreSchedule = date => {
+    const schedule = _.get(settings, 'schedule', {});
+    const { close = [] } = schedule;
+
+    if (close.length) return !close.find(each => isInSchedule(each, date));
+
+    return true;
+  };
+  return function pickEndDate(schedule = {}, skip = 0, date = undefined) {
+    const {
+      addDays = 1,
+      hour,
+      minute,
+      skipDays = [],
+      cutHour,
+      cutDay = 1,
+    } = schedule;
+    let days = skip || Number(addDays);
+
+    const todayTimezone = moment().tz(timezone);
+    const dateTimezone = date || todayTimezone;
+
+    if (
+      !skip &&
+      !date &&
+      cutHour &&
+      todayTimezone.isAfter(moment(schedule.cutHour, 'hh:mm:ss').tz(timezone))
+    ) {
+      console.log('cut day applied');
+      days += cutDay;
+    }
+
+    const endDate = dateTimezone.add(Number(days), 'days');
+    console.log('check date => ', endDate.format());
+
+    const isoWeekday = endDate.isoWeekday();
+    console.log('isoWeekday => ', isoWeekday);
+
+    if (skipDays && skipDays.includes(isoWeekday === 7 ? 0 : isoWeekday)) {
+      console.log('check next day: in Skip days');
+      return pickEndDate(schedule, 1, endDate);
+    }
+    if (!checkStoreSchedule(endDate)) {
+      console.log('check next day: in Close days');
+      return pickEndDate(schedule, 1, endDate);
+    }
+
+    if (hour !== undefined) endDate.set('hour', hour);
+    if (minute !== undefined) endDate.set('minute', minute);
+    endDate.set('second', 0);
+
+    console.log('final date in local', endDate.format());
+    return moment.utc(endDate).format();
+  };
+};

package/lib/order/removeApplyModifier.js

@@ -0,0 +1,24 @@
+module.exports = ({ actions }) =>
+  function removeApplyModifier({
+    order,
+    attribute,
+    modifier,
+    applyItems = true,
+  }) {
+    if (!order) return order;
+    let newOrder = { ...order };
+
+    if (attribute) {
+      newOrder = actions.removeModifierByAttribute({
+        order,
+        attribute,
+        applyItems,
+      });
+    }
+
+    if (modifier) {
+      newOrder = actions.addModifier({ order: newOrder, modifier });
+    }
+
+    return newOrder;
+  };

package/lib/order/removeDiscountModifier.js

@@ -0,0 +1,16 @@
+module.exports = ({ modifierActions, itemActions }) =>
+  function removeDiscountModifiers(order) {
+    if (!order || !Array.isArray(order.modifiers)) return order;
+    const nextOrder = { ...order };
+    let { modifiers, items } = nextOrder;
+    const discountModifiers = modifiers.filter(modifierActions.isDiscount);
+    modifiers = modifiers.filter(each => !modifierActions.isDiscount(each));
+    if (items)
+      items = items.map(each =>
+        itemActions.removeModifiers({
+          item: each,
+          modifiers: discountModifiers,
+        })
+      );
+    return { ...order, modifiers, items };
+  };

package/lib/order/removeItem.js

@@ -0,0 +1,55 @@
+module.exports = ({ actions, _, itemActions }) => {
+  const updateRelatedItems = (items, parentId) =>
+    items.map(each => {
+      const item = { ...each };
+      if (item.properties && item.properties.parentId === parentId)
+        item.properties.includeParent = false;
+      return item;
+    });
+
+  return function removeItem({ order, item, checkQuantity, hard = true }) {
+    if (!item) return order;
+
+    const orderItemIdx = actions.getItemIndex({ order, item });
+    if (orderItemIdx < 0) return order;
+
+    let { items } = order;
+    const orderItem = items[orderItemIdx];
+    const relatedItems = actions.getRelatedItems({ order, item });
+    const hasRelatedItem = !_.isEmpty(relatedItems);
+
+    if (!hard || hasRelatedItem) {
+      items[orderItemIdx] = { ...orderItem, price: 0, modifiers: [] };
+      if (hasRelatedItem) {
+        items = updateRelatedItems(items, item._id);
+        // console.log('Update related items ...', items);
+      }
+    }
+    // Decrease the quantity
+    else if (
+      checkQuantity &&
+      items[orderItemIdx] &&
+      items[orderItemIdx].quantity > 1
+    )
+      items[orderItemIdx] = { ...orderItem, quantity: orderItem.quantity - 1 };
+    // Remove
+    else items.splice(orderItemIdx, 1);
+
+    // if it is the last relatedItem
+    if (
+      itemActions.isRelatedItem(item) &&
+      !itemActions.isParentIncluded(item)
+    ) {
+      const parent = itemActions.getParentItem(items, orderItem);
+      const parentIndex = actions.getItemIndex({ order, item: parent });
+      const siblings = actions.getRelatedItems({ order, item: parent });
+      // console.log('Removing parent item ...');
+      if (siblings <= 1) items.splice(parentIndex, 1);
+    }
+
+    return {
+      ...order,
+      items,
+    };
+  };
+};

package/lib/order/removeItemByIndex.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function removeItemByIndex({ order, itemIndex }) {
+    if (!order || !order.items || itemIndex < 0) return order;
+    return actions.removeItem({ order, item: order.items[itemIndex] });
+  };

package/lib/order/removeItemModifier.js

@@ -0,0 +1,69 @@
+module.exports = ({ actions, modifierActions, itemActions, utils, _ }) => {
+  const { math } = utils;
+
+  const getPrice = ({ item, modifier }) => {
+    const amount =
+      (modifier && modifier.compute && modifier.compute.amount) || 0;
+    const { price = 0 } = item;
+    if (modifierActions.isMultiplier(modifier)) return math.mul(price, amount);
+    return amount;
+  };
+
+  const removeModifier = ({ item, modifier, originalItem }) => {
+    const nextItem = { ...item, modifiers: [] };
+
+    nextItem.modifiers = item.modifiers.filter(
+      each => (each.modifierId || each._id) !== modifier._id
+    );
+
+    if (modifierActions.isAmountOverride(modifier))
+      return {
+        ...originalItem,
+        ...nextItem,
+      };
+
+    if (modifierActions.isPriceOverride(modifier))
+      nextItem.price = getPrice({ modifier, item: nextItem });
+
+    if (modifierActions.isQuantityOverride(modifier)) nextItem.quantity = 1;
+
+    return nextItem;
+  };
+
+  return function removeItemModifier({
+    order: orderProp,
+    modifier,
+    itemIndex,
+    cache,
+  }) {
+    const order = _.cloneDeep(orderProp);
+    if (!order || itemIndex < 0 || !modifier) return order;
+
+    let item = actions.getSelectedItem({ order, itemIndex });
+    const customer = actions.getCustomer(order);
+    const originalItem = cache.items.find(_item => _item._id === item.itemId);
+    const contains = modifierActions.contains(item.modifiers, modifier);
+
+    if (!contains) return order;
+    if (
+      modifierActions.isGroupOfValues(modifier) ||
+      modifierActions.isRequiredAndOverride(modifier)
+    )
+      return order;
+
+    // Remove
+    item = removeModifier({
+      item,
+      modifier,
+      originalItem,
+    });
+    item.price = itemActions.getItemPrice({
+      item,
+      cache,
+      customer,
+    });
+    order.items[itemIndex] = item;
+
+    return order;
+  };
+};

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.4",
+  "version": "1.0.7",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -11,27 +11,29 @@
   },
   "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"
   },
   "dependencies": {
-    "bson-objectid": "^1.3.0",
-    "decimal.js": "^10.2.0",
-    "lodash": "^4.17.15"
+    "@darkpos/utils": "1.0.8",
+    "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": "1da217c88e3d86a5ef73a7ad5f1fc4f56427c10d"
+  "gitHead": "1c4565d3c097c833093794654d8adc18e37767b9"
 }