@zeniai/client-epic-state 4.9.30 → 4.9.31

package/lib/view/transactionList/fetchTransactionListByEntityEpic.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.fetchTransactionListByEntityEpic = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const timePeriod_1 = require("../../commonStateTypes/timePeriod");
+const transactionReducer_1 = require("../../entity/transaction/transactionReducer");
+const responsePayload_1 = require("../../responsePayload");
+const transactionListReducer_1 = require("./transactionListReducer");
+const transactionListState_1 = require("./transactionListState");
+const fetchTransactionListByEntityEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(transactionListReducer_1.fetchEntityTransactionList.match), (0, operators_1.mergeMap)((action) => {
+    const state = state$.value;
+    const key = (0, transactionListState_1.getEntityTranKey)(action.payload.entity, action.payload.period);
+    const entityTransactions = (0, get_1.default)(state.transactionListState.byEntity.transactionListByEntityKey, key, undefined);
+    if (action.payload.cacheOverride === true ||
+        entityTransactions == null ||
+        entityTransactions.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',
+            entity_id: action.payload.entity.id,
+            entity_name: action.payload.entity.name,
+            entity_type: action.payload.entity.type,
+            is_fetch_all_transactions: action.payload.isFetchAllTransactions === true
+                ? action.payload.isFetchAllTransactions
+                : null,
+        };
+        return zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/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.transactions, (value) => value.transaction_id));
+                updateActions.push((0, transactionListReducer_1.updateTransactionListByEntity)(response.data));
+                return (0, rxjs_1.from)(updateActions);
+            }
+            else {
+                return (0, rxjs_1.of)((0, transactionListReducer_1.updateTransactionListByEntityFailure)(action.payload.entity, action.payload.period, response.status));
+            }
+        }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, transactionListReducer_1.updateTransactionListByEntityFailure)(action.payload.entity, 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.fetchTransactionListByEntityEpic = fetchTransactionListByEntityEpic;

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

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

package/lib/view/transactionList/fetchTransactionsListByCategoryTypeEpic.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTransactionsListByCategoryTypeEpic = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const transactionListReducer_1 = require("./transactionListReducer");
+const transactionReducer_1 = require("../../entity/transaction/transactionReducer");
+const responsePayload_1 = require("../../responsePayload");
+const timePeriod_1 = require("../../commonStateTypes/timePeriod");
+const transactionListState_1 = require("./transactionListState");
+const fetchTransactionsListByCategoryTypeEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(transactionListReducer_1.fetchTransactionsListByCategoryType.match), (0, operators_1.mergeMap)((action) => {
+    const state = state$.value;
+    const { transactionCategoryType, period, cacheOverride, minimumTransactionAmount, } = action.payload;
+    const key = (0, transactionListState_1.getCategoryTypeTranKey)(transactionCategoryType, period);
+    const transactions = (0, get_1.default)(state.transactionListState.byType[transactionCategoryType]
+        .transactionListByCategoryType, key, undefined);
+    if (cacheOverride === true ||
+        transactions == null ||
+        transactions.hasValidState() === false) {
+        const queryParam = {
+            start_date: (0, timePeriod_1.toString)(period.start),
+            end_date: (0, timePeriod_1.toString)(period.end),
+            sort_by: 'transaction_date',
+            sort_order: 'desc',
+        };
+        if (transactionCategoryType === 'missingReceipts') {
+            queryParam.is_attachment_missing_only = true;
+        }
+        if (transactionCategoryType === 'miscategorizedExpense' ||
+            transactionCategoryType === 'miscategorizedIncome') {
+            queryParam.type = 'miscategorized';
+            queryParam.account_type =
+                transactionCategoryType === 'miscategorizedExpense'
+                    ? 'expenses'
+                    : 'income';
+        }
+        if (transactionCategoryType === 'uncategorizedIncome' ||
+            transactionCategoryType === 'uncategorizedExpense') {
+            queryParam.type = 'uncategorized';
+            queryParam.account_type =
+                transactionCategoryType === 'uncategorizedExpense'
+                    ? 'expenses'
+                    : 'income';
+        }
+        if (minimumTransactionAmount != null) {
+            queryParam.total_amount_min = minimumTransactionAmount.amount;
+        }
+        return zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/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.transactions, (value) => value.transaction_id));
+                updateActions.push((0, transactionListReducer_1.updateTransactionListByCategoryType)(transactionCategoryType, period, response.data.transactions));
+                return (0, rxjs_1.from)(updateActions);
+            }
+            else {
+                return (0, rxjs_1.of)((0, transactionListReducer_1.updateTransactionsListByCategoryTypeFailure)(transactionCategoryType, period, response.status));
+            }
+        }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, transactionListReducer_1.updateTransactionsListByCategoryTypeFailure)(transactionCategoryType, 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.fetchTransactionsListByCategoryTypeEpic = fetchTransactionsListByCategoryTypeEpic;

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

@@ -0,0 +1,12 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { TimePeriod } from '../../commonStateTypes/timePeriod';
+import { RootState } from '../../reducer';
+import { fetchClassTransactionList, parallelFetchClassTransactionList } from './transactionListReducer';
+export declare type ActionType = ReturnType<typeof parallelFetchClassTransactionList> | ReturnType<typeof fetchClassTransactionList>;
+export declare const parallelFetchClassTransactionListEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>) => Observable<ActionType>;
+/**
+ * Splits given period into month wise periods.
+ * @param period
+ */
+export declare function splitPeriod(period: TimePeriod): TimePeriod[];

