@darkpos/pricing 1.0.41 → 1.0.44

package/lib/modifier/index.js

@@ -19,8 +19,6 @@ const duplicate = require('./duplicate');
 const enableAutoPopup = require('./enableAutoPopup');
 const filterByRequiredModifiers = require('./filterByRequiredModifiers');
 const findById = require('./findById');
-const findByPaymentMethod = require('./findByPaymentMethod');
-const findByPaymentType = require('./findByPaymentType');
 const getAvailablePromotions = require('./getAvailablePromotions');
 const getAvailablePromotionsOrSubscriptions = require('./getAvailablePromotionsOrSubscriptions');
 const getAvailableSubscriptions = require('./getAvailableSubscriptions');
@@ -82,6 +80,7 @@ const isDirect = require('./isDirect');
 const hasNoTags = require('./hasNoTags');
 const isRemoveModifier = require('./isRemoveModifier');
 const isGroupOfModifiers = require('./isGroupOfModifiers');
+const areConditionsMet = require('./areConditionsMet');
 const isRequiredAndOverride = require('./isRequiredAndOverride');
 const isManual = require('./isManual');
 const isPriceOverride = require('./isPriceOverride');
@@ -102,6 +101,7 @@ const isDefault = require('./isDefault');
 const isIncluded = require('./isIncluded');
 const isCustomerTagsExtend = require('./isCustomerTagsExtend');
 const isAmountOverride = require('./isAmountOverride');
+const isValid = require('./isValid');
 const isDiscount = require('./isDiscount');
 const isHidden = require('./isHidden');
 const isIgnoreQuantity = require('./isIgnoreQuantity');
@@ -124,11 +124,19 @@ const isFixedAdd = require('./isFixedAdd');
 const isFee = require('./isFee');
 const isAdd = require('./isAdd');
 const mutateModifier = require('./mutateModifier');
-
 const isFixedDiscount = require('./isFixedDiscount');
 const removeLocked = require('./removeLocked');
 const hasItems = require('./hasItems');
 const getLockedModifiers = require('./getLockedModifiers');
