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

package/components/organisms/AddPointsAllocationLimitSlider/AddPointsAllocationLimitSlider.js

@@ -1,596 +0,0 @@
-import React, { useCallback, useState, useEffect } from 'react';
-import CapButton from '@capillarytech/cap-ui-library/CapButton';
-import CapHeader from '@capillarytech/cap-ui-library/CapHeader';
-import CapLabel from '@capillarytech/cap-ui-library/CapLabel';
-import CapTooltip from '@capillarytech/cap-ui-library/CapTooltip';
-import CapNotification from '@capillarytech/cap-ui-library/CapNotification';
-import CapRow from '@capillarytech/cap-ui-library/CapRow';
-import CapSlideBox from '@capillarytech/cap-ui-library/CapSlideBox';
-import { FormattedMessage, injectIntl, intlShape } from 'react-intl';
-import PropTypes from 'prop-types';
-import { compose } from 'redux';
-import withErrorBoundary from 'utils/withErrorBoundary';
-import withStyles from 'utils/withStyles';
-import isEmpty from 'lodash/isEmpty';
-import cloneDeep from 'lodash/cloneDeep';
-import debounce from 'lodash/debounce';
-import { debounceUtil } from '../../../utils/commonUtils';
-
-import moment from 'moment';
-import globalMessages from '../../pages/Cap/messages';
-import messages from './messages';
-import { styles } from './style';
-import AddPointsAllocationLimitDetails from '../AddPointsAllocationLimitDetails';
-import { DAYS, MONTHS } from '../../pages/App/constants';
-import {
-  ACROSS_CUSTOMERS_LIMIT,
-  ACROSS_EVENT,
-  ALL_POINTS,
-  COUNT,
-  CURRENT_EVENT,
-  LINE_ITEM_AMOUNT,
-  LINE_ITEM_QUANTITY,
-  POINTS,
-  PROMOTIONAL_POINTS,
-  QUANTITY,
-  REGULAR_POINTS,
-  SALES,
-  TRANSACTION,
-  TRANSACTION_COUNT,
-  FILTER_TRANSACTIONS,
-  ALL_TRANSACTIONS,
-  ACROSS_EVENTS,
-  CUSTOM,
-  AUDIENCE_FILTER,
-  ALTERNATE_CURRENCIES,
-  REGULAR,
-  ALL,
-  PROMOTIONAL,
-  POINTS_CAPITALIZED,
-} from '../ActivityRewardSlider/constants';
-import { LINEITEM } from '../PromotionsDetail/constants';
-import {
-  CAPPING,
-  FIXED_CALENDAR_WINDOW,
-  frequencyTypeToFrequencyValue,
-  pointsAllocationLimitCategoryMapping,
-} from './constants';
-import { dateDiffInDays, generateDateList, getDefaultValues } from './utils';
-import { MAX_CAPPING_CUSTOMER_LIMIT, MAX_CAPPING_TRANSACTION_LIMIT } from '../AddPointsAllocationLimitDetails/constants';
-
-export const AddPointsAllocationLimitSlider = ({
-  intl: { formatMessage },
-  programId,
-  show,
-  onCardClose,
-  onClickDone,
-  className,
-  pointsAllocationLimitType,
-  data = {},
-  limitsWithAllTransactionType = {},
-  lineItemAmountUsed,
-  lineItemQuantityUsed,
-  isDoneDisabled,
-  pointsAllocationLimitData,
-  setPointsAllocationLimitType,
-  setActivitySelection,
-  activitySelection,
-  transactionActiveLimit,
-  acrossCustomerActiveLimit,
-  customerLimitWithAllCustomerCount,
-  isRewardCurrencyEnabled,
-  rewardCurrencyOptions,
-  existingTransactionKPIs,
-}) => {
-  const isEditMode = !!Object.keys(data || {}).length;
-  const additionalFiltersData = cloneDeep(data?.additionalFilters || {});
-  delete additionalFiltersData.pointsFilters;
-  const [isEditable] = useState(!data?.target?.id || data?.target?.id === -1);
-  const [pointsAllocationLimitName, setPointsAllocationLimitName] = useState(
-    data?.name || data?.target?.name || undefined,
-  );
-  const [
-    pointsAllocationLimitCategory,
-    setPointsAllocationLimitCategory,
-  ] = useState(
-    pointsAllocationLimitCategoryMapping[(data?.entity)]?.[data?.cappingOn] ||
-      pointsAllocationLimitCategoryMapping[(data?.cappingOn)] ||
-      undefined,
-  );
-  const checkForFilterAttributes = additionalFiltersData => {
-    let flag = true;
-    if (!isEmpty(additionalFiltersData)) {
-      flag =
-        isEmpty(additionalFiltersData?.includedStoreIds) &&
-        isEmpty(additionalFiltersData?.includedZoneIds) &&
-        isEmpty(additionalFiltersData?.lineItemFilters?.includedBrands) &&
-        isEmpty(additionalFiltersData?.lineItemFilters?.includedCategories) &&
-        isEmpty(additionalFiltersData?.lineItemFilters?.includedSkus) &&
-        Object.keys(
-          additionalFiltersData?.lineItemFilters?.includedAttributes || {},
-        ).length === 0;
-    }
-    return flag;
-  };
-  const [
-    pointsAllocationTransactionType,
-    setPointsAllocationTransactionType,
-  ] = useState(
-    !checkForFilterAttributes(additionalFiltersData)
-      ? FILTER_TRANSACTIONS
-      : ALL_TRANSACTIONS,
-  );
-  const [limit, setLimit] = useState(data?.limit || '');
-  const [excludedPromotions, setExcludedPromotions] = useState([]);
-  const [
-    excludedPromotionsFilterValues,
-    setExcludedPromotionsFilterValues,
-  ] = useState(
-    data?.additionalFilters?.pointsFilters?.excludedPromotions || [],
-  );
-  const [refreshUnit, setRefreshUnit] = useState(
-    isEditMode
-      ? data?.targetGroup?.frequencyType === CUSTOM
-        ? DAYS
-        : data?.targetGroup?.frequencyType
-      : DAYS,
-  );
-  const [refreshValue, setRefreshValue] = useState(
-    data?.targetGroup?.frequencyType === CUSTOM
-      ? dateDiffInDays(
-          data?.targetGroup?.targetCycleStartDate,
-          data?.targetGroup?.targetCycleEndDate,
-        ) / data?.targetGroup?.totalPeriods
-      : undefined,
-  );
-  const [firstCycleStartDate, setFirstCycleStartDate] = useState(
-    data?.targetGroup?.targetCycleStartDate
-      ? moment(data?.targetGroup?.targetCycleStartDate)
-      : data?.targetGroup?.periods?.[0]?.startDate
-        ? moment(data?.targetGroup?.periods?.[0]?.startDate)
-        : null,
-  );
-  const [totalCycles, setTotalCycles] = useState(
-    data?.target?.defaultValues?.length,
-  );
-  const [refreshValueError, setRefreshValueError] = useState(false);
-
-  const [
-    additionalFilterTransactions,
-    setAdditionalFilterTransactions,
-  ] = useState(
-    data?.additionalFilters && Object.keys(data?.additionalFilters)
-      ? { additionalFilters: data?.additionalFilters }
-      : {},
-  );
-  useEffect(() => {
-    setActivitySelection(
-      isEditMode ? data?.eventName || 'TransactionAdd' : undefined,
-    );
-    setPointsAllocationLimitType(
-      isEditMode
-        ? data?.scope === CURRENT_EVENT
-          ? CURRENT_EVENT
-          : ACROSS_EVENTS
-        : transactionActiveLimit < MAX_CAPPING_TRANSACTION_LIMIT ? CURRENT_EVENT : ACROSS_EVENT,
-    );
-  }, []);
-  const [customerEnrolmentData, setCustomerEnrolmentData] = useState({}); //used for maintaining state for your component
-  const [targetAudienceFilterData, setTargetAudienceFilterData] = useState(
-    data?.target?.targetAudienceFilter || [],
-  ); //TODO: Why do we have 2 states for audience data?
-  const [audienceType, setAudienceType] = useState(
-    data?.target?.enrolmentMethod || undefined,
-  );
-
-  const [rewardCurrencyState, setRewardCurrencyState] = useState(() => {
-    const areRewardCurrencyOptionsAvailable = isRewardCurrencyEnabled && rewardCurrencyOptions?.length > 0;
-
-    const resolveRewardCurrencyIdentifier = () => {
-      if (!isEditMode) {
-        return areRewardCurrencyOptionsAvailable ? '' : POINTS;
-      }
-      const currencyIdentifier =
-        data?.scope === ACROSS_EVENT
-          ? data?.target?.extendedFieldInfo?.alternateCurrencyIdentifier
-          : data?.alternateCurrencyIdentifier;
-      return currencyIdentifier || POINTS;
-    };
-    const resolveRewardCurrencyName = () => {
-      if (!isEditMode) {
-        return areRewardCurrencyOptionsAvailable ? '' : POINTS_CAPITALIZED;
-      }
-      const findCurrencyName = (identifier) =>
-        rewardCurrencyOptions?.find(option => option?.value === identifier)?.key || POINTS_CAPITALIZED;
-      return data?.scope === ACROSS_EVENT
-        ? findCurrencyName(data?.target?.extendedFieldInfo?.alternateCurrencyIdentifier)
-        : findCurrencyName(data?.alternateCurrencyIdentifier);
-    };
-    const rewardCurrencyIdentifier = resolveRewardCurrencyIdentifier();
-    const rewardCurrencyName = resolveRewardCurrencyName();
-    return {
-      rewardCurrencyIdentifier,
-      rewardCurrencyName,
-    };
-  });
-
-  const rewardCurrencyIdentifier = rewardCurrencyState?.rewardCurrencyIdentifier;
-  const isAlternateCurrency = rewardCurrencyIdentifier && rewardCurrencyIdentifier !== POINTS;
-  
-  const getEntityCappingData = pointsAllocationLimitCategory => {
-    const rewardCurrencyEntity = isAlternateCurrency ? ALTERNATE_CURRENCIES : POINTS;
-    switch (pointsAllocationLimitCategory) {
-      case REGULAR_POINTS:
-        return {
-          entity: rewardCurrencyEntity,
-          cappingOn: isAlternateCurrency ? REGULAR : REGULAR_POINTS,
-        };
-      case PROMOTIONAL_POINTS:
-        return {
-          entity: rewardCurrencyEntity,
-          cappingOn: isAlternateCurrency ? PROMOTIONAL : PROMOTIONAL_POINTS,
-        };
-      case ALL_POINTS:
-        return {
-          entity: rewardCurrencyEntity,
-          cappingOn: isAlternateCurrency ? ALL : ALL_POINTS,
-        };
-      case LINE_ITEM_AMOUNT:
-        return {
-          entity: LINEITEM,
-          cappingOn: SALES,
-        };
-      case LINE_ITEM_QUANTITY:
-        return {
-          entity: LINEITEM,
-          cappingOn: QUANTITY,
-        };
-      case TRANSACTION_COUNT:
-        return {
-          entity: TRANSACTION,
-          cappingOn: COUNT,
-        };
-      case TRANSACTION:
-        return {
-          entity: TRANSACTION,
-          cappingOn: SALES,
-        };
-    }
-  };
-  const handleSave = useCallback(
-    debounceUtil(() => {
-      const cappingObject = getEntityCappingData(pointsAllocationLimitCategory);
-      const createOrUpdateTargetGroup = () => {
-        const periods = generateDateList(
-          firstCycleStartDate.toISOString(),
-          refreshUnit === DAYS
-            ? refreshValue
-            : frequencyTypeToFrequencyValue[refreshUnit],
-          totalCycles,
-          refreshUnit,
-          [],
-        );
-        let targetGroup = { ...data?.targetGroup };
-        targetGroup.active = true;
-        targetGroup.name = pointsAllocationLimitName;
-        targetGroup.periods = periods;
-        targetGroup.frequencyType = refreshUnit === DAYS ? CUSTOM : refreshUnit;
-        targetGroup.trackingType = CAPPING;
-        targetGroup.targetEvaluationType = FIXED_CALENDAR_WINDOW;
-        targetGroup.active = true;
-        return targetGroup;
-      };
-      const createOrUpdateTarget = targetGroupData => {
-        let target = { ...data?.target };
-        target.active = true;
-        target.name = pointsAllocationLimitName;
-        target.targetEntity = cappingObject.entity;
-        target.defaultValues = getDefaultValues(
-          data?.targetPeriod || targetGroupData.periods,
-          limit,
-        );
-        target.enrolmentMethod = audienceType;
-        target.targetType = cappingObject.cappingOn;
-        if (isAlternateCurrency) {
-          target.extendedFieldInfo = {
-            programId: programId,
-            alternateCurrencyIdentifier: rewardCurrencyIdentifier,
-          }
-        }
-        return target;
-      };
-      let payload = {};
-      if (pointsAllocationLimitType === CURRENT_EVENT) {
-        payload = {
-          name: pointsAllocationLimitName,
-          scope: CURRENT_EVENT,
-          limit,
-          entity: cappingObject?.entity,
-          cappingOn: cappingObject?.cappingOn,
-          additionalFilters: additionalFilterTransactions.additionalFilters,
-          eventName: activitySelection ? activitySelection : 'TransactionAdd',
-          ...(isAlternateCurrency && { alternateCurrencyIdentifier: rewardCurrencyIdentifier }),
-        };
-      }
-      if (pointsAllocationLimitType === ACROSS_EVENTS) {
-        const targetGroup = createOrUpdateTargetGroup();
-        const target = createOrUpdateTarget(targetGroup);
-        payload = {
-          name: pointsAllocationLimitName,
-          scope: ACROSS_EVENT,
-          limit,
-          entity: cappingObject?.entity,
-          cappingOn: cappingObject?.cappingOn,
-          additionalFilters: additionalFilterTransactions.additionalFilters,
-          targetId: data?.targetId || -1,
-          targetGroupId: data?.targetGroupId || -1,
-          target,
-          targetGroup,
-          eventName: activitySelection ? activitySelection : 'TransactionAdd',
-        };
-      }
-      if (excludedPromotionsFilterValues.length) {
-        payload.additionalFilters = {
-          ...payload.additionalFilters,
-          pointsFilters: {
-            excludedPromotions: excludedPromotionsFilterValues,
-          },
-        };
-      }
-      if (audienceType === AUDIENCE_FILTER) {
-        const previouslySelectedAudienceObject = {};
-        targetAudienceFilterData.forEach(audience => {
-          previouslySelectedAudienceObject[audience.audienceGroupId] = true;
-        });
-        payload.customerEnrolmentData = customerEnrolmentData.includeAudienceData
-          .map(({ id, versionId }) => {
-            if (previouslySelectedAudienceObject[id]) return null;
-            return {
-              groupId: parseInt(id, 10),
-              versionId: parseInt(versionId, 10),
-            };
-          })
-          .filter(value => value);
-      }
-      onClickDone(payload);
-    }, 300),
-  );
- 
-  const hasDuplicateName = () => {
-    if (
-      !pointsAllocationLimitData ||
-      [data?.name, data?.target?.name].includes(pointsAllocationLimitName)
-    ) {
-      return false;
-    }
-    let duplicateExists = false;
-    switch (pointsAllocationLimitType) {
-      case CURRENT_EVENT:
-        duplicateExists = pointsAllocationLimitData?.transactionLimit.some(
-          data => data.name === pointsAllocationLimitName,
-        );
-        break;
-      case ACROSS_EVENT:
-        duplicateExists = pointsAllocationLimitData?.acrossCustomerLimit.some(
-          data => data?.target?.name === pointsAllocationLimitName,
-        );
-        break;
-    }
-    return duplicateExists;
-  };
-  const isActivityAndAudienceDisabled = () => {
-    if (pointsAllocationLimitType === ACROSS_EVENT) {
-      if (!activitySelection || !audienceType) {
-        return true;
-      } else if (
-        audienceType === AUDIENCE_FILTER &&
-        !customerEnrolmentData?.includeAudienceData?.length
-      ) {
-        return true;
-      }
-      return false;
-    }
-    return false;
-  };
-  const checkIfDisabled = () => {
-    let acrossCustomerError = false;
-    let filterTransactionError = false;
-    let isNameDuplicate = false;
-    if (pointsAllocationTransactionType === FILTER_TRANSACTIONS) {
-      if (!isEmpty(additionalFilterTransactions?.additionalFilters)) {
-        filterTransactionError =
-          isEmpty(
-            additionalFilterTransactions?.additionalFilters?.includedStoreIds,
-          ) &&
-          isEmpty(
-            additionalFilterTransactions?.additionalFilters?.includedZoneIds,
-          ) &&
-          isEmpty(
-            additionalFilterTransactions?.additionalFilters?.lineItemFilters
-              ?.includedBrands,
-          ) &&
-          isEmpty(
-            additionalFilterTransactions?.additionalFilters?.lineItemFilters
-              ?.includedCategories,
-          ) &&
-          isEmpty(
-            additionalFilterTransactions?.additionalFilters?.lineItemFilters
-              ?.includedSkus,
-          ) &&
-          Object.keys(
-            additionalFilterTransactions?.additionalFilters?.lineItemFilters
-              ?.includedAttributes || {},
-          ).length === 0;
-      }
-    }
-    if (pointsAllocationLimitType === ACROSS_EVENT) {
-      acrossCustomerError =
-        !totalCycles ||
-        +totalCycles <= 0 ||
-        (refreshUnit === DAYS ? +totalCycles > 1000 : +totalCycles > 100) ||
-        isEmpty(firstCycleStartDate) ||
-        refreshValueError ||
-        (refreshUnit === DAYS &&
-          (+refreshValue > 1000 || +refreshValue <= 0 || !refreshValue));
-    }
-    if (hasDuplicateName()) {
-      isNameDuplicate = true;
-    }
-    return (
-      isActivityAndAudienceDisabled() ||
-      isEmpty(pointsAllocationLimitName) ||
-      isEmpty(pointsAllocationLimitCategory) ||
-      isEmpty(pointsAllocationTransactionType) ||
-      limit <= 0 ||
-      acrossCustomerError ||
-      filterTransactionError ||
-      isDoneDisabled ||
-      isNameDuplicate ||
-      (isRewardCurrencyEnabled && !rewardCurrencyIdentifier)
-    );
-  };
-
-  const getSliderHeader = () => (
-    <CapRow className="header-flex">
-      <CapHeader
-        size="h1"
-        title={formatMessage(messages.addPointsAlloctionLimitHeading)}
-      />
-
-      <CapRow type="flex" className="header-flex-item">
-        <CapLabel type="label1" className="points-allocation-limit-label">
-          {formatMessage(globalMessages.maxLimitOn)}
-          <CapLabel type="label2" className="header-description points-allocation-limit-header-description-count">
-            {
-              pointsAllocationLimitType === ACROSS_EVENT
-              ? MAX_CAPPING_CUSTOMER_LIMIT
-              : MAX_CAPPING_TRANSACTION_LIMIT
-            }
-          </CapLabel>
-        </CapLabel>
-      </CapRow>
-    </CapRow>
-  );
-
-  const getSliderContent = () => (
-    <CapRow className="addLimit-pointsLimit-content">
-      <AddPointsAllocationLimitDetails
-        pointsAllocationLimitName={pointsAllocationLimitName}
-        setPointsAllocationLimitName={setPointsAllocationLimitName}
-        pointsAllocationLimitCategory={pointsAllocationLimitCategory}
-        setPointsAllocationLimitCategory={setPointsAllocationLimitCategory}
-        pointsAllocationTransactionType={pointsAllocationTransactionType}
-        setPointsAllocationTransactionType={setPointsAllocationTransactionType}
-        limit={limit}
-        setLimit={setLimit}
-        excludedPromotions={excludedPromotions}
-        setExcludedPromotions={setExcludedPromotions}
-        excludedPromotionsFilterValues={excludedPromotionsFilterValues}
-        setExcludedPromotionsFilterValues={setExcludedPromotionsFilterValues}
-        refreshUnit={refreshUnit}
-        setRefreshUnit={setRefreshUnit}
-        refreshValue={refreshValue}
-        setRefreshValue={setRefreshValue}
-        firstCycleStartDate={firstCycleStartDate}
-        setFirstCycleStartDate={setFirstCycleStartDate}
-        totalCycles={totalCycles}
-        setTotalCycles={setTotalCycles}
-        pointsAllocationLimitType={pointsAllocationLimitType}
-        setRefreshValueError={setRefreshValueError}
-        additionalFilterTransactions={additionalFilterTransactions}
-        setAdditionalFilterTransactions={setAdditionalFilterTransactions}
-        isEditable={!isEditMode}
-        limitsWithAllTransactionType={limitsWithAllTransactionType}
-        lineItemAmountUsed={lineItemAmountUsed}
-        lineItemQuantityUsed={lineItemQuantityUsed}
-        isEditMode={isEditMode}
-        hasDuplicateName={hasDuplicateName}
-        setPointsAllocationLimitType={setPointsAllocationLimitType}
-        setActivitySelection={setActivitySelection}
-        activitySelection={activitySelection}
-        customerEnrolmentData={customerEnrolmentData}
-        setCustomerEnrolmentData={setCustomerEnrolmentData}
-        setAudienceType={setAudienceType}
-        audienceType={audienceType}
-        targetAudienceFilterData={targetAudienceFilterData}
-        transactionActiveLimit={transactionActiveLimit}
-        acrossCustomerActiveLimit={acrossCustomerActiveLimit}
-        customerLimitWithAllCustomerCount={customerLimitWithAllCustomerCount}
-        isRewardCurrencyEnabled={isRewardCurrencyEnabled}
-        rewardCurrencyOptions={rewardCurrencyOptions}
-        rewardCurrencyState={rewardCurrencyState}
-        setRewardCurrencyState={setRewardCurrencyState}
-        existingTransactionKPIs={existingTransactionKPIs}
-      />
-    </CapRow>
-  );
-  const getDoneButton = () => (
-    <CapButton
-      className="add-limit-btn"
-      disabled={checkIfDisabled()}
-      onClick={handleSave}
-    >
-      {formatMessage(globalMessages.done)}
-    </CapButton>
-  );
-  const getFooter = () =>
-    checkIfDisabled() ? (
-      <CapTooltip
-        title={
-          isDoneDisabled
-            ? formatMessage(messages.saveInProgress)
-            : formatMessage(globalMessages.mandatoryFields)
-        }
-      >
-        <span className="button-disabled-tooltip-wrapper">
-          {getDoneButton()}
-        </span>
-      </CapTooltip>
-    ) : (
-      <>{getDoneButton()}</>
-    );
-
-  return (
-    <CapRow className={className}>
-      <CapSlideBox
-        className="points-limit-detail-slidebox"
-        showShadow
-        show={show}
-        header={getSliderHeader()}
-        content={getSliderContent()}
-        footer={getFooter()}
-        handleClose={onCardClose}
-        size="size-s"
-      />
-    </CapRow>
-  );
-};
-
-AddPointsAllocationLimitSlider.propTypes = {
-  intl: intlShape.isRequired,
-  header: PropTypes.element,
-  showSpinner: PropTypes.bool,
-  show: PropTypes.bool,
-  onCardClose: PropTypes.func,
-  className: PropTypes.string,
-  actions: PropTypes.object,
-  eventType: PropTypes.string,
-  pointsAllocationLimitType: PropTypes.string,
-  pointsAllocationLimitData: PropTypes.object,
-  setPointsAllocationLimitType: PropTypes.func,
-  isRewardCurrencyEnabled: PropTypes.bool,
-  rewardCurrencyOptions: PropTypes.array,
-  programId: PropTypes.string,
-  existingTransactionKPIs: PropTypes.object,
-};
-
-AddPointsAllocationLimitSlider.defaultValues = {
-  isRewardCurrencyEnabled: false,
-  rewardCurrencyOptions: [],
-  programId: '',
-  existingTransactionKPIs: {},
-};
-
-export default compose(withErrorBoundary)(
-  injectIntl(withStyles(AddPointsAllocationLimitSlider, styles)),
-);