package/lib/view/transactionList/parallelFetchClassTransactionListEpic.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitPeriod = exports.parallelFetchClassTransactionListEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const timePeriod_1 = require("../../commonStateTypes/timePeriod");
+const transactionListState_1 = require("./transactionListState");
+const zeniDayJS_1 = require("../../zeniDayJS");
+const transactionListReducer_1 = require("./transactionListReducer");
+const parallelFetchClassTransactionListEpic = (actions$, state$) => actions$.pipe((0, operators_1.filter)(transactionListReducer_1.parallelFetchClassTransactionList.match), (0, operators_1.mergeMap)((action) => {
+    const state = state$.value.transactionListState;
+    const timePeriods = splitPeriod(action.payload.period);
+    const filteredTimePeriods = timePeriods.filter((value) => {
+        if (action.payload.cacheOverride === false) {
+            return (isDataAvailableOrFetching(state.byClass, action.payload.accountId, action.payload.accountType, action.payload.classId, value) === false);
+        }
+        else {
+            return true;
+        }
+    });
+    if (filteredTimePeriods.length > 12) {
+        console.error('Only maximum 12 parallel fetch are allowed!');
+        return (0, rxjs_1.from)([]);
+    }
+    else {
+        const fetchActions = filteredTimePeriods.map((period) => (0, transactionListReducer_1.fetchClassTransactionList)(action.payload.accountId, action.payload.accountType, action.payload.classId, period, true));
+        return (0, rxjs_1.from)(fetchActions);
+    }
+}));
+exports.parallelFetchClassTransactionListEpic = parallelFetchClassTransactionListEpic;
+/**
+ * Splits given period into month wise periods.
+ * @param period
+ */
+function splitPeriod(period) {
+    let startDate = (0, zeniDayJS_1.date)((0, timePeriod_1.toString)(period.start));
+    const endDate = (0, zeniDayJS_1.date)((0, timePeriod_1.toString)(period.end));
+    // Make sure we fetch from the start of the month.
+    startDate = startDate.set('date', 1);
+    const numOfMonths = Math.ceil(endDate.diff(startDate, 'month', true));
+    const result = [];
+    if (numOfMonths > 0 || numOfMonths == 0) {
+        let date = startDate.clone().set('date', 1);
+        for (let i = 0; i < numOfMonths - 1; ++i) {
+            const daysInMonth = date.daysInMonth();
+            const start = {
+                day: 1,
+                month: (date.month() + 1),
+                year: date.year(),
+            };
+            const end = {
+                day: daysInMonth,
+                month: (date.month() + 1),
+                year: date.year(),
+            };
+            result.push({ start, end });
+            date = date.add(1, 'month');
+        }
+        result.push({
+            start: {
+                day: date.date(),
+                month: (date.month() + 1),
+                year: date.year(),
+            },
+            end: {
+                day: endDate.date(),
+                month: (endDate.month() + 1),
+                year: endDate.year(),
+            },
+        });
+    }
+    else {
+        console.error(`Invalid time period ${JSON.stringify(period)}`);
+    }
+    return result;
+}
+exports.splitPeriod = splitPeriod;
+function isDataAvailableOrFetching(state, accountId, accountType, classId, period) {
+    const key = (0, transactionListState_1.getClassAcTranKey)(accountId, accountType, classId, period);
+    const classTransactions = state.transactionListByClassKey[key];
+    return (classTransactions != null &&
+        (classTransactions.fetchState === 'In-Progress' ||
+            classTransactions.hasValidState()));
+}

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

