@zeniai/client-epic-state 5.0.46 → 5.0.47

package/lib/esm/view/creditAgentView/creditAgentViewSelector.js

@@ -0,0 +1,85 @@
+import { createSelector } from '@reduxjs/toolkit';
+import orderBy from 'lodash/orderBy';
+export const getCreditAgentView = (state) => state.creditAgentViewState;
+export const getCreditAgentEntity = (state) => state.creditAgentEntityState;
+export const getCreditAgentMacro = createSelector(getCreditAgentView, getCreditAgentEntity, (view, entity) => ({
+    ...view.macro,
+    data: entity.macro,
+}));
+export const getCardProfilesData = createSelector(getCreditAgentView, getCreditAgentEntity, (view, entity) => {
+    const { uiState } = view;
+    const allRows = Object.values(entity.rowByTenantId).map((row) => {
+        const tenantView = view.tenantViewByTenantId[row.tenantId];
+        return {
+            ...row,
+            analyzeStatus: tenantView?.analyzeStatus ?? {
+                fetchState: 'Not-Started',
+            },
+            updateStatus: tenantView?.updateStatus ?? { fetchState: 'Not-Started' },
+        };
+    });
+    let filteredRows = allRows;
+    // Text filter
+    const trimmedFilterText = uiState.filterText.trim();
+    if (trimmedFilterText.length > 0) {
+        const query = trimmedFilterText.toLowerCase();
+        filteredRows = filteredRows.filter((row) => (row.customerName ?? '').toLowerCase().includes(query) ||
+            row.tenantId.toLowerCase().includes(query));
+    }
+    // Focus filter
+    filteredRows = applyFocusFilter(filteredRows, uiState.focus);
+    // Min score filter
+    if (uiState.minScore > 0) {
+        filteredRows = filteredRows.filter((row) => {
+            const score = parseFloat(row.creditScore ?? '0');
+            return score >= uiState.minScore;
+        });
+    }
+    // Sorting
+    const sortedRows = getSortedRows(filteredRows, uiState.sortKey, uiState.sortDir);
+    return {
+        fetchStatus: view.profilesFetchStatus,
+        rows: sortedRows,
+        uiState,
+    };
+});
+// ── Helpers ──
+const applyFocusFilter = (rows, focus) => {
+    switch (focus) {
+        case 'New only':
+            return rows.filter((row) => row.isNew);
+        case 'Interested':
+            return rows.filter((row) => row.cardStatus === 'Interested');
+        case 'Active only':
+            return rows.filter((row) => row.cardStatus === 'Active' || row.cardStatus === 'Enabled');
+        case 'All':
+        default:
+            return rows;
+    }
+};
+const getSortedRows = (rows, sortKey, sortDir) => {
+    if (sortKey == null) {
+        return rows;
+    }
+    const direction = sortDir === 'asc' ? 'asc' : 'desc';
+    return orderBy(rows, (row) => {
+        switch (sortKey) {
+            case 'name':
+                return (row.customerName ?? '').toLowerCase();
+            case 'status':
+                return row.cardStatus.toLowerCase();
+            case 'creditLimit':
+                return row.creditLimit ?? 0;
+            case 'creditScore':
+                return parseFloat(row.creditScore ?? '0');
+            case 'recAmount':
+                return row.recommendedAmount ?? 0;
+            case 'reportDate':
+                return row.reportDate?.valueOf() ?? 0;
+            case 'updatedBy':
+                return (row.updatedByName ?? '').toLowerCase();
+            default:
+                return (row.customerName ?? '').toLowerCase();
+        }
+    }, direction);
+};

package/lib/esm/view/creditAgentView/creditAgentViewState.js

@@ -0,0 +1,20 @@
+import { stringToUnion } from '../../commonStateTypes/stringToUnion';
+const ALL_CREDIT_AGENT_SORT_KEYS = [
+    'name',
+    'status',
+    'creditLimit',
+    'creditScore',
+    'recAmount',
+    'reportDate',
+    'updatedBy',
+];
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const toCreditAgentSortKeyType = (v) => stringToUnion(v, ALL_CREDIT_AGENT_SORT_KEYS);
+const ALL_CREDIT_AGENT_FOCUS_FILTERS = [
+    'All',
+    'New only',
+    'Interested',
+    'Active only',
+];
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const toCreditAgentFocusFilterType = (v) => stringToUnion(v, ALL_CREDIT_AGENT_FOCUS_FILTERS);

