@zeniai/client-epic-state 4.9.30 → 4.9.31

package/lib/view/transactionDetail/epics/saveTransactionHelper.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTransactionUpdatesFromTransactionDetailLocalData = void 0;
+const recommendationBase_1 = require("../../../commonStateTypes/recommendationBase");
+const entity_1 = require("../../../entity/genericEntity/entity");
+const customerTransaction_1 = require("../../../entity/transaction/stateTypes/customerTransaction");
+const vendorTransaction_1 = require("../../../entity/transaction/stateTypes/vendorTransaction");
+const recommendationState_1 = require("../../recommendation/recommendationState");
+// This function will extract the data that will determine which all APIs need to be called
+/**
+ *
+ * @param transactionDetailLocalData
+ * Uncategorized transaction
+ * 1. Update transaction with recommended (either historical/most recently used) ->
+ * 1a. Only fire transaction save.
+ * 2. Update transaction with recommended category but different class ->
+ * 2a. fire updateRecommendation with both category & Class chosen.
+ * 2b. Fire transaction Save with chosen recommendations,
+ * 3. Update transaction with recommended category, different class, check update all ->
+ * 3a. fire updateRecommendation with both category & Class chosen.
+ * 3b. Fire transaction save with chosen recommendation
+ * 3c. Fire bulk update with all Amounts
+ * 4. Only difference between this and Miscategorized will be that we will
+ * additionally fire “Mark as not miscat” for every point above.
+ */
+const toTransactionUpdatesFromTransactionDetailLocalData = (transactionDetailLocalData, transaction, uncategorizedIncomeExpense) => {
+    var _a, _b, _c;
+    const updates = {
+        updatesByLineId: {},
+    };
+    const updatesByLineId = {};
+    const entityUpdates = {};
+    const isTransactionMisCategorized = isTransactionMiscategorized(transaction);
+    const isTransactionUnCategorized = isTransactionUncategorized(transaction, uncategorizedIncomeExpense);
+    updates.memo = transactionDetailLocalData.memo;
+    const updatedEntityId = transactionDetailLocalData.updatePreviousTransactionsWithUpdatedVendor ===
+        true
+        ? (_a = transactionDetailLocalData.vendorUpdates) === null || _a === void 0 ? void 0 : _a.qboId
+        : undefined;
+    if ((0, vendorTransaction_1.isVendorTransaction)(transaction)) {
+        updates.vendorId = (_b = transactionDetailLocalData.vendorUpdates) === null || _b === void 0 ? void 0 : _b.id;
+    }
+    let isBulkUpdate = false;
+    const entity = getEntityFromTransaction(transaction);
+    let lastUpdatedCategory;
+    let lastUpdatedClass;
+    // single recommendation to just pick the last recommendation in the list of lines
+    (_c = transaction.lines) === null || _c === void 0 ? void 0 : _c.forEach((line) => {
+        var _a, _b, _c, _d, _e, _f;
+        const entityDetails = getEntityDetails(entity, transactionDetailLocalData.lineItemById[line.id], transactionDetailLocalData.vendorUpdates);
+        if (line.type === 'transaction_with_account_and_class_line' ||
+            line.type === 'transaction_with_product_or_service_line' ||
+            line.type === 'journal_entry_transaction_line') {
+            const lineItem = transactionDetailLocalData.lineItemById[line.id];
+            updatesByLineId[line.id] = {
+                lineDescription: lineItem.lineDescription,
+                class: lineItem.class,
+                account: lineItem.account,
+                recommendation: lineItem.recommendations,
+            };
+            if (line.type === 'journal_entry_transaction_line' ||
+                line.platformLineDetailType === 'deposit_line_detail') {
+                updatesByLineId[line.id] = Object.assign(Object.assign({}, updatesByLineId[line.id]), getVendorOrCustomerDetails(lineItem));
+            }
+            let hasCategoryChanged = false;
+            let hasClassChanged = false;
+            const accountLine = line;
+            hasCategoryChanged =
+                ((_a = lineItem.account) === null || _a === void 0 ? void 0 : _a.qboId) !== accountLine.account.qboId &&
+                    Boolean((_b = lineItem.account) === null || _b === void 0 ? void 0 : _b.qboId);
+            hasClassChanged =
+                Boolean((_c = lineItem.class) === null || _c === void 0 ? void 0 : _c.qboId) &&
+                    ((_d = lineItem.class) === null || _d === void 0 ? void 0 : _d.qboId) !== accountLine.class.qboId;
+            const recommendedAccountBase = toRecommendedAccountBase(lineItem.amount.amount, lineItem.account);
+            const recommendedClassBase = toRecommendedClassBase(lineItem.amount.amount, lineItem.class);
+            const latestRecommendedCategory = transactionDetailLocalData.lineItemById[line.id].recommendedAccount;
+            const latestrecommendedClass = transactionDetailLocalData.lineItemById[line.id].recommendedClass;
+            // If at any time the recommended category selected is different from the most recent
+            const isMostRecentRecommendedCategorySelected = Boolean(recommendedAccountBase) &&
+                Boolean(latestRecommendedCategory) &&
+                (recommendedAccountBase === null || recommendedAccountBase === void 0 ? void 0 : recommendedAccountBase.qboId) === (latestRecommendedCategory === null || latestRecommendedCategory === void 0 ? void 0 : latestRecommendedCategory.qboId);
+            // If at any time the recommended class selected is different from the most recent
+            const isMostRecentRecommendedClassSelected = Boolean(recommendedClassBase) &&
+                Boolean(latestrecommendedClass) &&
+                (recommendedClassBase === null || recommendedClassBase === void 0 ? void 0 : recommendedClassBase.qboId) === (latestrecommendedClass === null || latestrecommendedClass === void 0 ? void 0 : latestrecommendedClass.qboId);
+            const recommendationToBeUpdated = (lineItem.isRecommendedCategorySelected === false ||
+                lineItem.isRecommendedClassSelected === false ||
+                isMostRecentRecommendedCategorySelected === false ||
+                isMostRecentRecommendedClassSelected === false) &&
+                lineItem.recommendations != null &&
+                (hasCategoryChanged || hasClassChanged);
+            // If any bulkUpdate is true, call bulk update
+            isBulkUpdate = isBulkUpdate || ((_e = lineItem.isUpdateAllChecked) !== null && _e !== void 0 ? _e : false);
+            if (entityDetails != null &&
+                (recommendationToBeUpdated === true ||
+                    (lineItem.isUpdateAllChecked != null &&
+                        lineItem.isUpdateAllChecked === true) ||
+                    updatedEntityId !== null)) {
+                lastUpdatedCategory =
+                    hasCategoryChanged === true ||
+                        lineItem.isRetainedCategorySelected === true
+                        ? recommendedAccountBase
+                        : undefined;
+                lastUpdatedClass =
+                    hasClassChanged === true || lineItem.isRetainedClassSelected === true
+                        ? recommendedClassBase
+                        : undefined;
+                // Category might have been recommended one, and class may not have been updated and was undefined
+                // in this case check for each
+                const recommended = {
+                    account: lastUpdatedCategory,
+                    class: lastUpdatedClass,
+                };
+                if (recommended.class != null ||
+                    recommended.account != null ||
+                    updatedEntityId != null) {
+                    const vendorIdToUpdate = (_f = transactionDetailLocalData.vendorUpdates) === null || _f === void 0 ? void 0 : _f.qboId;
+                    let entityId = entityDetails.entityId;
+                    if (vendorIdToUpdate != null) {
+                        entityId =
+                            transactionDetailLocalData.updatePreviousTransactionsWithUpdatedVendor ===
+                                true
+                                ? entityId
+                                : vendorIdToUpdate;
+                    }
+                    doUpdateEntityUpdates(entityUpdates, entityId, entityDetails.entityType, recommended, lineItem.isUpdateAllChecked, updatedEntityId);
+                }
+            }
+        }
+        else {
+            updatesByLineId[line.id] = line;
+        }
+    });
+    updates.updatesByLineId = updatesByLineId;
+    return {
+        updates,
+        entityRelatedUpdates: entityUpdates,
+        /*Note: We need to call `mark-miscategorized-as-correct` api only when any of the line item is miscategorized
+        and all the line items are NOT uncategorized*/
+        markAsMiscatUpdates: isTransactionMisCategorized && !isTransactionUnCategorized,
+        anyBulkUpdates: isBulkUpdate,
+    };
+};
+exports.toTransactionUpdatesFromTransactionDetailLocalData = toTransactionUpdatesFromTransactionDetailLocalData;
+const doUpdateEntityUpdates = (entityUpdates, entityId, entityType, recommendation, isBulkUpdate = false, updatedEntityId) => {
+    // see if this entity is already being updated
+    const entityKey = (0, recommendationState_1.getEntityRecommendationKey)(entityType, entityId);
+    const entityUpdate = entityUpdates[entityKey];
+    if (entityUpdate == null) {
+        entityUpdates[entityKey] = {
+            entityId,
+            entityType,
+            recommendations: recommendation,
+            isBulkUpdate,
+            updatedEntityId,
+        };
+    }
+    else {
+        entityUpdates[entityKey] = Object.assign(Object.assign({}, entityUpdate), { recommendations: recommendation });
+    }
+};
+const toRecommendedAccountBase = (amountValue, accountBase, recommendationBase) => {
+    if (accountBase != null && recommendationBase != null) {
+        return Object.assign(Object.assign({}, accountBase), { min: recommendationBase.min, max: recommendationBase.max, reason: recommendationBase.reason, type: recommendationBase.type });
+    }
+    else if (accountBase != null) {
+        const { min, max } = (0, recommendationBase_1.getRecommendationAmountRange)(amountValue);
+        return Object.assign(Object.assign({}, accountBase), { min,
+            max, reason: '', type: '' });
+    }
+    else
+        return undefined;
+};
+const toRecommendedClassBase = (amountValue, classBase, recommendationBase) => {
+    if (classBase != null && recommendationBase != null) {
+        return Object.assign(Object.assign({}, classBase), { min: recommendationBase.min, max: recommendationBase.max, reason: recommendationBase.reason, type: recommendationBase.type });
+    }
+    else if (classBase != null) {
+        const { min, max } = (0, recommendationBase_1.getRecommendationAmountRange)(amountValue);
+        return Object.assign(Object.assign({}, classBase), { min,
+            max, reason: '', type: '' });
+    }
+    else
+        return undefined;
+};
+const getVendorOrCustomerDetails = (lineItem) => {
+    var _a;
+    if (lineItem.lineEntity != null) {
+        const lineEntity = lineItem.lineEntity;
+        const type = lineItem.vendor != null ? 'vendor' : 'customer';
+        return {
+            [type]: {
+                name: lineEntity.name,
+                id: (_a = lineEntity.qboId) !== null && _a !== void 0 ? _a : lineEntity.id, // For vendor we don't have qbo_id in VendorBase so using id instead
+            },
+        };
+    }
+    return {};
+};
+const getEntityFromTransaction = (transaction) => {
+    let entity = undefined;
+    if ((0, vendorTransaction_1.isVendorTransaction)(transaction)) {
+        const vendorEntity = transaction.vendor;
+        if (vendorEntity != null) {
+            entity = {
+                id: vendorEntity.id,
+                name: vendorEntity.name,
+                type: (0, entity_1.toEntityType)('vendor'),
+                qboId: vendorEntity.id,
+                zeniId: vendorEntity.id,
+            };
+        }
+    }
+    if ((0, customerTransaction_1.isCustomerTransaction)(transaction)) {
+        const customerEntity = transaction.customer;
+        if (customerEntity != null) {
+            entity = {
+                id: customerEntity.id,
+                name: customerEntity.name,
+                type: (0, entity_1.toEntityType)('customer'),
+                qboId: customerEntity.id,
+                zeniId: customerEntity.id,
+            };
+        }
+    }
+    return entity;
+};
+const getEntityDetails = (entity, lineItemLocalData, vendorUpdates) => {
+    var _a, _b;
+    if (entity != null) {
+        return {
+            entityId: (_a = entity.qboId) !== null && _a !== void 0 ? _a : entity.id,
+            entityType: entity.type,
+        };
+    }
+    if (lineItemLocalData.lineEntity != null) {
+        return {
+            entityId: (_b = lineItemLocalData.lineEntity.qboId) !== null && _b !== void 0 ? _b : lineItemLocalData.lineEntity.id,
+            entityType: lineItemLocalData.vendor != null ? 'vendor' : 'customer',
+        };
+    }
+    if (vendorUpdates != null && vendorUpdates.id != null) {
+        return {
+            entityId: vendorUpdates.id,
+            entityType: 'vendor',
+        };
+    }
+    return undefined;
+};
+const isTransactionMiscategorized = (transaction) => {
+    const lines = transaction.lines;
+    let isTransactionMisCategorized = false;
+    lines === null || lines === void 0 ? void 0 : lines.forEach((line) => {
+        if (line.type === 'transaction_with_account_and_class_line' ||
+            line.type === 'transaction_with_product_or_service_line' ||
+            line.type === 'journal_entry_transaction_line') {
+            const lineItem = line;
+            if (lineItem.isCategoryMiscategorized || lineItem.isClassMiscategorized) {
+                isTransactionMisCategorized = true;
+            }
+        }
+    });
+    return isTransactionMisCategorized;
+};
+const isTransactionUncategorized = (transaction, uncategorizedIncomeExpense) => {
+    const lines = transaction.lines;
+    let isTransactionUnCategorized = false;
+    lines === null || lines === void 0 ? void 0 : lines.forEach((line) => {
+        if (line.type === 'transaction_with_account_and_class_line' ||
+            line.type === 'transaction_with_product_or_service_line' ||
+            line.type === 'journal_entry_transaction_line') {
+            const lineItem = line;
+            if (isAccountUncategorized(uncategorizedIncomeExpense, lineItem.account.qboId)) {
+                isTransactionUnCategorized = true;
+            }
+        }
+    });
+    return isTransactionUnCategorized;
+};
+const isAccountUncategorized = (uncategorizedIncomeExpense, lineQboId) => {
+    var _a, _b;
+    if (lineQboId != null &&
+        (lineQboId === ((_a = uncategorizedIncomeExpense === null || uncategorizedIncomeExpense === void 0 ? void 0 : uncategorizedIncomeExpense.expense) === null || _a === void 0 ? void 0 : _a.qboId) ||
+            lineQboId === ((_b = uncategorizedIncomeExpense === null || uncategorizedIncomeExpense === void 0 ? void 0 : uncategorizedIncomeExpense.income) === null || _b === void 0 ? void 0 : _b.qboId))) {
+        return true;
+    }
+    return false;
+};