@@ -0,0 +1,14 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { TimePeriod } from '../../commonStateTypes/timePeriod';
+import { RootState } from '../../reducer';
+import { parallelFetchEntityTransactionList, fetchEntityTransactionList } from './transactionListReducer';
+export declare type ActionType = ReturnType<typeof parallelFetchEntityTransactionList> | ReturnType<typeof fetchEntityTransactionList>;
+export declare const parallelFetchEntityTransactionListEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>) => Observable<ActionType>;
+/**
+ * Splits given period into month wise periods. Returns only the last quarter
+ * Last four months in the given period. If the period is less than 4 months
+ * it will return all
+ * @param period
+ */
+export declare function splitPeriodLastQuarter(period: TimePeriod): TimePeriod[];

package/lib/view/transactionList/parallelFetchEntityTransactionListEpic.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitPeriodLastQuarter = exports.parallelFetchEntityTransactionListEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const timePeriod_1 = require("../../commonStateTypes/timePeriod");
+const transactionListState_1 = require("./transactionListState");
+const transactionListReducer_1 = require("./transactionListReducer");
+const zeniDayJS_1 = require("../../zeniDayJS");
+const parallelFetchEntityTransactionListEpic = (actions$, state$) => actions$.pipe((0, operators_1.filter)(transactionListReducer_1.parallelFetchEntityTransactionList.match), (0, operators_1.mergeMap)((action) => {
+    const state = state$.value.transactionListState;
+    const timePeriods = splitPeriodLastQuarter(action.payload.period);
+    const filteredTimePeriods = timePeriods.filter((value) => {
+        if (action.payload.cacheOverride === false) {
+            return (isDataAvailableOrFetching(state.byEntity, action.payload.entity, value) === false);
+        }
+        else {
+            return true;
+        }
+    });
+    if (filteredTimePeriods.length > 12) {
+        console.error('Only maximum 12 parallel fetch are allowed!');
+        return (0, rxjs_1.from)([]);
+    }
+    else {
+        const fetchActions = filteredTimePeriods.map((period) => (0, transactionListReducer_1.fetchEntityTransactionList)(action.payload.entity, period, true));
+        return (0, rxjs_1.from)(fetchActions);
+    }
+}));
+exports.parallelFetchEntityTransactionListEpic = parallelFetchEntityTransactionListEpic;
+function isDataAvailableOrFetching(state, entity, period) {
+    const key = (0, transactionListState_1.getEntityTranKey)(entity, period);
+    const entityTransactions = state.transactionListByEntityKey[key];
+    return (entityTransactions != null &&
+        (entityTransactions.fetchState === 'In-Progress' ||
+            entityTransactions.hasValidState()));
+}
+/**
+ * Splits given period into month wise periods. Returns only the last quarter
+ * Last four months in the given period. If the period is less than 4 months
+ * it will return all
+ * @param period
+ */
+function splitPeriodLastQuarter(period) {
+    let startDate = (0, zeniDayJS_1.date)((0, timePeriod_1.toString)(period.start));
+    const endDate = (0, zeniDayJS_1.date)((0, timePeriod_1.toString)(period.end));
+    const quarterStart = endDate.startOf('quarter');
+    // Make sure we fetch from the start of the month.
+    startDate = startDate.set('date', 1);
+    if (startDate.isBefore(quarterStart)) {
+        startDate = quarterStart;
+    }
+    const numOfMonths = Math.ceil(endDate.diff(startDate, 'month', true));
+    const result = [];
+    if (numOfMonths > 0 || numOfMonths == 0) {
+        let date = startDate.clone().set('date', 1);
+        for (let i = 0; i < numOfMonths - 1; ++i) {
+            const daysInMonth = date.daysInMonth();
+            const start = {
+                day: 1,
+                month: (date.month() + 1),
+                year: date.year(),
+            };
+            const end = {
+                day: daysInMonth,
+                month: (date.month() + 1),
+                year: date.year(),
+            };
+            result.push({ start, end });
+            date = date.add(1, 'month');
+        }
+        result.push({
+            start: {
+                day: date.date(),
+                month: (date.month() + 1),
+                year: date.year(),
+            },
+            end: {
+                day: endDate.date(),
+                month: (endDate.month() + 1),
+                year: endDate.year(),
+            },
+        });
+    }
+    else {
+        console.error(`Invalid time period ${JSON.stringify(period)}`);
+    }
+    return result;
+}
+exports.splitPeriodLastQuarter = splitPeriodLastQuarter;

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

