@zeniai/client-epic-state 4.19.28 → 4.19.30

package/lib/esm/view/spendManagement/reimbursement/editRemiView/epics/parseReceiptsToRemiEpic.js

@@ -0,0 +1,191 @@
+import { from, of } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { getAccountBase } from '../../../../../entity/account/accountSelector';
+import { getClassById } from '../../../../../entity/class/classSelector';
+import { mapMerchantPayloadToMerchant } from '../../../../../entity/merchant/merchantPayload';
+import { getMerchantsByMerchantIds } from '../../../../../entity/merchant/merchantSelector';
+import { getCurrentTenant } from '../../../../../entity/tenant/tenantSelector';
+import { mapFileToAttachment } from '../../../../../entity/transaction/payloadTypes/attachmentPayload';
+import { date } from '../../../../../zeniDayJS';
+import { fetchDuplicateReimbursement } from '../../remiDetailView/remiDetailViewReducer';
+import { fetchCurrencyConversionValue, fetchRecommendationsAndUpdateMerchantRecommendations, parseReceiptsToRemi, saveRemiUpdatesToLocalStore, updateAddRemiAutoFields, updateTentativeMerchantNames, updateUploadFetchState, } from '../editRemiViewReducer';
+export const parseReceiptsToRemiEpic = (actions$, state$) => actions$.pipe(filter(parseReceiptsToRemi.match), mergeMap((action) => {
+    const { receiptsProcessingPayload, lineId, reimbursementId, shouldOverwrite, signedInUserId, } = action.payload;
+    const state = state$.value;
+    const remiState = reimbursementId != null
+        ? state.editRemiDetailViewState.editRemiStateById[reimbursementId]
+        : state.editRemiDetailViewState.newRemiState;
+    const loggedInUserDepartmentId = getCurrentTenant(state).accountingClassIDs?.[0];
+    const newUpdatesByLineId = {
+        ...remiState.remiDetailLocalData.updatesByLineId,
+    };
+    if (shouldOverwrite === false) {
+        let currentLineId = lineId;
+        receiptsProcessingPayload.receipts.forEach((receipt) => {
+            newUpdatesByLineId[currentLineId] = {
+                ...newUpdatesByLineId[currentLineId],
+                type: 'out_of_pocket',
+                fileId: receipt.file_id ?? '',
+                lineId: String(currentLineId),
+            };
+            currentLineId++;
+        });
+        const files = receiptsProcessingPayload.files.map((file) => mapFileToAttachment(file));
+        return of(saveRemiUpdatesToLocalStore({
+            remiDetailLocalData: {
+                ...remiState.remiDetailLocalData,
+                files: remiState.remiDetailLocalData.files != null
+                    ? [...remiState.remiDetailLocalData.files, ...files]
+                    : files,
+                updatesByLineId: newUpdatesByLineId,
+            },
+            reimbursementId,
+        }), updateUploadFetchState({ reimbursementId, fetchState: 'Completed' }));
+    }
+    else {
+        const actions = [];
+        const currencyConversionActions = [];
+        const merchantsById = {};
+        receiptsProcessingPayload.merchants.forEach((merchant) => {
+            if (Boolean(merchant.merchant_id) === true) {
+                //if condition check for merchant_id empty string
+                merchantsById[merchant.merchant_id] =
+                    mapMerchantPayloadToMerchant(merchant);
+            }
+        });
+        const addRemiAutoFields = {};
+        const tentativeMerchantNameByLineId = {};
+        let currentLineId = lineId;
+        const merchants = getMerchantsByMerchantIds(state.merchantState, state.merchantListState.merchantIds);
+        receiptsProcessingPayload.receipts.forEach((receipt) => {
+            const parsedMerchantId = receipt.merchant_id;
+            const parsedMerchant = merchantsById[parsedMerchantId];
+            const parsedMerchantName = parsedMerchant?.name;
+            let finalMerchant;
+            if (parsedMerchantName != null && parsedMerchantName.length > 0) {
+                finalMerchant = merchants.filter((merchant) => merchant.name.toLowerCase() === parsedMerchantName.toLowerCase())[0];
+            }
+            newUpdatesByLineId[currentLineId] = {
+                lineId: String(currentLineId),
+                type: 'out_of_pocket',
+                fileId: receipt.file_id ?? '',
+                homeCurrencyConversions: {
+                    amount: receipt.amount,
+                    currencyCode: receipt.currency_code ?? 'USD',
+                    currencySymbol: receipt.currency_symbol ?? '$',
+                },
+                outOfPocket: {
+                    ...toUpdateLine(state.accountState, state.classState, receipt, finalMerchant, loggedInUserDepartmentId),
+                },
+                mileage: {},
+            };
+            if (receipt.currency_code !== 'USD') {
+                currencyConversionActions.push(fetchCurrencyConversionValue('USD', currentLineId.toString(), reimbursementId));
+            }
+            addRemiAutoFields[currentLineId] = getAutoFieldData(newUpdatesByLineId[currentLineId]);
+            const tentativeMerchantNameByLineIdData = getTentativeMerchantNameByLineIdData(newUpdatesByLineId[currentLineId], parsedMerchantName);
+            if (tentativeMerchantNameByLineIdData != null &&
+                tentativeMerchantNameByLineIdData !== '') {
+                tentativeMerchantNameByLineId[currentLineId] =
+                    tentativeMerchantNameByLineIdData;
+            }
+            if (finalMerchant != null) {
+                //add recommendation for existing merchant
+                actions.push(fetchRecommendationsAndUpdateMerchantRecommendations(false, currentLineId.toString(), reimbursementId, finalMerchant.id, undefined));
+            }
+            else {
+                // add recommendation for new merchant
+                actions.push(fetchRecommendationsAndUpdateMerchantRecommendations(false, currentLineId.toString(), reimbursementId, undefined, tentativeMerchantNameByLineId[currentLineId]));
+            }
+            currentLineId++;
+        });
+        const files = receiptsProcessingPayload.files.map((file) => mapFileToAttachment(file));
+        actions.push(saveRemiUpdatesToLocalStore({
+            remiDetailLocalData: {
+                ...remiState.remiDetailLocalData,
+                files: remiState.remiDetailLocalData.files != null
+                    ? [...remiState.remiDetailLocalData.files, ...files]
+                    : files,
+                updatesByLineId: newUpdatesByLineId,
+            },
+            reimbursementId,
+        }), updateAddRemiAutoFields({ reimbursementId, addRemiAutoFields }), updateTentativeMerchantNames({
+            reimbursementId,
+            tentativeMerchantNameByLineId,
+        }), ...currencyConversionActions, updateUploadFetchState({ reimbursementId, fetchState: 'Completed' }));
+        if (signedInUserId != null) {
+            actions.push(fetchDuplicateReimbursement(signedInUserId, true, reimbursementId));
+        }
+        return from(actions);
+    }
+}));
+const toUpdateLine = (accountState, classState, receiptPayload, finalMerchant, classId) => {
+    return {
+        merchant: finalMerchant != null
+            ? {
+                id: finalMerchant.id,
+                name: finalMerchant.name,
+            }
+            : undefined,
+        description: receiptPayload.transaction_memo,
+        lineDetail: {
+            account: getAccountBase(accountState, finalMerchant?.accountId ?? '', 'account_list'),
+            class: classId != null
+                ? getClassById(classState, {
+                    classId,
+                    reportId: 'class_list',
+                })
+                : undefined,
+        },
+        transactionDate: date(receiptPayload.transaction_date),
+        amount: receiptPayload.amount,
+        currencyCode: receiptPayload.currency_code ?? 'USD',
+        currencySymbol: receiptPayload.currency_symbol ?? '$',
+        recommendations: [],
+        isCategoryUpdateSelected: false,
+        isCategoryFirstTimeAutofilled: false,
+        isRetainedCategorySelected: false,
+    };
+};
+const getAutoFieldData = (reimbursementLine) => {
+    const fields = [];
+    const lineData = reimbursementLine.type === 'mileage'
+        ? reimbursementLine.mileage
+        : reimbursementLine.outOfPocket;
+    Object.keys(lineData).forEach((item) => {
+        switch (item) {
+            case 'merchant':
+                fields.push('merchant');
+                break;
+            case 'amount':
+                if (lineData.amount !== 0) {
+                    fields.push('amount');
+                }
+                break;
+            case 'transactionDate':
+                fields.push('transactionDate');
+                break;
+            case 'description':
+                if (lineData.description !== '') {
+                    fields.push('memo');
+                }
+                break;
+            case 'lineDetail':
+                if (lineData.lineDetail?.account?.accountId != null) {
+                    fields.push('account');
+                }
+                break;
+        }
+    });
+    return fields;
+};
+const getTentativeMerchantNameByLineIdData = (reimbursementLine, tentativeMerchantName) => {
+    if (tentativeMerchantName != null &&
+        reimbursementLine.type === 'out_of_pocket' &&
+        reimbursementLine.merchant != null) {
+        return undefined;
+    }
+    else {
+        return tentativeMerchantName;
+    }
+};