package/lib/esm/view/creditAgentView/epics/fetchCardProfilesEpic.js

@@ -0,0 +1,20 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { updateCreditAgentRows } from '../../../entity/creditAgent/creditAgentReducer';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchCardProfiles, fetchCardProfilesFailure, fetchCardProfilesSuccess, } from '../creditAgentViewReducer';
+export const fetchCardProfilesEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCardProfiles.match), switchMap(() => {
+    const url = `${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/cockpit/card-tenant-profiles`;
+    return zeniAPI.getJSON(url).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const rawRows = response.data.rows;
+            return from([
+                updateCreditAgentRows(rawRows),
+                fetchCardProfilesSuccess(rawRows),
+            ]);
+        }
+        else {
+            return of(fetchCardProfilesFailure(response.status));
+        }
+    }), catchError((error) => of(fetchCardProfilesFailure(createZeniAPIStatus('Unexpected error', 'REST API call errored out: ' + JSON.stringify(error))))));
+}));

package/lib/esm/view/creditAgentView/epics/fetchCreditAgentAccessEpic.js

@@ -0,0 +1,13 @@
+import { of } from 'rxjs';
+import { catchError, filter, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchCreditAgentAccess, fetchCreditAgentAccessFailure, fetchCreditAgentAccessSuccess, } from '../creditAgentViewReducer';
+export const fetchCreditAgentAccessEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCreditAgentAccess.match), switchMap(() => {
+    const url = `${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/cockpit/cards-cockpit-access`;
+    return zeniAPI.getJSON(url).pipe(switchMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return of(fetchCreditAgentAccessSuccess(response.data.is_allowed === true));
+        }
+        return of(fetchCreditAgentAccessFailure(response.status));
+    }), catchError((error) => of(fetchCreditAgentAccessFailure(createZeniAPIStatus('Unexpected error', 'REST API call errored out: ' + JSON.stringify(error))))));
+}));

package/lib/esm/view/creditAgentView/epics/fetchCreditAgentMacroEpic.js

@@ -0,0 +1,19 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { updateCreditAgentMacro } from '../../../entity/creditAgent/creditAgentReducer';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchCreditAgentMacro, fetchCreditAgentMacroFailure, fetchCreditAgentMacroSuccess, } from '../creditAgentViewReducer';
+export const fetchCreditAgentMacroEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCreditAgentMacro.match), switchMap(() => {
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/macros/credit-agent`;
+    return zeniAPI.getJSON(url).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return from([
+                updateCreditAgentMacro(response.data),
+                fetchCreditAgentMacroSuccess(),
+            ]);
+        }
+        else {
+            return of(fetchCreditAgentMacroFailure(response.status));
+        }
+    }), catchError((error) => of(fetchCreditAgentMacroFailure(createZeniAPIStatus('Unexpected error', 'REST API call errored out: ' + JSON.stringify(error))))));
+}));

package/lib/esm/view/creditAgentView/epics/saveCreditAgentMacroEpic.js

@@ -0,0 +1,58 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { updateCreditAgentMacro } from '../../../entity/creditAgent/creditAgentReducer';
+import { openSnackbar } from '../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { saveCreditAgentMacro, saveCreditAgentMacroFailure, saveCreditAgentMacroSuccess, } from '../creditAgentViewReducer';
+export const saveCreditAgentMacroEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(saveCreditAgentMacro.match), switchMap((action) => {
+    const { instructions } = action.payload;
+    const existingMacro = state$.value.creditAgentEntityState.macro;
+    // Fail fast if macro has not been loaded yet — avoids overwriting server-side
+    // name/description fields with empty defaults.
+    if (existingMacro == null) {
+        return from([
+            saveCreditAgentMacroFailure(createZeniAPIStatus('Save failed', 'Cannot save macro: macro data has not been loaded yet.')),
+            openSnackbar({
+                messageSection: 'credit_agent_save_macro',
+                messageText: 'failed',
+                type: 'error',
+            }),
+        ]);
+    }
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/macros/credit-agent`;
+    const body = {
+        instructions,
+        name: existingMacro.name,
+        description: existingMacro.description,
+    };
+    return zeniAPI.putAndGetJSON(url, body).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return from([
+                updateCreditAgentMacro(response.data),
+                saveCreditAgentMacroSuccess(),
+                openSnackbar({
+                    messageSection: 'credit_agent_save_macro',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ]);
+        }
+        else {
+            return from([
+                saveCreditAgentMacroFailure(response.status),
+                openSnackbar({
+                    messageSection: 'credit_agent_save_macro',
+                    messageText: 'failed',
+                    type: 'error',
+                }),
+            ]);
+        }
+    }), catchError((error) => from([
+        saveCreditAgentMacroFailure(createZeniAPIStatus('Unexpected error', 'REST API call errored out: ' + JSON.stringify(error))),
+        openSnackbar({
+            messageSection: 'credit_agent_save_macro',
+            messageText: 'failed',
+            type: 'error',
+        }),
+    ])));
+}));