@@ -0,0 +1,6 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../reducer';
+import { parallelFetchTransactionListByCategoryType, fetchTransactionsListByCategoryType } from './transactionListReducer';
+export declare type ActionType = ReturnType<typeof parallelFetchTransactionListByCategoryType> | ReturnType<typeof fetchTransactionsListByCategoryType>;
+export declare const parallelFetchTransactionListByCategoryTypeEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>) => Observable<ActionType>;

package/lib/view/transactionList/parallelFetchTransactionListByCategoryTypeEpic.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parallelFetchTransactionListByCategoryTypeEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const transactionListReducer_1 = require("./transactionListReducer");
+const parallelFetchAccountTransactionListEpic_1 = require("./parallelFetchAccountTransactionListEpic");
+const transactionListState_1 = require("./transactionListState");
+const parallelFetchTransactionListByCategoryTypeEpic = (actions$, state$) => actions$.pipe((0, operators_1.filter)(transactionListReducer_1.parallelFetchTransactionListByCategoryType.match), (0, operators_1.mergeMap)((action) => {
+    const { transactionCategoryType, minimumTransactionAmount } = action.payload;
+    const state = state$.value.transactionListState;
+    const timePeriods = (0, parallelFetchAccountTransactionListEpic_1.splitPeriod)(action.payload.period);
+    const filteredTimePeriods = timePeriods.filter((value) => {
+        if (action.payload.cacheOverride === false) {
+            return (isDataAvailableOrFetching(state.byType[transactionCategoryType], value, transactionCategoryType) === false);
+        }
+        else {
+            return true;
+        }
+    });
+    if (filteredTimePeriods.length > 12) {
+        console.error('Only maximum 12 parallel fetch are allowed!');
+        return (0, rxjs_1.from)([]);
+    }
+    else {
+        const fetchActions = filteredTimePeriods.map((period) => (0, transactionListReducer_1.fetchTransactionsListByCategoryType)(true, transactionCategoryType, period, minimumTransactionAmount));
+        return (0, rxjs_1.from)(fetchActions);
+    }
+}));
+exports.parallelFetchTransactionListByCategoryTypeEpic = parallelFetchTransactionListByCategoryTypeEpic;
+function isDataAvailableOrFetching(state, period, transactionCategoryType) {
+    const key = (0, transactionListState_1.getCategoryTypeTranKey)(transactionCategoryType, period);
+    const tansactions = state.transactionListByCategoryType[key];
+    return (tansactions != null &&
+        (tansactions.fetchState === 'In-Progress' || tansactions.hasValidState()));
+}

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

