@zeniai/client-epic-state 4.9.30 → 4.9.31

package/lib/view/scheduleView/scheduleListView/scheduleListHelper.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountsTypesForScheduleEpics = exports.getAccountLabelForScheduleType = exports.getAccountsTypesForScheduleList = exports.getDurationOfMonthOutTotalMonth = exports.calculateCOABalanceGroupedByPeriod = exports.mapScheduleJournalToCOABalance = exports.calculateTotalBalanceTimeframeTick = exports.setDefaultTotalBalanceTimeframeTicks = exports.mapTotalBalanceTimeframeTickToCOAGroupedBalance = exports.getAllTimeframeTicks = exports.getAllAccountNested = exports.getAllAccountBase = exports.getAccountLabelForSchedulesTab = exports.getAccountListKeyForSchedules = exports.getCalculatedScheduleTotals = exports.scheduleTypesAccountLabels = void 0;
+const amount_1 = require("../../../commonStateTypes/amount");
+const formatZeniDateFY_1 = require("../../../commonStateTypes/fiscalYearHelpers/formatZeniDateFY");
+const getFYMonths_1 = require("../../../commonStateTypes/fiscalYearHelpers/getFYMonths");
+const zeniDayJS_1 = require("../../../zeniDayJS");
+exports.scheduleTypesAccountLabels = {
+    prepaid_expenses: 'other_current_assets',
+    fixed_assets: 'fixed_assets',
+    accrued_expenses: 'other_expense',
+    deferred_revenue: 'other_income',
+};
+/**
+ * This helper function calculates Total Amount and Total Running balances
+ * for all the JE transactions which can be used to display the totals on the Schedule List page.
+ * @param jeTransactions
+ * @returns
+ */
+const getCalculatedScheduleTotals = (jeTransactions) => {
+    if (jeTransactions.length == 0) {
+        return {
+            totalAmount: (0, amount_1.toAmount)(0, '', ''),
+            totalRunningBalances: (0, amount_1.toAmount)(0, '', ''),
+        };
+    }
+    const totalAmountSum = jeTransactions.reduce((sum, schedule) => {
+        return sum + schedule.baseTransaction.amount.amount;
+    }, 0);
+    const totalRunningBalanceSum = jeTransactions.reduce((sum, schedule) => {
+        return (sum +
+            (schedule.balanceAsOfToday != null ? schedule.balanceAsOfToday.amount : 0));
+    }, 0);
+    return {
+        totalAmount: Object.assign(Object.assign({}, jeTransactions[0].baseTransaction.amount), { amount: totalAmountSum }),
+        totalRunningBalances: Object.assign(Object.assign({}, jeTransactions[0].baseTransaction.amount), { amount: totalRunningBalanceSum }),
+    };
+};
+exports.getCalculatedScheduleTotals = getCalculatedScheduleTotals;
+const getAccountListKeyForSchedules = () => {
+    return 'schedulesAccountList';
+};
+exports.getAccountListKeyForSchedules = getAccountListKeyForSchedules;
+const getAccountLabelForSchedulesTab = (tab) => {
+    switch (tab) {
+        case 'prepaid_expenses':
+        case 'fixed_assets':
+            return tab;
+        case 'accrued_expenses':
+        case 'deferred_revenue':
+            return 'uncategorized_expense';
+    }
+};
+exports.getAccountLabelForSchedulesTab = getAccountLabelForSchedulesTab;
+const getAllAccountBase = () => ({
+    accountDescription: 'All',
+    accountId: 'all',
+    qboId: 'all',
+    accountName: 'All',
+    labels: [],
+});
+exports.getAllAccountBase = getAllAccountBase;
+const getAllAccountNested = () => ({
+    accountId: ['all'],
+    accountName: 'All',
+    qboId: 'all',
+    children: [],
+    hasSiblings: false,
+});
+exports.getAllAccountNested = getAllAccountNested;
+/**
+ * This helper function is to get all possible timeframe
+ * Logic --> Timeframe Range is startDate = (currentDate to 3 months back )and endDate = (currentDate to 9 months ahead)
+ * @param sortedJETransactionView
+ * @param startMonth
+ * @returns
+ */
+const getAllTimeframeTicks = (sortedJETransactionView, startMonth) => {
+    const tickLabel = [];
+    if (sortedJETransactionView.length > 0) {
+        const jeTransaction = sortedJETransactionView[0];
+        const { currencySymbol } = jeTransaction;
+        const start = (0, zeniDayJS_1.dateNow)().startOf('month').subtract(startMonth, 'month');
+        let months = 0;
+        while (months < getFYMonths_1.NUM_OF_MONTHS_IN_YEAR) {
+            tickLabel.push({
+                startDate: start.add(months, 'month'),
+                endDate: start.add(months, 'month').endOf('month'),
+                currencySymbol: currencySymbol,
+                balanceType: 'default',
+            });
+            months++;
+        }
+    }
+    return tickLabel;
+};
+exports.getAllTimeframeTicks = getAllTimeframeTicks;
+/**
+ * This is a helper function to map totalBalanceTimeframeTicks to COABalance
+ * @param totalBalanceTimeframeTicks
+ * @returns
+ */
+const mapTotalBalanceTimeframeTickToCOAGroupedBalance = (totalBalanceTimeframeTicks) => {
+    const coaBalanceTotalByTimeframe = [];
+    Object.keys(totalBalanceTimeframeTicks).map((timeframeLabel) => {
+        const coaBalance = totalBalanceTimeframeTicks[timeframeLabel];
+        if (coaBalance.length > 0) {
+            const totalCOABalance = Object.assign(Object.assign({}, coaBalance[0]), { balance: Object.assign(Object.assign({}, coaBalance[0].balance), { amount: 0 }) });
+            const calculatedCOABalance = coaBalance.reduce((prev, curr) => {
+                return Object.assign(Object.assign({}, curr), { balance: (0, amount_1.toAmount)(prev.balance.amount + curr.balance.amount, curr.balance.currencyCode, curr.balance.currencySymbol) });
+            }, totalCOABalance);
+            coaBalanceTotalByTimeframe.push(calculatedCOABalance);
+        }
+    });
+    return coaBalanceTotalByTimeframe;
+};
+exports.mapTotalBalanceTimeframeTickToCOAGroupedBalance = mapTotalBalanceTimeframeTickToCOAGroupedBalance;
+/**
+ * This function setting default values in the totalBalanceTimeframeTicks using allTimeframeTicks
+ * e.g {'Feb 2023' : [], 'Mar 2023' : [], 'Apr 2023' : [], 'Jun 2023' : [], 'Jun 2023' : [], 'Jul 2023' : []}
+ *
+ * @param allTimeframeTicks
+ * @returns
+ */
+const setDefaultTotalBalanceTimeframeTicks = (allTimeframeTicks) => {
+    const totalBalanceTimeframeTicks = {};
+    allTimeframeTicks.map((timeframe) => {
+        totalBalanceTimeframeTicks[timeframe.startDate.format(formatZeniDateFY_1.MONTH_YEAR_FORMAT)] =
+            [];
+    });
+    return totalBalanceTimeframeTicks;
+};
+exports.setDefaultTotalBalanceTimeframeTicks = setDefaultTotalBalanceTimeframeTicks;
+/**
+ * This function returns an COABalanceGroupedByPeriod (months, weeks, years, quarters) with an array of COABalances
+ * in which we loop over the totalBalanceTimeframeTicks which is a record of <Labels(mm yy), Balances>- {'Feb 2023' : [20, 30, 40]}
+ * e.g - { months : { balance, startDate, endDate, type}}
+ * @param allTimeframeTickBalances
+ * @param allTimeframeTicks
+ * @param timeframe
+ * @returns
+ */
+const calculateTotalBalanceTimeframeTick = (allTimeframeTickBalances, allTimeframeTicks, timeframe) => {
+    const totalBalanceTimeframeTicks = (0, exports.setDefaultTotalBalanceTimeframeTicks)(allTimeframeTicks);
+    allTimeframeTickBalances.forEach((jeScheduleKey) => {
+        const coaBalanceByPeriodByTimeframe = jeScheduleKey.coaBalanceByPeriod[timeframe];
+        if (coaBalanceByPeriodByTimeframe != null) {
+            coaBalanceByPeriodByTimeframe.map((coaBalancePeriod) => {
+                if (coaBalancePeriod.label != null &&
+                    totalBalanceTimeframeTicks[coaBalancePeriod.label] != null) {
+                    totalBalanceTimeframeTicks[coaBalancePeriod.label].push(coaBalancePeriod);
+                }
+            });
+        }
+    });
+    const coaBalanceGrouped = (0, exports.mapTotalBalanceTimeframeTickToCOAGroupedBalance)(totalBalanceTimeframeTicks);
+    return {
+        months: coaBalanceGrouped,
+    };
+};
+exports.calculateTotalBalanceTimeframeTick = calculateTotalBalanceTimeframeTick;
+/**
+ * This is a helper function just to map COABalance for every ScheduledJournalEntry
+ * @param scheduleJournal
+ * @param currencyCode
+ * @param currencySymbol
+ * @param timeframe
+ * @returns
+ */
+const mapScheduleJournalToCOABalance = (scheduleJournal, currencyCode, currencySymbol, timeframe) => {
+    var _a, _b, _c, _d, _e, _f;
+    const startDate = scheduleJournal.expectedPostDate.startOf('month');
+    const endDate = scheduleJournal.expectedPostDate.endOf('month');
+    const label = startDate.format(formatZeniDateFY_1.MONTH_YEAR_FORMAT);
+    return {
+        balance: (0, amount_1.toAmount)((_b = (_a = scheduleJournal.amount) === null || _a === void 0 ? void 0 : _a.amount) !== null && _b !== void 0 ? _b : 0, (_d = (_c = scheduleJournal.amount) === null || _c === void 0 ? void 0 : _c.currencyCode) !== null && _d !== void 0 ? _d : currencyCode, (_f = (_e = scheduleJournal.amount) === null || _e === void 0 ? void 0 : _e.currencySymbol) !== null && _f !== void 0 ? _f : currencySymbol),
+        balanceTimeFrame: timeframe,
+        type: 'default',
+        startDate,
+        endDate,
+        label,
+    };
+};
+exports.mapScheduleJournalToCOABalance = mapScheduleJournalToCOABalance;
+/**
+ * This function helps us in finding COABalanceGroupedByPeriod for months
+ * @param jeSchedule
+ * @returns
+ */
+const calculateCOABalanceGroupedByPeriod = (jeSchedule) => {
+    const scheduleJournalEntry = jeSchedule.scheduledJournalEntry;
+    const { currencyCode, currencySymbol } = jeSchedule;
+    return {
+        months: scheduleJournalEntry.map((scheduleJournal) => (0, exports.mapScheduleJournalToCOABalance)(scheduleJournal, currencyCode, currencySymbol, 'month')),
+    };
+};
+exports.calculateCOABalanceGroupedByPeriod = calculateCOABalanceGroupedByPeriod;
+const countStatusForDuration = (statusCode) => {
+    return ['unknown', 'posted'].includes(statusCode);
+};
+/**
+ * Function to get Duration of months out total months Eg 5/12 or 9/12
+ * @param jeSchedule
+ * @returns
+ */
+const getDurationOfMonthOutTotalMonth = (jeSchedule) => {
+    let totalDurationCompleted = 0;
+    const scheduledEntries = jeSchedule.scheduledJournalEntry;
+    const allowedJEScheduleStatus = ['ongoing', 'completed'];
+    if (allowedJEScheduleStatus.includes(jeSchedule.status.code) === true &&
+        scheduledEntries.length > 0) {
+        totalDurationCompleted = scheduledEntries.filter((scheduledEntry) => countStatusForDuration(scheduledEntry.status.code)).length;
+    }
+    return totalDurationCompleted;
+};
+exports.getDurationOfMonthOutTotalMonth = getDurationOfMonthOutTotalMonth;
+/**
+ * Function to get accountListKey and allowedAccountList for a given tab
+ * @param scheduleType
+ * @returns
+ */
+const getAccountsTypesForScheduleList = (scheduleType) => {
+    switch (scheduleType) {
+        case 'prepaid_expenses':
+            return {
+                accountListKey: 'schedulesAccountList',
+                allowedAccountList: ['other_current_assets'],
+            };
+        case 'fixed_assets':
+            return {
+                accountListKey: 'schedulesAccountList',
+                allowedAccountList: ['fixed_assets'],
+            };
+        default:
+            return {
+                accountListKey: 'accountList',
+                allowedAccountList: [],
+            };
+    }
+};
+exports.getAccountsTypesForScheduleList = getAccountsTypesForScheduleList;
+const getAccountLabelForScheduleType = (scheduleType) => {
+    switch (scheduleType) {
+        case 'prepaid_expenses':
+        case 'fixed_assets':
+            return scheduleType;
+        default:
+            return undefined;
+    }
+};
+exports.getAccountLabelForScheduleType = getAccountLabelForScheduleType;
+/**
+ * Function to get accountListKey and allowedAccountList for a given tab
+ * @param scheduleType
+ * @returns
+ */
+const getAccountsTypesForScheduleEpics = () => {
+    return {
+        accountListKey: 'schedulesAccountList',
+        allowedAccountList: [
+            'other_current_assets',
+            'fixed_assets',
+            'cogs',
+            'expenses',
+            'other_expense',
+        ],
+    };
+};
+exports.getAccountsTypesForScheduleEpics = getAccountsTypesForScheduleEpics;