package/components/organisms/AddPointsAllocationLimitSlider/constants.js

@@ -1,40 +0,0 @@
-import {
-  ALL_POINTS,
-  LINE_ITEM_AMOUNT,
-  LINE_ITEM_QUANTITY,
-  PROMOTIONAL_POINTS,
-  REGULAR_POINTS,
-  TRANSACTION,
-  TRANSACTION_COUNT,
-} from '../ActivityRewardSlider/constants';
-
-export const pointsAllocationLimitCategoryMapping = {
-  TRANSACTION: {
-    SALES: TRANSACTION,
-    COUNT: TRANSACTION_COUNT,
-  },
-  LINEITEM: {
-    SALES: LINE_ITEM_AMOUNT,
-    QUANTITY: LINE_ITEM_QUANTITY,
-  },
-  ALL_POINTS: ALL_POINTS,
-  REGULAR_POINTS: REGULAR_POINTS,
-  PROMOTIONAL_POINTS: PROMOTIONAL_POINTS,
-  REGULAR: REGULAR_POINTS, //converted back to REGULAR in payload
-  PROMOTIONAL: PROMOTIONAL_POINTS, //converted back to PROMOTIONAL in payload
-  ALL: ALL_POINTS, //converted back to ALL in payload
-};
-
-export const MONTHLY = 'MONTHLY';
-export const QUARTERLY = 'QUARTERLY';
-export const YEARLY = 'YEARLY';
-export const HALF_YEARLY = 'HALF_YEARLY';
-export const CAPPING = 'CAPPING';
-export const FIXED_CALENDAR_WINDOW = 'FIXED_CALENDAR_WINDOW';
-
-export const frequencyTypeToFrequencyValue = {
-  [MONTHLY]: 1,
-  [QUARTERLY]: 3,
-  [YEARLY]: 12,
-  [HALF_YEARLY]: 6,
-};