package/lib/esm/view/creditAgentView/epics/scheduleTenantCreditScoreCronEpic.js

@@ -0,0 +1,39 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../responsePayload';
+import { scheduleTenantCreditScoreCron, scheduleTenantCreditScoreCronFailure, scheduleTenantCreditScoreCronSuccess, } from '../creditAgentViewReducer';
+export const scheduleTenantCreditScoreCronEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(scheduleTenantCreditScoreCron.match), mergeMap((action) => {
+    const { tenantId } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/crons/cards/tenant-credit-score`;
+    const body = tenantId != null ? { tenant_id: tenantId } : {};
+    return zeniAPI.postAndGetJSON(url, body).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response)) {
+            return from([
+                scheduleTenantCreditScoreCronSuccess(tenantId),
+                openSnackbar({
+                    messageSection: 'credit_agent_schedule_cron',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ]);
+        }
+        else {
+            return from([
+                scheduleTenantCreditScoreCronFailure(tenantId, response.status),
+                openSnackbar({
+                    messageSection: 'credit_agent_schedule_cron',
+                    messageText: 'failed',
+                    type: 'error',
+                }),
+            ]);
+        }
+    }), catchError((error) => from([
+        scheduleTenantCreditScoreCronFailure(tenantId, createZeniAPIStatus('Unexpected error', 'REST API call errored out: ' + JSON.stringify(error))),
+        openSnackbar({
+            messageSection: 'credit_agent_schedule_cron',
+            messageText: 'failed',
+            type: 'error',
+        }),
+    ])));
+}));

package/lib/esm/view/creditAgentView/epics/updateCardProfileEpic.js

@@ -0,0 +1,62 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { updateCreditAgentRow } from '../../../entity/creditAgent/creditAgentReducer';
+import { openSnackbar } from '../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { updateCardProfile, updateCardProfileFailure, updateCardProfileSuccess, } from '../creditAgentViewReducer';
+export const updateCardProfileEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(updateCardProfile.match), mergeMap((action) => {
+    const { tenantId, tenantEmailDomain, update } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/cockpit/card-tenant-profiles`;
+    const body = {
+        tenant_namespace: tenantEmailDomain,
+    };
+    if (update.cardStatus != null) {
+        body.card_status = update.cardStatus;
+    }
+    if (update.creditLimit != null) {
+        body.credit_limit = update.creditLimit;
+    }
+    if (update.updatedByName != null) {
+        body.updated_by_name = update.updatedByName;
+    }
+    if (update.reason != null && update.reason.trim() !== '') {
+        body.reason = update.reason.trim();
+    }
+    return zeniAPI
+        .putAndGetJSON(url, body)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) &&
+            response.data != null &&
+            response.data.profile != null) {
+            return from([
+                updateCreditAgentRow({
+                    payload: response.data.profile,
+                    tenantId,
+                }),
+                updateCardProfileSuccess(tenantId),
+                openSnackbar({
+                    messageSection: 'credit_agent_update_profile',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ]);
+        }
+        else {
+            return from([
+                updateCardProfileFailure(tenantId, response.status),
+                openSnackbar({
+                    messageSection: 'credit_agent_update_profile',
+                    messageText: 'failed',
+                    type: 'error',
+                }),
+            ]);
+        }
+    }), catchError((error) => from([
+        updateCardProfileFailure(tenantId, createZeniAPIStatus('Unexpected error', 'REST API call errored out: ' + JSON.stringify(error))),
+        openSnackbar({
+            messageSection: 'credit_agent_update_profile',
+            messageText: 'failed',
+            type: 'error',
+        }),
+    ])));
+}));