@@ -0,0 +1,21 @@
+import { COABalanceTimeFrame } from '../../commonStateTypes/coaBalance/coaBalance';
+import { ID } from '../../commonStateTypes/common';
+import { EntityOrder } from '../../commonStateTypes/selectorTypes/selectorTypes';
+import { TimePeriod } from '../../commonStateTypes/timePeriod';
+import { SelectorView } from '../../commonStateTypes/viewAndReport/viewAndReport';
+import { AccountBase, AccountType } from '../../entity/account/accountState';
+import { Transaction } from '../../entity/transaction/stateTypes/transaction';
+import { TransactionState } from '../../entity/transaction/transactionState';
+import { TransactionListSelectorView, TransactionListState, TransactionListUIState } from './transactionListState';
+export interface TransactionListByAccountReport extends SelectorView, TransactionListSelectorView {
+    timeframe: COABalanceTimeFrame;
+    filterByTimePeriod: TimePeriod;
+    accountId: ID;
+    accountType: AccountType;
+    account?: AccountBase;
+    transactionOrder: EntityOrder;
+    transactions: Transaction[];
+    uiState: TransactionListUIState;
+}
+export declare const getTransactionListByAccount: (transactionState: TransactionState, transactionListState: TransactionListState, accountId: ID, accountType: AccountType, timeframe: COABalanceTimeFrame, filterByTimePeriod: TimePeriod) => TransactionListByAccountReport;
+export declare const getTransactionListUIStateByAccountKey: (transactionListState: TransactionListState, accountId: ID, accountType: AccountType) => TransactionListUIState | undefined;

package/lib/view/transactionList/transactionListByAccountSelector.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransactionListUIStateByAccountKey = exports.getTransactionListByAccount = void 0;
+const flatMap_1 = __importDefault(require("lodash/flatMap"));
+const get_1 = __importDefault(require("lodash/get"));
+const orderBy_1 = __importDefault(require("lodash/orderBy"));
+const parallelFetchAccountTransactionListEpic_1 = require("./parallelFetchAccountTransactionListEpic");
+const reduceTransactionListFetchState_1 = require("./reduceTransactionListFetchState");
+const transactionListState_1 = require("./transactionListState");
+const transactionSelector_1 = require("../../entity/transaction/transactionSelector");
+const getTransactionListByAccount = (transactionState, transactionListState, accountId, accountType, timeframe, filterByTimePeriod) => {
+    const timePeriods = (0, parallelFetchAccountTransactionListEpic_1.splitPeriod)(filterByTimePeriod); // Note: Split by months.
+    const accountTransactions = timePeriods
+        .map((thisTimePeriod) => {
+        const key = (0, transactionListState_1.getAcTranKey)(accountId, accountType, thisTimePeriod);
+        return (0, get_1.default)(transactionListState.byAccount.transactionListByAccountKey, key, undefined);
+    })
+        .filter((acTransaction) => acTransaction != null);
+    let account = undefined;
+    if (accountTransactions.length > 0) {
+        account = accountTransactions[0].account;
+    }
+    const fetchState = (0, reduceTransactionListFetchState_1.reduceFetchState)(accountTransactions);
+    let transactions = [];
+    if ((0, reduceTransactionListFetchState_1.isAnyFetchCompleted)(accountTransactions)) {
+        const allTransactionIDs = (0, flatMap_1.default)(accountTransactions, (value) => value.transactionIDs);
+        const transactionsUnsorted = allTransactionIDs
+            .map((transactionId) => (0, transactionSelector_1.getSupportedTransactionById)(transactionState, transactionId))
+            .filter((value) => {
+            if (value == null) {
+                console.error("Can't have null transaction at this stage!");
+            }
+            return value != null;
+        });
+        transactions = (0, orderBy_1.default)(transactionsUnsorted, (value) => value.date.valueOf(), 'desc');
+    }
+    const key = (0, transactionListState_1.getAcKey)(accountId, accountType);
+    const uiState = (0, get_1.default)(transactionListState.byAccount.transactionListUIStateByAccountKey, key, {});
+    return {
+        reportId: 'transaction_list_of_account',
+        reportTitle: 'Transaction List By Account',
+        version: 0,
+        status: undefined,
+        fetchState: fetchState.fetchState,
+        error: fetchState.error,
+        timeframe,
+        filterByTimePeriod,
+        accountId,
+        accountType,
+        account,
+        transactionOrder: 'descending_transaction_date',
+        transactions,
+        uiState,
+        latestTransactionId: transactionListState.latestTransactionId,
+    };
+};
+exports.getTransactionListByAccount = getTransactionListByAccount;
+const getTransactionListUIStateByAccountKey = (transactionListState, accountId, accountType) => {
+    const key = (0, transactionListState_1.getAcKey)(accountId, accountType);
+    return (0, get_1.default)(transactionListState.byAccount.transactionListUIStateByAccountKey, key, undefined);
+};
+exports.getTransactionListUIStateByAccountKey = getTransactionListUIStateByAccountKey;

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