+const getGroupedModifiers = require('./getGroupedModifiers');
+const getNotesToModifierTags = require('./getNotesToModifierTags');
+const isOptionsOverride = require('./isOptionsOverride');
+const getGroupedModifierLabels = require('./getGroupedModifierLabels');
+const validate = require('./validate');
+const validateNumberCondition = require('./validateNumberCondition');
+const validateRequiredModifiers = require('./validateRequiredModifiers');
+const validateDateDaysDiff = require('./validateDateDaysDiff');
+const validateInArr = require('./validateInArr');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -159,8 +167,6 @@ const modifierActions = (deps = {}) => {
     enableAutoPopup: enableAutoPopup(innerDeps),
     filterByRequiredModifiers: filterByRequiredModifiers(innerDeps),
     findById: findById(innerDeps),
-    findByPaymentMethod: findByPaymentMethod(innerDeps),
-    findByPaymentType: findByPaymentType(innerDeps),
     getAvailablePromotions: getAvailablePromotions(innerDeps),
     getAvailablePromotionsOrSubscriptions:
       getAvailablePromotionsOrSubscriptions(innerDeps),
@@ -243,6 +249,7 @@ const modifierActions = (deps = {}) => {
     isDefault: isDefault(innerDeps),
     isCustomerTagsExtend: isCustomerTagsExtend(innerDeps),
     isAmountOverride: isAmountOverride(innerDeps),
+    isValid: isValid(innerDeps),
     isDiscount: isDiscount(innerDeps),
     isHidden: isHidden(innerDeps),
     isIgnoreQuantity: isIgnoreQuantity(innerDeps),
@@ -269,6 +276,16 @@ const modifierActions = (deps = {}) => {
     isFee: isFee(innerDeps),
     isAdd: isAdd(innerDeps),
     mutateModifier: mutateModifier(innerDeps),
+    getGroupedModifiers: getGroupedModifiers(innerDeps),
+    getNotesToModifierTags: getNotesToModifierTags(innerDeps),
+    isOptionsOverride: isOptionsOverride(innerDeps),
+    getGroupedModifierLabels: getGroupedModifierLabels(innerDeps),
+    validate: validate(innerDeps),
+    validateNumberCondition: validateNumberCondition(innerDeps),
+    validateRequiredModifiers: validateRequiredModifiers(innerDeps),
+    validateDateDaysDiff: validateDateDaysDiff(innerDeps),
+    validateInArr: validateInArr(innerDeps),
+    areConditionsMet: areConditionsMet(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isOptionsOverride.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isOptionsOverride(modifier) {
+    if (!modifier || !modifier.properties || !modifier.properties.override)
+      return false;
+    return (
+      modifier.properties.override.options &&
+      modifier.properties.override.options.length > 0
+    );
+  };

package/lib/modifier/isPaymentMethodModifier.js

@@ -3,6 +3,6 @@ module.exports = () =>
     return !!(
       modifier &&
       modifier.conditions &&
-      (modifier.conditions.paymentMethods || []).length > 0
+      modifier.conditions.some(condition => condition.key === 'paymentMethods')
     );
   };

package/lib/modifier/isPaymentTypeModifier.js

@@ -3,6 +3,6 @@ module.exports = () =>
     return !!(
       modifier &&
       modifier.conditions &&
-      (modifier.conditions.paymentTypes || []).length > 0
+      modifier.conditions.some(condition => condition.key === 'paymentTypes')
     );
   };

package/lib/modifier/isValid.js

@@ -0,0 +1,12 @@
+module.exports = () =>
+  function isValid(modifier) {
+    if (
+      !modifier ||
+      !modifier.conditions ||
+      modifier.conditions.valid === undefined ||
+      modifier.conditions.valid === null
+    )
+      return true;
+
+    return !!modifier.conditions.valid;
+  };

package/lib/modifier/validate.js

@@ -0,0 +1,14 @@
+module.exports = ({ actions }) => {
+  function validate(modifier, opts) {
+    if (!modifier) return modifier;
+
+    return {
+      ...modifier,
+      conditions: {
+        ...(modifier.conditions || {}),
+        valid: !!actions.areConditionsMet(modifier, opts),
+      },
+    };
+  }
+  return validate;
+};

package/lib/modifier/validateDateDaysDiff.js

@@ -0,0 +1,30 @@
+module.exports = () =>
+  function validateDateDaysDiff(
+    startRequestDate,
+    endRequestDate,
+    conditionNumber,
+    operand
+  ) {
+    if (!conditionNumber && !operand) return true;
+    if (!startRequestDate || !endRequestDate) return false;
+    const diff = Math.abs(
+      new Date(endRequestDate) - new Date(startRequestDate)
+    );
+    const diffDays = Math.ceil(diff / (1000 * 60 * 60 * 24));
+    switch (operand) {
+      case '$eq':
+        return diffDays === conditionNumber;
+      case '$ne':
+        return diffDays !== conditionNumber;
+      case '$gt':
+        return diffDays > conditionNumber;
+      case '$gte':
+        return diffDays >= conditionNumber;
+      case '$lt':
+        return diffDays < conditionNumber;
+      case '$lte':
+        return diffDays <= conditionNumber;
+      default:
+        return false;
+    }
+  };

package/lib/modifier/validateInArr.js

@@ -0,0 +1,12 @@
+module.exports = ({ _ }) =>
+  function validateInArr(item, requiredArr, operand) {
+    if (_.isEmpty(requiredArr) && !operand) return true;
+    switch (operand) {
+      case '$in':
+        return requiredArr.some(each => item === each);
+      case '$nin':
+        return requiredArr.every(each => item !== each);
+      default:
+        return false;
+    }
+  };

package/lib/modifier/validateNumberCondition.js

@@ -0,0 +1,20 @@
+module.exports = () =>
+  function validateNumberCondition(itemNumber, conditionNumber, operand) {
+    if (!conditionNumber && !operand) return true;
+    switch (operand) {
+      case '$eq':
+        return Number(conditionNumber) === itemNumber;
+      case '$ne':
+        return Number(conditionNumber) !== itemNumber;
+      case '$gt':
+        return Number(conditionNumber) < itemNumber;
+      case '$gte':
+        return Number(conditionNumber) <= itemNumber;
+      case '$lt':
+        return Number(conditionNumber) > itemNumber;
+      case '$lte':
+        return Number(conditionNumber) >= itemNumber;
+      default:
+        return false;
+    }
+  };

package/lib/modifier/validateRequiredModifiers.js

@@ -0,0 +1,16 @@
+module.exports = ({ actions, _ }) =>
+  function validateRequiredModifiers(modifiers, requiredModifiers, operand) {
+    if (_.isEmpty(requiredModifiers) && !operand) return true;
+    switch (operand) {
+      case '$in':
+        return requiredModifiers.some(each =>
+          actions.contains(modifiers, each)
+        );
+      case '$nin':
+        return requiredModifiers.every(
+          each => !actions.contains(modifiers, each)
+        );
+      default:
+        return false;
+    }
+  };

package/lib/order/addItemModifier.js

@@ -27,31 +27,71 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     return false;
   };
 
-  const validateItemPiecesCondition = (itemPieces, minPieces) => {
-    if (!minPieces) return true;
-    return minPieces <= itemPieces;
-  };
-
-  const validateItemQtyCondition = (itemQuantity, minQuantity) => {
-    if (!minQuantity) return true;
-    return minQuantity <= itemQuantity;
-  };
-
-  const validateRequiredModifiers = (modifiers, requiredModifiers) => {
-    if (_.isEmpty(modifiers) || _.isEmpty(requiredModifiers)) return true;
-    return requiredModifiers.every(each =>
-      modifierActions.contains(modifiers, each)
-    );
-  };
-
   const areConditionsMet = (item, conditions) => {
-    if (!conditions) return true;
-
-    return (
-      validateItemPiecesCondition(item.pieces, conditions.minItemPieces) &&
-      validateItemQtyCondition(item.quantity, conditions.minItemQuantity) &&
-      validateRequiredModifiers(item.modifiers, conditions.modifiers)
+    const conditionsBag = [];
+    if (!conditions || !conditions.rules) return conditionsBag;
+    // Find conditions with itemPieces as key
+    const itemPiecesConditions = conditions.rules.filter(
+      each => each.key === 'itemPieces'
     );
+    if (itemPiecesConditions.length > 0) {
+      itemPiecesConditions.forEach(each => {
+        if (
+          !modifierActions.validateNumberCondition(
+            item.pieces,
+            each.value,
+            each.operand
+          )
+        ) {
+          conditionsBag.push({
+            name: `${each.operand}.itemPieces`,
+            value: each.value,
+            current: item.pieces,
+          });
+        }
+      });
+    }
+    const itemQtyConditions = conditions.rules.filter(
+      each => each.key === 'itemQuantity'
+    );
+    if (itemQtyConditions.length > 0) {
+      itemQtyConditions.forEach(each => {
+        if (
+          !modifierActions.validateNumberCondition(
+            item.quantity,
+            each.value,
+            each.operand
+          )
+        ) {
+          conditionsBag.push({
+            name: `${each.operand}.itemQuantity`,
+            value: each.value,
+            current: item.quantity,
+          });
+        }
+      });
+    }
+    const requiredModifiersConditions = conditions.rules.filter(
+      each => each.key === 'modifiers'
+    );
+    if (requiredModifiersConditions.length > 0) {
+      requiredModifiersConditions.forEach(each => {
+        if (
+          !modifierActions.validateRequiredModifiers(
+            item.modifiers,
+            each.value,
+            each.operand
+          )
+        ) {
+          conditionsBag.push({
+            name: `${each.operand}.modifiers`,
+            value: each.value,
+            current: item.modifiers,
+          });
+        }
+      });
+    }
+    return conditionsBag;
   };
 
   const addModifier = ({
@@ -63,19 +103,21 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
       items: [],
       itemModifiers: [],
     },
+    onConditionsNotMet,
   }) => {
     const modifier = _modifier; // to avoid no param reassign lint rule
     let item = { ...itemProp };
     const compute = getComputeModField(modifier);
     if (hasBehaivoralFields(modifier)) return item;
-    // check conditions
-    if (!areConditionsMet(item, modifier.conditions)) return item;
+    const conditionsBag = areConditionsMet(item, modifier.conditions);
     const isAmountOverride = modifierActions.isAmountOverride(modifier);
     const isPriceOverride = modifierActions.isPriceOverride(modifier);
-
-    // change modifier compute based on onverride and creates a clone of  the modifier
+    // is the modifier suggestion required
+    if (conditionsBag.length > 0 && !modifierActions.isRequired(modifier)) {
+      if (onConditionsNotMet) onConditionsNotMet(conditionsBag);
+      return item;
+    }
     const modifierToAdd = modifierActions.mutateModifier(modifier);
-
     const modifierIndex = item.modifiers.findIndex(
       ieach => ieach.modifierId === modifier._id
     );
@@ -122,6 +164,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     modifier,
     itemIndex,
     cache,
+    onConditionsNotMet,
   }) {
     let order = _.cloneDeep(orderProp);
     if (!order || itemIndex < 0 || !modifier) return order;
@@ -166,6 +209,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
       modifier,
       cache,
       customer,
+      onConditionsNotMet,
     });
 
     // Recursive Rules:

package/lib/order/calculate.js

@@ -3,18 +3,23 @@
  * return calculated Order
  */
 module.exports = ({ _, actions, itemActions, modifierActions }) =>
-  function calculateorder(inputOrder) {
+  function calculateorder(inputOrder, opts = {}) {
     if (!inputOrder) return inputOrder;
     const order = _.cloneDeep(inputOrder);
     const { items = [], orders = [] } = order;
-
     if (!items.length) {
       if (!orders.length)
         return { ...order, subTotals: {}, subTotal: 0, total: 0 };
 
       return { ...order, ...actions.getTotals(order.orders) };
     }
-
+    const startRequestDate = order.start ? order.start.requestDate : null;
+    const endRequestDate = order.end ? order.end.requestDate : null;
+    const options = {
+      ...opts,
+      startRequestDate,
+      endRequestDate,
+    };
     const sortedOrderModifiers = modifierActions.sort(
       modifierActions.removeLocked(order.modifiers)
     );
@@ -23,7 +28,7 @@ module.exports = ({ _, actions, itemActions, modifierActions }) =>
       itemActions.removeModifiers({ item, modifiers: sortedOrderModifiers })
     );
 
-    itemsWNIM = itemActions.calculate(itemsWNIM);
+    itemsWNIM = itemActions.calculate(itemsWNIM, options);
 
     const newOrder = {
       ...order,
@@ -55,11 +60,11 @@ module.exports = ({ _, actions, itemActions, modifierActions }) =>
         } else {
           tempItems = itemsWIM;
         }
-        tempItems = itemActions.calculate(tempItems);
+        tempItems = itemActions.calculate(tempItems, options);
       }
 
       if (isCredit) {
-        const calculatedItemWIM = itemActions.calculate(itemsWIM);
+        const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
         computedTotal = itemActions.getTotals(calculatedItemWIM).total;
       }
 
