@capillarytech/creatives-library 1.0.0 → 1.0.1-alpha.0

package/components/organisms/ConfigureWorkflows/utils.js

@@ -0,0 +1,1485 @@
+import React from 'react';
+import moment from 'moment';
+import isEmpty from 'lodash/isEmpty';
+import cloneDeep from 'lodash/cloneDeep';
+import findIndex from 'lodash/findIndex';
+import without from 'lodash/without';
+import { v4 as uuidv4 } from 'uuid';
+
+import { getUpgradeData } from 'utils/tiers';
+import { isRulesetInIdentifier } from 'utils/workflow';
+import { isTrue, getActualEventName } from 'utils/commonUtils';
+
+import GroupItemLabel from '../GroupItemLabel';
+import {
+  DYNAMIC,
+  TRACKER_VALUE_BASED,
+  CUMULATIVE_PURCHASES,
+  NEWBILL_RS_START,
+  TRACKER_RS_START,
+  POINTS_TRACKER_RS_START,
+  SOURCE_PROMOTION,
+  DATE_FORMAT_DB,
+  MODE_VIEW,
+} from '../../pages/App/constants';
+
+import {
+  EXP,
+  TEN,
+  JNODE,
+  YEARS,
+  TWENTY,
+  SERVER,
+  EXP_JSON,
+  RULE_NAME,
+  RULE_DESC,
+  // ACTIONS
+  FORWARD,
+  EBILL_ACTION,
+  PE_SMS_ACTION,
+  PE_EMAIL_ACTION,
+  DEFAULT_ACTIONS,
+  PE_MESSAGE_ACTION,
+  RENEW_SLAB_ACTION,
+  BILL_POINTS_ACTION,
+  RETURN_BILL_ACTION,
+  PE_FACEBOOK_ACTION,
+  TAG_CUSTOMER_ACTION,
+  AWARD_POINTS_ACTION,
+  REDEEM_POINTS_ACTION,
+  PE_MOBILE_PUSH_ACTION,
+  DELAYED_ACCRUAL_ACTION,
+  POINTS_TRANSFER_ACTION,
+  PE_ISSUE_VOUCHER_ACTION,
+  REEVALUATE_REGULAR_BILL,
+  UPGRADE_SLAB_ACTION_SLAB,
+  PE_WECHAT_MESSAGE_ACTION,
+  TRACKER_EVALUATION_ACTION,
+  AWARD_REFEREE_POINTS_ACTION,
+  UPGRADE_SLAB_ACTION_STRATEGY,
+  POINTS_GROUP_TRANSFER_ACTION,
+  AWARD_REFERRER_POINTS_ACTION,
+  POINTS_GROUP_REDEMPTION_ACTION,
+  POINTS_REDEMPTION_REVERSAL_ACTION,
+  POINTS_CONTRIBUTION_TO_GROUP_ACTION,
+  TRIGGER_BASED_DELAYED_ACCRUAL_ACTION,
+  INITIATE_SUPPLEMENTARY_MEMBERSHIP,
+  RENEW_TIER_BASED_ON_PARTNER_PROGRAM,
+  UPGRADE_TIER_BASED_ON_PARTNER_PROGRAM,
+  // RULE SET NAME
+  TRANSACTION_FINISHED_RS_START,
+  SLAB_UPGRADE_EVENT_TYPE,
+  TEMP_LOYALTY_TYPE,
+  LOYALTY_TYPE1,
+  LOYALTY_TYPE_FILTER_IMPL,
+  TEMP_EVENT_SOURCE,
+  EVENT_SOURCE_FILTER_IMPL,
+  EVENT_SOURCE1,
+  INSTORE,
+  TEMP_CONCEPTS,
+  CONCEPTS1,
+  CONCEPTS_FILTER_IMPL,
+  STORES,
+  TEMP_STORES,
+  STORES_FILTER_IMPL,
+  ZONES,
+  TEMP_ZONES,
+  ZONES_FILTER_IMPL,
+  DATE_RANGE1,
+  TEMP_DATE_RANGE,
+  DATE_RANGE_FILTER_IMPL,
+  CUSTOMER_CLUSTER,
+  TEMP_CUSTOMER_CLUSTER,
+  CUSTOMER_CLUSTER_FILTER_IMPL,
+  AWARD_TARGET_POINTS_ACTION,
+  UNITS_LOWERCASE,
+  CONVERT_POINTS_TO_REWARD_ACTION,
+  BADGE_EARN_ACTION,
+  TRACKER_TYPE,
+  BILL_LINE_ITEM_INVENTORY,
+  TOTAL_POINTS_CAPPING,
+  SOURCE_VALUE_CAPPING,
+  TENDER_SUM_SOURCE_VALUE_CAPPING,
+  TRACKER_SOURCE_VALUE_CAPPING,
+  STATUS_LABEL_UPDATE_ACTION,
+  RETURN_BILL,
+  GROUP_RETURN_BILL,
+  GROUP_MEMBER_JOIN,
+  GROUP_MEMBER_LEAVE,
+  DELAYED_ACCRUAL,
+  POINTS_CONTRIBUTION_GROUP,
+  POINTS_REDEMPTION_REVERSAL,
+  PARTNER_PROGRAM_LINKING,
+  PARTNER_PROGRAM_TIER_UPDATE,
+  PARTNER_PROGRAM_DELINKING,
+  POINTS_CONTRIBUTION_TO_GROUP,
+  POINTS_TRANSFER,
+} from './constants';
+import {
+  POSITIVE_INTEGER_REGEX,
+  POSITIVE_DECIMAL_REGEX,
+} from '../../molecules/NumberInput/constants';
+
+const processForwardRuleSets = ({
+  caseActions,
+  rulesets,
+  groupObj,
+  groupTreeObj,
+  trackersDetails,
+  setIndex,
+  dependentRulesetIds,
+  evaluatedTrackers,
+  internalParentShouldUnroll,
+  downloadRuleSet,
+  treeLevel,
+  currentProgram,
+  eventType,
+  draftDestinationName,
+  processWorflowData,
+  source,
+}) => {
+  // FILTER FORWARD TO SET
+  const forwardActions = caseActions.filter(
+    ({ actionName }) =>
+      actionName === FORWARD || actionName === TRACKER_EVALUATION_ACTION,
+  );
+  if (!forwardActions.length) return setIndex;
+  forwardActions.forEach(forwardAction => {
+    const {
+      mandatoryPropertiesValues: {
+        ruleset: ruleSetName,
+        TrackerStrategy: TrackerStrategyId,
+        shouldUnroll = false,
+        shouldTenderUnroll = false,
+      } = {},
+    } = forwardAction;
+
+    let filterList = [];
+    if (TrackerStrategyId) {
+      // GET TRACKER FORWARD RULE SET ID FORM TRACKER
+      evaluatedTrackers[TrackerStrategyId] = true;
+      const { conditions = [], propertyValues: { tracker_type = '' } = {} } =
+        trackersDetails
+          .filter(({ id }) => `${id}` === `${TrackerStrategyId}`)
+          .pop() || {};
+      const forwardedRulesets = (conditions || [])
+        .sort(({ rank: currentRank = '' }, { rank: nextRank = '' }) =>
+          `${currentRank}`.localeCompare(`${nextRank}`),
+        )
+        .map(({ rulesetId }) => `${rulesetId}`);
+      if (forwardedRulesets.length) {
+        // FILTER FORWARD RULESET BY ID
+        filterList = rulesets.filter(ruleset => {
+          if (forwardedRulesets.includes(`${ruleset.id}`)) {
+            ruleset.internalTrackerType = tracker_type;
+            return ruleset;
+          }
+        });
+      }
+    } else {
+      // FILTER FORWARD RULESET BY NAME
+      const filterRuleSet = rulesets.find(({ name }) => name === ruleSetName);
+      if (filterRuleSet) {
+        filterRuleSet.internalShouldUnroll =
+          internalParentShouldUnroll || isTrue(shouldUnroll);
+        filterRuleSet.internalShouldTenderUnroll = isTrue(shouldTenderUnroll);
+        filterList = [filterRuleSet];
+      }
+    }
+
+    const filterRulesetIds = filterList.map(({ id }) => id);
+    forwardAction.dependentRulesetIds = filterRulesetIds;
+    dependentRulesetIds.push(filterRulesetIds);
+
+    // RECURSIVE CALL
+    setIndex = ruleSetRecursion({
+      groupObj,
+      rulesets,
+      filterRulesets: filterList,
+      groupTreeList: groupTreeObj.children,
+      trackersDetails,
+      setIndex,
+      evaluatedTrackers,
+      downloadRuleSet,
+      treeLevel: { level: treeLevel.level + 1 },
+      currentProgram,
+      eventType,
+      draftDestinationName,
+      processWorflowData,
+      source,
+    });
+  });
+  return setIndex;
+};
+
+const ruleSetRecursion = ({
+  rulesets,
+  groupObj,
+  groupTreeList,
+  filterRulesets,
+  trackersDetails,
+  setIndex = 1,
+  evaluatedTrackers,
+  downloadRuleSet,
+  treeLevel,
+  currentProgram,
+  eventType,
+  draftDestinationName,
+  processWorflowData,
+  source,
+}) => {
+  filterRulesets.forEach(ruleset => {
+    const {
+      id,
+      name,
+      rules = [],
+      internalShouldUnroll: internalParentShouldUnroll = false,
+      label = '',
+    } = ruleset || {};
+    let activeRules =
+      Array.isArray(rules) && rules.length > 0
+        ? rules.filter(({ isActive }) => `${isActive}` === 'true')
+        : [];
+    // GROUPS
+    let groupName = `Set${setIndex}`;
+    if (name === TRACKER_RS_START) {
+      groupName = 'TrackerSet';
+    } else if (name.includes('Tracker_ruleset_')) {
+      groupName = name;
+    }
+    if (label) groupName = label;
+    setIndex++;
+    let groupTreeObj = {
+      name,
+      id,
+      key: `${id}`,
+      'data-id': id,
+      children: [],
+      label: groupName,
+    };
+
+    activeRules = activeRules.map(rule => {
+      let dependentRulesetIds = [];
+      const {
+        caseToActions: {
+          true: trueActions = [],
+          false: falseActions = [],
+        } = {},
+      } = rule || {};
+
+      [trueActions, falseActions].forEach(caseActions => {
+        if (Array.isArray(caseActions) && caseActions.length > 0) {
+          setIndex = processForwardRuleSets({
+            caseActions,
+            rulesets,
+            groupObj,
+            groupTreeObj,
+            trackersDetails,
+            setIndex,
+            dependentRulesetIds,
+            evaluatedTrackers,
+            internalParentShouldUnroll,
+            downloadRuleSet,
+            treeLevel,
+            currentProgram,
+            eventType,
+            draftDestinationName,
+            processWorflowData,
+            source,
+          });
+        }
+      });
+      rule.dependentRulesetIds = dependentRulesetIds.flat();
+      return rule;
+    });
+    groupTreeObj = {
+      ...groupTreeObj,
+      title: (
+        <GroupItemLabel
+          label={groupName}
+          downloadRuleSet={downloadRuleSet}
+          lastChildSet={getLastChildSet(groupTreeObj.children)}
+          treeLevel={treeLevel}
+          currentProgram={currentProgram}
+          rulesetId={id}
+          programId={currentProgram.id}
+          eventType={eventType}
+          draftDestinationName={draftDestinationName}
+          rulesets={rulesets}
+          processWorflowData={processWorflowData}
+          source={source}
+        />
+      ),
+    };
+    groupTreeList.push(groupTreeObj);
+
+    // ADD GROUP DATA FOR ID
+
+    groupObj[id] = { ...ruleset, rules: activeRules, displayName: groupName };
+  });
+  return setIndex;
+};
+function getLastChildSet(sets) {
+  if (!(Array.isArray(sets) && sets.length > 0)) {
+    return '';
+  }
+  const { children, label } = sets[sets.length - 1];
+  if (children?.length > 0) {
+    return getLastChildSet(children);
+  } else {
+    return label;
+  }
+}
+export const processRuleSetsData = ({
+  // *** ruleset recursion
+  rulesets = [],
+  rulesetsByEventType = [],
+  eventType,
+  trackersDetails = [],
+  currentProgram = {},
+  source,
+  downloadRuleSet,
+  draftDestinationName,
+  processWorflowData,
+  setIsV2FlowEnabled
+}) => {
+  const groupObj = {};
+  const evaluatedTrackers = {};
+  const groupTreeList = [];
+  let filterRulesets = [];
+
+  if (eventType === SLAB_UPGRADE_EVENT_TYPE) {
+    filterRulesets = rulesets.filter(
+      ({ name }) => name === currentProgram?.slabUpgradeRuleIdentifier,
+    );
+  } else {
+    const orderList = [
+      NEWBILL_RS_START,
+      TRACKER_RS_START,
+      POINTS_TRACKER_RS_START,
+      TRANSACTION_FINISHED_RS_START,
+    ];
+    let rulesetIds = rulesetsByEventType.map(ruleset => ruleset.id);
+    if (rulesetIds.length > 0) {
+      let filterConfiguredRulesets = rulesets.filter(({ id }) =>
+        rulesetIds.includes(id),
+      );
+      if (
+        rulesets?.length > 0 &&
+        filterConfiguredRulesets?.length !== rulesetIds?.length
+      ) {
+        setIsV2FlowEnabled(false);
+      }
+      filterRulesets = filterConfiguredRulesets;
+    } else if (source === SOURCE_PROMOTION && eventType) {
+      filterRulesets = rulesets.filter(
+        ({ eventType: eventTypeInRuleset }) => eventType === eventTypeInRuleset,
+      );
+    }
+    filterRulesets.sort(({ name: nextName }, { name: firstName }) => {
+      const firstIndex = orderList.indexOf(firstName);
+      const nextIndex = orderList.indexOf(nextName);
+      return firstIndex > -1 && nextIndex > -1 && firstIndex > nextIndex
+        ? -1
+        : 0;
+    });
+  }
+  const treeLevel = { level: 0 };
+  ruleSetRecursion({
+    rulesets,
+    groupObj,
+    groupTreeList,
+    filterRulesets,
+    trackersDetails,
+    evaluatedTrackers,
+    downloadRuleSet,
+    treeLevel,
+    currentProgram,
+    eventType,
+    draftDestinationName,
+    processWorflowData,
+    source,
+  });
+  const rulesetMap = rulesets.reduce((acc, data) => {
+    const { id } = data;
+    acc[id] = data;
+    return acc;
+  }, {});
+  return {
+    groupObj: {
+      ...rulesetMap,
+      ...groupObj,
+    },
+    groupTreeList,
+    evaluatedTrackers,
+  };
+};
+
+export const getNewCondition = ({ user, ruleSetId }) => {
+  const { id: userId = -1 } = user || {};
+  const startDate = moment()
+    .subtract(TWENTY, YEARS)
+    .format('x');
+  const endDate = moment()
+    .add(TEN, YEARS)
+    .format('x');
+  const time = new Date().getTime();
+
+  const ruleId = `temp_${new Date().getTime()}`;
+  return {
+    id: ruleId,
+    name: RULE_NAME,
+    createdBy: userId,
+    createdOn: time,
+    description: RULE_DESC,
+    endDate,
+    exp: EXP,
+    expDataType: null,
+    expJSON: EXP_JSON,
+    filterInfo: [],
+    isActive: true,
+    jsonType: JNODE,
+    modifiedBy: userId,
+    modifiedOn: time,
+    priority: -1,
+    ruleScope: SERVER,
+    startDate,
+    caseToActions: {},
+    ruleSetId,
+  };
+};
+
+const isFoundInImmediateNextRulesetByIdentifier = ({
+  ruleset,
+  groups = [],
+  identifierName,
+}) => {
+  const { id: rulesetId = '' } = ruleset || {};
+  let isIdFound = false;
+  const filterList = groups.filter(({ name }) => name === identifierName);
+  if (filterList.length > 0) {
+    const { children = [] } = filterList[0];
+    isIdFound = children.find(({ id }) => id === rulesetId);
+  }
+  return isIdFound;
+};
+
+const getTransactionAddAction = ({ actions, ruleset, groups }) => {
+  if (!ruleset) {
+    return actions;
+  }
+  const { name = '' } = ruleset;
+
+  //Only forward is allowed if selected ruleset is Tracker start rs
+  if (name === TRACKER_RS_START || name === POINTS_TRACKER_RS_START) {
+    return [FORWARD];
+  }
+
+  actions.push(BILL_POINTS_ACTION);
+  // At finish add facebook action
+  if (name === TRANSACTION_FINISHED_RS_START) {
+    actions.push(PE_FACEBOOK_ACTION);
+  }
+
+  const isImmediateNextTrackerStrategyRsSelected =
+    isFoundInImmediateNextRulesetByIdentifier({
+      ruleset,
+      groups,
+      identifierName: TRACKER_RS_START,
+    }) ||
+    isFoundInImmediateNextRulesetByIdentifier({
+      ruleset,
+      groups,
+      identifierName: POINTS_TRACKER_RS_START,
+    });
+
+  const isNestedPointsTrackerCaseRsSelected = isRulesetInIdentifier({
+    ruleset,
+    groups,
+    identifierName: POINTS_TRACKER_RS_START,
+  });
+
+  const isNestedTransactionFinishedRsSelected = isRulesetInIdentifier({
+    ruleset,
+    groups,
+    identifierName: TRANSACTION_FINISHED_RS_START,
+  });
+
+  //Returning only tracker evaluation action in case of tracker condition
+  if (isImmediateNextTrackerStrategyRsSelected) {
+    return [TRACKER_EVALUATION_ACTION];
+  }
+  //returning ebill action along with default actions in case of transaction finished ruleset
+  else if (isNestedTransactionFinishedRsSelected) {
+    return actions.concat([EBILL_ACTION]);
+  }
+  // in case of points type tracker case rulesets only slab upgrade is allowed
+  else if (isNestedPointsTrackerCaseRsSelected) {
+    return [UPGRADE_SLAB_ACTION_SLAB];
+  }
+  //Returning all supported actions in case normal ruleset
+  else {
+    return actions;
+  }
+};
+
+const checkIsDependencyEnable = responseList => {
+  const { value } = responseList?.[0] || {};
+  return `${value}` === '1' || `${value}`.toLowerCase() === 'true';
+};
+
+export const getActionList = ({
+  tier,
+  groups,
+  ruleset,
+  eventType,
+  currentProgram,
+  actionDependencies,
+  isGenericEvent = false,
+}) => {
+  if (isEmpty(groups)) {
+    return [];
+  }
+  eventType = getActualEventName(eventType);
+  const { isDefault } = currentProgram || {};
+  const { tierUpgrade = [] } = tier;
+  const { propertyValues: upgradePropertyValues } = tierUpgrade?.[0] || {};
+  const {
+    // UPGRADE
+    current_value_type: upgradeType,
+    slab_upgrade_mode: slabUpgradeMode,
+  } = getUpgradeData(upgradePropertyValues, currentProgram);
+  const isDefaultProgram = isTrue(isDefault);
+
+  // ACTION DEPENDENCIES FROM API
+  const {
+    isAccountsSet = false,
+    groupRedemptionEnabled = [],
+    allowPromisedPointsConversion = [],
+    partnerProgramLinkingEnabled = [],
+  } = actionDependencies || {};
+
+  // VALIDATE API RESPONSE
+  const isGroupRedemptionEnabled = checkIsDependencyEnable(
+    groupRedemptionEnabled,
+  );
+  const isAllowPromisedPointsConversion = checkIsDependencyEnable(
+    allowPromisedPointsConversion,
+  );
+  const isPartnerProgramLinkingEnabled = checkIsDependencyEnable(
+    partnerProgramLinkingEnabled,
+  );
+
+  const actions = [...DEFAULT_ACTIONS];
+  let supportedActions = [];
+
+  if (isAccountsSet) {
+    actions.push(PE_MOBILE_PUSH_ACTION);
+  }
+  switch (eventType) {
+    case 'NewBill':
+      supportedActions = actions.concat([BILL_POINTS_ACTION]);
+      break;
+    case 'PointsRedemption':
+      supportedActions = actions.concat([REDEEM_POINTS_ACTION]);
+      if (isDefaultProgram && isGroupRedemptionEnabled) {
+        supportedActions = [
+          ...supportedActions,
+          POINTS_GROUP_REDEMPTION_ACTION,
+        ];
+      }
+      break;
+    case 'ConvertPointsToReward':
+      supportedActions = [
+        FORWARD,
+        PE_SMS_ACTION,
+        PE_MESSAGE_ACTION,
+        PE_EMAIL_ACTION,
+        PE_MOBILE_PUSH_ACTION,
+        PE_ISSUE_VOUCHER_ACTION,
+        PE_WECHAT_MESSAGE_ACTION,
+        RENEW_SLAB_ACTION,
+        UPGRADE_SLAB_ACTION_SLAB,
+        AWARD_POINTS_ACTION,
+        BILL_POINTS_ACTION,
+        UPGRADE_SLAB_ACTION_STRATEGY,
+        CONVERT_POINTS_TO_REWARD_ACTION,
+        BADGE_EARN_ACTION,
+        STATUS_LABEL_UPDATE_ACTION,
+      ];
+      break;
+    case 'ReturnBill':
+    case 'GroupReturnBill':
+      supportedActions = actions.concat([
+        RETURN_BILL_ACTION,
+        REEVALUATE_REGULAR_BILL,
+      ]);
+      break;
+    case eventType.indexOf('Tracker') >= 0:
+      supportedActions = actions.concat([BILL_POINTS_ACTION]);
+      break;
+    case 'SocialConnect':
+      supportedActions = actions;
+      break;
+    case 'TransactionUpdate':
+      supportedActions = [
+        BADGE_EARN_ACTION,
+        STATUS_LABEL_UPDATE_ACTION,
+        AWARD_POINTS_ACTION,
+        CONVERT_POINTS_TO_REWARD_ACTION,
+      ];
+      if (isAllowPromisedPointsConversion) {
+        supportedActions = [
+          ...supportedActions,
+          TRIGGER_BASED_DELAYED_ACCRUAL_ACTION,
+        ];
+      }
+      break;
+    case 'GroupTransactionUpdate':
+      supportedActions = [
+        FORWARD,
+        PE_SMS_ACTION,
+        PE_EMAIL_ACTION,
+        PE_MESSAGE_ACTION,
+        PE_ISSUE_VOUCHER_ACTION,
+        BADGE_EARN_ACTION,
+        STATUS_LABEL_UPDATE_ACTION,
+        CONVERT_POINTS_TO_REWARD_ACTION,
+      ];
+      if (isPartnerProgramLinkingEnabled) {
+        supportedActions = [
+          ...supportedActions,
+          INITIATE_SUPPLEMENTARY_MEMBERSHIP,
+        ];
+      }
+      if (isAllowPromisedPointsConversion) {
+        supportedActions = [
+          ...supportedActions,
+          TRIGGER_BASED_DELAYED_ACCRUAL_ACTION,
+        ];
+      }
+      if (isAccountsSet) {
+        supportedActions = [...supportedActions, PE_MOBILE_PUSH_ACTION];
+      }
+      break;
+    case 'CustomerRegistration':
+      supportedActions = actions;
+      if (isPartnerProgramLinkingEnabled) {
+        supportedActions = [
+          ...supportedActions,
+          INITIATE_SUPPLEMENTARY_MEMBERSHIP,
+        ];
+      }
+      if (isDefaultProgram) {
+        supportedActions = [
+          ...supportedActions,
+          AWARD_REFERRER_POINTS_ACTION,
+          AWARD_REFEREE_POINTS_ACTION,
+        ];
+      }
+      break;
+    case 'CustomerUpdate':
+      supportedActions = actions;
+      if (isPartnerProgramLinkingEnabled) {
+        supportedActions = [
+          ...supportedActions,
+          INITIATE_SUPPLEMENTARY_MEMBERSHIP,
+        ];
+      }
+      break;
+    case 'TransactionAdd':
+      if (isPartnerProgramLinkingEnabled) {
+        supportedActions = [
+          ...supportedActions,
+          INITIATE_SUPPLEMENTARY_MEMBERSHIP,
+        ];
+      }
+      if (isDefaultProgram) {
+        supportedActions = [
+          ...supportedActions,
+          AWARD_REFERRER_POINTS_ACTION,
+          AWARD_REFEREE_POINTS_ACTION,
+        ];
+      }
+      actions.push(...supportedActions);
+    // eslint-disable-next-line no-fallthrough
+    case 'GroupTransactionAdd':
+      supportedActions = getTransactionAddAction({ actions, ruleset, groups });
+      break;
+    case 'DelayedAccrual':
+      supportedActions = actions.concat([DELAYED_ACCRUAL_ACTION]);
+      break;
+    case 'PointsTransfer':
+      supportedActions = [
+        POINTS_TRANSFER_ACTION,
+        FORWARD,
+        TAG_CUSTOMER_ACTION,
+        BADGE_EARN_ACTION,
+        STATUS_LABEL_UPDATE_ACTION,
+        CONVERT_POINTS_TO_REWARD_ACTION,
+      ];
+      // add group redemption action if it is group program and config is enabled
+      if (isDefaultProgram && isGroupRedemptionEnabled) {
+        supportedActions = [...supportedActions, POINTS_GROUP_TRANSFER_ACTION];
+      }
+      break;
+    case 'TargetCompleted':
+      supportedActions = actions.concat([AWARD_TARGET_POINTS_ACTION]);
+      if (isPartnerProgramLinkingEnabled) {
+        supportedActions = [
+          ...supportedActions,
+          INITIATE_SUPPLEMENTARY_MEMBERSHIP,
+        ];
+      }
+      break;
+    case 'PointsRedemptionReversal':
+      supportedActions = [
+        POINTS_REDEMPTION_REVERSAL_ACTION,
+        TAG_CUSTOMER_ACTION,
+        STATUS_LABEL_UPDATE_ACTION,
+        CONVERT_POINTS_TO_REWARD_ACTION,
+      ];
+      break;
+    case 'PartnerProgramLinking':
+    case 'PartnerProgramTierUpdate':
+      // TO-DO PROMOTION RULE SET ARE HANDLE LATER
+      supportedActions = [
+        FORWARD,
+        PE_MESSAGE_ACTION,
+        PE_WECHAT_MESSAGE_ACTION,
+        RENEW_TIER_BASED_ON_PARTNER_PROGRAM,
+        UPGRADE_TIER_BASED_ON_PARTNER_PROGRAM,
+        BADGE_EARN_ACTION,
+        STATUS_LABEL_UPDATE_ACTION,
+        CONVERT_POINTS_TO_REWARD_ACTION,
+      ];
+      break;
+    case 'PartnerProgramDeLinking':
+      supportedActions = [
+        PE_MESSAGE_ACTION,
+        PE_WECHAT_MESSAGE_ACTION,
+        BADGE_EARN_ACTION,
+        STATUS_LABEL_UPDATE_ACTION,
+        CONVERT_POINTS_TO_REWARD_ACTION,
+      ];
+      break;
+    case 'PointsContributionToGroup':
+      supportedActions = [
+        POINTS_CONTRIBUTION_TO_GROUP_ACTION,
+        STATUS_LABEL_UPDATE_ACTION,
+        CONVERT_POINTS_TO_REWARD_ACTION,
+      ];
+      break;
+    default:
+      supportedActions = actions;
+  }
+
+  if (
+    upgradeType == CUMULATIVE_PURCHASES ||
+    upgradeType == TRACKER_VALUE_BASED
+  ) {
+    if (eventType == 'CustomerRegistration' || eventType == 'CustomerUpdate') {
+      supportedActions = without(
+        supportedActions,
+        UPGRADE_SLAB_ACTION_STRATEGY,
+      );
+    }
+  }
+
+  if (eventType == 'DelayedAccrual') {
+    // AWARD_POINTS_ACTION repeated in old loyalty code
+    supportedActions = without(
+      supportedActions,
+      FORWARD,
+      RENEW_SLAB_ACTION,
+      AWARD_POINTS_ACTION,
+      UPGRADE_SLAB_ACTION_STRATEGY,
+    );
+  }
+
+  if (eventType == 'ReturnBill' || eventType == 'GroupReturnBill') {
+    supportedActions = without(
+      supportedActions,
+      AWARD_POINTS_ACTION,
+      UPGRADE_SLAB_ACTION_SLAB,
+      UPGRADE_SLAB_ACTION_STRATEGY,
+    );
+  }
+  if (eventType == 'SlabUpgrade') {
+    supportedActions = without(supportedActions, STATUS_LABEL_UPDATE_ACTION);
+    if (isPartnerProgramLinkingEnabled) {
+      supportedActions = [
+        ...supportedActions,
+        INITIATE_SUPPLEMENTARY_MEMBERSHIP,
+      ];
+    }
+  }
+
+  if (eventType == 'GroupMemberJoin' || eventType == 'GroupMemberLeave') {
+    supportedActions = without(supportedActions, AWARD_POINTS_ACTION);
+  }
+
+  if (slabUpgradeMode == DYNAMIC) {
+    supportedActions = without(supportedActions, UPGRADE_SLAB_ACTION_STRATEGY);
+  }
+
+  if (isGenericEvent) {
+    supportedActions = without(
+      supportedActions,
+      RENEW_SLAB_ACTION,
+      BILL_POINTS_ACTION,
+      UPGRADE_SLAB_ACTION_SLAB,
+      UPGRADE_SLAB_ACTION_STRATEGY,
+    );
+  }
+
+  if (eventType == 'TargetCompleted') {
+    supportedActions = without(
+      supportedActions,
+      RENEW_SLAB_ACTION,
+      BILL_POINTS_ACTION,
+      AWARD_POINTS_ACTION,
+      UPGRADE_SLAB_ACTION_SLAB,
+      UPGRADE_SLAB_ACTION_STRATEGY,
+    );
+  }
+  return supportedActions;
+};
+
+export const getUpdatedRuleSetByAction = (
+  processedRuleSets,
+  actionData,
+  responseData = {},
+  source,
+) => {
+  const { actionType, action_id, ruleset_id, rule_id, case_value, isEditMode } =
+    actionData || {};
+  const { group = {} } = processedRuleSets || {};
+  const groupClone = cloneDeep(group);
+  responseData.actionName = actionType;
+  let isNewRuleSet = false;
+
+  if (actionType === FORWARD) {
+    if (!isEditMode && responseData.newRuleset) {
+      const { newRuleset = {}, ...rest } = responseData;
+      responseData = rest;
+      const { id } = newRuleset;
+      groupClone[id] = cloneDeep(newRuleset);
+      groupClone[id].isPristine = false;
+    }
+    isNewRuleSet = true;
+  }
+
+  if (actionType === TRACKER_EVALUATION_ACTION) {
+    // Need to hanlde here
+    isNewRuleSet = true;
+  }
+
+  const ruleIndex = findIndex(groupClone[ruleset_id]?.rules, {
+    id: rule_id,
+  });
+  if (ruleIndex > -1) {
+    const currentRuleObj = groupClone[ruleset_id].rules[ruleIndex];
+    const { caseToActions } = currentRuleObj;
+    // case actions
+    let currentCaseToActions = caseToActions?.[case_value] || [];
+    if (action_id && `${action_id}` !== '-1') {
+      currentCaseToActions = currentCaseToActions.map(action => {
+        const { id } = action;
+        if (action_id === id) {
+          return { ...responseData };
+        }
+        return action;
+      });
+    } else {
+      currentCaseToActions.push(responseData);
+    }
+    // set updated case
+    currentRuleObj.caseToActions[case_value] = currentCaseToActions;
+    // set updated rule obj
+    groupClone[ruleset_id].rules[ruleIndex] = currentRuleObj;
+    groupClone[ruleset_id].isPristine = false;
+  }
+
+  return { rules: { ...processedRuleSets, group: groupClone }, isNewRuleSet };
+};
+
+export const processRuleSetDelete = ({
+  processedRuleSets: { group = {} } = {},
+  dependentRulesetIds = [],
+  ruleId = '',
+  rulesetId = '',
+  isConditionDelete = false,
+}) => {
+  const groupClone = cloneDeep(group);
+  dependentRulesetIds.length &&
+    dependentRulesetIds.forEach(rulesetId => {
+      delete groupClone[rulesetId];
+    });
+  if (isConditionDelete && ruleId && rulesetId && groupClone[rulesetId]) {
+    const { rules } = groupClone[rulesetId];
+    groupClone[rulesetId].rules = (rules || []).filter(
+      ({ id }) => `${id}` !== `${ruleId}`,
+    );
+  }
+  return groupClone;
+};
+
+const getOrgId = () => window.localStorage.getItem('orgID');
+
+const getCommonFilterProps = ({ isInclude, propertyToValues }) => ({
+  isInclude,
+  propertyToValues,
+  ruleID: -1,
+});
+
+const getLoyaltyFilterInfo = ({
+  scopeId,
+  scopeMode: isInclude = true,
+  propertyValues: propertyToValues = {},
+}) => ({
+  orgID: getOrgId(),
+  id: scopeId || TEMP_LOYALTY_TYPE,
+  name: LOYALTY_TYPE1,
+  className: LOYALTY_TYPE_FILTER_IMPL,
+  ...getCommonFilterProps({ isInclude, propertyToValues }),
+});
+
+const getEventSourceFilterInfo = ({
+  scopeId,
+  scopeMode: isInclude = true,
+  propertyValues: propertyToValues = {},
+}) => ({
+  orgID: getOrgId(),
+  id: scopeId || TEMP_EVENT_SOURCE,
+  name: EVENT_SOURCE1,
+  className: EVENT_SOURCE_FILTER_IMPL,
+  ...getCommonFilterProps({ isInclude, propertyToValues }),
+});
+
+const getConceptsFilterInfo = ({
+  scopeId,
+  scopeMode: isInclude = true,
+  propertyValues: propertyToValues = {},
+}) => ({
+  orgID: getOrgId(),
+  id: scopeId || TEMP_CONCEPTS,
+  name: CONCEPTS1,
+  className: CONCEPTS_FILTER_IMPL,
+  ...getCommonFilterProps({ isInclude, propertyToValues }),
+});
+
+const getStoresFilterInfo = ({
+  scopeId,
+  scopeMode: isInclude = true,
+  propertyValues: propertyToValues = {},
+}) => ({
+  orgID: getOrgId(),
+  id: scopeId || TEMP_STORES,
+  name: STORES,
+  className: STORES_FILTER_IMPL,
+  ...getCommonFilterProps({ isInclude, propertyToValues }),
+});
+
+const getZonesFilterInfo = ({
+  scopeId,
+  scopeMode: isInclude = true,
+  propertyValues: propertyToValues = {},
+}) => ({
+  orgID: getOrgId(),
+  id: scopeId || TEMP_ZONES,
+  name: ZONES,
+  className: ZONES_FILTER_IMPL,
+  ...getCommonFilterProps({ isInclude, propertyToValues }),
+});
+
+const getCustomerClusterFilterInfo = ({
+  scopeId,
+  scopeMode: isInclude = true,
+  propertyValues: propertyToValues = {},
+}) => ({
+  orgID: getOrgId(),
+  id: scopeId || TEMP_CUSTOMER_CLUSTER,
+  name: CUSTOMER_CLUSTER,
+  className: CUSTOMER_CLUSTER_FILTER_IMPL,
+  ...getCommonFilterProps({ isInclude, propertyToValues }),
+});
+
+const getDateRangeFilterInfo = ({
+  scopeId,
+  scopeMode = true,
+  propertyValues = {},
+}) => ({
+  orgID: getOrgId(),
+  id: scopeId || TEMP_DATE_RANGE,
+  name: DATE_RANGE1,
+  className: DATE_RANGE_FILTER_IMPL,
+  isInclude: scopeMode,
+  propertyToValues: propertyValues,
+  ruleID: -1,
+});
+
+const getTrackerFilterInfo = ({
+  scopeId,
+  scopeMode: isInclude = true,
+  propertyValues: propertyToValues,
+}) => ({
+  orgID: getOrgId(),
+  id: scopeId || 'temp_Tracker',
+  name: 'Tracker',
+  className: 'com.capillary.shopbook.emf.impl.filter.TrackerFilterImpl',
+  ...getCommonFilterProps({ isInclude, propertyToValues }),
+});
+
+const getBillLineItemInventoryFilterInfo = ({
+  scopeId,
+  scopeMode: isInclude = true,
+  propertyValues: propertyToValues,
+}) => ({
+  orgID: getOrgId(),
+  id: scopeId || 'temp_BillLineItemInventory',
+  name: 'BillLineItemInventory',
+  className:
+    'com.capillary.shopbook.emf.impl.filter.BillLineItemInventoryFilterImpl',
+  ...getCommonFilterProps({ isInclude, propertyToValues }),
+});
+
+/**
+ * Kept is commented for future reference
+ * case 'BillLineItemInventory': {
+      Object.keys(scopingInfo).forEach((key) => {
+        if (key.includes('bill_line_item_attribute_')) {
+          propertyValues[key.substr(25)] = [encodeURI(scopingInfo[key])];
+        }
+      });
+      scope.name = 'BillLineItemInventory';
+      scope.className = 'com.capillary.shopbook.emf.impl.filter.BillLineItemInventoryFilterImpl';
+      scope.propertyToValues = propertyValues;
+      break;
+    }
+ */
+
+export const getFilterInfo = ({ scopingData, source = '' }) => {
+  const filterInfoLocal = [];
+  (scopingData || []).map(
+    ({ propertyValues, scopeId, scopeMode, scopingType }) => {
+      switch (scopingType) {
+        case LOYALTY_TYPE1:
+          {
+            const { loyaltyType } = propertyValues || {};
+            filterInfoLocal.push(
+              getLoyaltyFilterInfo({
+                scopeId,
+                scopeMode,
+                propertyValues: { loyaltyType: [loyaltyType] },
+              }),
+            );
+          }
+          break;
+        case EVENT_SOURCE1:
+          {
+            filterInfoLocal.push(
+              getEventSourceFilterInfo({
+                scopeId,
+                scopeMode,
+                propertyValues,
+              }),
+            );
+          }
+          break;
+        case ZONES:
+          {
+            const { zones = [] } = propertyValues || {};
+            filterInfoLocal.push(
+              getZonesFilterInfo({
+                scopeId,
+                scopeMode,
+                propertyValues: { zoneIds: zones },
+              }),
+            );
+          }
+          break;
+        case CONCEPTS1:
+          {
+            const { concepts = [] } = propertyValues || {};
+            filterInfoLocal.push(
+              getConceptsFilterInfo({
+                scopeId,
+                scopeMode,
+                propertyValues: { conceptIds: concepts },
+              }),
+            );
+          }
+          break;
+        case STORES:
+          {
+            const { stores = [] } = propertyValues || {};
+            filterInfoLocal.push(
+              getStoresFilterInfo({
+                scopeId,
+                scopeMode,
+                propertyValues: { storeId: stores },
+              }),
+            );
+          }
+          break;
+        case DATE_RANGE1:
+          {
+            const { startDate, endDate } = propertyValues || {};
+            filterInfoLocal.push(
+              getDateRangeFilterInfo({
+                scopeId,
+                scopeMode,
+                propertyValues: {
+                  startDate: [startDate],
+                  endDate: [endDate],
+                },
+              }),
+            );
+          }
+          break;
+        case CUSTOMER_CLUSTER:
+          {
+            const {
+              clusterName,
+              clusterValues,
+              clusterNameStr,
+              clusterValuesStr,
+            } = propertyValues || {};
+            filterInfoLocal.push(
+              getCustomerClusterFilterInfo({
+                scopeId,
+                scopeMode,
+                propertyValues: {
+                  clusterName: [clusterName],
+                  clusterValues,
+                  clusterNameStr,
+                  clusterValuesStr,
+                },
+              }),
+            );
+          }
+          break;
+        case TRACKER_TYPE:
+          if (source !== SOURCE_PROMOTION) {
+            const { tracker } = propertyValues || {};
+            filterInfoLocal.push(
+              getTrackerFilterInfo({
+                scopeId,
+                scopeMode,
+                propertyValues: {
+                  trackerId: tracker,
+                },
+              }),
+            );
+          }
+          break;
+        case BILL_LINE_ITEM_INVENTORY:
+          if (source !== SOURCE_PROMOTION) {
+            const propertyValuesData = {};
+            Object.keys(propertyValues).forEach(key => {
+              if (key.includes('bill_line_item_attribute_')) {
+                propertyValuesData[key.substr(25)] = [
+                  encodeURI(propertyValues[key]),
+                ];
+              }
+            });
+            filterInfoLocal.push(
+              getBillLineItemInventoryFilterInfo({
+                scopeId,
+                scopeMode,
+                propertyValues: propertyValuesData,
+              }),
+            );
+          }
+          break;
+      }
+    },
+  );
+  return filterInfoLocal;
+};
+
+export const getNewRuleSetInfo = ({
+  orgId = window.localStorage.getItem('orgID'),
+  userId,
+  newRulesetId = `temp_${uuidv4()}`,
+  newRulesetName = `ruleset_${moment().format(DATE_FORMAT_DB)}`,
+  contextId,
+  contextType = 'program',
+  eventType = 'TransactionAdd',
+  isRoot = true,
+  orgName = '',
+}) => {
+  const startDate = parseInt(
+    moment()
+      .subtract(TWENTY, 'years')
+      .format('x'),
+    10,
+  );
+  const endDate = parseInt(
+    moment()
+      .add(TEN, 'years')
+      .format('x'),
+    10,
+  );
+
+  const filterInfos = [];
+  if (isRoot) {
+    filterInfos.push(
+      getLoyaltyFilterInfo({ propertyValues: { loyaltyType: ['loyalty'] } }),
+      getEventSourceFilterInfo({ propertyValues: { eventSource: [INSTORE] } }),
+    );
+  }
+  return {
+    id: newRulesetId,
+    name: newRulesetName,
+    contextID: contextId,
+    contextType,
+    ...(eventType && { eventType }),
+    createdBy: userId,
+    createdOn: new Date().getTime(),
+    description: '',
+    endDate,
+    filterInfo: filterInfos,
+    isPrivate: false,
+    modifiedBy: userId,
+    modifiedOn: new Date().getTime(),
+    orgID: orgId,
+    orgName,
+    packageName: '',
+    rules: [
+      getNewRuleInfo({
+        userId,
+        newRuleId: `temp_${new Date().getTime()}`,
+        newRuleName: 'Rule 1',
+      }),
+    ],
+    ruleScope: SERVER,
+    startDate,
+  };
+};
+
+export const getNewRuleInfo = ({ userId, newRuleId, newRuleName }) => {
+  const startDate = parseInt(
+    moment()
+      .subtract(TWENTY, 'years')
+      .format('x'),
+    10,
+  );
+  const endDate = parseInt(
+    moment()
+      .add(TEN, 'years')
+      .format('x'),
+    10,
+  );
+
+  return {
+    id: newRuleId,
+    name: newRuleName,
+    createdBy: userId,
+    createdOn: new Date().getTime(),
+    description: '',
+    endDate,
+    exp: 'true',
+    expDataType: '',
+    expJSON: EXP_JSON,
+    filterInfo: {},
+    isActive: true,
+    jsonType: JNODE,
+    modifiedBy: userId,
+    modifiedOn: new Date().getTime(),
+    priority: -1,
+    ruleScope: SERVER,
+    startDate,
+    caseToActions: {},
+  };
+};
+
+export const getRulesetsOrRulesetsByEventTypeV2 = (
+  mode,
+  version,
+  programId,
+  actionCallMethod,
+  orgConfigDetailsList,
+) => {
+  orgConfigDetailsList.forEach(data => {
+    /* Wrt the selected version, updating the version's status & making api call to get rulesets data */
+    const currentVersion = Math.round(data?.version);
+    const selectedVersion = version?.replace('Version', '');
+    if (currentVersion == selectedVersion) {
+      const { version, status, endpointName } = data;
+      const queryParams = { programId, version, status, endpointName };
+      if (mode === MODE_VIEW) actionCallMethod(queryParams);
+    }
+  });
+};
+
+export const checkIfNonNegativeInteger = (value, label) => {
+  const positiveIntegerExpression =
+    (!isNaN(value) &&
+      POSITIVE_INTEGER_REGEX.test(value) &&
+      !value.includes('.')) ||
+    value === '';
+  if (label === UNITS_LOWERCASE) {
+    return value !== '0' && positiveIntegerExpression;
+  }
+  return positiveIntegerExpression;
+};
+
+export const checkIfPositiveDecimal = (value, label) => {
+  const positiveDecimalExpression =
+    (!isNaN(value) && POSITIVE_DECIMAL_REGEX.test(value)) || value === '';
+  if (label === UNITS_LOWERCASE) {
+    return value !== '0' && positiveDecimalExpression;
+  }
+  return positiveDecimalExpression;
+};
+
+const getTotalPointsCappingInfo = ({
+  cappingId,
+  propertyValues: propertyValuesJson,
+  cappingType,
+}) => ({
+  orgId: parseInt(getOrgId(), 10),
+  id: cappingId,
+  name: 'TotalPointsCapping',
+  className: 'com.capillary.shopbook.emf.impl.capping.TotalPointsCappingImpl',
+  propertyValuesJson,
+  ...(cappingId === -1 && { cappingId: `temp_${cappingType}` }),
+});
+const getSourceValueCappingInfo = ({
+  cappingId,
+  propertyValues: propertyValuesJson,
+  cappingType,
+}) => ({
+  orgId: parseInt(getOrgId(), 10),
+  id: cappingId,
+  name: 'SourceValueCapping',
+  className: 'com.capillary.shopbook.emf.impl.capping.SourceValueCappingImpl',
+  propertyValuesJson,
+  ...(cappingId === -1 && { cappingId: `temp_${cappingType}` }),
+});
+const getTenderSumSourceValueCappingInfo = ({
+  cappingId,
+  propertyValues: propertyValuesJson,
+  cappingType,
+}) => ({
+  orgId: parseInt(getOrgId(), 10),
+  id: cappingId,
+  name: 'TenderSumSourceValueCapping',
+  className:
+    'com.capillary.shopbook.emf.impl.capping.TenderSumSourceValueCappingImpl',
+  propertyValuesJson,
+  ...(cappingId === -1 && { cappingId: `temp_${cappingType}` }),
+});
+const getTrackerSourceValueCappingInfo = ({
+  cappingId,
+  propertyValues: propertyValuesJson,
+  cappingType,
+}) => ({
+  orgId: parseInt(getOrgId(), 10),
+  id: cappingId,
+  name: 'TrackerSourceValueCapping',
+  className:
+    'com.capillary.shopbook.emf.impl.capping.TrackerSourceValueCappingImpl',
+  propertyValuesJson,
+  ...(cappingId === -1 && { cappingId: `temp_${cappingType}` }),
+});
+
+export const getCappingInfo = ({ cappingData }) => {
+  const cappingInfoLocal = [];
+  (cappingData || []).map(({ propertyValues, cappingId, cappingType }) => {
+    switch (cappingType) {
+      case TOTAL_POINTS_CAPPING:
+        {
+          const { totalPointsLimit } = propertyValues || {};
+          cappingInfoLocal.push(
+            getTotalPointsCappingInfo({
+              cappingId,
+              propertyValues: JSON.stringify({ totalPointsLimit }),
+              cappingType,
+            }),
+          );
+        }
+        break;
+      case SOURCE_VALUE_CAPPING:
+        {
+          const { sourceValueLimit } = propertyValues || {};
+          cappingInfoLocal.push(
+            getSourceValueCappingInfo({
+              cappingId,
+              propertyValues: JSON.stringify({ sourceValueLimit }),
+              cappingType,
+            }),
+          );
+        }
+        break;
+      case TENDER_SUM_SOURCE_VALUE_CAPPING:
+        {
+          const { isInclude, selectedTenderCombinationIds } =
+            propertyValues || {};
+          cappingInfoLocal.push(
+            getTenderSumSourceValueCappingInfo({
+              cappingId,
+              propertyValues: JSON.stringify({
+                isInclude,
+                selectedTenderCombinationIds,
+              }),
+              cappingType,
+            }),
+          );
+        }
+        break;
+      case TRACKER_SOURCE_VALUE_CAPPING:
+        {
+          const { trackerId, trackerCaseLimit = {} } = propertyValues || {};
+          const propertyValuesData = {
+            trackerId,
+            trackerCaseLimitList: {},
+          };
+          // Verify this logic
+          Object.entries(trackerCaseLimit).forEach(([trackerCaseId, limit]) => {
+            propertyValuesData.trackerCaseLimitList[trackerCaseId] = {
+              trackerCaseId: Number(trackerCaseId),
+              limit,
+            };
+          });
+          cappingInfoLocal.push(
+            getTrackerSourceValueCappingInfo({
+              cappingId,
+              propertyValues: JSON.stringify(propertyValuesData),
+              cappingType,
+            }),
+          );
+        }
+        break;
+    }
+  });
+  return cappingInfoLocal;
+};
+
+export const checkForAlternateCurrencyEventType = (eventType, ruleset) => {
+  const { name = '' } = ruleset;
+  if (
+    name === TRACKER_RS_START ||
+    name === POINTS_TRACKER_RS_START ||
+    name.includes('Tracker_ruleset_')
+  )
+    return false;
+
+  const inValidEventTypes = [
+    RETURN_BILL,
+    GROUP_RETURN_BILL,
+    DELAYED_ACCRUAL,
+    GROUP_MEMBER_JOIN,
+    GROUP_MEMBER_LEAVE,
+    POINTS_CONTRIBUTION_GROUP,
+    POINTS_REDEMPTION_REVERSAL,
+    PARTNER_PROGRAM_LINKING,
+    PARTNER_PROGRAM_TIER_UPDATE,
+    PARTNER_PROGRAM_DELINKING,
+    POINTS_CONTRIBUTION_TO_GROUP,
+    POINTS_TRANSFER,
+  ];
+  return !inValidEventTypes.includes(eventType);
+};