package/components/organisms/AddPointsAllocationLimitSlider/index.js

@@ -1 +0,0 @@
-export { default } from './AddPointsAllocationLimitSlider';

package/components/organisms/AddPointsAllocationLimitSlider/messages.js

@@ -1,44 +0,0 @@
-/*
- * ActivityRewardSlider Messages
- *
- */
-
-import { defineMessages } from 'react-intl';
-
-export const scope =
-  'loyaltyPlus.components.organisms.AddPointsAllocationLimitSlider';
-
-export default defineMessages({
-  zones: {
-    id: `${scope}.zones`,
-    defaultMessage: 'zones',
-  },
-  addPointsAlloctionLimitHeading: {
-    id: `${scope}.addPointsAlloctionLimitHeading`,
-    defaultMessage: 'Add points allocation limit',
-  },
-  stores: {
-    id: `${scope}.stores`,
-    defaultMessage: 'stores',
-  },
-  limitType: {
-    id: `${scope}.limitType`,
-    defaultMessage: 'Limit type',
-  },
-  transactionLimits: {
-    id: `${scope}.transactionLimits`,
-    defaultMessage: 'Transaction limits',
-  },
-  acrossCustomerLimits: {
-    id: `${scope}.acrossCustomerLimits`,
-    defaultMessage: 'Across customer limits',
-  },
-  addTransaction: {
-    id: `${scope}.addTransaction`,
-    defaultMessage: 'Add transaction',
-  },
-  saveInProgress: {
-    id: `${scope}.saveInProgress`,
-    defaultMessage: 'Save in progress',
-  }
-});