@zeniai/client-epic-state 4.9.30 → 4.9.31

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

@@ -0,0 +1,214 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTransactionDetailEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const get_1 = __importDefault(require("lodash/get"));
+const responsePayload_1 = require("../../../responsePayload");
+const transactionReducer_1 = require("../../../entity/transaction/transactionReducer");
+const transactionIDPayload_1 = require("../../../entity/transaction/payloadTypes/transactionIDPayload");
+const transactionDetailState_1 = require("../transactionDetailState");
+const transactionDetailReducer_1 = require("../transactionDetailReducer");
+const customerTransactionPayload_1 = require("../../../entity/transaction/payloadTypes/customerTransactionPayload");
+const otherTransactionPayload_1 = require("../../../entity/transaction/payloadTypes/otherTransactionPayload");
+const transactionPayload_1 = require("../../../entity/transaction/payloadTypes/transactionPayload");
+const vendorTransactionPayload_1 = require("../../../entity/transaction/payloadTypes/vendorTransactionPayload");
+const customerTransaction_1 = require("../../../entity/transaction/stateTypes/customerTransaction");
+const otherTransaction_1 = require("../../../entity/transaction/stateTypes/otherTransaction");
+const vendorTransaction_1 = require("../../../entity/transaction/stateTypes/vendorTransaction");
+const snackbarReducer_1 = require("../../../entity/snackbar/snackbarReducer");
+const recommendationPayload_1 = require("../../../commonPayloadTypes/recommendationPayload");
+const vendorSelector_1 = require("../../../entity/vendor/vendorSelector");
+const vendorReducer_1 = require("../../../entity/vendor/vendorReducer");
+const transactionType_1 = require("../../../entity/transaction/stateTypes/transactionType");
+const transactionSelector_1 = require("../../../entity/transaction/transactionSelector");
+const updateTransactionDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(transactionDetailReducer_1.updateTransactionDetail.match), (0, operators_1.mergeMap)((action) => {
+    const { transactionState, vendorState, transactionDetailState } = state$.value;
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/transactions/${action.payload.transactionId.id}/categorize`, preparePayload(transactionState, vendorState, transactionDetailState, action.payload.transactionId, action.payload.transactionSaveUpdates))
+        .pipe((0, operators_1.mergeMap)((response) => {
+        var _a, _b, _c, _d, _e;
+        if ((0, responsePayload_1.isSuccessResponse)(response)) {
+            const transactionIdResp = (0, transactionIDPayload_1.toTransactionID)(response.data.transaction // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            );
+            const transactionDetailKeyForResponse = (0, transactionDetailState_1.getTransactionDetailKey)(transactionIdResp);
+            const tranDetail = (0, get_1.default)(transactionDetailState.transactionDetailById, transactionDetailKeyForResponse, undefined);
+            const tranVendorUpdates = tranDetail === null || tranDetail === void 0 ? void 0 : tranDetail.transactionDetailLocalData.vendorUpdates;
+            let vendorUpdates = undefined;
+            if ((tranVendorUpdates === null || tranVendorUpdates === void 0 ? void 0 : tranVendorUpdates.qboId) != null) {
+                const vendor = (0, vendorSelector_1.getVendorByVendorId)(vendorState, tranVendorUpdates.qboId);
+                if (vendor != null) {
+                    vendorUpdates = {
+                        id: vendor === null || vendor === void 0 ? void 0 : vendor.qboId,
+                        name: vendor === null || vendor === void 0 ? void 0 : vendor.name,
+                    };
+                }
+                else if (tranVendorUpdates.name != null) {
+                    vendorUpdates = {
+                        id: tranVendorUpdates.qboId,
+                        name: tranVendorUpdates.name,
+                    };
+                }
+            }
+            const actions = [];
+            if (((_a = response.data) === null || _a === void 0 ? void 0 : _a.vendors) != null) {
+                actions.push((0, vendorReducer_1.updateVendors)(response.data.vendors, 'merge'));
+            }
+            actions.push((0, transactionReducer_1.updateTransaction)(transactionDetailKeyForResponse, 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            response.data.transaction));
+            actions.push((0, transactionDetailReducer_1.initializeTransactionDetailLocalData)({
+                transactionId: transactionIdResp,
+                vendorId: (_d = (_c = (_b = response.data) === null || _b === void 0 ? void 0 : _b.vendors) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.vendor_id,
+            }));
+            actions.push((0, transactionDetailReducer_1.updateTransactionDetailSaveStatus)(transactionIdResp, 'Completed'));
+            let callMarkTransactionAsNotMiscategorized = true;
+            // NOTE: If tran is vendorType transaction and there is no vendor chosen on this tranaction while saving,
+            // then we need to skip mark-miscategorized-as-correct api call
+            if ((0, transactionType_1.toVendorTransactionTypeStrict)((_e = response.data) === null || _e === void 0 ? void 0 : _e.transaction.transaction_type) != null) {
+                if ((vendorUpdates === null || vendorUpdates === void 0 ? void 0 : vendorUpdates.id) == null) {
+                    callMarkTransactionAsNotMiscategorized = false;
+                }
+            }
+            if (action.payload.transactionSaveUpdates.markAsMiscatUpdates ===
+                true &&
+                callMarkTransactionAsNotMiscategorized === true) {
+                actions.push((0, transactionDetailReducer_1.markTransactionAsNotMiscategorized)(transactionIdResp, action.payload.transactionSaveUpdates));
+            }
+            else {
+                actions.push((0, transactionDetailReducer_1.updateStatusConsolidatedSaveTransactionDetail)({
+                    transactionId: action.payload.transactionId,
+                    fetchState: 'Completed',
+                }));
+                if (action.payload.transactionSaveUpdates.anyBulkUpdates === true) {
+                    actions.push((0, snackbarReducer_1.openSnackbar)({
+                        messageSection: 'transactionDetails_updatingPastTransactions',
+                        messageText: 'success',
+                        type: 'success',
+                    }));
+                }
+                else {
+                    actions.push((0, snackbarReducer_1.openSnackbar)({
+                        messageSection: 'transactionDetails_transactionUpdated',
+                        messageText: 'success',
+                        type: 'success',
+                    }));
+                }
+            }
+            return (0, rxjs_1.from)(actions);
+        }
+        else if ((0, responsePayload_1.isActionNotAllowed)(response)) {
+            return (0, rxjs_1.of)((0, transactionDetailReducer_1.updateTransactionDetailSaveStatus)(action.payload.transactionId, 'Error', response.status), (0, transactionDetailReducer_1.updateTransactionStateIfUpdateActionNotAllowed)({
+                transactionId: action.payload.transactionId,
+            }));
+        }
+        else {
+            return (0, rxjs_1.of)((0, transactionDetailReducer_1.updateTransactionDetailSaveStatus)(action.payload.transactionId, 'Error', response.status));
+        }
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, transactionDetailReducer_1.updateTransactionDetailSaveStatus)(action.payload.transactionId, 'Error', (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', `REST API call errored out ${error}`)))));
+}));
+exports.updateTransactionDetailEpic = updateTransactionDetailEpic;
+function preparePayload(transactionState, vendorState, transactionDetailState, transactionId, saveUpdates) {
+    const transactionDetailKey = (0, transactionDetailState_1.getTransactionDetailKey)(transactionId);
+    const detail = (0, transactionSelector_1.getSupportedTransactionById)(transactionState, transactionDetailKey);
+    const tranDetail = (0, get_1.default)(transactionDetailState.transactionDetailById, transactionDetailKey, undefined);
+    const tranVendorUpdates = tranDetail === null || tranDetail === void 0 ? void 0 : tranDetail.transactionDetailLocalData.vendorUpdates;
+    let vendorUpdates = undefined;
+    if ((tranVendorUpdates === null || tranVendorUpdates === void 0 ? void 0 : tranVendorUpdates.qboId) != null) {
+        const vendor = (0, vendorSelector_1.getVendorByVendorId)(vendorState, tranVendorUpdates.qboId);
+        if (vendor != null) {
+            vendorUpdates = {
+                id: vendor === null || vendor === void 0 ? void 0 : vendor.qboId,
+                name: vendor === null || vendor === void 0 ? void 0 : vendor.name,
+            };
+        }
+        else if (tranVendorUpdates.name != null) {
+            vendorUpdates = {
+                id: tranVendorUpdates.qboId,
+                name: tranVendorUpdates.name,
+            };
+        }
+    }
+    if (detail != null) {
+        const transUpdates = toTransactionUpdatePayload(saveUpdates.updates, detail, vendorUpdates);
+        const entityUpdates = toEntityUpdatePayload(saveUpdates.entityRelatedUpdates);
+        return {
+            entity_related_updates: entityUpdates,
+            transaction_id: transactionId.id,
+            transaction: transUpdates,
+        };
+    }
+    return undefined;
+}
+const toTransactionUpdatePayload = (updates, detail, vendorUpdates) => {
+    var _a, _b;
+    const transaction = Object.assign({}, detail);
+    transaction.memo = (_a = updates.memo) !== null && _a !== void 0 ? _a : '';
+    const recommendationUpdates = {};
+    for (const key in updates.updatesByLineId) {
+        const lineUpdates = updates.updatesByLineId[key];
+        const newLineMap = (_b = transaction.lines) === null || _b === void 0 ? void 0 : _b.map((line) => {
+            var _a;
+            if (line.id === key) {
+                const lineTobeUpdated = Object.assign({}, line);
+                lineTobeUpdated.lineDescription = (_a = lineUpdates.lineDescription) !== null && _a !== void 0 ? _a : '';
+                if (lineUpdates.class != null) {
+                    lineTobeUpdated.class = lineUpdates.class;
+                }
+                if (lineUpdates.account != null) {
+                    lineTobeUpdated.account = lineUpdates.account;
+                }
+                if (lineUpdates.customer != null) {
+                    lineTobeUpdated.customer = lineUpdates.customer;
+                }
+                else {
+                    lineTobeUpdated.customer = undefined;
+                }
+                if (lineUpdates.vendor != null) {
+                    lineTobeUpdated.vendor = lineUpdates.vendor;
+                }
+                else {
+                    lineTobeUpdated.vendor = undefined;
+                }
+                if (lineUpdates.recommendation != null) {
+                    recommendationUpdates[line.id] = lineUpdates.recommendation;
+                }
+                return lineTobeUpdated;
+            }
+            return line;
+        });
+        transaction.lines = newLineMap;
+    }
+    transaction.recommendations = recommendationUpdates;
+    if ((0, customerTransaction_1.isCustomerTransaction)(transaction)) {
+        return (0, customerTransactionPayload_1.toCustomerTransactionPayload)(transaction);
+    }
+    else if ((0, vendorTransaction_1.isVendorTransaction)(transaction)) {
+        return (0, vendorTransactionPayload_1.toVendorTransactionPayload)(transaction, vendorUpdates);
+    }
+    else if ((0, otherTransaction_1.isTransferTransaction)(transaction)) {
+        return (0, otherTransactionPayload_1.toTransferTransactionPayload)(transaction);
+    }
+    else {
+        return (0, transactionPayload_1.toTransactionPayload)(transaction);
+    }
+};
+const toEntityUpdatePayload = (entityUpdates) => {
+    const entityUpdatesPayload = [];
+    let entityKey;
+    for (entityKey in entityUpdates) {
+        const entityUpdate = entityUpdates[entityKey];
+        const entityUpdatePayload = {
+            recommendations: (0, recommendationPayload_1.toRecommendationPayload)(entityUpdate.recommendations),
+            entity_id: entityUpdate.entityId,
+            entity_type: entityUpdate.entityType,
+            is_bulk_update: entityUpdate.isBulkUpdate,
+            updated_entity_id: entityUpdate.updatedEntityId,
+        };
+        entityUpdatesPayload.push(entityUpdatePayload);
+    }
+    return entityUpdatesPayload;
+};

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

@@ -0,0 +1,10 @@
+import { ActionsObservable } from 'redux-observable';
+import { uploadMissingReceiptSuccess } from '../transactionDetailReducer';
+import { updateTransaction } from '../../../entity/transaction/transactionReducer';
+export declare type ActionType = ReturnType<typeof uploadMissingReceiptSuccess> | ReturnType<typeof updateTransaction>;
+export declare const uploadMissingReceiptSuccessEpic: (actions$: ActionsObservable<ActionType>) => import("rxjs").Observable<import("@reduxjs/toolkit").PayloadAction<{
+    id: string;
+    payload: import("../../..").SupportedTransactionPayload;
+}, string, {
+    updateType: import("../../..").UpdateType;
+}, never>>;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadMissingReceiptSuccessEpic = 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 transactionDetailState_1 = require("../transactionDetailState");
+const transactionIDPayload_1 = require("../../../entity/transaction/payloadTypes/transactionIDPayload");
+const uploadMissingReceiptSuccessEpic = (actions$) => actions$.pipe((0, operators_1.filter)(transactionDetailReducer_1.uploadMissingReceiptSuccess.match), (0, operators_1.switchMap)((action) => {
+    const transcationId = (0, transactionIDPayload_1.toTransactionID)(action.payload.payload);
+    const transactionDetailKeyForResponse = (0, transactionDetailState_1.getTransactionDetailKey)(transcationId);
+    return (0, rxjs_1.of)((0, transactionReducer_1.updateTransaction)(transactionDetailKeyForResponse, action.payload.payload));
+}));
+exports.uploadMissingReceiptSuccessEpic = uploadMissingReceiptSuccessEpic;

package/lib/view/transactionDetail/transactionDetailPayload.d.ts

@@ -0,0 +1,34 @@
+import { EntityRecommendationPayload } from '../../commonPayloadTypes/recommendationPayload';
+import { TransactionPayload } from '../../entity/transaction/payloadTypes/transactionPayload';
+import { SupportedTransactionPayload } from '../../entity/transaction/transactionState';
+import { VendorPayload } from '../../entity/vendor/vendorPayload';
+import { ZeniAPIResponse } from '../../responsePayload';
+export interface TransactionDetailPayload {
+    transaction: SupportedTransactionPayload;
+    query: {
+        transaction_id: string;
+        transaction_type: string;
+    };
+    query_definitions: Record<string, unknown>;
+    vendors?: VendorPayload[];
+}
+export declare type TransactionDetailResponse = ZeniAPIResponse<TransactionDetailPayload>;
+export interface EntityRelatedUpdatesPayload {
+    recommendations: EntityRecommendationPayload;
+    entity_id: string;
+    entity_type: string;
+    is_bulk_update: boolean;
+    updated_entity_id: string | undefined;
+}
+export interface UpdateTransactionDetailPayload {
+    transaction: Partial<TransactionPayload>;
+    entity_related_updates?: EntityRelatedUpdatesPayload[];
+    transaction_type: string;
+    transaction_id: string;
+}
+interface UpdateTransactionDetailResponsePayload {
+    transaction: SupportedTransactionPayload;
+    vendors?: VendorPayload[];
+}
+export declare type TransactionDetailUpdateResponse = ZeniAPIResponse<UpdateTransactionDetailResponsePayload>;
+export {};

package/lib/view/transactionDetail/transactionDetailPayload.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/view/transactionDetail/transactionDetailSelector.d.ts

@@ -0,0 +1,34 @@
+import { SelectorView } from '../../commonStateTypes/viewAndReport/viewAndReport';
+import { TransactionID } from '../../entity/transaction/stateTypes/transaction';
+import { SupportedTransaction } from '../../entity/transaction/transactionState';
+import { FetchStateAndError } from '../../commonStateTypes/common';
+import { RootState } from '../../reducer';
+import { ClassListSelectorView } from '../classList/classListSelector';
+import { AccountListSelectorView } from '../accountList/accountListSelector';
+import { ZeniDate } from '../../zeniDayJS';
+import { TransactionDetailLocalData } from './transactionDetailTypes';
+import { NestedAccountHeirarchyForReport } from '../../commonStateTypes/accountView/nestedAccountID';
+import { NestedClassHeirarchyForReport } from '../../commonStateTypes/classesView/nestedClassID';
+import { Vendor } from '../../entity/vendor/vendorState';
+export interface TransactionDetailReport extends SelectorView {
+    transaction?: SupportedTransaction;
+    transactionDetailUpdateStatus: FetchStateAndError;
+    linkedTransactions: SupportedTransaction[];
+    accountList: AccountListSelectorView;
+    classList: ClassListSelectorView;
+    transactionDetailLocalData: TransactionDetailLocalData;
+    accountsHeirarchyList: NestedAccountHeirarchyForReport[];
+    classHeirarchyList: NestedClassHeirarchyForReport[];
+    isUpdateNotAllowed?: boolean;
+    allVendors: Vendor[];
+}
+export interface VendorDetailsView extends SelectorView {
+    vendors: Vendor[];
+}
+export declare const getTransactionDetail: (state: RootState, transactionId: TransactionID, fetchLinkedTransactions?: boolean) => TransactionDetailReport;
+export declare function getTransactionDetailForTransaction(rootState: RootState, transactionId: TransactionID): TransactionDetailReport | undefined;
+export declare const getInitialUpdatablePeriodsForTransactionRecommendations: (companyIncorporationDate?: import("dayjs").Dayjs | undefined, bookCloseDate?: import("dayjs").Dayjs | undefined) => {
+    minDate: ZeniDate;
+    startDate?: ZeniDate;
+    endDate?: ZeniDate;
+};

package/lib/view/transactionDetail/transactionDetailSelector.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInitialUpdatablePeriodsForTransactionRecommendations = exports.getTransactionDetailForTransaction = exports.getTransactionDetail = void 0;
+const transactionType_1 = require("../../entity/transaction/stateTypes/transactionType");
+const transactionDetailState_1 = require("./transactionDetailState");
+const get_1 = __importDefault(require("lodash/get"));
+const reduceFetchState_1 = require("../../commonStateTypes/reduceFetchState");
+const classListSelector_1 = require("../classList/classListSelector");
+const accountListSelector_1 = require("../accountList/accountListSelector");
+const zeniDayJS_1 = require("../../zeniDayJS");
+const vendorSelector_1 = require("../../entity/vendor/vendorSelector");
+const transactionSelector_1 = require("../../entity/transaction/transactionSelector");
+const getTransactionDetail = (state, transactionId, fetchLinkedTransactions = true) => {
+    var _a, _b;
+    const { transactionDetailState, transactionState, vendorState, vendorListState, accountState, classState, classListState, accountListState, } = state;
+    const detailKey = (0, transactionDetailState_1.getTransactionDetailKey)(transactionId);
+    const transactionDetail = (0, get_1.default)(transactionDetailState.transactionDetailById, detailKey);
+    let fetchState = {
+        fetchState: (_a = transactionDetail === null || transactionDetail === void 0 ? void 0 : transactionDetail.fetchState) !== null && _a !== void 0 ? _a : 'Not-Started',
+        error: transactionDetail === null || transactionDetail === void 0 ? void 0 : transactionDetail.error,
+    };
+    const transaction = (0, transactionSelector_1.getSupportedTransactionById)(transactionState, detailKey);
+    let linkedTransactions = [];
+    if ((transactionDetail === null || transactionDetail === void 0 ? void 0 : transactionDetail.fetchState) === 'Completed' && transaction != null) {
+        // IMPORTANT: filtering out unsupported linked transactions
+        // Quick work around for now until we come up with a default teamplate for
+        // un-supported transactions!!
+        const supportedLinkedTransactionIDs = (0, transactionDetailState_1.getAllLinkedTransactions)(transaction).filter((linkedTranId) => (0, transactionType_1.toTransactionTypeStrict)(linkedTranId.type) != null);
+        const linkedTransactionDetails = supportedLinkedTransactionIDs
+            .map((linkedTranID) => {
+            const key = (0, transactionDetailState_1.getTransactionDetailKey)(linkedTranID);
+            return (0, get_1.default)(transactionDetailState.transactionDetailById, key);
+        })
+            .filter((value) => value != null);
+        const linkedTransactionsFetchState = linkedTransactionDetails.length > 0
+            ? (0, reduceFetchState_1.reduceFetchState)(linkedTransactionDetails)
+            : fetchState;
+        if (fetchLinkedTransactions &&
+            linkedTransactionsFetchState.fetchState === 'Completed') {
+            linkedTransactions = linkedTransactionDetails
+                .map((linkedTranDetail) => {
+                const key = (0, transactionDetailState_1.getTransactionDetailKey)(linkedTranDetail.transactionId); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                return (0, transactionSelector_1.getSupportedTransactionById)(transactionState, key);
+            })
+                .filter((value) => {
+                if (value == null) {
+                    console.error("Can't have null transaction detail at this point");
+                }
+                return value != null;
+            });
+        }
+        else if (fetchLinkedTransactions) {
+            fetchState = linkedTransactionsFetchState;
+        }
+    }
+    const accountsList = (0, accountListSelector_1.getAccountList)(accountState, accountListState, 'accountList');
+    const classList = (0, classListSelector_1.getClassList)(classState, classListState);
+    const accountsHeirarchyList = (0, accountListSelector_1.getNestedAccountListHeirarchy)(accountListState, 'accountList');
+    const classHeirarchyList = (0, classListSelector_1.getNestedClassListHeirarchy)(classListState);
+    const transactionDetailAnyUpdateStatus = reduceUpdateFetchStates(transactionDetail);
+    const vendors = (0, vendorSelector_1.getVendorsByVendorIds)(vendorState, vendorListState.vendorIds);
+    return {
+        reportId: 'transaction_detail',
+        reportTitle: 'Transaction Detail',
+        version: 0,
+        status: undefined,
+        fetchState: fetchState.fetchState,
+        error: fetchState.error,
+        transaction,
+        linkedTransactions,
+        transactionDetailUpdateStatus: transactionDetailAnyUpdateStatus,
+        accountList: accountsList,
+        classHeirarchyList,
+        accountsHeirarchyList,
+        classList: classList,
+        isUpdateNotAllowed: transactionDetail === null || transactionDetail === void 0 ? void 0 : transactionDetail.isUpdateNotAllowed,
+        transactionDetailLocalData: (_b = transactionDetail === null || transactionDetail === void 0 ? void 0 : transactionDetail.transactionDetailLocalData) !== null && _b !== void 0 ? _b : transactionDetailState_1.initialSupportedTransactionDetail.transactionDetailLocalData,
+        selectedVendor: transactionDetail === null || transactionDetail === void 0 ? void 0 : transactionDetail.transactionDetailLocalData.vendorUpdates,
+        allVendors: vendors,
+    };
+};
+exports.getTransactionDetail = getTransactionDetail;
+function getTransactionDetailForTransaction(rootState, transactionId) {
+    if (transactionId != null) {
+        return (0, exports.getTransactionDetail)(rootState, transactionId);
+    }
+    else {
+        return undefined;
+    }
+}
+exports.getTransactionDetailForTransaction = getTransactionDetailForTransaction;
+const getInitialUpdatablePeriodsForTransactionRecommendations = (companyIncorporationDate, bookCloseDate) => {
+    return {
+        minDate: bookCloseDate != null
+            ? bookCloseDate.add(1, 'day')
+            : companyIncorporationDate != null
+                ? companyIncorporationDate
+                : // when both book close date and incorporation date arent present
+                    // only allow user to go back 5 years
+                    (0, zeniDayJS_1.dateNow)().subtract(60, 'month'),
+        startDate: bookCloseDate != null
+            ? bookCloseDate.add(1, 'day')
+            : companyIncorporationDate != null
+                ? companyIncorporationDate
+                : (0, zeniDayJS_1.dateNow)(),
+        endDate: (0, zeniDayJS_1.dateNow)(),
+    };
+};
+exports.getInitialUpdatablePeriodsForTransactionRecommendations = getInitialUpdatablePeriodsForTransactionRecommendations;
+const reduceUpdateFetchStates = (transactionDetail) => {
+    if (transactionDetail == null) {
+        return {
+            fetchState: 'Not-Started',
+            error: undefined,
+        };
+    }
+    return reduceFetchStateForUpdates([
+        {
+            fetchState: transactionDetail.transactionDetailUpdateStatus.consolidatedFetchState,
+            error: undefined,
+        },
+        transactionDetail.transactionDetailUpdateStatus.saveStatus,
+        transactionDetail.transactionDetailUpdateStatus.recommendationUpdateStatus,
+        transactionDetail.transactionDetailUpdateStatus.bulkUpdateStatus,
+        transactionDetail.transactionDetailUpdateStatus.markAsNotMiscatStatus,
+    ]);
+};
+const reduceFetchStateForUpdates = (fetchStateList) => {
+    const isAnyError = fetchStateList.reduce((prevValue, currentValue) => {
+        return prevValue === true || currentValue.fetchState === 'Error';
+    }, false);
+    const isAnyFetchCompleted = fetchStateList.reduce((prevValue, currentValue) => {
+        return prevValue === true || currentValue.fetchState === 'Completed';
+    }, false);
+    const isAnyFetchInProgress = fetchStateList.reduce((prevValue, currentValue) => {
+        return prevValue === true || currentValue.fetchState === 'In-Progress';
+    }, false);
+    if (isAnyError) {
+        const error = fetchStateList.reduce((prevValue, currentValue) => {
+            return prevValue !== null && prevValue !== void 0 ? prevValue : currentValue.error;
+        }, undefined);
+        return {
+            fetchState: 'Error',
+            error,
+        };
+    }
+    else if (isAnyFetchInProgress) {
+        return {
+            fetchState: 'In-Progress',
+            error: undefined,
+        };
+    }
+    else if (isAnyFetchCompleted) {
+        return {
+            fetchState: 'Completed',
+            error: undefined,
+        };
+    }
+    else {
+        return {
+            fetchState: 'Not-Started',
+            error: undefined,
+        };
+    }
+};

package/lib/view/transactionList/fetchTransactionListByAccountEpic.d.ts

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { fetchAccountTransactionList, updateTransactionListByAccount, updateTransactionListByAccountFailure } from './transactionListReducer';
+import { updateTransactions } from '../../entity/transaction/transactionReducer';
+import { ZeniAPI } from '../../zeniAPI';
+import { RootState } from '../../reducer';
+export declare type ActionType = ReturnType<typeof fetchAccountTransactionList> | ReturnType<typeof updateTransactions> | ReturnType<typeof updateTransactionListByAccount> | ReturnType<typeof updateTransactionListByAccountFailure>;
+export declare const fetchTransactionListByAccountEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/transactionList/fetchTransactionListByAccountEpic.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTransactionListByAccountEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const js_base64_1 = require("js-base64");
+const get_1 = __importDefault(require("lodash/get"));
+const transactionListReducer_1 = require("./transactionListReducer");
+const transactionReducer_1 = require("../../entity/transaction/transactionReducer");
+const transactionListState_1 = require("./transactionListState");
+const responsePayload_1 = require("../../responsePayload");
+const timePeriod_1 = require("../../commonStateTypes/timePeriod");
+const fetchTransactionListByAccountEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(transactionListReducer_1.fetchAccountTransactionList.match), (0, operators_1.mergeMap)((action) => {
+    const state = state$.value;
+    const key = (0, transactionListState_1.getAcTranKey)(action.payload.accountId, action.payload.accountType, action.payload.period);
+    const accountTransactions = (0, get_1.default)(state.transactionListState.byAccount.transactionListByAccountKey, key, undefined);
+    if (action.payload.cacheOverride === true ||
+        accountTransactions == null ||
+        accountTransactions.hasValidState() === false) {
+        const queryParam = {
+            start_date: (0, timePeriod_1.toString)(action.payload.period.start),
+            end_date: (0, timePeriod_1.toString)(action.payload.period.end),
+            sort_by: 'transaction_date',
+            sort_order: 'desc',
+            account_id: action.payload.accountId,
+            account_type: action.payload.accountType,
+            account_name: action.payload.accountName,
+        };
+        // only if includeSubAccounts is false, only then send this flag. else
+        // dont send anything
+        if (action.payload.includeSubAccountTransactions === false) {
+            queryParam.include_sub_account_transactions =
+                action.payload.includeSubAccountTransactions;
+        }
+        const base64AccountId = (0, js_base64_1.toBase64)(action.payload.accountId);
+        return zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/accounts/${base64AccountId}/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
+            .pipe((0, operators_1.mergeMap)((response) => {
+            if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+                const updateActions = [];
+                updateActions.push((0, transactionReducer_1.updateTransactions)(response.data.account.transactions, (value) => value.transaction_id));
+                updateActions.push((0, transactionListReducer_1.updateTransactionListByAccount)(response.data));
+                return (0, rxjs_1.from)(updateActions);
+            }
+            else {
+                return (0, rxjs_1.of)((0, transactionListReducer_1.updateTransactionListByAccountFailure)(action.payload.accountId, action.payload.accountType, action.payload.period, response.status));
+            }
+        }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, transactionListReducer_1.updateTransactionListByAccountFailure)(action.payload.accountId, action.payload.accountType, action.payload.period, (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'fetch transaction list REST API call errored out' +
+            JSON.stringify(error))))));
+    }
+    else {
+        return (0, rxjs_1.from)([]);
+    }
+}));
+exports.fetchTransactionListByAccountEpic = fetchTransactionListByAccountEpic;

package/lib/view/transactionList/fetchTransactionListByClassEpic.d.ts

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { fetchClassTransactionList, updateTransactionListByClass, updateTransactionListByClassFailure } from './transactionListReducer';
+import { updateTransactions } from '../../entity/transaction/transactionReducer';
+import { ZeniAPI } from '../../zeniAPI';
+import { RootState } from '../../reducer';
+export declare type ActionType = ReturnType<typeof fetchClassTransactionList> | ReturnType<typeof updateTransactions> | ReturnType<typeof updateTransactionListByClass> | ReturnType<typeof updateTransactionListByClassFailure>;
+export declare const fetchTransactionListByClassEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/transactionList/fetchTransactionListByClassEpic.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTransactionListByClassEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const js_base64_1 = require("js-base64");
+const get_1 = __importDefault(require("lodash/get"));
+const transactionListReducer_1 = require("./transactionListReducer");
+const transactionReducer_1 = require("../../entity/transaction/transactionReducer");
+const transactionListState_1 = require("./transactionListState");
+const responsePayload_1 = require("../../responsePayload");
+const timePeriod_1 = require("../../commonStateTypes/timePeriod");
+const fetchTransactionListByClassEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(transactionListReducer_1.fetchClassTransactionList.match), (0, operators_1.mergeMap)((action) => {
+    const state = state$.value;
+    const key = (0, transactionListState_1.getClassAcTranKey)(action.payload.accountId, action.payload.accountType, action.payload.classId, action.payload.period);
+    const classTransactions = (0, get_1.default)(state.transactionListState.byClass.transactionListByClassKey, key, undefined);
+    if (action.payload.cacheOverride === true ||
+        classTransactions == null ||
+        classTransactions.hasValidState() === false) {
+        const queryParam = {
+            start_date: (0, timePeriod_1.toString)(action.payload.period.start),
+            end_date: (0, timePeriod_1.toString)(action.payload.period.end),
+            sort_by: 'create_time',
+            sort_order: 'desc',
+            account_id: action.payload.accountId,
+            account_type: action.payload.accountType,
+            accounting_class_id: action.payload.classId,
+            include_sub_class_transactions: false,
+        };
+        const base64AccountId = (0, js_base64_1.toBase64)(action.payload.accountId);
+        return zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/accounts/${base64AccountId}/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
+            .pipe((0, operators_1.mergeMap)((response) => {
+            if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+                const updateActions = [];
+                updateActions.push((0, transactionReducer_1.updateTransactions)(response.data.account.transactions, (value) => value.transaction_id));
+                updateActions.push((0, transactionListReducer_1.updateTransactionListByClass)(response.data));
+                return (0, rxjs_1.from)(updateActions);
+            }
+            else {
+                return (0, rxjs_1.of)((0, transactionListReducer_1.updateTransactionListByClassFailure)(action.payload.accountId, action.payload.accountType, action.payload.classId, action.payload.period, response.status));
+            }
+        }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, transactionListReducer_1.updateTransactionListByClassFailure)(action.payload.accountId, action.payload.accountType, action.payload.classId, action.payload.period, (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'fetch transaction list REST API call errored out' +
+            JSON.stringify(error))))));
+    }
+    else {
+        return (0, rxjs_1.from)([]);
+    }
+}));
+exports.fetchTransactionListByClassEpic = fetchTransactionListByClassEpic;

package/lib/view/transactionList/fetchTransactionListByEntityEpic.d.ts

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { updateTransactions } from '../../entity/transaction/transactionReducer';
+import { RootState } from '../../reducer';
+import { ZeniAPI } from '../../zeniAPI';
+import { fetchEntityTransactionList, updateTransactionListByEntity, updateTransactionListByEntityFailure } from './transactionListReducer';
+export declare type ActionType = ReturnType<typeof fetchEntityTransactionList> | ReturnType<typeof updateTransactions> | ReturnType<typeof updateTransactionListByEntity> | ReturnType<typeof updateTransactionListByEntityFailure>;
+export declare const fetchTransactionListByEntityEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;