@@ -0,0 +1,15 @@
+import { COABalanceTimeFrame } from '../../commonStateTypes/coaBalance/coaBalance';
+import { EntityOrder } from '../../commonStateTypes/selectorTypes/selectorTypes';
+import { SupportedTransaction, TransactionState } from '../../entity/transaction/transactionState';
+import { TransactionCategoryType, TransactionListSelectorView, TransactionListState, TransactionListUIState } from './transactionListState';
+import { SelectorView } from '../../commonStateTypes/viewAndReport/viewAndReport';
+import { TimePeriod } from '../../commonStateTypes/timePeriod';
+export interface TransactionListByCategoryType extends SelectorView, TransactionListSelectorView {
+    timeframe: COABalanceTimeFrame;
+    filterByTimePeriod: TimePeriod;
+    transactionOrder: EntityOrder;
+    transactions: SupportedTransaction[];
+    uiState: TransactionListUIState;
+}
+export declare const getTransactionsListByCategoryType: (transactionState: TransactionState, transactionListState: TransactionListState, filterByTimePeriod: TimePeriod, timeframe: COABalanceTimeFrame, transactionCategoryType: TransactionCategoryType) => TransactionListByCategoryType;
+export declare const getTransactionListUIStateByCategoryType: (transactionListState: TransactionListState, transactionCategoryType: TransactionCategoryType) => TransactionListUIState | undefined;