package/lib/esm/view/spendManagement/reimbursement/editRemiView/epics/saveRemiDetailEpic.js

@@ -0,0 +1,113 @@
+import recordGet from 'lodash/get';
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { updateApprovalRules } from '../../../../../entity/approvalRule/approvalRuleReducer';
+import { updateEntityApprovalStatus } from '../../../../../entity/entityApprovalStatus/entityApprovalStatusReducer';
+import { updateMerchants } from '../../../../../entity/merchant/merchantReducer';
+import { toReimbursementLinePayload, } from '../../../../../entity/reimbursement/reimbursementPayload';
+import { updateReimbursement } from '../../../../../entity/reimbursement/reimbursementReducer';
+import { openSnackbar } from '../../../../../entity/snackbar/snackbarReducer';
+import { updateAllUsers } from '../../../../../entity/user/userReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
+import { dateNow } from '../../../../../zeniDayJS';
+import { getRecommendationFromRecommendationPayload } from '../../../../recommendation/recommendationHelper';
+import { updateRecommendationForEntity } from '../../../../recommendation/recommendationReducer';
+import { updateMerchantListIds } from '../../../merchantList/merchantListReducer';
+import { clearDuplicateReimbursementDetail, } from '../../remiDetailView/remiDetailViewReducer';
+import { saveRemiDetail, saveRemiSuccessOrFailure } from '../editRemiViewReducer';
+export const saveRemiDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(saveRemiDetail.match), mergeMap((action) => {
+    const state = state$.value;
+    const { remiStageCode, reimbursementId, isSubmitted } = action.payload;
+    const remiDetail = reimbursementId != null
+        ? state.editRemiDetailViewState.editRemiStateById[reimbursementId]
+        : state.editRemiDetailViewState.newRemiState;
+    const payload = prepareSaveRemiPayload(state.reimbursementState, state.tenantState, remiDetail, remiStageCode, isSubmitted);
+    const saveVendorApi = reimbursementId != null
+        ? zeniAPI.putAndGetJSON(`${zeniAPI.apiEndPoints.spendManagementMicroServiceBaseUrl}/1.0/reimbursements/transactions/${action.payload.reimbursementId}`, payload)
+        : zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.spendManagementMicroServiceBaseUrl}/1.0/reimbursements/transactions`, payload);
+    return saveVendorApi.pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) &&
+            response.data?.transactions[0]?.transaction_id != null) {
+            const actions = [
+                updateReimbursement(response.data.transactions[0]),
+                updateAllUsers({ users: response.data.users ?? [] }),
+                updateApprovalRules(response.data.approval_rules),
+                updateEntityApprovalStatus(response.data.entity_approvals),
+                updateMerchants(response.data.merchants),
+                updateMerchantListIds(response.data.merchants),
+                clearDuplicateReimbursementDetail(),
+                saveRemiSuccessOrFailure('Completed', action.payload.reimbursementId),
+                openSnackbar({
+                    messageSection: remiStageCode === 'pending_approval'
+                        ? 'reimbursement_sent_for_approval'
+                        : 'reimbursement_updated',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ];
+            //update the merchants recommendation in recommendation view
+            response.data.merchants.forEach((merchant) => {
+                const recommendations = getRecommendationFromRecommendationPayload(merchant.recommendations ?? []);
+                if (recommendations != null &&
+                    Boolean(merchant.merchant_id) === true) {
+                    actions.push(updateRecommendationForEntity({
+                        entityId: merchant.merchant_id,
+                        entityType: 'merchant',
+                        recommendations,
+                    }));
+                }
+            });
+            return from(actions);
+        }
+        else {
+            return of(saveRemiSuccessOrFailure('Error', action.payload.reimbursementId, response.status), openSnackbar({
+                messageSection: remiStageCode === 'pending_approval'
+                    ? 'reimbursement_sent_for_approval'
+                    : 'reimbursement_updated',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }));
+        }
+    }), catchError((error) => of(saveRemiSuccessOrFailure('Error', action.payload.reimbursementId, createZeniAPIStatus('Unexpected Error', `REST API call errored out ${JSON.stringify(error)}`)))));
+}));
+function prepareSaveRemiPayload(reimbursementState, tenantState, remiDetail, remiStageCode, isSubmitted) {
+    const reimbursementId = remiDetail.reimbursementId;
+    const detail = recordGet(reimbursementState.reimbursementById, reimbursementId ?? '', undefined);
+    const payload = {
+        reimbursement_provider: 'zeni',
+        transaction_type: 'reimbursement',
+        is_include_approval_info: true,
+        reimbursee_user_id: detail?.reimburseeUserId ?? tenantState.loggedInUser?.userId,
+        sync_token: detail?.syncToken ?? null,
+        reimbursement_date: dateNow().format('YYYY-MM-DD'), // fix for https://app.clickup.com/t/10555925/POD2-1894
+        due_date: null,
+        currency_code: remiDetail.remiDetailLocalData.totalAmount?.currencyCode,
+        report_title: remiDetail.remiDetailLocalData.whatForSection?.reportTitle,
+        is_transaction_submitted: isSubmitted,
+        total_amount: remiDetail.remiDetailLocalData.totalAmount?.amount,
+        reimbursement_info: {
+            stage: {
+                code: remiStageCode,
+            },
+            to_account: remiDetail.remiDetailLocalData.paymentTo != null
+                ? {
+                    account_id: remiDetail.remiDetailLocalData.paymentTo,
+                }
+                : undefined,
+        },
+        lines: Object.keys(remiDetail.remiDetailLocalData.updatesByLineId).map((lineId) => {
+            const line = remiDetail.remiDetailLocalData.updatesByLineId[lineId];
+            return toReimbursementLinePayload(line);
+        }),
+    };
+    if (reimbursementId == null) {
+        payload.are_approvals_serialized = true;
+    }
+    return payload;
+}

package/lib/esm/view/spendManagement/reimbursement/reimbursementConfig/fetchReimbursementConfigEpic.js

@@ -0,0 +1,21 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { updateCurrencies } from '../../../../entity/currency/currencyReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchReimbursementConfig, updateReimbursementConfig, updateReimbursementConfigFailure, } from './reimbursementConfigReducer';
+export const fetchReimbursementConfigEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchReimbursementConfig.match), mergeMap(() => {
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.spendManagementMicroServiceBaseUrl}/1.0/reimbursements/config`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const updateActions = [];
+            updateActions.push(updateReimbursementConfig(response.data));
+            updateActions.push(updateCurrencies(response.data.currency_country_map));
+            return from(updateActions);
+        }
+        else {
+            return of(updateReimbursementConfigFailure(response.status));
+        }
+    }), catchError((error) => of(updateReimbursementConfigFailure(createZeniAPIStatus('Unexpected Error', 'fetch reimbursement config REST API call errored out' +
+        JSON.stringify(error))))));
+}));