package/lib/view/transactionDetail/epics/transactionDetailEpic.d.ts

@@ -0,0 +1,14 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { fetchTransactionDetail, updateTransactionDetailFetchState, removeTransactionDetail, initializeTransactionDetailLocalData } from '../transactionDetailReducer';
+import { updateTransaction, removeTransaction } from '../../../entity/transaction/transactionReducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { RootState } from '../../../reducer';
+import { fetchClassList } from '../../classList/classListReducer';
+import { fetchAccountList } from '../../accountList/accountListReducer';
+import { updateSortUiState } from '../../vendorList/vendorListReducer';
+import { updateVendors } from '../../../entity/vendor/vendorReducer';
+import { updateTransactionVendorLocalData } from '../../commonVendorView/transactionVendorView/transactionVendorViewReducer';
+import { fetchOwnerList } from '../../ownerList/ownerListReducer';
+export declare type ActionType = ReturnType<typeof fetchTransactionDetail> | ReturnType<typeof updateTransaction> | ReturnType<typeof updateTransactionDetailFetchState> | ReturnType<typeof initializeTransactionDetailLocalData> | ReturnType<typeof removeTransaction> | ReturnType<typeof removeTransactionDetail> | ReturnType<typeof fetchClassList> | ReturnType<typeof fetchAccountList> | ReturnType<typeof updateSortUiState> | ReturnType<typeof updateVendors> | ReturnType<typeof updateTransactionVendorLocalData> | ReturnType<typeof fetchOwnerList>;
+export declare const fetchTransactionDetailEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/transactionDetail/epics/transactionDetailEpic.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTransactionDetailEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const transactionDetailReducer_1 = require("../transactionDetailReducer");
+const transactionReducer_1 = require("../../../entity/transaction/transactionReducer");
+const responsePayload_1 = require("../../../responsePayload");
+const get_1 = __importDefault(require("lodash/get"));
+const transactionDetailState_1 = require("../transactionDetailState");
+const transactionPayload_1 = require("../../../entity/transaction/payloadTypes/transactionPayload");
+const transactionIDPayload_1 = require("../../../entity/transaction/payloadTypes/transactionIDPayload");
+const classListReducer_1 = require("../../classList/classListReducer");
+const accountListReducer_1 = require("../../accountList/accountListReducer");
+const vendorReducer_1 = require("../../../entity/vendor/vendorReducer");
+const transactionVendorViewReducer_1 = require("../../commonVendorView/transactionVendorView/transactionVendorViewReducer");
+const transactionVendorLocalDataHelper_1 = require("../../commonVendorView/transactionVendorView/transactionVendorLocalDataHelper");
+const vendorPayload_1 = require("../../../entity/vendor/vendorPayload");
+const transactionType_1 = require("../../../entity/transaction/stateTypes/transactionType");
+const ownerListReducer_1 = require("../../ownerList/ownerListReducer");
+const transactionSelector_1 = require("../../../entity/transaction/transactionSelector");
+const fetchTransactionDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(transactionDetailReducer_1.fetchTransactionDetail.match), (0, operators_1.mergeMap)((action) => {
+    const { transactionId, cacheOverride } = action.payload;
+    const detailKey = (0, transactionDetailState_1.getTransactionDetailKey)(transactionId);
+    const transactionActions = [];
+    if (cacheOverride === true) {
+        const transaction = (0, transactionSelector_1.getSupportedTransactionById)(state$.value.transactionState, detailKey);
+        transactionActions.push(...removeCompleteTransaction(transactionId, transaction));
+    }
+    const transactionDetail = (0, get_1.default)(state$.value.transactionDetailState.transactionDetailById, detailKey, undefined);
+    if (cacheOverride === true ||
+        transactionDetail == null ||
+        (transactionDetail.hasValidState() === false &&
+            transactionDetail.fetchState !== 'In-Progress')) {
+        const accountList = state$.value.accountListState.byReportId.accountList;
+        if (accountList.hasValidState() === false &&
+            accountList.fetchState !== 'In-Progress') {
+            transactionActions.push((0, accountListReducer_1.fetchAccountList)('accountList'));
+        }
+        const classList = state$.value.classListState;
+        if (classList.hasValidState() === false &&
+            classList.fetchState !== 'In-Progress') {
+            transactionActions.push((0, classListReducer_1.fetchClassList)());
+        }
+        transactionActions.push((0, transactionDetailReducer_1.updateTransactionDetailFetchState)(transactionId, 'In-Progress'));
+        const query = { transaction_type: transactionId.type };
+        const getTransactionDetail$ = zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/transactions/${transactionId.id}?query=${encodeURIComponent(JSON.stringify(query))}`)
+            .pipe((0, operators_1.mergeMap)((response) => {
+            var _a, _b, _c, _d, _e;
+            if ((0, responsePayload_1.isSuccessResponse)(response) &&
+                ((_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.transaction) === null || _b === void 0 ? void 0 : _b.transaction_id) != null) {
+                const updateActions = [];
+                const transcationId = (0, transactionIDPayload_1.toTransactionID)(response.data.transaction);
+                if (response.data.vendors != null) {
+                    updateActions.push((0, vendorReducer_1.updateVendors)(response.data.vendors, 'merge'));
+                }
+                const transactionDetailKeyForResponse = (0, transactionDetailState_1.getTransactionDetailKey)(transcationId);
+                updateActions.push((0, transactionReducer_1.updateTransaction)(transactionDetailKeyForResponse, response.data.transaction));
+                updateActions.push((0, transactionDetailReducer_1.initializeTransactionDetailLocalData)({
+                    transactionId: transcationId,
+                    vendorId: (_d = (_c = response.data.vendors) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.vendor_id,
+                }));
+                updateActions.push((0, transactionDetailReducer_1.updateTransactionDetailFetchState)(transcationId, 'Completed'));
+                // IMPORTANT: Fetch linked transactions..
+                updateActions.push(...getAllFetchLinkedTransactionDetailActions(response.data.transaction, state$.value));
+                if (response.data.vendors != null &&
+                    response.data.vendors.length > 0) {
+                    updateActions.push((0, transactionVendorViewReducer_1.updateTransactionVendorLocalData)({
+                        vendorId: response.data.vendors[0].vendor_id,
+                        localData: (0, transactionVendorLocalDataHelper_1.getInitializedTransactionVendorLocalData)((0, vendorPayload_1.mapVendorPayloadToVendor)(response.data.vendors[0])),
+                    }));
+                }
+                // If vendor transaction, fetch owners list
+                if ((0, transactionType_1.toVendorTransactionTypeStrict)((_e = response.data) === null || _e === void 0 ? void 0 : _e.transaction.transaction_type) != null) {
+                    updateActions.push((0, ownerListReducer_1.fetchOwnerList)());
+                }
+                return (0, rxjs_1.from)(updateActions);
+            }
+            else {
+                return (0, rxjs_1.of)((0, transactionDetailReducer_1.updateTransactionDetailFetchState)(action.payload.transactionId, 'Error', response.status));
+            }
+        }), (0, operators_1.catchError)((error) => {
+            console.error(`REST API call errored out ${error}`);
+            return (0, rxjs_1.of)((0, transactionDetailReducer_1.updateTransactionDetailFetchState)(action.payload.transactionId, 'Error', (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', `REST API call errored out ${error}`)));
+        }));
+        return (0, rxjs_1.concat)((0, rxjs_1.from)(transactionActions), getTransactionDetail$);
+    }
+    else {
+        return (0, rxjs_1.from)(transactionActions);
+    }
+}));
+exports.fetchTransactionDetailEpic = fetchTransactionDetailEpic;
+/**
+ * Helper functions
+ */
+function removeCompleteTransaction(transactionId, transaction) {
+    const actions = [];
+    actions.push((0, transactionDetailReducer_1.removeTransactionDetail)(transactionId));
+    if (transaction != null) {
+        actions.push((0, transactionReducer_1.removeTransaction)((0, transactionDetailState_1.getTransactionDetailKey)(transactionId)));
+        // remove all the linked transactions too..
+        const linkedTransactions = (0, transactionDetailState_1.getAllLinkedTransactions)(transaction);
+        linkedTransactions.forEach((linkedTransaction) => {
+            actions.push((0, transactionDetailReducer_1.removeTransactionDetail)(linkedTransaction));
+            actions.push((0, transactionReducer_1.removeTransaction)((0, transactionDetailState_1.getTransactionDetailKey)(linkedTransaction)));
+        });
+    }
+    return actions;
+}
+function isTransactionDetailInCacheOrFetching(transactionId, state) {
+    const detailKey = (0, transactionDetailState_1.getTransactionDetailKey)(transactionId);
+    const detail = state.transactionDetailState.transactionDetailById[detailKey];
+    return (detail != null &&
+        (detail.hasValidState() === true || detail.fetchState === 'In-Progress'));
+}
+function getAllFetchLinkedTransactionDetailActions(transactionPayload, state) {
+    const fetchLinkedTransactionActions = [];
+    const currentTransaction = (0, transactionPayload_1.toTransaction)(transactionPayload);
+    const linkedTransaction = (0, transactionDetailState_1.getAllLinkedTransactions)(currentTransaction);
+    const linkedTransactionFiltered = linkedTransaction.filter((value) => isTransactionDetailInCacheOrFetching(value, state) === false);
+    linkedTransactionFiltered.forEach((transactionDetailToFetch) => fetchLinkedTransactionActions.push((0, transactionDetailReducer_1.fetchTransactionDetail)(transactionDetailToFetch, false)));
+    if (linkedTransactionFiltered.length === 0) {
+        console.log('Phew all linked transactions are fetched or there are no linked transactions..');
+    }
+    return fetchLinkedTransactionActions;
+}

package/lib/view/transactionDetail/epics/updateTransactionDetailEpic.d.ts

@@ -0,0 +1,9 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { ZeniAPI } from '../../../zeniAPI';
+import { RootState } from '../../../reducer';
+import { updateTransaction } from '../../../entity/transaction/transactionReducer';
+import { initializeTransactionDetailLocalData, updateStatusConsolidatedSaveTransactionDetail, updateTransactionDetail, updateTransactionDetailSaveStatus, updateTransactionStateIfUpdateActionNotAllowed } from '../transactionDetailReducer';
+import { openSnackbar } from '../../../entity/snackbar/snackbarReducer';
+import { updateVendors } from '../../../entity/vendor/vendorReducer';
+export declare type ActionType = ReturnType<typeof updateTransactionDetail> | ReturnType<typeof updateTransaction> | ReturnType<typeof updateTransactionStateIfUpdateActionNotAllowed> | ReturnType<typeof openSnackbar> | ReturnType<typeof updateTransactionDetailSaveStatus> | ReturnType<typeof updateStatusConsolidatedSaveTransactionDetail> | ReturnType<typeof initializeTransactionDetailLocalData> | ReturnType<typeof updateVendors>;
+export declare const updateTransactionDetailEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<ActionType>;