package/lib/esm/view/projectList/fetchProjectListEpic.js

@@ -0,0 +1,38 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap, withLatestFrom, } from 'rxjs/operators';
+import { updateProjects } from '../../entity/project/projectReducer';
+import { getIsAccountingProjectsEnabled } from '../../entity/tenant/tenantSelector';
+import { createZeniAPIStatus, isSuccessResponse } from '../../responsePayload';
+import { fetchProjectList, updateProjectList, updateProjectListFailure, } from './projectListReducer';
+const buildProjectListQuery = (isIncludeDeleted) => {
+    const query = {
+        is_deleted: isIncludeDeleted,
+        sort_by: 'project_name',
+        sort_order: 'asc',
+        is_full: true,
+    };
+    return `?query=${encodeURIComponent(JSON.stringify(query))}`;
+};
+export const fetchProjectListEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchProjectList.match), withLatestFrom(state$), switchMap(([action, state]) => {
+    if (!getIsAccountingProjectsEnabled(state)) {
+        return of(updateProjectList({
+            status: createZeniAPIStatus('Success', ''),
+            data: { projects: [] },
+        }));
+    }
+    const { isIncludeDeleted } = action.payload;
+    const queryParams = buildProjectListQuery(isIncludeDeleted);
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/projects${queryParams}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response)) {
+            return of(updateProjects(response.data?.projects ?? []), updateProjectList(response));
+        }
+        else {
+            return of(updateProjectListFailure(response.status));
+        }
+    }), catchError((error) => {
+        return of(updateProjectListFailure(createZeniAPIStatus('Unexpected Error', 'Fetch Projects REST API call errored out' +
+            JSON.stringify(error))));
+    }));
+}));

package/lib/esm/view/projectList/projectListPayload.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/projectList/projectListReducer.js