package/lib/view/transactionList/transactionListByCategoryTypeSelector.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransactionListUIStateByCategoryType = exports.getTransactionsListByCategoryType = void 0;
+const orderBy_1 = __importDefault(require("lodash/orderBy"));
+const get_1 = __importDefault(require("lodash/get"));
+const flatMap_1 = __importDefault(require("lodash/flatMap"));
+const transactionListState_1 = require("./transactionListState");
+const reduceTransactionListFetchState_1 = require("./reduceTransactionListFetchState");
+const parallelFetchAccountTransactionListEpic_1 = require("./parallelFetchAccountTransactionListEpic");
+const transactionSelector_1 = require("../../entity/transaction/transactionSelector");
+const getTransactionsListByCategoryType = (transactionState, transactionListState, filterByTimePeriod, timeframe, transactionCategoryType) => {
+    const timePeriods = (0, parallelFetchAccountTransactionListEpic_1.splitPeriod)(filterByTimePeriod); // Note: Split by months.
+    const categoryTransactions = timePeriods
+        .map((thisTimePeriod) => {
+        const key = (0, transactionListState_1.getCategoryTypeTranKey)(transactionCategoryType, thisTimePeriod);
+        return (0, get_1.default)(transactionListState.byType[transactionCategoryType]
+            .transactionListByCategoryType, key, undefined);
+    })
+        .filter((transaction) => transaction != null);
+    const fetchState = (0, reduceTransactionListFetchState_1.reduceFetchState)(categoryTransactions);
+    let transactions = [];
+    if ((0, reduceTransactionListFetchState_1.isAnyFetchCompleted)(categoryTransactions)) {
+        const allTransactionIDs = (0, flatMap_1.default)(categoryTransactions, (value) => value.transactionIDs);
+        const transactionsUnsorted = allTransactionIDs
+            .map((transactionId) => (0, transactionSelector_1.getSupportedTransactionById)(transactionState, transactionId))
+            .filter((value) => {
+            if (value == null) {
+                console.error("Can't have null transaction at this stage!");
+            }
+            return value != null;
+        });
+        transactions = (0, orderBy_1.default)(transactionsUnsorted, (value) => value.date.valueOf(), 'desc');
+    }
+    const uiState = transactionListState.byType[transactionCategoryType].transactionListUIState;
+    return {
+        fetchState: fetchState.fetchState,
+        error: fetchState.error,
+        timeframe,
+        filterByTimePeriod,
+        transactionOrder: 'descending_transaction_date',
+        transactions,
+        uiState,
+        latestTransactionId: transactionListState.latestTransactionId,
+    };
+};
+exports.getTransactionsListByCategoryType = getTransactionsListByCategoryType;
+const getTransactionListUIStateByCategoryType = (transactionListState, transactionCategoryType) => {
+    return transactionListState.byType[transactionCategoryType]
+        .transactionListUIState;
+};
+exports.getTransactionListUIStateByCategoryType = getTransactionListUIStateByCategoryType;

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

@@ -0,0 +1,22 @@
+import { COABalanceTimeFrame } from '../../commonStateTypes/coaBalance/coaBalance';
+import { ID } from '../../commonStateTypes/common';
+import { EntityOrder } from '../../commonStateTypes/selectorTypes/selectorTypes';
+import { TimePeriod } from '../../commonStateTypes/timePeriod';
+import { SelectorView } from '../../commonStateTypes/viewAndReport/viewAndReport';
+import { AccountBase, AccountType } from '../../entity/account/accountState';
+import { Transaction } from '../../entity/transaction/stateTypes/transaction';
+import { TransactionState } from '../../entity/transaction/transactionState';
+import { TransactionListSelectorView, TransactionListState, TransactionListUIState } from './transactionListState';
+export interface TransactionListByClassReport extends SelectorView, TransactionListSelectorView {
+    timeframe: COABalanceTimeFrame;
+    filterByTimePeriod: TimePeriod;
+    accountId: ID;
+    accountType: AccountType;
+    classId: ID;
+    account?: AccountBase;
+    transactionOrder: EntityOrder;
+    transactions: Transaction[];
+    uiState: TransactionListUIState;
+}
+export declare const getTransactionListByClass: (transactionState: TransactionState, transactionListState: TransactionListState, accountId: ID, accountType: AccountType, classId: ID, timeframe: COABalanceTimeFrame, filterByTimePeriod: TimePeriod) => TransactionListByClassReport;
+export declare const getTransactionListUIStateByClassKey: (transactionListState: TransactionListState, accountId: ID, accountType: AccountType, classId: ID) => TransactionListUIState | undefined;