package/lib/view/scheduleView/scheduleListView/scheduleListPayload.d.ts

@@ -0,0 +1,7 @@
+import { JEScheduledTransactionPayload, ScheduledJournalEntryPayload } from '../../../entity/jeSchedules/jeSchedulesPayload';
+import { ZeniAPIResponse } from '../../../responsePayload';
+export interface ScheduleListPayload {
+    je_schedules: JEScheduledTransactionPayload[];
+    scheduled_journal_entries?: ScheduledJournalEntryPayload[];
+}
+export declare type FetchScheduleListResponse = ZeniAPIResponse<ScheduleListPayload>;

package/lib/view/scheduleView/scheduleListView/scheduleListPayload.js

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

package/lib/view/scheduleView/scheduleListView/scheduleListSelector.d.ts

@@ -0,0 +1,36 @@
+import { FetchState, FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { EntityOrder } from '../../../commonStateTypes/selectorTypes/selectorTypes';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { RootState } from '../../../reducer';
+import { ScheduleListLocalData, ScheduleListUIState } from './scheduleListState';
+import { NestedAccountHeirarchyForReport } from '../../../commonStateTypes/accountView/nestedAccountID';
+import { TimeframeTick, TimeframeTickWithMetaData } from '../../../commonStateTypes/timeframeTick';
+import { AccountBase } from '../../../entity/account/accountState';
+import { JEScheduledTransaction } from '../../../entity/jeSchedules/jeSchedulesSelector';
+import { ScheduleTypes } from '../../../entity/jeSchedules/jeSchedulesTypes';
+import { Amount } from '../../../commonStateTypes/amount';
+import { COABalanceGroupedByPeriod } from '../../../commonStateTypes/coaBalance/coaBalance';
+export interface JEScheduledTransactionWithBalance extends JEScheduledTransaction {
+    coaBalanceByPeriod: COABalanceGroupedByPeriod;
+    durationOfMonths: number;
+}
+export interface ScheduleListReport extends SelectorView {
+    scheduleType: ScheduleTypes;
+    downloadUIState: FetchStateAndError;
+    jeScheduleOrder: EntityOrder;
+    jeScheduledTransactions: JEScheduledTransactionWithBalance[];
+    scheduleListAccounts: AccountBase[];
+    scheduleListNestedAccountHierarchy: NestedAccountHeirarchyForReport[];
+    uiState: ScheduleListUIState;
+    selectedCategoryId: ID;
+    selectedTimeframe: TimeframeTick;
+    scheduleListLocalData: ScheduleListLocalData;
+    allTimeframeTicks: TimeframeTickWithMetaData[];
+    totalBalanceTimeframeTicks: COABalanceGroupedByPeriod;
+    totalAmount: Amount;
+    totalRunningBalances: Amount;
+    selectedScheduledId?: ID;
+}
+export declare const getScheduleListReport: (state: RootState, scheduleType: ScheduleTypes) => ScheduleListReport;
+export declare const getFetchStateForScheduleAccountList: (state: RootState) => FetchState;
+export declare const getFetchStateForScheduleListByType: (state: RootState, scheduleType: ScheduleTypes) => FetchState;

package/lib/view/scheduleView/scheduleListView/scheduleListSelector.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFetchStateForScheduleListByType = exports.getFetchStateForScheduleAccountList = exports.getScheduleListReport = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+const orderBy_1 = __importDefault(require("lodash/orderBy"));
+const accountListSelector_1 = require("../../accountList/accountListSelector");
+const jeSchedulesSelector_1 = require("../../../entity/jeSchedules/jeSchedulesSelector");
+const scheduleListReducer_1 = require("./scheduleListReducer");
+const scheduleListTypes_1 = require("./scheduleListTypes");
+const amount_1 = require("../../../commonStateTypes/amount");
+const scheduleListHelper_1 = require("./scheduleListHelper");
+const sortedJETransactionsView = (jeTransactions, sortKey, sortOrder) => {
+    return (0, orderBy_1.default)(jeTransactions, (jeTransaction) => {
+        var _a;
+        switch (sortKey) {
+            case 'transactionDate':
+                return jeTransaction.baseTransaction.date.valueOf();
+            case 'vendor':
+                return jeTransaction.vendor.name.toLowerCase();
+            case 'scheduleCategory':
+                return jeTransaction.baseTransaction.account.accountName.toLowerCase();
+            case 'expenseCategory':
+                return jeTransaction.jeDebit.account != null
+                    ? jeTransaction.jeDebit.account.accountName.toLowerCase()
+                    : null;
+            case 'accumulatedDepreciationCategory':
+                return jeTransaction.jeCredit.account != null
+                    ? jeTransaction.jeCredit.account.accountName.toLowerCase()
+                    : null;
+            case 'class':
+                return jeTransaction.jeDebit.accountingClass != null
+                    ? jeTransaction.jeDebit.accountingClass.className.toLowerCase()
+                    : null;
+            case 'amount':
+                return jeTransaction.baseTransaction.amount != null
+                    ? jeTransaction.baseTransaction.amount.amount
+                    : 0;
+            case 'balanceAsOfToday':
+                return jeTransaction.balanceAsOfToday != null
+                    ? jeTransaction.balanceAsOfToday.amount
+                    : 0;
+            case 'memo':
+                return jeTransaction.baseTransaction.memo.toLowerCase();
+            case 'startMonth':
+                return jeTransaction.startDate != null
+                    ? jeTransaction.startDate.valueOf()
+                    : null;
+            case 'endMonth':
+                return jeTransaction.endDate != null
+                    ? jeTransaction.endDate.valueOf()
+                    : null;
+            case 'months':
+                return (_a = jeTransaction.period) !== null && _a !== void 0 ? _a : null;
+            case 'transactionType':
+                return jeTransaction.baseTransaction.type.toLowerCase();
+            case 'status':
+                return jeTransaction.status.code.toLowerCase();
+            case 'assetId':
+                return jeTransaction.otherAttributes.assetId != null
+                    ? jeTransaction.otherAttributes.assetId.toLowerCase()
+                    : null;
+            default:
+                return jeTransaction.updatedByUser != null
+                    ? jeTransaction.updatedByUser.firstName.toLowerCase()
+                    : null;
+        }
+    }, sortOrder === 'ascending' ? 'asc' : 'desc');
+};
+const getScheduleListReport = (state, scheduleType) => {
+    const { scheduleListState, accountListState, accountState } = state;
+    const scheduleState = (0, scheduleListReducer_1.getState)(scheduleListState, scheduleType);
+    const downloadState = scheduleState.downloadState;
+    const allScheduleAccounts = (0, accountListSelector_1.getAccountList)(accountState, accountListState, (0, scheduleListHelper_1.getAccountListKeyForSchedules)());
+    let allNestedAccounts = (0, accountListSelector_1.getNestedAccountListHeirarchy)(accountListState, (0, scheduleListHelper_1.getAccountListKeyForSchedules)());
+    let allAccounts = allScheduleAccounts.accounts;
+    const accountTypes = (0, scheduleListHelper_1.getAccountsTypesForScheduleList)(scheduleType);
+    const accountLabel = (0, scheduleListHelper_1.getAccountLabelForScheduleType)(scheduleType);
+    const scheduleListCurrentTabAccountIds = accountLabel != null
+        ? (0, accountListSelector_1.getAccountIdsForLabel)(accountListState, accountTypes.accountListKey, accountLabel)
+        : [];
+    if (accountLabel != null) {
+        const filteredList = (0, accountListSelector_1.getFilteredNestedAndAccountListsForLabel)(accountState, accountListState, (0, scheduleListHelper_1.getAccountListKeyForSchedules)(), accountLabel);
+        // Use this list only if there is some account in it.
+        if (filteredList.accountList.length > 0) {
+            allAccounts = filteredList.accountList.filter((account) => scheduleListCurrentTabAccountIds.includes(account.accountId));
+            allNestedAccounts = filteredList.nestedAccountList.filter((account) => account.accountId[0] != null &&
+                scheduleListCurrentTabAccountIds.includes(account.accountId[0]));
+        }
+    }
+    const key = (0, scheduleListTypes_1.getScheduleListKey)(scheduleState.selectedCategoryId, scheduleState.selectedTimeframe);
+    const scheduleJETransactions = (0, get_1.default)(scheduleState.jeScheduleKeysByListKey, key, undefined);
+    if (scheduleJETransactions == null) {
+        return {
+            reportTitle: 'Schedule List',
+            version: 1,
+            status: undefined,
+            jeScheduleOrder: 'descending_transaction_date',
+            jeScheduledTransactions: [],
+            scheduleType,
+            selectedScheduledId: undefined,
+            downloadUIState: downloadState,
+            selectedCategoryId: scheduleState.selectedCategoryId,
+            selectedTimeframe: scheduleState.selectedTimeframe,
+            uiState: scheduleState.uiState,
+            scheduleListAccounts: [(0, scheduleListHelper_1.getAllAccountBase)(), ...allAccounts],
+            scheduleListNestedAccountHierarchy: [
+                (0, scheduleListHelper_1.getAllAccountNested)(),
+                ...allNestedAccounts,
+            ],
+            fetchState: 'Not-Started',
+            error: undefined,
+            scheduleListLocalData: scheduleState.scheduleListLocalData,
+            allTimeframeTicks: [],
+            totalBalanceTimeframeTicks: {
+                months: [],
+            },
+            totalAmount: (0, amount_1.toAmount)(0, '', ''),
+            totalRunningBalances: (0, amount_1.toAmount)(0, '', ''),
+        };
+    }
+    else {
+        const jeScheduleIds = scheduleJETransactions.jeScheduleTransactionKeys;
+        const { uiState, selectedScheduleId } = scheduleState;
+        const { fetchState, error } = scheduleJETransactions;
+        const { sortKey, sortOrder } = uiState;
+        const scheduleTransactionsUnsorted = jeScheduleIds
+            .map((jeScheduleId) => (0, jeSchedulesSelector_1.getJEScheduledTransactionByJEScheduleKey)(jeScheduleId, state))
+            .filter((value) => {
+            if (value == null) {
+                console.error("Can't have null transaction at this stage!");
+            }
+            return value != null;
+        });
+        const currentTabTransactions = (0, orderBy_1.default)(scheduleTransactionsUnsorted, (value) => value.baseTransaction.date.valueOf(), 'desc');
+        let jeTransactionsView = [];
+        switch (uiState.currentSubTab) {
+            case 'new':
+                jeTransactionsView = currentTabTransactions.filter((tran) => tran.status.code === 'new');
+                break;
+            case 'ongoing':
+                jeTransactionsView = currentTabTransactions.filter((tran) => tran.status.code === 'ongoing');
+                break;
+            case 'completed':
+                jeTransactionsView = currentTabTransactions.filter((tran) => tran.status.code === 'completed');
+                break;
+            default:
+                jeTransactionsView = currentTabTransactions;
+        }
+        const loweredSearchText = scheduleState.uiState.searchText
+            .trim()
+            .toLowerCase();
+        const sortedJETransactionView = sortedJETransactionsView(jeTransactionsView.filter((jeTransaction) => {
+            return (jeTransaction.vendor.name
+                .toLowerCase()
+                .includes(loweredSearchText) === true ||
+                jeTransaction.baseTransaction.memo
+                    .toLowerCase()
+                    .includes(loweredSearchText) === true);
+        }), sortKey, sortOrder);
+        const totalBalances = (0, scheduleListHelper_1.getCalculatedScheduleTotals)(jeTransactionsView);
+        const allTimeframeTicks = (0, scheduleListHelper_1.getAllTimeframeTicks)(sortedJETransactionView, 2);
+        const jeScheduledTransactionWithBalance = [];
+        sortedJETransactionView.forEach((jeSchedule) => {
+            jeScheduledTransactionWithBalance.push(Object.assign(Object.assign({}, jeSchedule), { coaBalanceByPeriod: (0, scheduleListHelper_1.calculateCOABalanceGroupedByPeriod)(jeSchedule), durationOfMonths: (0, scheduleListHelper_1.getDurationOfMonthOutTotalMonth)(jeSchedule) }));
+        });
+        const totalBalanceTimeframeTicks = (0, scheduleListHelper_1.calculateTotalBalanceTimeframeTick)(jeScheduledTransactionWithBalance, allTimeframeTicks, 'months');
+        return {
+            reportTitle: 'Schedule List',
+            version: 1,
+            status: undefined,
+            jeScheduleOrder: 'descending_transaction_date',
+            jeScheduledTransactions: jeScheduledTransactionWithBalance,
+            selectedScheduledId: selectedScheduleId,
+            downloadUIState: downloadState,
+            selectedCategoryId: scheduleState.selectedCategoryId,
+            selectedTimeframe: scheduleState.selectedTimeframe,
+            uiState,
+            scheduleType,
+            scheduleListAccounts: [(0, scheduleListHelper_1.getAllAccountBase)(), ...allAccounts],
+            scheduleListNestedAccountHierarchy: [
+                (0, scheduleListHelper_1.getAllAccountNested)(),
+                ...allNestedAccounts,
+            ],
+            fetchState,
+            error,
+            scheduleListLocalData: scheduleState.scheduleListLocalData,
+            totalAmount: totalBalances.totalAmount,
+            totalRunningBalances: totalBalances.totalRunningBalances,
+            allTimeframeTicks,
+            totalBalanceTimeframeTicks,
+        };
+    }
+};
+exports.getScheduleListReport = getScheduleListReport;
+const getFetchStateForScheduleAccountList = (state) => {
+    return (0, accountListSelector_1.getAccountListFetchState)(state.accountListState, (0, scheduleListHelper_1.getAccountListKeyForSchedules)());
+};
+exports.getFetchStateForScheduleAccountList = getFetchStateForScheduleAccountList;
+const getFetchStateForScheduleListByType = (state, scheduleType) => {
+    const scheduleState = state.scheduleListState.listByScheduleType[scheduleType];
+    const key = (0, scheduleListTypes_1.getScheduleListKey)(scheduleState.selectedCategoryId, scheduleState.selectedTimeframe);
+    const fetchState = scheduleState.jeScheduleKeysByListKey[key] != null
+        ? scheduleState.jeScheduleKeysByListKey[key].fetchState
+        : 'Not-Started';
+    return fetchState;
+};
+exports.getFetchStateForScheduleListByType = getFetchStateForScheduleListByType;

package/lib/view/settingsView/epic/fetchBankAccountsListEpic.d.ts

@@ -0,0 +1,22 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { fetchBankAccountsList, updateBankConnectionOnSuccess, updateBankConnectionOnFailure } from '../settingsViewReducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { RootState } from '../../../reducer';
+import { updateAccounts } from '../../../entity/account/accountReducer';
+export declare type ActionType = ReturnType<typeof fetchBankAccountsList> | ReturnType<typeof updateBankConnectionOnSuccess> | ReturnType<typeof updateBankConnectionOnFailure> | ReturnType<typeof updateAccounts>;
+export declare const fetchBankAccountsListEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<{
+    payload: undefined;
+    type: string;
+} | {
+    payload: import("../../../responsePayload").ZeniAPIStatus<Record<string, unknown>>;
+    type: string;
+} | {
+    payload: {
+        bankAccountIds: string[];
+    };
+    type: string;
+} | import("@reduxjs/toolkit").PayloadAction<import("../../../entity/account/accountPayload").AccountPayload[], string, {
+    reportId: import("../../..").ReportIDPlusForecastID;
+    classesViewParentId: import("../../../commonStateTypes/classesView/nestedClassID").ClassesViewParentID | undefined;
+    updateType: import("../../..").UpdateType;
+}, never>>;

package/lib/view/settingsView/epic/fetchBankAccountsListEpic.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchBankAccountsListEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const settingsViewReducer_1 = require("../settingsViewReducer");
+const responsePayload_1 = require("../../../responsePayload");
+const accountReducer_1 = require("../../../entity/account/accountReducer");
+const fetchBankAccountsListEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(settingsViewReducer_1.fetchBankAccountsList.match), (0, operators_1.switchMap)(() => {
+    const queryValue = {
+        is_full: true,
+        is_exclude_account_payable_accounts: true,
+        is_exclude_account_receivable_accounts: true,
+        account_types: ['bank'],
+    };
+    const URL = `${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/accounts?query=${encodeURIComponent(JSON.stringify(queryValue))}`;
+    return zeniAPI.getJSON(URL).pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            const bankAccountIds = response.data.accounts.map((account) => account.account_id);
+            const updateActions = [];
+            updateActions.push((0, settingsViewReducer_1.updateBankConnectionOnSuccess)({ bankAccountIds }), (0, accountReducer_1.updateAccounts)(response.data.accounts, 'bill_pay'));
+            return (0, rxjs_1.of)(...updateActions);
+        }
+        else {
+            return (0, rxjs_1.of)((0, settingsViewReducer_1.updateBankConnectionOnFailure)(response.status));
+        }
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, settingsViewReducer_1.updateBankConnectionOnFailure)((0, responsePayload_1.createZeniAPIStatus)('Unexpected error', 'Fetch Bank Accounts REST API call errored out' +
+        JSON.stringify(error))))));
+}));
+exports.fetchBankAccountsListEpic = fetchBankAccountsListEpic;

