@zeniai/client-epic-state 5.2.41 → 5.2.42-betaAK0

package/lib/esm/view/expenseAutomationView/reducers/actualMatchingViewReducer.js

@@ -0,0 +1,462 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { toMonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
+import { generateJEOneTimeAccrualKey } from '../../../entity/jeSchedules/jeScheduleHelper';
+import { createZeniAPIStatus } from '../../../responsePayload';
+import { clearAll } from '../../../rootActions';
+import { actualMatchingTransactionLineKey, isMatchAndReverseCompleteStatus } from '../types/actualMatchingViewState';
+export const initialTransactionSearchState = {
+    query: '',
+    results: [],
+    fetchState: 'Not-Started',
+    error: undefined,
+    nextPageToken: null,
+    isLoadingMore: false,
+};
+export const initialAccrualSearchState = {
+    query: '',
+    results: [],
+    fetchState: 'Not-Started',
+    error: undefined,
+    nextPageToken: null,
+    isLoadingMore: false,
+};
+export const initialMatchModalState = {
+    isOpen: false,
+    openedFromMatchId: undefined,
+    didPinPrefillTransactions: false,
+    pinnedTransactionResults: [],
+    transactionSearch: initialTransactionSearchState,
+    accrualSearch: initialAccrualSearchState,
+    confirmStatus: { fetchState: 'Not-Started', error: undefined },
+};
+export const initialState = {
+    matchIdsByPeriod: {},
+    fetchState: 'Not-Started',
+    error: undefined,
+    refreshStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    detailFetchStateByMatchId: {},
+    detailRefreshStatusByMatchId: {},
+    uiState: {
+        sortKey: 'date',
+        sortOrder: 'descending',
+        searchString: '',
+        scrollPosition: { scrollTop: 0, scrollLeft: undefined },
+    },
+    matchModal: initialMatchModalState,
+    undoReversalStatusByMatchId: {},
+    closeMatchAfterUndo: false,
+    lastMatchResultsByMatchId: {},
+    lastUndoResultsByMatchId: {},
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+function pruneLastMatchResultsForUndone(draft, matchId, results) {
+    const undoneIds = new Set(results
+        .filter((result) => result.status === 'undone')
+        .map((result) => result.accrualId));
+    if (undoneIds.size === 0) {
+        return;
+    }
+    const existing = draft.lastMatchResultsByMatchId[matchId];
+    if (existing == null) {
+        return;
+    }
+    const kept = existing.filter((result) => !undoneIds.has(result.accrualId));
+    if (kept.length === 0) {
+        delete draft.lastMatchResultsByMatchId[matchId];
+        return;
+    }
+    draft.lastMatchResultsByMatchId[matchId] = kept;
+}
+function pruneLastUndoResultsForMatched(draft, matchId, results) {
+    const matchedIds = new Set(results.map((result) => result.accrualId));
+    if (matchedIds.size === 0) {
+        return;
+    }
+    const existing = draft.lastUndoResultsByMatchId[matchId];
+    if (existing == null) {
+        return;
+    }
+    const kept = existing.filter((result) => !matchedIds.has(result.accrualId));
+    if (kept.length === 0) {
+        delete draft.lastUndoResultsByMatchId[matchId];
+        return;
+    }
+    draft.lastUndoResultsByMatchId[matchId] = kept;
+}
+function resetMatchModalSearches(draft) {
+    draft.matchModal.transactionSearch = initialTransactionSearchState;
+    draft.matchModal.accrualSearch = initialAccrualSearchState;
+    draft.matchModal.confirmStatus = {
+        fetchState: 'Not-Started',
+        error: undefined,
+    };
+    draft.matchModal.lastBatchResults = undefined;
+    draft.matchModal.openedFromMatchId = undefined;
+    draft.matchModal.didPinPrefillTransactions = false;
+    draft.matchModal.pinnedTransactionResults = [];
+}
+const expenseAutomationActualMatchingView = createSlice({
+    name: 'expenseAutomationActualMatchingView',
+    initialState,
+    reducers: {
+        fetchActualMatchingPage: {
+            prepare(period, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        period,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+            reducer() {
+                // Epic-only fan-out.
+            },
+        },
+        fetchActualMatching: {
+            reducer(draft, action) {
+                const { refreshViewInBackground } = action.payload;
+                if (refreshViewInBackground) {
+                    draft.refreshStatus = { fetchState: 'In-Progress', error: undefined };
+                    if (draft.fetchState === 'Not-Started') {
+                        draft.fetchState = 'In-Progress';
+                    }
+                }
+                else {
+                    draft.fetchState = 'In-Progress';
+                    draft.error = undefined;
+                }
+            },
+            prepare(period, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        period,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+        },
+        fetchActualMatchingSuccess(draft, action) {
+            const { matchIds, selectedPeriod, refreshViewInBackground } = action.payload;
+            const periodId = toMonthYearPeriodId(selectedPeriod);
+            draft.matchIdsByPeriod[periodId] = matchIds;
+            if (refreshViewInBackground) {
+                draft.refreshStatus = { fetchState: 'Completed', error: undefined };
+                if (draft.fetchState !== 'Completed') {
+                    draft.fetchState = 'Completed';
+                    draft.error = undefined;
+                }
+            }
+            else {
+                draft.fetchState = 'Completed';
+                draft.error = undefined;
+            }
+        },
+        fetchActualMatchingFailure(draft, action) {
+            const { status, refreshViewInBackground, selectedPeriod } = action.payload;
+            const periodId = toMonthYearPeriodId(selectedPeriod);
+            // Stamp an empty slot so the selector does not remap this month's Error
+            // to leftover Not-Started chrome. Do not clobber ids from a prior success.
+            if (draft.matchIdsByPeriod[periodId] == null) {
+                draft.matchIdsByPeriod[periodId] = [];
+            }
+            if (refreshViewInBackground) {
+                draft.refreshStatus = { fetchState: 'Error', error: status };
+                if (draft.fetchState !== 'Completed') {
+                    draft.fetchState = 'Error';
+                    draft.error = status;
+                }
+            }
+            else {
+                draft.fetchState = 'Error';
+                draft.error = status;
+            }
+        },
+        fetchActualMatchingMatch: {
+            prepare(matchId, refreshViewInBackground = false) {
+                return { payload: { matchId, refreshViewInBackground } };
+            },
+            reducer(draft, action) {
+                const { matchId, refreshViewInBackground } = action.payload;
+                if (refreshViewInBackground) {
+                    draft.detailRefreshStatusByMatchId[matchId] = {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                }
+                else {
+                    draft.detailFetchStateByMatchId[matchId] = {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                }
+            },
+        },
+        fetchActualMatchingMatchSuccess(draft, action) {
+            const { matchId, refreshViewInBackground } = action.payload;
+            if (refreshViewInBackground) {
+                draft.detailRefreshStatusByMatchId[matchId] = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
+            else {
+                draft.detailFetchStateByMatchId[matchId] = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
+        },
+        fetchActualMatchingMatchFailure(draft, action) {
+            const { matchId, refreshViewInBackground, status } = action.payload;
+            if (refreshViewInBackground) {
+                draft.detailRefreshStatusByMatchId[matchId] = {
+                    fetchState: 'Error',
+                    error: status,
+                };
+            }
+            else {
+                draft.detailFetchStateByMatchId[matchId] = {
+                    fetchState: 'Error',
+                    error: status,
+                };
+            }
+        },
+        updateActualMatchingUIState(draft, action) {
+            if (action.payload.sortKey != null) {
+                draft.uiState.sortKey = action.payload.sortKey;
+            }
+            if (action.payload.sortOrder != null) {
+                draft.uiState.sortOrder = action.payload.sortOrder;
+            }
+            if (action.payload.searchString != null) {
+                draft.uiState.searchString = action.payload.searchString;
+            }
+            if (action.payload.scrollPosition != null) {
+                draft.uiState.scrollPosition = action.payload.scrollPosition;
+            }
+        },
+        openMatchNewModal: {
+            prepare(matchId) {
+                return { payload: { matchId } };
+            },
+            reducer(draft, action) {
+                resetMatchModalSearches(draft);
+                draft.matchModal.isOpen = true;
+                const matchId = action.payload.matchId;
+                draft.matchModal.openedFromMatchId =
+                    matchId != null && matchId !== '' ? matchId : undefined;
+                if (draft.matchModal.openedFromMatchId != null) {
+                    draft.matchModal.accrualSearch.fetchState = 'Completed';
+                }
+            },
+        },
+        // Dismiss (Cancel / overlay). Store reset matches `clearMatchNewModal`;
+        // the actions stay distinct so confirm-success vs user-dismiss stay observable.
+        closeMatchNewModal(draft) {
+            draft.matchModal.isOpen = false;
+            resetMatchModalSearches(draft);
+        },
+        // Confirm-success / host reset. Same slice write as close; different action type.
+        clearMatchNewModal(draft) {
+            draft.matchModal.isOpen = false;
+            resetMatchModalSearches(draft);
+        },
+        searchMatchTransactions: {
+            reducer(draft, action) {
+                const { query, pageToken } = action.payload;
+                const isLoadMore = pageToken != null;
+                draft.matchModal.transactionSearch.query = query;
+                if (isLoadMore) {
+                    draft.matchModal.transactionSearch.isLoadingMore = true;
+                }
+                else {
+                    draft.matchModal.transactionSearch.isLoadingMore = false;
+                    draft.matchModal.transactionSearch.results = [];
+                    draft.matchModal.transactionSearch.nextPageToken = null;
+                    draft.matchModal.transactionSearch.fetchState = 'In-Progress';
+                    draft.matchModal.transactionSearch.error = undefined;
+                }
+            },
+            prepare(query, pageToken, transactionType, transactionIntegrationId) {
+                return {
+                    payload: {
+                        query,
+                        pageToken: pageToken ?? undefined,
+                        transactionType,
+                        transactionIntegrationId,
+                    },
+                };
+            },
+        },
+        searchMatchTransactionsSuccess(draft, action) {
+            const { append, nextPageToken, results } = action.payload;
+            if (append) {
+                const merged = [
+                    ...draft.matchModal.transactionSearch.results,
+                    ...results,
+                ];
+                const byKey = new Map(merged.map((result) => [
+                    actualMatchingTransactionLineKey(result.transactionType, result.transactionIntegrationId, result.lineId),
+                    result,
+                ]));
+                draft.matchModal.transactionSearch.results = Array.from(byKey.values());
+            }
+            else {
+                draft.matchModal.transactionSearch.results = results;
+                if (draft.matchModal.openedFromMatchId != null &&
+                    !draft.matchModal.didPinPrefillTransactions) {
+                    draft.matchModal.didPinPrefillTransactions = true;
+                    draft.matchModal.pinnedTransactionResults = results;
+                }
+            }
+            draft.matchModal.transactionSearch.nextPageToken = nextPageToken;
+            draft.matchModal.transactionSearch.isLoadingMore = false;
+            draft.matchModal.transactionSearch.fetchState = 'Completed';
+            draft.matchModal.transactionSearch.error = undefined;
+        },
+        searchMatchTransactionsFailure(draft, action) {
+            draft.matchModal.transactionSearch.isLoadingMore = false;
+            draft.matchModal.transactionSearch.fetchState = 'Error';
+            draft.matchModal.transactionSearch.error = action.payload.error;
+        },
+        searchMatchAccruals: {
+            reducer(draft, action) {
+                const { query, pageToken } = action.payload;
+                const isLoadMore = pageToken != null;
+                draft.matchModal.accrualSearch.query = query;
+                if (isLoadMore) {
+                    draft.matchModal.accrualSearch.isLoadingMore = true;
+                }
+                else {
+                    draft.matchModal.accrualSearch.isLoadingMore = false;
+                    draft.matchModal.accrualSearch.results = [];
+                    draft.matchModal.accrualSearch.nextPageToken = null;
+                    draft.matchModal.accrualSearch.fetchState = 'In-Progress';
+                    draft.matchModal.accrualSearch.error = undefined;
+                }
+            },
+            prepare(query, pageToken) {
+                return { payload: { query, pageToken: pageToken ?? undefined } };
+            },
+        },
+        searchMatchAccrualsSuccess(draft, action) {
+            const { append, nextPageToken, results } = action.payload;
+            const keys = results.map((accrual) => generateJEOneTimeAccrualKey(accrual._id));
+            if (append) {
+                const merged = [...draft.matchModal.accrualSearch.results, ...keys];
+                draft.matchModal.accrualSearch.results = Array.from(new Set(merged));
+            }
+            else {
+                draft.matchModal.accrualSearch.results = keys;
+            }
+            draft.matchModal.accrualSearch.nextPageToken = nextPageToken;
+            draft.matchModal.accrualSearch.isLoadingMore = false;
+            draft.matchModal.accrualSearch.fetchState = 'Completed';
+            draft.matchModal.accrualSearch.error = undefined;
+        },
+        searchMatchAccrualsFailure(draft, action) {
+            draft.matchModal.accrualSearch.isLoadingMore = false;
+            draft.matchModal.accrualSearch.fetchState = 'Error';
+            draft.matchModal.accrualSearch.error = action.payload.error;
+        },
+        matchAndReverseAccruals: {
+            reducer(draft) {
+                draft.matchModal.confirmStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(transactionId, transactionIntegrationId, transactionType, lineIds, transactionSyncToken, accrualIds) {
+                return {
+                    payload: {
+                        transactionId,
+                        transactionIntegrationId,
+                        transactionType,
+                        lineIds,
+                        transactionSyncToken,
+                        accrualIds,
+                    },
+                };
+            },
+        },
+        matchAndReverseAccrualsSuccess(draft, action) {
+            const { results } = action.payload;
+            const allComplete = results.length > 0 &&
+                results.every((result) => isMatchAndReverseCompleteStatus(result.status));
+            draft.matchModal.confirmStatus = allComplete
+                ? { fetchState: 'Completed', error: undefined }
+                : {
+                    fetchState: 'Error',
+                    error: createZeniAPIStatus('Partial match-and-reverse', 'Some accruals were not reversed'),
+                };
+            draft.matchModal.lastBatchResults = results;
+            if (action.payload.matchId != null) {
+                draft.lastMatchResultsByMatchId[action.payload.matchId] = results;
+                pruneLastUndoResultsForMatched(draft, action.payload.matchId, action.payload.results);
+            }
+        },
+        matchAndReverseAccrualsFailure(draft, action) {
+            draft.matchModal.confirmStatus = {
+                fetchState: 'Error',
+                error: action.payload.status,
+            };
+        },
+        undoReversalAccruals: {
+            reducer(draft, action) {
+                draft.undoReversalStatusByMatchId[action.payload.matchId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(matchId, accrualIds) {
+                return { payload: { matchId, accrualIds } };
+            },
+        },
+        undoReversalAccrualsSuccess: {
+            reducer(draft, action) {
+                const { matchId, results } = action.payload;
+                draft.undoReversalStatusByMatchId[matchId] = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+                const allUndone = results.length > 0 &&
+                    results.every((result) => result.status === 'undone');
+                draft.closeMatchAfterUndo = allUndone;
+                pruneLastMatchResultsForUndone(draft, matchId, results);
+                if (allUndone) {
+                    delete draft.lastUndoResultsByMatchId[matchId];
+                }
+                else {
+                    draft.lastUndoResultsByMatchId[matchId] = results;
+                }
+            },
+            prepare(matchId, results) {
+                return { payload: { matchId, results } };
+            },
+        },
+        ackCloseMatchAfterUndo(draft) {
+            draft.closeMatchAfterUndo = false;
+        },
+        undoReversalAccrualsFailure(draft, action) {
+            draft.undoReversalStatusByMatchId[action.payload.matchId] = {
+                fetchState: 'Error',
+                error: action.payload.status,
+            };
+        },
+        clearActualMatchingView(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(clearAll, (draft) => {
+            Object.assign(draft, initialState);
+        });
+    },
+});
+export const { ackCloseMatchAfterUndo, clearActualMatchingView, clearMatchNewModal, closeMatchNewModal, fetchActualMatching, fetchActualMatchingFailure, fetchActualMatchingMatch, fetchActualMatchingMatchFailure, fetchActualMatchingMatchSuccess, fetchActualMatchingPage, fetchActualMatchingSuccess, matchAndReverseAccruals, matchAndReverseAccrualsFailure, matchAndReverseAccrualsSuccess, openMatchNewModal, searchMatchAccruals, searchMatchAccrualsFailure, searchMatchAccrualsSuccess, searchMatchTransactions, searchMatchTransactionsFailure, searchMatchTransactionsSuccess, undoReversalAccruals, undoReversalAccrualsFailure, undoReversalAccrualsSuccess, updateActualMatchingUIState, } = expenseAutomationActualMatchingView.actions;
+export default expenseAutomationActualMatchingView.reducer;

package/lib/esm/view/expenseAutomationView/reducers/jeSchedulesViewReducer.js

@@ -105,11 +105,12 @@ const expenseAutomationJESchedulesView = createSlice({
     initialState,
     reducers: {
         fetchJeSchedulesPage: {
-            prepare(period, refreshViewInBackground = false) {
+            prepare(period, refreshViewInBackground = false, isAccrualEnabled = false) {
                 return {
                     payload: {
                         period,
                         refreshViewInBackground,
+                        isAccrualEnabled,
                     },
                 };
             },

package/lib/esm/view/expenseAutomationView/selectorTypes/actualMatchingViewSelectorTypes.js

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