@@ -0,0 +1,39 @@
+import { createSlice } from '@reduxjs/toolkit';
+export const initialState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    projectIds: [],
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const projectList = createSlice({
+    name: 'projectList',
+    initialState,
+    reducers: {
+        fetchProjectList: {
+            reducer(draft) {
+                draft.fetchState = 'In-Progress';
+                draft.error = undefined;
+            },
+            prepare(isIncludeDeleted) {
+                return { payload: { isIncludeDeleted: isIncludeDeleted ?? false } };
+            },
+        },
+        updateProjectList(draft, action) {
+            draft.projectIds =
+                action.payload.data?.projects?.map((project) => project.zeni_project_id) ?? [];
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+        },
+        updateProjectListFailure(draft, action) {
+            draft.fetchState = 'Error';
+            draft.error = action.payload;
+        },
+        clearProjectList(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchProjectList, updateProjectList, updateProjectListFailure, clearProjectList, } = projectList.actions;
+export default projectList.reducer;

package/lib/esm/view/projectList/projectListSelector.js

@@ -0,0 +1,9 @@
+import { getProjectsByIds } from '../../entity/project/projectSelector';
+export const getProjectList = (projectState, projectListState) => {
+    return {
+        projects: getProjectsByIds(projectState, projectListState.projectIds),
+        fetchState: projectListState.fetchState,
+        error: projectListState.error,
+        version: 0,
+    };
+};

package/lib/esm/view/projectList/projectListState.js

@@ -0,0 +1 @@
+export {};

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

@@ -51,6 +51,7 @@ export const toTransactionUpdatesFromTransactionDetailLocalData = (transactionDe
                 lineDescription: lineItem.lineDescription,
                 class: lineItem.class,
                 account: lineItem.account,
+                project: lineItem.project,
                 recommendation: convertCOTRecommendationsToRegular(lineItem.recommendationsWithCOT),
             };
             if (line.type === 'journal_entry_transaction_line' ||

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

@@ -14,6 +14,7 @@ import { fetchClassList } from '../../classList/classListReducer';
 import { getInitializedTransactionVendorLocalData } from '../../commonVendorView/transactionVendorView/transactionVendorLocalDataHelper';
 import { updateTransactionVendorLocalData } from '../../commonVendorView/transactionVendorView/transactionVendorViewReducer';
 import { fetchOwnerList } from '../../ownerList/ownerListReducer';
+import { fetchProjectList } from '../../projectList/projectListReducer';
 import { fetchTransactionDetail, initializeTransactionDetailLocalData, removeTransactionDetail, updateTransactionDetailFetchState, } from '../transactionDetailReducer';
 import { getAllLinkedTransactions, getTransactionDetailKey, } from '../transactionDetailState';
 export const fetchTransactionDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchTransactionDetail.match), mergeMap((action) => {
@@ -39,6 +40,11 @@ export const fetchTransactionDetailEpic = (actions$, state$, zeniAPI) => actions
             classList.fetchState !== 'In-Progress') {
             transactionActions.push(fetchClassList());
         }
+        const projectList = state$.value.projectListState;
+        if (projectList.hasValidState() === false &&
+            projectList.fetchState !== 'In-Progress') {
+            transactionActions.push(fetchProjectList());
+        }
         transactionActions.push(updateTransactionDetailFetchState(transactionId, 'In-Progress'));
         const query = { transaction_type: transactionId.type };
         const getTransactionDetail$ = zeniAPI

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

@@ -181,6 +181,9 @@ const toTransactionUpdatePayload = (updates, detail, cotTransactionTracking, ven
                 if (lineUpdates.account != null) {
                     lineTobeUpdated.account = lineUpdates.account;
                 }
+                if (lineUpdates.project != null) {
+                    lineTobeUpdated.project = lineUpdates.project;
+                }
                 if (lineUpdates.customer != null) {
                     lineTobeUpdated.customer = lineUpdates.customer;
                 }

package/lib/esm/view/transactionDetail/transactionDetailSelector.js

@@ -1,6 +1,6 @@
 import recordGet from 'lodash/get';
 import { reduceFetchState } from '../../commonStateTypes/reduceFetchState';
-import { getIsAccountingClassesEnabled } from '../../entity/tenant/tenantSelector';
+import { getIsAccountingClassesEnabled, getIsAccountingProjectsEnabled, } from '../../entity/tenant/tenantSelector';
 import { toTransactionTypeStrict } from '../../entity/transaction/stateTypes/transactionType';
 import { getTransactionWithCOT } from '../../entity/transaction/transactionHelper';
 import { getSupportedTransactionById } from '../../entity/transaction/transactionSelector';
@@ -8,9 +8,10 @@ import { getVendorsByVendorIds } from '../../entity/vendor/vendorSelector';
 import { dateNow } from '../../zeniDayJS';
 import { getAccountList, getNestedAccountListHierarchy, } from '../accountList/accountListSelector';
 import { getClassList, getNestedClassListHierarchy, } from '../classList/classListSelector';
+import { getProjectList, } from '../projectList/projectListSelector';
 import { getAllLinkedTransactions, getTransactionDetailKey, initialSupportedTransactionDetail, } from './transactionDetailState';
 export const getTransactionDetail = (state, transactionId, fetchLinkedTransactions = true) => {
-    const { transactionDetailState, transactionState, vendorState, vendorListState, accountState, classState, classListState, accountListState, } = state;
+    const { transactionDetailState, transactionState, vendorState, vendorListState, accountState, classState, classListState, accountListState, projectState, projectListState, } = state;
     const detailKey = getTransactionDetailKey(transactionId);
     const transactionDetail = recordGet(transactionDetailState.transactionDetailById, detailKey);
     let fetchState = {
@@ -56,6 +57,15 @@ export const getTransactionDetail = (state, transactionId, fetchLinkedTransactio
     const classList = isAccountingClassesEnabled
         ? getClassList(classState, classListState)
         : { classes: [], nestedClassHierarchy: [], fetchState: 'Completed', error: undefined, version: 0 };
+    const isAccountingProjectsEnabled = getIsAccountingProjectsEnabled(state);
+    const projectList = isAccountingProjectsEnabled
+        ? getProjectList(projectState, projectListState)
+        : {
+            projects: [],
+            fetchState: 'Completed',
+            error: undefined,
+            version: 0,
+        };
     const accountsHierarchyList = getNestedAccountListHierarchy(accountListState, 'accountList');
     const classHierarchyList = isAccountingClassesEnabled
         ? getNestedClassListHierarchy(classListState)
@@ -78,6 +88,8 @@ export const getTransactionDetail = (state, transactionId, fetchLinkedTransactio
         accountsHierarchyList,
         classList: classList,
         isAccountingClassesEnabled,
+        isAccountingProjectsEnabled,
+        projectList,
         isUpdateNotAllowed: transactionDetail?.isUpdateNotAllowed,
         transactionDetailLocalData: transactionDetail?.transactionDetailLocalData ??
             initialSupportedTransactionDetail.transactionDetailLocalData,

package/lib/esm/view/transactionList/fetchTransactionListByProjectEpic.js

@@ -0,0 +1,45 @@
+import { toBase64 } from 'js-base64';
+import lodashGet from 'lodash/get';
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { toString } from '../../commonStateTypes/timePeriod';
+import { updateTransactions } from '../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse } from '../../responsePayload';
+import { fetchProjectTransactionList, updateTransactionListByProject, updateTransactionListByProjectFailure, } from './transactionListReducer';
+import { getProjectAcTranKey } from './transactionListState';
+export const fetchTransactionListByProjectEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchProjectTransactionList.match), mergeMap((action) => {
+    const state = state$.value;
+    const key = getProjectAcTranKey(action.payload.accountId, action.payload.accountType, action.payload.projectId, action.payload.period);
+    const projectTransactions = lodashGet(state.transactionListState.byProject.transactionListByProjectKey, key, undefined);
+    if (action.payload.cacheOverride === true ||
+        projectTransactions == null ||
+        projectTransactions.hasValidState() === false) {
+        const queryParam = {
+            start_date: toString(action.payload.period.start),
+            end_date: toString(action.payload.period.end),
+            sort_by: 'create_time',
+            sort_order: 'desc',
+            account_id: action.payload.accountId,
+            account_type: action.payload.accountType,
+            zeni_project_id: action.payload.projectId,
+        };
+        const base64AccountId = toBase64(action.payload.accountId);
+        return zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/accounts/${base64AccountId}/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
+            .pipe(mergeMap((response) => {
+            if (isSuccessResponse(response) && response.data != null) {
+                const updateActions = [];
+                updateActions.push(updateTransactions(response.data.account.transactions, (value) => value.transaction_id));
+                updateActions.push(updateTransactionListByProject(response.data));
+                return from(updateActions);
+            }
+            else {
+                return of(updateTransactionListByProjectFailure(action.payload.accountId, action.payload.accountType, action.payload.projectId, action.payload.period, response.status));
+            }
+        }), catchError((error) => of(updateTransactionListByProjectFailure(action.payload.accountId, action.payload.accountType, action.payload.projectId, action.payload.period, createZeniAPIStatus('Unexpected Error', 'fetch transaction list REST API call errored out' +
+            JSON.stringify(error))))));
+    }
+    else {
+        return from([]);
+    }
+}));

package/lib/esm/view/transactionList/parallelFetchProjectTransactionListEpic.js

@@ -0,0 +1,32 @@
+import { from } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { splitPeriod } from './parallelFetchClassTransactionListEpic';
+import { fetchProjectTransactionList, parallelFetchProjectTransactionList, } from './transactionListReducer';
+import { getProjectAcTranKey, } from './transactionListState';
+export const parallelFetchProjectTransactionListEpic = (actions$, state$) => actions$.pipe(filter(parallelFetchProjectTransactionList.match), 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.byProject, action.payload.accountId, action.payload.accountType, action.payload.projectId, value) === false);
+        }
+        else {
+            return true;
+        }
+    });
+    if (filteredTimePeriods.length > 12) {
+        console.error('Only maximum 12 parallel fetch are allowed!');
+        return from([]);
+    }
+    else {
+        const fetchActions = filteredTimePeriods.map((period) => fetchProjectTransactionList(action.payload.accountId, action.payload.accountType, action.payload.projectId, period, true));
+        return from(fetchActions);
+    }
+}));
+function isDataAvailableOrFetching(state, accountId, accountType, projectId, period) {
+    const key = getProjectAcTranKey(accountId, accountType, projectId, period);
+    const projectTransactions = state.transactionListByProjectKey[key];
+    return (projectTransactions != null &&
+        (projectTransactions.fetchState === 'In-Progress' ||
+            projectTransactions.hasValidState()));
+}