package/lib/view/settingsView/epic/fetchBankConnectionsViewEpic.d.ts

@@ -0,0 +1,6 @@
+import { ActionsObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { fetchBankConnectionsView, fetchBankAccountsList } from '../settingsViewReducer';
+import { getPaymentAccounts } from '../../spendManagement/commonSetup/setupViewReducer';
+export declare type ActionType = ReturnType<typeof fetchBankConnectionsView> | ReturnType<typeof fetchBankAccountsList> | ReturnType<typeof getPaymentAccounts>;
+export declare const fetchBankConnectionsViewEpic: (actions$: ActionsObservable<ActionType>) => Observable<ActionType>;

package/lib/view/settingsView/epic/fetchBankConnectionsViewEpic.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchBankConnectionsViewEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const settingsViewReducer_1 = require("../settingsViewReducer");
+const setupViewReducer_1 = require("../../spendManagement/commonSetup/setupViewReducer");
+const fetchBankConnectionsViewEpic = (actions$) => actions$.pipe((0, operators_1.filter)(settingsViewReducer_1.fetchBankConnectionsView.match), (0, operators_1.switchMap)(() => {
+    return (0, rxjs_1.from)([
+        (0, settingsViewReducer_1.fetchBankAccountsList)(),
+        (0, setupViewReducer_1.getPaymentAccounts)('bill_pay', false),
+    ]);
+}));
+exports.fetchBankConnectionsViewEpic = fetchBankConnectionsViewEpic;

package/lib/view/settingsView/epic/fetchMyProfileEpic.d.ts

@@ -0,0 +1,43 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { fetchMyProfile, updateMyProfileOnSuccess, updateMyProfileOnFailure } from '../settingsViewReducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { UserPayload } from '../../../entity/user/userPayload';
+import { RootState } from '../../../reducer';
+import { updateUserRoles } from '../../../entity/userRole/userRoleReducer';
+import { updateAllUsers } from '../../../entity/user/userReducer';
+import { updateUserIds } from '../../userListView/userListViewReducer';
+import { UserRolePayload } from '../../../entity/userRole/userRolePayload';
+import { ID } from '../../../commonStateTypes/common';
+export declare type ActionType = ReturnType<typeof fetchMyProfile> | ReturnType<typeof updateUserRoles> | ReturnType<typeof updateAllUsers> | ReturnType<typeof updateMyProfileOnSuccess> | ReturnType<typeof updateUserIds> | ReturnType<typeof updateMyProfileOnFailure>;
+export declare const fetchMyProfileEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<{
+    payload: undefined;
+    type: string;
+} | {
+    payload: import("../../../responsePayload").ZeniAPIStatus<Record<string, unknown>>;
+    type: string;
+} | {
+    payload: {
+        users: UserPayload[];
+        updateType?: import("../../../commonStateTypes/common").UpdateType | undefined;
+    };
+    type: string;
+} | {
+    payload: UserRolePayload[];
+    type: string;
+} | {
+    payload: {
+        userType: import("../../userListView/userListViewState").UserListType;
+        usersPayload: UserPayload[];
+    };
+    type: string;
+} | {
+    payload: {
+        userId: string;
+    };
+    type: string;
+}>;
+/**
+ *  Helpers
+ */
+export declare function getUserPayloadByUserId(userId: ID | undefined, usersPayload: UserPayload[]): UserPayload[] | undefined;
+export declare function getManagerUserIdFromUserRolesPayloadByUserId(userId: ID | undefined, userRolesPayload: UserRolePayload[]): ID | undefined;

package/lib/view/settingsView/epic/fetchMyProfileViewEpic.d.ts

@@ -0,0 +1,7 @@
+import { ActionsObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { fetchMyProfile } from '../settingsViewReducer';
+import { fetchCompanyPassportView } from '../../companyView/companyViewReducer';
+import { fetchClassList } from '../../classList/classListReducer';
+export declare type ActionType = ReturnType<typeof fetchCompanyPassportView> | ReturnType<typeof fetchMyProfile> | ReturnType<typeof fetchClassList>;
+export declare const fetchMyProfileViewEpic: (actions$: ActionsObservable<ActionType>) => Observable<ActionType>;