package/lib/view/transactionList/transactionListByClassSelector.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransactionListUIStateByClassKey = exports.getTransactionListByClass = void 0;
+const flatMap_1 = __importDefault(require("lodash/flatMap"));
+const get_1 = __importDefault(require("lodash/get"));
+const orderBy_1 = __importDefault(require("lodash/orderBy"));
+const parallelFetchAccountTransactionListEpic_1 = require("./parallelFetchAccountTransactionListEpic");
+const reduceTransactionListFetchState_1 = require("./reduceTransactionListFetchState");
+const transactionListState_1 = require("./transactionListState");
+const transactionSelector_1 = require("../../entity/transaction/transactionSelector");
+const getTransactionListByClass = (transactionState, transactionListState, accountId, accountType, classId, timeframe, filterByTimePeriod) => {
+    const timePeriods = (0, parallelFetchAccountTransactionListEpic_1.splitPeriod)(filterByTimePeriod); // Note: Split by months.
+    const accountTransactions = timePeriods
+        .map((thisTimePeriod) => {
+        const key = (0, transactionListState_1.getClassAcTranKey)(accountId, accountType, classId, thisTimePeriod);
+        return (0, get_1.default)(transactionListState.byClass.transactionListByClassKey, key, undefined);
+    })
+        .filter((acTransaction) => acTransaction != null);
+    let account = undefined;
+    if (accountTransactions.length > 0) {
+        account = accountTransactions[0].account;
+    }
+    const fetchState = (0, reduceTransactionListFetchState_1.reduceFetchState)(accountTransactions);
+    let transactions = [];
+    if ((0, reduceTransactionListFetchState_1.isAnyFetchCompleted)(accountTransactions)) {
+        const allTransactionIDs = (0, flatMap_1.default)(accountTransactions, (value) => value.transactionIDs);
+        const transactionsUnsorted = allTransactionIDs
+            .map((transactionId) => (0, transactionSelector_1.getSupportedTransactionById)(transactionState, transactionId))
+            .filter((value) => {
+            if (value == null) {
+                console.error("Can't have null transaction at this stage!");
+            }
+            return value != null;
+        });
+        transactions = (0, orderBy_1.default)(transactionsUnsorted, (value) => value.date.valueOf(), 'desc');
+    }
+    const key = (0, transactionListState_1.getClassAcKey)(accountId, accountType, classId);
+    const uiState = (0, get_1.default)(transactionListState.byClass.transactionListUIStateByClassKey, key, {});
+    return {
+        reportId: 'transaction_list_of_account_by_class',
+        reportTitle: 'Transaction List of Account By Class',
+        version: 1,
+        status: undefined,
+        fetchState: fetchState.fetchState,
+        error: fetchState.error,
+        timeframe,
+        filterByTimePeriod,
+        accountId,
+        accountType,
+        classId,
+        account,
+        transactionOrder: 'descending_transaction_date',
+        transactions,
+        uiState,
+        latestTransactionId: transactionListState.latestTransactionId,
+    };
+};
+exports.getTransactionListByClass = getTransactionListByClass;
+const getTransactionListUIStateByClassKey = (transactionListState, accountId, accountType, classId) => {
+    const key = (0, transactionListState_1.getClassAcKey)(accountId, accountType, classId);
+    return (0, get_1.default)(transactionListState.byClass.transactionListUIStateByClassKey, key, undefined);
+};
+exports.getTransactionListUIStateByClassKey = getTransactionListUIStateByClassKey;

package/lib/view/trend/fetchExpenseTrendEpic.d.ts

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { updateVendorExpenseTrend } from '../../entity/vendorExpense/vendorExpenseReducer';
+import { RootState } from '../../reducer';
+import { ZeniAPI } from '../../zeniAPI';
+import { fetchExpenseTrend, updateTrendFailure, updateTrendSuccess } from './trendReducer';
+import { updateVendorSpendTrend } from '../../entity/vendor/vendorReducer';
+export declare type ActionType = ReturnType<typeof fetchExpenseTrend> | ReturnType<typeof updateVendorExpenseTrend> | ReturnType<typeof updateTrendSuccess> | ReturnType<typeof updateVendorSpendTrend> | ReturnType<typeof updateTrendFailure>;
+export declare const fetchExpenseTrendEpic: (actions$: ActionsObservable<ActionType>, _: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<ActionType>;