@@ -92,7 +97,7 @@ module.exports = ({ _, actions, itemActions, modifierActions }) =>
       prvSort = sort;
     }
 
-    const calculatedItemWIM = itemActions.calculate(itemsWIM);
+    const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
 
     return {
       ...order,

package/lib/order/index.js

@@ -72,7 +72,6 @@ const getItemIndex = require('./getItemIndex');
 const getRelatedItems = require('./getRelatedItems');
 const getItemByItemId = require('./getItemByItemId');
 const getScheduleByCustomer = require('./getScheduleByCustomer');
-const pickEndDate = require('./pickEndDate');
 const getAppliedCredit = require('./getAppliedCredit');
 const addCreditModifier = require('./addCreditModifier');
 const adjustCreditModifiersDifference = require('./adjustCreditModifiersDifference');
@@ -172,7 +171,6 @@ const orderActions = (deps = {}) => {
     getItemIndex: getItemIndex(innerDeps),
     getRelatedItems: getRelatedItems(innerDeps),
     getScheduleByCustomer: getScheduleByCustomer(innerDeps),
-    pickEndDate: pickEndDate(innerDeps),
     getAppliedCredit: getAppliedCredit(innerDeps),
     addCreditModifier: addCreditModifier(innerDeps),
     adjustCreditModifiersDifference: adjustCreditModifiersDifference(innerDeps),

package/lib/order/removeModifiersWithPaymentMethods.js

@@ -1,8 +1,7 @@
 module.exports = () => {
   const hasPaymentMethods = modifier =>
     modifier.conditions &&
-    Array.isArray(modifier.conditions.paymentMethods) &&
-    modifier.conditions.paymentMethods.length;
+    modifier.conditions.some(condition => condition.key === 'paymentMethods');
 
   return function removeModifiersWithPaymentMethods({
     order,

package/lib/order/removeModifiersWithPaymentTypes.js

@@ -1,8 +1,7 @@
 module.exports = () => {
   const hasPaymentTypes = modifier =>
     modifier.conditions &&
-    Array.isArray(modifier.conditions.paymentTypes) &&
-    modifier.conditions.paymentTypes.length;
+    modifier.conditions.some(condition => condition.key === 'paymentMethods');
 
   return function removeModifiersWithPaymentTypes({
     order,

package/lib/store/getRecommendedEndDate.js

@@ -0,0 +1,13 @@
+module.exports = ({ actions, settings }) =>
+  function getRecommendedEndDate() {
+    const defaultSchedule =
+      settings.order &&
+      settings.order.endDate &&
+      settings.order.endDate.default;
+
+    return defaultSchedule
+      ? actions.pickEndDate({
+          ...defaultSchedule,
+        })
+      : null;
+  };

package/lib/store/index.js

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

package/lib/store/pickEndDate.js

@@ -0,0 +1,62 @@
+module.exports = ({ settings, _, moment }) => {
+  const timezone = _.get(settings, 'localization.timezone', 'America/New_York');
+
+  const getClosedDays = () => {
+    const schedule = _.get(settings, 'schedule', {});
+    const { close = [] } = schedule;
+
+    if (!Array.isArray(close)) return [];
+    return close.map(closedDate => ({
+      date: moment(closedDate.date), // the date is saved with the user timezone, no need to convert it back here (ex: date: '2024-08-27' would become date:'2024-08-26 23:00 -4:00')
+    }));
+  };
+
+  return function pickEndDate(schedule = {}) {
+    const {
+      addDays = 1,
+      hour,
+      minute,
+      skipDays = [],
+      cutHour,
+      cutDay = 1,
+    } = schedule;
+
+    const todayTZ = moment().tz(timezone);
+    let endDateTZ = todayTZ.clone();
+    const closedDays = getClosedDays();
+    const todayHours = todayTZ.get('hours');
+    const todayMinutes = todayTZ.get('minutes');
+    if (
+      (cutHour && todayHours > cutHour.hour) ||
+      (todayHours >= cutHour.hour && todayMinutes > cutHour.minute)
+    ) {
+      endDateTZ = endDateTZ.add(cutDay, 'days'); // if the cut day is zero should we add a day based on hours? ask Nabil/Vicky
+    }
+
+    endDateTZ.add(addDays, 'days');
+    // do the logic related to skipdays
+    // if the date already pass the skip day, do nothing
+    // if the date is the same as one of the skip day, check the next skip day if any, then add one more day
+    skipDays.forEach(day => {
+      if (todayTZ.isoWeekday() <= day) {
+        endDateTZ.add(1, 'days');
+      }
+    });
+
+    /**
+     * setting the hour and minute so we can compare with closedDays
+     */
+    if (hour !== undefined) endDateTZ.set('hour', hour);
+    if (minute !== undefined) endDateTZ.set('minute', minute);
+    closedDays.forEach(closed => {
+      const closedDay = moment(closed.date);
+      closedDay.set('hour', hour);
+      closedDay.set('minute', minute);
+      if (endDateTZ.startOf('day').isSame(closedDay, 'day')) {
+        endDateTZ.add(1, 'days');
+      }
+    });
+
+    return moment.utc(endDateTZ).format();
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.41",
+  "version": "1.0.44",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -13,7 +13,7 @@
   "scripts": {
     "test": "jest --runInBand --detectOpenHandles --logHeapUsage --verbose --forceExit ./__TEST__",
     "test:me": "jest --runInBand --detectOpenHandles --logHeapUsage --verbose --forceExit",
-    "lint": "eslint --quiet --fix lib/"
+    "lint": "eslint --quiet --fix lib/ __TEST__/"
   },
   "publishConfig": {
     "access": "public"
@@ -36,5 +36,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "0ab9e8f6bf59ef671ffb2005712a5ec6f998b36e"
+  "gitHead": "9237aef8561cbdf9c29150a0915cf55ff54f3c80"
 }

package/lib/modifier/findByPaymentMethod.js

@@ -1,10 +0,0 @@
-module.exports = ({ actions }) =>
-  function findByPaymentMethod({ modifiers, paymentMethod = '' }) {
-    if (!Array.isArray(modifiers) || !paymentMethod) return null;
-
-    return modifiers.find(
-      each =>
-        actions.isPaymentMethodModifier(each) &&
-        each.conditions.paymentMethods.includes(paymentMethod)
-    );
-  };

package/lib/modifier/findByPaymentType.js

@@ -1,10 +0,0 @@
-module.exports = ({ actions }) =>
-  function findByPaymentType({ modifiers, paymentType = '' }) {
-    if (!Array.isArray(modifiers) || !paymentType) return null;
-
-    return modifiers.find(
-      each =>
-        actions.isPaymentTypeModifier(each) &&
-        each.conditions.paymentTypes.includes(paymentType)
-    );
-  };

package/lib/order/pickEndDate.js

@@ -1,65 +0,0 @@
-module.exports = ({ settings, _, moment }) => {
-  const timezone = _.get(settings, 'localization.timezone', 'America/New_York');
-
-  const getClosedDays = () => {
-    const schedule = _.get(settings, 'schedule', {});
-    const { close = [] } = schedule;
-
-    if (!Array.isArray(close)) return [];
-    return close.map(closedDate => ({
-      date: moment(closedDate.date), // the date is saved with the user timezone, no need to convert it back here (ex: date: '2024-08-27' would become date:'2024-08-26 23:00 -4:00')
-    }));
-  };
-
-  return function pickEndDate(schedule = {}) {
-    const {
-      addDays = 1,
-      hour,
-      minute,
-      skipDays = [],
-      cutHour,
-      cutDay = 1,
-    } = schedule;
-
-    const todayTZ = moment().tz(timezone);
-    let endDateTZ = todayTZ.clone();
-
-    const closedDays = getClosedDays();
-
-    if (
-      (cutHour && todayTZ.get('hours') > cutHour.hour) ||
-      (todayTZ.get('hours') >= cutHour.hour &&
-        todayTZ.get('minutes') > cutHour.minute)
-    ) {
-      endDateTZ = endDateTZ.add(cutDay, 'days');
-    }
-
-    let addDaysCounter = 0;
-    // adding the skip days to the loop
-    const loop = addDays + skipDays.length;
-    while (addDaysCounter < loop) {
-      endDateTZ = endDateTZ.add(1, 'days');
-      const endDateISOWeekday = endDateTZ.isoWeekday();
-      // does the current endDateISOWeekday match with any skip day?
-      // is endDateISOWeekday a sunday?
-      const shouldSkip =
-        skipDays.includes(endDateISOWeekday) || endDateISOWeekday === 7;
-      // if addDaysCounter is greater than loop, than we shouldn't add more days
-      // day condition stays working until addDaysCounter is greater than loop
-      if (
-        !shouldSkip ||
-        // eslint-disable-next-line no-loop-func
-        !closedDays.some(closedDay => closedDay.date.isSame(endDateTZ, 'day'))
-      ) {
-        // eslint-disable-next-line no-plusplus
-        addDaysCounter++;
-      }
-    }
-
-    if (hour !== undefined) endDateTZ.set('hour', hour);
-    if (minute !== undefined) endDateTZ.set('minute', minute);
-    endDateTZ.set('second', 0);
-
-    return moment.utc(endDateTZ).format();
-  };
-};