package/lib/esm/view/spendManagement/reimbursement/reimbursementConfig/reimbursementConfigPayload.js

@@ -0,0 +1,15 @@
+import { getReimbursementConfigKey, } from './reimbursementConfigState';
+export const mapReimbursementConfigPayloadToReimbursementConfig = (payload, code, subCode) => {
+    const { payment_timeline } = payload.payment_processor;
+    return {
+        minPeriod: {
+            value: payment_timeline[code][subCode].min.value ?? 0,
+            units: payment_timeline[code][subCode].min.units ?? 'days',
+        },
+        maxPeriod: {
+            value: payment_timeline[code][subCode].max.value ?? 0,
+            units: payment_timeline[code][subCode].max.units ?? 'days',
+        },
+        method: getReimbursementConfigKey(code, subCode) ?? '',
+    };
+};

package/lib/esm/view/spendManagement/reimbursement/reimbursementConfig/reimbursementConfigReducer.js

@@ -0,0 +1,52 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { PAYMENT_ACH_SUB_CODES } from '../../billPay/billPayConfig/billPayConfigState';
+import { mapReimbursementConfigPayloadToReimbursementConfig, } from './reimbursementConfigPayload';
+import { REIMBURSEMENT_PAYMENT_METHOD_CODE, getReimbursementConfigKey, } from './reimbursementConfigState';
+export const initialState = {
+    methodById: {},
+    reimbursementBotEmail: '',
+    fetchState: 'Not-Started',
+    error: undefined,
+    reimbursementBulkSubmissionLimit: 10,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const reimbursementConfig = createSlice({
+    name: 'reimbursementConfig',
+    initialState,
+    reducers: {
+        fetchReimbursementConfig(draft) {
+            draft.fetchState = 'In-Progress';
+            draft.error = undefined;
+        },
+        updateReimbursementConfig(draft, action) {
+            const { payload } = action;
+            REIMBURSEMENT_PAYMENT_METHOD_CODE.forEach((code) => {
+                switch (code) {
+                    case 'ach': {
+                        PAYMENT_ACH_SUB_CODES.forEach((subCode) => {
+                            draft.methodById[getReimbursementConfigKey(code, subCode)] =
+                                mapReimbursementConfigPayloadToReimbursementConfig(payload, code, subCode);
+                        });
+                        break;
+                    }
+                }
+            });
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+            draft.reimbursementBotEmail = payload.reimbursement_bot_email;
+            draft.reimbursementBulkSubmissionLimit =
+                payload.max_reimbursements_allowed_for_bulk_action;
+        },
+        updateReimbursementConfigFailure(draft, action) {
+            draft.fetchState = 'Error';
+            draft.error = action.payload;
+        },
+        clearReimbursementConfig(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchReimbursementConfig, updateReimbursementConfig, updateReimbursementConfigFailure, clearReimbursementConfig, } = reimbursementConfig.actions;
+export default reimbursementConfig.reducer;

package/lib/esm/view/spendManagement/reimbursement/reimbursementConfig/reimbursementConfigSelector.js

@@ -0,0 +1,7 @@
+import recordGet from 'lodash/get';
+export function getReimbursementConfigByKey(reimbursementConfigState, reimbursementConfigKey) {
+    return recordGet(reimbursementConfigState.methodById, reimbursementConfigKey, undefined);
+}
+export function getReimbursementConfigBotEmail(reimbursementConfigState) {
+    return reimbursementConfigState.reimbursementBotEmail;
+}

package/lib/esm/view/spendManagement/reimbursement/reimbursementConfig/reimbursementConfigState.js

@@ -0,0 +1,6 @@
+import { stringToUnion } from '../../../../commonStateTypes/stringToUnion';
+export const getReimbursementConfigKey = (method, subMethod) => `reimbursement_${method}_${subMethod}`;
+export const REIMBURSEMENT_PAYMENT_METHOD_CODE = ['ach'];
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const toReimbursementMethodCodeType = (v) => stringToUnion(v, REIMBURSEMENT_PAYMENT_METHOD_CODE);
+export const REIMBURSEMENT_PAYMENT_NUMBER_OF_DAYS = 2;

package/lib/esm/view/spendManagement/reimbursement/remiDetailView/epics/approveOrRejectRemiEpic.js

@@ -0,0 +1,52 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { updateEntityApprovalStatus } from '../../../../../entity/entityApprovalStatus/entityApprovalStatusReducer';
+import { openSnackbar } from '../../../../../entity/snackbar/snackbarReducer';
+import { updateAllUsers } from '../../../../../entity/user/userReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
+import { approveOrRejectRemi, approveOrRejectRemiFailure, approveOrRejectRemiSuccess, } from '../remiDetailViewReducer';
+export const approveOrRejectRemiEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(approveOrRejectRemi.match), mergeMap((action) => {
+    const { reimbursementId, approvalType, description } = action.payload;
+    const payload = {
+        approval_status: approvalType,
+        is_include_entity_approval: true,
+        description,
+    };
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.spendManagementMicroServiceBaseUrl}/1.0/reimbursements/transactions/${reimbursementId}/approval-status`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const entityApprovalIds = response.data.entity_approvals.map((entityApproval) => entityApproval.entity_approval_id);
+            return from([
+                updateAllUsers({ users: response.data.users ?? [] }),
+                updateEntityApprovalStatus(response.data?.entity_approvals),
+                approveOrRejectRemiSuccess(reimbursementId, entityApprovalIds),
+                openSnackbar({
+                    messageSection: approvalType === 'approved'
+                        ? 'reimbursement_approved'
+                        : 'reimbursement_rejected',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ]);
+        }
+        else {
+            return of(approveOrRejectRemiFailure(reimbursementId, response.status), openSnackbar({
+                messageSection: approvalType === 'approved'
+                    ? 'reimbursement_approved'
+                    : 'reimbursement_rejected',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }));
+        }
+    }), catchError((error) => {
+        return of(approveOrRejectRemiFailure(reimbursementId, createZeniAPIStatus('Unexpected Error', 'Approve Or Reject Reimbursement errored out' +
+            JSON.stringify(error))));
+    }));
+}));

package/lib/esm/view/spendManagement/reimbursement/remiDetailView/epics/cancelAndDeleteRemiEpic.js

@@ -0,0 +1,61 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { removeReimbursement, updateReimbursement, } from '../../../../../entity/reimbursement/reimbursementReducer';
+import { openSnackbar } from '../../../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse, isSuccessStatus, } from '../../../../../responsePayload';
+import { removeReimbursementIdfromRemiTabList } from '../../remiListView/remiListReducer';
+import { cancelAndDeleteRemi, cancelAndDeleteRemiSuccessOrFailure, } from '../remiDetailViewReducer';
+export const cancelAndDeleteRemiEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(cancelAndDeleteRemi.match), mergeMap((action) => {
+    const query = {
+        reimbursement_provider: 'zeni',
+        is_delete_reimbursement: action.payload.isDeleteRemi,
+    };
+    const { reimbursementState } = state$.value;
+    const transaction = reimbursementState.reimbursementById[action.payload.reimbursementId];
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.spendManagementMicroServiceBaseUrl}/1.0/reimbursements/transactions/${action.payload.reimbursementId}/cancel-payment`, query)
+        .pipe(mergeMap((response) => {
+        if (action.payload.isDeleteRemi === true &&
+            isSuccessStatus(response)) {
+            const actions = [
+                cancelAndDeleteRemiSuccessOrFailure('Completed', action.payload.reimbursementId, action.payload.isDeleteRemi),
+            ];
+            if (transaction != null) {
+                actions.push(removeReimbursementIdfromRemiTabList({
+                    remiId: action.payload.reimbursementId,
+                    tab: transaction.reimbursementInfo.stage.code,
+                }));
+            }
+            actions.push(removeReimbursement(action.payload.reimbursementId));
+            actions.push(openSnackbar({
+                messageSection: 'reimbursement_cancelled_deleted',
+                messageText: 'success',
+                type: 'success',
+            }));
+            return from(actions);
+        }
+        else if (isSuccessResponse(response) &&
+            response.data != null &&
+            response.data?.transaction?.transaction_id != null) {
+            return of(updateReimbursement(response.data.transaction), cancelAndDeleteRemiSuccessOrFailure('Completed', action.payload.reimbursementId, action.payload.isDeleteRemi), openSnackbar({
+                messageSection: 'reimbursement_cancelled',
+                messageText: 'success',
+                type: 'success',
+            }));
+        }
+        else {
+            return of(cancelAndDeleteRemiSuccessOrFailure('Error', action.payload.reimbursementId, action.payload.isDeleteRemi, response.status), openSnackbar({
+                messageSection: 'reimbursement_cancelled',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }));
+        }
+    }), catchError((error) => of(cancelAndDeleteRemiSuccessOrFailure('Error', action.payload.reimbursementId, action.payload.isDeleteRemi, createZeniAPIStatus('Unexpected Error', `Cancel and Delete reimbursement REST API call errored out ` +
+        JSON.stringify(error))))));
+}));

package/lib/esm/view/spendManagement/reimbursement/remiDetailView/epics/deleteRemiEpic.js

@@ -0,0 +1,51 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { removeReimbursement } from '../../../../../entity/reimbursement/reimbursementReducer';
+import { openSnackbar } from '../../../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessStatus, } from '../../../../../responsePayload';
+import { removeReimbursementIdfromRemiTabList } from '../../remiListView/remiListReducer';
+import { deleteRemi, deleteRemiSuccessOrFailure } from '../remiDetailViewReducer';
+const query = {
+    transaction_type: 'reimbursement',
+    reimbursement_provider: 'zeni',
+};
+export const deleteRemiEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(deleteRemi.match), mergeMap((action) => {
+    const { reimbursementState } = state$.value;
+    const transaction = reimbursementState.reimbursementById[action.payload.reimbursementId];
+    return zeniAPI
+        .deleteAndGetJSON(`${zeniAPI.apiEndPoints.spendManagementMicroServiceBaseUrl}/1.0/reimbursements/transactions/${action.payload.reimbursementId}?query=${encodeURIComponent(JSON.stringify(query))}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessStatus(response)) {
+            const actions = [
+                deleteRemiSuccessOrFailure('Completed', action.payload.reimbursementId),
+            ];
+            if (transaction != null) {
+                actions.push(removeReimbursementIdfromRemiTabList({
+                    remiId: action.payload.reimbursementId,
+                    tab: transaction.reimbursementInfo.stage.code,
+                }));
+            }
+            actions.push(removeReimbursement(action.payload.reimbursementId));
+            actions.push(openSnackbar({
+                messageSection: 'reimbursement_deleted',
+                messageText: 'success',
+                type: 'success',
+            }));
+            return from(actions);
+        }
+        else {
+            return of(deleteRemiSuccessOrFailure('Error', action.payload.reimbursementId, response.status), openSnackbar({
+                messageSection: 'reimbursement_deleted',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }));
+        }
+    }), catchError((error) => of(deleteRemiSuccessOrFailure('Error', action.payload.reimbursementId, createZeniAPIStatus('Unexpected Error', 'Delete reimbursement REST API call errored out ' +
+        JSON.stringify(error))))));
+}));

package/lib/esm/view/spendManagement/reimbursement/remiDetailView/epics/fetchDuplicateReimbursementEpic.js

@@ -0,0 +1,67 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { toReimbursementLinePayload } from '../../../../../entity/reimbursement/reimbursementPayload';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../../responsePayload';
+import { toReimbursementLineWithRecommendationFromMileage, toReimbursementLineWithRecommendationFromOutOfPocket, } from '../../editRemiView/editRemiViewPayload';
+import { fetchDuplicateReimbursement, updateDuplicateReimbursementFailure, updateDuplicateReimbursementSuccess, } from '../remiDetailViewReducer';
+export const fetchDuplicateReimbursementEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchDuplicateReimbursement.match), switchMap((action) => {
+    const { reimbursementId, signedInUserId, isManuallyTriggered } = action.payload;
+    const { editRemiDetailViewState, reimbursementState } = state$.value;
+    let lines = [];
+    const createdByUserId = reimbursementId != null
+        ? reimbursementState.reimbursementById[reimbursementId]
+            ?.createdBy
+        : signedInUserId;
+    //edit reimbursememnt case
+    if (isManuallyTriggered === true) {
+        //get lines detail from editRemiDetailViewState
+        //we can't use reimbursementState as from edit reimbursement page, user can change line details
+        lines =
+            reimbursementId != null
+                ? Object.values(editRemiDetailViewState.editRemiStateById[reimbursementId]
+                    .remiDetailLocalData.updatesByLineId).filter((value) => value != null)
+                : Object.values(editRemiDetailViewState.newRemiState.remiDetailLocalData
+                    .updatesByLineId).filter((value) => value != null);
+    }
+    //reimbursement detail page case
+    else if (reimbursementId != null) {
+        //get from reimbursememntState
+        const currentLines = reimbursementState.reimbursementById[reimbursementId]?.lines ?? [];
+        lines = currentLines.map((line) => {
+            if (line.type === 'mileage') {
+                return toReimbursementLineWithRecommendationFromMileage(line);
+            }
+            else {
+                return toReimbursementLineWithRecommendationFromOutOfPocket(line);
+            }
+        });
+    }
+    const payload = {
+        reimbursement_provider: 'zeni',
+        transaction_type: 'reimbursement',
+        created_by_user_id: createdByUserId,
+        transaction_id: reimbursementId ?? null,
+        lines: lines.map(toReimbursementLinePayload),
+    };
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.spendManagementMicroServiceBaseUrl}/1.0/reimbursements/transactions/duplicates`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const updateActions = [];
+            updateActions.push(updateDuplicateReimbursementSuccess({
+                duplicateLinesPayload: response.data.lines,
+            }));
+            return from(updateActions);
+        }
+        else {
+            return of(updateDuplicateReimbursementFailure({
+                status: response.status,
+            }));
+        }
+    }), catchError((error) => {
+        return of(updateDuplicateReimbursementFailure({
+            status: createZeniAPIStatus('Unexpected error', 'Duplicate Reimbursement Rest API errored out' +
+                JSON.stringify(error)),
+        }));
+    }));
+}));