package/lib/esm/view/transactionList/transactionListByProjectSelector.js

@@ -0,0 +1,58 @@
+import flatMap from 'lodash/flatMap';
+import recordGet from 'lodash/get';
+import orderBy from 'lodash/orderBy';
+import { getSupportedTransactionById } from '../../entity/transaction/transactionSelector';
+import { splitPeriod } from './parallelFetchAccountTransactionListEpic';
+import { isAnyFetchCompleted, reduceFetchState, } from './reduceTransactionListFetchState';
+import { getProjectAcKey, getProjectAcTranKey, } from './transactionListState';
+export const getTransactionListByProject = (transactionState, transactionListState, accountId, accountType, projectId, timeframe, filterByTimePeriod) => {
+    const timePeriods = splitPeriod(filterByTimePeriod); // Note: Split by months.
+    const accountTransactions = timePeriods
+        .map((thisTimePeriod) => {
+        const key = getProjectAcTranKey(accountId, accountType, projectId, thisTimePeriod);
+        return recordGet(transactionListState.byProject.transactionListByProjectKey, key, undefined);
+    })
+        .filter((acTransaction) => acTransaction != null);
+    let account = undefined;
+    if (accountTransactions.length > 0) {
+        account = accountTransactions[0].account;
+    }
+    const fetchState = reduceFetchState(accountTransactions);
+    let transactions = [];
+    if (isAnyFetchCompleted(accountTransactions)) {
+        const allTransactionIDs = flatMap(accountTransactions, (value) => value.transactionIDs);
+        const transactionsUnsorted = allTransactionIDs
+            .map((transactionId) => getSupportedTransactionById(transactionState, transactionId))
+            .filter((value) => {
+            if (value == null) {
+                console.error("Can't have null transaction at this stage!");
+            }
+            return value != null;
+        });
+        transactions = orderBy(transactionsUnsorted, (value) => value.date.valueOf(), 'desc');
+    }
+    const key = getProjectAcKey(accountId, accountType, projectId);
+    const uiState = recordGet(transactionListState.byProject.transactionListUIStateByProjectKey, key, {});
+    return {
+        reportId: 'transaction_list_of_account_by_project',
+        reportTitle: 'Transaction List of Account By Project',
+        version: 1,
+        status: undefined,
+        fetchState: fetchState.fetchState,
+        error: fetchState.error,
+        timeframe,
+        filterByTimePeriod,
+        accountId,
+        accountType,
+        projectId,
+        account,
+        transactionOrder: 'descending_transaction_date',
+        transactions,
+        uiState,
+        latestTransactionId: transactionListState.latestTransactionId,
+    };
+};
+export const getTransactionListUIStateByProjectKey = (transactionListState, accountId, accountType, projectId) => {
+    const key = getProjectAcKey(accountId, accountType, projectId);
+    return recordGet(transactionListState.byProject.transactionListUIStateByProjectKey, key, undefined);
+};