@zeniai/client-epic-state 5.0.37 → 5.0.38-betaNB1

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

@@ -2,6 +2,7 @@ import { createSlice } from '@reduxjs/toolkit';
 import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { toReconciliationAccountSource } from '../../../entity/account/accountState';
 import { toBankStatusCodeType } from '../../../entity/accountRecon/accountReconState';
+import { toReconciliationViewSummary, } from '../types/reconciliationViewState';
 // Initial state
 export const initialReconciliationTabsState = {
     balances: {
@@ -75,6 +76,7 @@ export const initialState = {
         },
     },
     excludedAccountIDs: [],
+    summary: undefined,
 };
 // Create slice with reducers
 const expenseAutomationReconciliationView = createSlice({
@@ -143,7 +145,7 @@ const expenseAutomationReconciliationView = createSlice({
         fetchReconciliationSuccess: {
             reducer(draft, action) {
                 if (action.payload.accountId == null) {
-                    updateAllReconciliation(draft, action.payload.reconciliation.accounts, action.payload.selectedPeriod, action.payload.reconciliation.reconciliation, action.payload.refreshViewInBackground, action.payload.reconciliation.excluded_accounts ?? []);
+                    updateAllReconciliation(draft, action.payload.reconciliation.accounts, action.payload.selectedPeriod, action.payload.reconciliation.reconciliation, action.payload.refreshViewInBackground, action.payload.reconciliation.excluded_accounts ?? [], action.payload.reconciliation.summary);
                 }
                 else if (action.payload.reconciliation.reconciliation.length > 0 &&
                     action.payload.reconciliation.accounts.length > 0) {
@@ -527,7 +529,7 @@ const expenseAutomationReconciliationView = createSlice({
 export const { fetchReconciliation, fetchReconciliationFailure, fetchReconciliationSuccess, saveReconciliationDetail, saveReconciliationDetailFailure, updateSelectedAccountId, setConnectionInProgressForAccount, setStatementParseInProgress, updateReconcileTabLocalData, updateReconcileTabListSortState, updateReconcileTabListScrollState, saveReconciliationDetailSuccess, updateSelectedTab, updateBalancesLocalData, initialiseLocalDataForSelectedAccountId, clearExpenseAutomationReconciliationView, updateSelectedDrawerAccountId, updateReviewTabSortState, initializeReconciliationReviewTabLocalData, updateReviewTabLocalData, saveReconciliationReview, updateSaveReconciliationReviewFetchStatus, updateReconListScrollPosition, updateAccountReconciliationLocalData, deleteAccountStatement, deleteAccountStatementSuccess, deleteAccountStatementFailure, excludeAccountFromReconciliation, excludeAccountFromReconciliationSuccess, excludeAccountFromReconciliationFailure, includeAccountInReconciliation, includeAccountInReconciliationSuccess, includeAccountInReconciliationFailure, uploadAccountStatement, uploadAccountStatementSuccess, uploadAccountStatementFailure, updateStatementUploadChosen, updateNodeCollapseState, } = expenseAutomationReconciliationView.actions;
 // Export reducer
 export default expenseAutomationReconciliationView.reducer;
-function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground, excludedAccounts) {
+function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground, excludedAccounts, summary) {
     draft.excludedAccountIDs = excludedAccounts.map((ea) => ea.account_id);
     draft.excludedAccountExclusionInfo = {};
     excludedAccounts.forEach((ea) => {
@@ -609,6 +611,9 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
         draft.fetchState = 'Completed';
         draft.error = undefined;
     }
+    if (summary !== undefined) {
+        draft.summary = toReconciliationViewSummary(summary);
+    }
 }
 function updateReconciliationByAccountID(draft, accounts, selectedPeriod, accountId, reconciliationData, refreshViewInBackground) {
     const oldRecord = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId];

package/lib/esm/view/expenseAutomationView/selectors/reconciliationViewSelector.js

@@ -115,6 +115,7 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
             excludeAccountFetchState: reconciliationViewState.actionFetchState.excludeAccountFetch,
             includeAccountFetchState: reconciliationViewState.actionFetchState.includeAccountFetch,
             excludedAccountIDs: reconciliationViewState.excludedAccountIDs,
+            summary: reconciliationViewState.summary,
         };
     }
     const allAccountIDs = accountReconForMonthYearPeriod.accountIDs;
@@ -423,6 +424,7 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
         excludeAccountFetchState: reconciliationViewState.actionFetchState.excludeAccountFetch,
         includeAccountFetchState: reconciliationViewState.actionFetchState.includeAccountFetch,
         excludedAccountIDs: reconciliationViewState.excludedAccountIDs,
+        summary: reconciliationViewState.summary,
     };
 });
 export const isAccountReconReport = (reportId) => {

package/lib/esm/view/expenseAutomationView/types/reconciliationViewState.js

@@ -1,4 +1,24 @@
 import { stringToUnion } from '../../../commonStateTypes/stringToUnion';
+export function toReconciliationViewSummary(payload) {
+    return {
+        accounts: {
+            done: payload.accounts.done,
+            failed: payload.accounts.failed,
+            inProgress: payload.accounts.in_progress,
+            total: payload.accounts.total,
+        },
+        accountsToConnectCount: payload.accounts_to_connect_count,
+        autoMatched: {
+            matchedTxns: payload.auto_matched.matched_txns,
+            totalTxns: payload.auto_matched.total_txns,
+        },
+        needsReview: {
+            accountCount: payload.needs_review.account_count,
+            txnCount: payload.needs_review.txn_count,
+        },
+        timeSavedPercentage: payload.time_saved_percentage,
+    };
+}
 export const RECONCILE_ACTIONS = [
     'reconcile',
     'save_reconcile_for_later',

package/lib/esm/view/featureNotificationView/epics/fetchRegisteredInterestsEpic.js

@@ -0,0 +1,23 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { toFeatureInterest, } from '../featureNotificationViewPayload';
+import { fetchRegisteredInterests, fetchRegisteredInterestsFailure, fetchRegisteredInterestsSuccess, } from '../featureNotificationViewReducer';
+export const fetchRegisteredInterestsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchRegisteredInterests.match), switchMap((action) => zeniAPI
+    .getJSON(`${zeniAPI.apiEndPoints.notificationMicroServiceBaseUrl}/1.0/feature-interests?feature=${encodeURIComponent(action.payload.feature)}`)
+    .pipe(mergeMap((response) => {
+    if (isSuccessResponse(response) && response.data != null) {
+        const interests = response.data.feature_interests.map(toFeatureInterest);
+        return from([fetchRegisteredInterestsSuccess(interests)]);
+    }
+    const status = response.status ??
+        createZeniAPIStatus('Failed to fetch registered interests. Please try again.');
+    return from([fetchRegisteredInterestsFailure(status)]);
+}), catchError((error) => {
+    const message = error instanceof Error
+        ? error.message
+        : 'Unexpected error fetching registered interests.';
+    return from([
+        fetchRegisteredInterestsFailure(createZeniAPIStatus(message)),
+    ]);
+}))));

package/lib/esm/view/featureNotificationView/epics/notifyMeForFeatureEpic.js

@@ -0,0 +1,25 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { notifyMeForFeature, notifyMeForFeatureFailure, notifyMeForFeatureSuccess, } from '../featureNotificationViewReducer';
+export const notifyMeForFeatureEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(notifyMeForFeature.match), switchMap((action) => zeniAPI
+    .postAndGetJSON(`${zeniAPI.apiEndPoints.notificationMicroServiceBaseUrl}/1.0/feature-interests`, {
+    additional_info: action.payload.additionalInfo,
+    email: action.payload.email,
+    feature: action.payload.feature,
+})
+    .pipe(mergeMap((response) => {
+    if (isSuccessResponse(response) && response.data != null) {
+        return from([notifyMeForFeatureSuccess(response.data)]);
+    }
+    const status = response.status ??
+        createZeniAPIStatus('Failed to register interest. Please try again.');
+    return from([notifyMeForFeatureFailure(status)]);
+}), catchError((error) => {
+    const message = error instanceof Error
+        ? error.message
+        : 'Unexpected error registering interest.';
+    return from([
+        notifyMeForFeatureFailure(createZeniAPIStatus(message)),
+    ]);
+}))));

package/lib/esm/view/featureNotificationView/featureNotificationViewPayload.js

@@ -0,0 +1,11 @@
+import { date } from '../../zeniDayJS';
+export const toFeatureInterest = (payload) => ({
+    interestId: payload.interest_id,
+    feature: payload.feature,
+    notified: payload.notified,
+    createTime: date(payload.create_time),
+    updateTime: date(payload.update_time),
+    additionalInfo: payload.additional_info ?? undefined,
+    email: payload.email ?? undefined,
+    notifiedTime: payload.notified_time != null ? date(payload.notified_time) : undefined,
+});

package/lib/esm/view/featureNotificationView/featureNotificationViewReducer.js

@@ -0,0 +1,106 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { toFeatureInterest, } from './featureNotificationViewPayload';
+export const initialState = {
+    fetchRegisteredInterestsState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    notifyMeForFeatureState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    registeredInterests: [],
+};
+const featureNotificationView = createSlice({
+    name: 'featureNotificationView',
+    initialState,
+    reducers: {
+        notifyMeForFeature: {
+            prepare(feature, additionalInfo, email) {
+                return { payload: { feature, additionalInfo, email } };
+            },
+            reducer(draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                draft.notifyMeForFeatureState = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+        },
+        notifyMeForFeatureSuccess: {
+            prepare(payload) {
+                return { payload };
+            },
+            reducer(draft, action) {
+                draft.notifyMeForFeatureState = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+                const interest = toFeatureInterest(action.payload);
+                // Idempotent: if a row for this (feature, additional_info) already
+                // exists in the slice, replace it; otherwise append.
+                const existingIndex = draft.registeredInterests.findIndex((r) => r.feature === interest.feature &&
+                    r.additionalInfo === interest.additionalInfo);
+                if (existingIndex >= 0) {
+                    draft.registeredInterests[existingIndex] = interest;
+                }
+                else {
+                    draft.registeredInterests.push(interest);
+                }
+            },
+        },
+        notifyMeForFeatureFailure: {
+            prepare(status) {
+                return { payload: { status } };
+            },
+            reducer(draft, action) {
+                draft.notifyMeForFeatureState = {
+                    fetchState: 'Error',
+                    error: action.payload.status,
+                };
+            },
+        },
+        fetchRegisteredInterests: {
+            prepare(feature) {
+                return { payload: { feature } };
+            },
+            reducer(draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                draft.fetchRegisteredInterestsState = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+        },
+        fetchRegisteredInterestsSuccess: {
+            prepare(interests) {
+                return { payload: { interests } };
+            },
+            reducer(draft, action) {
+                draft.fetchRegisteredInterestsState = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+                draft.registeredInterests = action.payload.interests;
+            },
+        },
+        fetchRegisteredInterestsFailure: {
+            prepare(status) {
+                return { payload: { status } };
+            },
+            reducer(draft, action) {
+                draft.fetchRegisteredInterestsState = {
+                    fetchState: 'Error',
+                    error: action.payload.status,
+                };
+            },
+        },
+        clearFeatureNotificationView(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { clearFeatureNotificationView, fetchRegisteredInterests, fetchRegisteredInterestsFailure, fetchRegisteredInterestsSuccess, notifyMeForFeature, notifyMeForFeatureFailure, notifyMeForFeatureSuccess, } = featureNotificationView.actions;
+export default featureNotificationView.reducer;

package/lib/esm/view/featureNotificationView/featureNotificationViewSelector.js

@@ -0,0 +1,4 @@
+export const getFeatureNotificationView = (state) => state.featureNotificationViewState;
+export const getRegisteredInterests = (state) => state.featureNotificationViewState.registeredInterests;
+export const getRegisteredInterestsByFeature = (state, feature) => state.featureNotificationViewState.registeredInterests.filter((interest) => interest.feature === feature);
+export const isFeatureInterestRegistered = (state, feature, additionalInfo) => state.featureNotificationViewState.registeredInterests.some((interest) => interest.feature === feature && interest.additionalInfo === additionalInfo);

package/lib/esm/view/featureNotificationView/featureNotificationViewState.js

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

package/lib/esm/view/taskManager/cannedResponsesView/cannedResponses.js

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

package/lib/esm/view/taskManager/cannedResponsesView/cannedResponsesPayload.js

@@ -0,0 +1,12 @@
+import { date } from '../../../zeniDayJS';
+export function mapCannedResponsePayloadToCannedResponse(payload) {
+    return {
+        cannedResponseId: payload.canned_response_id,
+        content: payload.content,
+        createTime: date(payload.create_time),
+        createdBy: payload.created_by,
+        isDeleted: payload.is_deleted,
+        name: payload.name,
+        updateTime: date(payload.update_time),
+    };
+}

package/lib/esm/view/taskManager/cannedResponsesView/cannedResponsesReducer.js

@@ -0,0 +1,64 @@
+import { createSlice } from '@reduxjs/toolkit';
+export const initialState = {
+    cannedResponses: [],
+    fetchState: 'Not-Started',
+    saveFetchState: 'Not-Started',
+    deleteFetchState: 'Not-Started',
+    error: undefined,
+};
+const cannedResponsesView = createSlice({
+    name: 'cannedResponsesView',
+    initialState,
+    reducers: {
+        fetchCannedResponses(draft) {
+            draft.fetchState =
+                draft.cannedResponses.length > 0 ? 'Completed' : 'In-Progress';
+            draft.error = undefined;
+        },
+        updateCannedResponses(draft, action) {
+            draft.cannedResponses = action.payload.cannedResponses;
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+        },
+        updateCannedResponsesFetchStatus(draft, action) {
+            draft.fetchState = action.payload.fetchState;
+            draft.error = action.payload.error;
+        },
+        saveCannedResponse: {
+            reducer(draft) {
+                draft.saveFetchState = 'In-Progress';
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        saveCannedResponseSuccess(draft) {
+            draft.saveFetchState = 'Completed';
+        },
+        saveCannedResponseFailure(draft, action) {
+            draft.saveFetchState = 'Error';
+            draft.error = action.payload.error;
+        },
+        deleteCannedResponse: {
+            reducer(draft) {
+                draft.deleteFetchState = 'In-Progress';
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        deleteCannedResponseSuccess(draft, action) {
+            draft.deleteFetchState = 'Completed';
+            draft.cannedResponses = draft.cannedResponses.filter((r) => r.cannedResponseId !== action.payload.cannedResponseId);
+        },
+        deleteCannedResponseFailure(draft, action) {
+            draft.deleteFetchState = 'Error';
+            draft.error = action.payload.error;
+        },
+        clearCannedResponses() {
+            return initialState;
+        },
+    },
+});
+export const { fetchCannedResponses, updateCannedResponses, updateCannedResponsesFetchStatus, saveCannedResponse, saveCannedResponseSuccess, saveCannedResponseFailure, deleteCannedResponse, deleteCannedResponseSuccess, deleteCannedResponseFailure, clearCannedResponses, } = cannedResponsesView.actions;
+export default cannedResponsesView.reducer;

package/lib/esm/view/taskManager/cannedResponsesView/cannedResponsesSelector.js

@@ -0,0 +1,3 @@
+export function getCannedResponsesView(state) {
+    return state.cannedResponsesState;
+}

package/lib/esm/view/taskManager/cannedResponsesView/epics/deleteCannedResponseEpic.js

@@ -0,0 +1,17 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { deleteCannedResponse, deleteCannedResponseFailure, deleteCannedResponseSuccess, } from '../cannedResponsesReducer';
+export const deleteCannedResponseEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(deleteCannedResponse.match), mergeMap((action) => {
+    const { cannedResponseId } = action.payload;
+    return zeniAPI
+        .deleteAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/canned-responses/${cannedResponseId}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response)) {
+            return of(deleteCannedResponseSuccess({ cannedResponseId }));
+        }
+        return of(deleteCannedResponseFailure({ error: response.status }));
+    }), catchError((error) => of(deleteCannedResponseFailure({
+        error: createZeniAPIStatus('Unexpected Error', 'Delete Canned Response errored: ' + JSON.stringify(error)),
+    }))));
+}));

package/lib/esm/view/taskManager/cannedResponsesView/epics/fetchCannedResponsesEpic.js

@@ -0,0 +1,21 @@
+import { of } from 'rxjs';
+import { catchError, filter, switchMap, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { mapCannedResponsePayloadToCannedResponse, } from '../cannedResponsesPayload';
+import { fetchCannedResponses, updateCannedResponses, updateCannedResponsesFetchStatus, } from '../cannedResponsesReducer';
+export const fetchCannedResponsesEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCannedResponses.match), switchMap(() => zeniAPI
+    .getJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/canned-responses`)
+    .pipe(mergeMap((response) => {
+    if (isSuccessResponse(response) && response.data != null) {
+        return of(updateCannedResponses({
+            cannedResponses: (response.data.canned_responses ?? []).map(mapCannedResponsePayloadToCannedResponse),
+        }));
+    }
+    return of(updateCannedResponsesFetchStatus({
+        fetchState: 'Error',
+        error: response.status,
+    }));
+}), catchError((error) => of(updateCannedResponsesFetchStatus({
+    fetchState: 'Error',
+    error: createZeniAPIStatus('Unexpected Error', 'Fetch Canned Responses errored: ' + JSON.stringify(error)),
+}))))));

package/lib/esm/view/taskManager/cannedResponsesView/epics/saveCannedResponseEpic.js

@@ -0,0 +1,29 @@
+import { of } from 'rxjs';
+import { catchError, filter, switchMap, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchCannedResponses, saveCannedResponse, saveCannedResponseFailure, saveCannedResponseSuccess, } from '../cannedResponsesReducer';
+export const saveCannedResponseEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(saveCannedResponse.match), switchMap((action) => {
+    const { name, content, cannedResponseId } = action.payload;
+    const isUpdate = cannedResponseId != null;
+    const url = isUpdate
+        ? `${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/canned-responses/${cannedResponseId}`
+        : `${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/canned-responses`;
+    const apiCall = isUpdate
+        ? zeniAPI.putAndGetJSON(url, {
+            name,
+            content,
+        })
+        : zeniAPI.postAndGetJSON(url, {
+            name,
+            content,
+        });
+    return apiCall.pipe(mergeMap((response) => {
+        if (isSuccessResponse(response)) {
+            return of(saveCannedResponseSuccess(), fetchCannedResponses() // Refresh list after save
+            );
+        }
+        return of(saveCannedResponseFailure({ error: response.status }));
+    }), catchError((error) => of(saveCannedResponseFailure({
+        error: createZeniAPIStatus('Unexpected Error', 'Save Canned Response errored: ' + JSON.stringify(error)),
+    }))));
+}));

package/lib/esm/view/taskManager/taskDetailView/epics/archiveTaskEpic.js

@@ -4,6 +4,7 @@ import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
 import { updateTasks } from '../../../../entity/task/taskReducer';
 import { getTaskById } from '../../../../entity/task/taskSelector';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchTaskList, removeTaskFromList, } from '../../taskListView/taskListReducer';
 import { archiveTask, archiveTaskSuccessOrFailure } from '../taskDetailReducer';
 // Epic function to handle archiving of tasks
 export const archiveTaskEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(archiveTask.match), mergeMap((action) => handleArchiveTask(action.payload.taskId, state$, zeniAPI)));
@@ -25,6 +26,8 @@ const handleApiResponse = (response, taskId) => {
         response.data.tasks.length > 0) {
         const fetchActions = [
             updateTasks(response.data.tasks),
+            removeTaskFromList(taskId),
+            fetchTaskList(),
             archiveTaskSuccessOrFailure({
                 fetchState: 'Completed',
                 taskId,

package/lib/esm/view/taskManager/taskDetailView/epics/deleteTaskEpic.js

@@ -2,6 +2,7 @@ import { from, of } from 'rxjs';
 import { catchError, filter, mergeMap } from 'rxjs/operators';
 import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
 import { createZeniAPIStatus, isSuccessStatus, } from '../../../../responsePayload';
+import { fetchTaskList, removeTaskFromList, } from '../../taskListView/taskListReducer';
 import { deleteTask, deleteTaskSuccessOrFailure } from '../taskDetailReducer';
 export const deleteTaskEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(deleteTask.match), mergeMap((action) => {
     const { taskId } = action.payload;
@@ -10,6 +11,10 @@ export const deleteTaskEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filt
         .pipe(mergeMap((response) => {
         if (isSuccessStatus(response)) {
             const actions = [];
+            if (taskId != null) {
+                actions.push(removeTaskFromList(taskId));
+            }
+            actions.push(fetchTaskList());
             actions.push(deleteTaskSuccessOrFailure({ fetchState: 'Completed', taskId }));
             return from(actions);
         }

package/lib/esm/view/taskManager/taskDetailView/epics/initializeTaskToLocalStoreEpic.js

@@ -25,6 +25,7 @@ export const initializeTaskToLocalStoreEpic = (actions$, state$) => actions$.pip
             savedRecurringEndDate: task.recurringEndDate,
             recurringStartDate: task.recurringStartDate,
             timeSpent: task.timeSpent,
+            isPrivate: task.isPrivate,
         };
         const actions = [
             saveTaskUpdatesToLocalStore({ taskDetailLocalData, taskId }),

package/lib/esm/view/taskManager/taskDetailView/epics/saveTaskDetailEpic.js

@@ -94,5 +94,6 @@ const prepareTaskPayload = (state, taskId, taskGroupId) => {
         sync_token: syncToken,
         task_group_ids: taskGroupId != null ? [taskGroupId] : [],
         time_spent: convertHHMMStrToMinutes(localData.timeSpent),
+        ...(taskId == null ? { is_private: localData.isPrivate ?? false } : {}),
     };
 };

package/lib/esm/view/taskManager/taskDetailView/epics/snoozeTaskEpic.js

@@ -0,0 +1,66 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { SNOOZED_DISPLAY_FORMAT } from '../../../../commonStateTypes/fiscalYearHelpers/formatZeniDateFY';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { updateTasks } from '../../../../entity/task/taskReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { date } from '../../../../zeniDayJS';
+import { fetchTaskList, removeTaskFromList, } from '../../taskListView/taskListReducer';
+import { snoozeTask, snoozeTaskSuccessOrFailure } from '../taskDetailReducer';
+export const snoozeTaskEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(snoozeTask.match), mergeMap((action) => handleSnoozeTask(action.payload.taskId, action.payload.snoozedUntil, zeniAPI)));
+const formatSnoozedUntilForDisplay = (snoozedUntil) => date(snoozedUntil).format(SNOOZED_DISPLAY_FORMAT);
+const handleSnoozeTask = (taskId, snoozedUntil, zeniAPI) => {
+    const snoozeTaskApi$ = zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks/${taskId}/snooze`, { snoozed_until: snoozedUntil });
+    return snoozeTaskApi$.pipe(mergeMap((response) => handleApiResponse(response, taskId, snoozedUntil)), catchError((error) => of(snoozeTaskSuccessOrFailure({
+        fetchState: 'Error',
+        taskId,
+        error: createZeniAPIStatus('Unexpected Error', 'Snooze Task REST API call errored out: ' + JSON.stringify(error)),
+    }))));
+};
+const handleApiResponse = (response, taskId, snoozedUntil) => {
+    if (isSuccessResponse(response) &&
+        response.data != null &&
+        response.data.tasks.length > 0) {
+        const fetchActions = [
+            updateTasks(response.data.tasks),
+            removeTaskFromList(taskId),
+            fetchTaskList(),
+            snoozeTaskSuccessOrFailure({
+                fetchState: 'Completed',
+                taskId,
+            }),
+            openSnackbar({
+                messageSection: 'snooze_task',
+                messageText: 'success',
+                type: 'success',
+                variables: [
+                    {
+                        variableName: '_snoozed_until_',
+                        variableValue: formatSnoozedUntilForDisplay(snoozedUntil),
+                    },
+                ],
+            }),
+        ];
+        return from(fetchActions);
+    }
+    else {
+        return from([
+            snoozeTaskSuccessOrFailure({
+                fetchState: 'Error',
+                taskId,
+                error: response.status,
+            }),
+            openSnackbar({
+                messageSection: 'snooze_task',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }),
+        ]);
+    }
+};

package/lib/esm/view/taskManager/taskDetailView/epics/unsnoozeTaskEpic.js

@@ -0,0 +1,57 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { updateTasks } from '../../../../entity/task/taskReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchTaskList, removeTaskFromList, } from '../../taskListView/taskListReducer';
+import { snoozeTaskSuccessOrFailure, unsnoozeTask, } from '../taskDetailReducer';
+export const unsnoozeTaskEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(unsnoozeTask.match), mergeMap((action) => handleUnsnoozeTask(action.payload.taskId, zeniAPI)));
+const handleUnsnoozeTask = (taskId, zeniAPI) => {
+    const unsnoozeTaskApi$ = zeniAPI.deleteAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks/${taskId}/snooze`);
+    return unsnoozeTaskApi$.pipe(mergeMap((response) => handleApiResponse(response, taskId)), catchError((error) => of(snoozeTaskSuccessOrFailure({
+        fetchState: 'Error',
+        taskId,
+        error: createZeniAPIStatus('Unexpected Error', 'Unsnooze Task REST API call errored out: ' + JSON.stringify(error)),
+    }))));
+};
+const handleApiResponse = (response, taskId) => {
+    if (isSuccessResponse(response) &&
+        response.data != null &&
+        response.data.tasks.length > 0) {
+        const fetchActions = [
+            updateTasks(response.data.tasks),
+            removeTaskFromList(taskId),
+            fetchTaskList(),
+            snoozeTaskSuccessOrFailure({
+                fetchState: 'Completed',
+                taskId,
+            }),
+            openSnackbar({
+                messageSection: 'unsnooze_task',
+                messageText: 'success',
+                type: 'success',
+            }),
+        ];
+        return from(fetchActions);
+    }
+    else {
+        return from([
+            snoozeTaskSuccessOrFailure({
+                fetchState: 'Error',
+                taskId,
+                error: response.status,
+            }),
+            openSnackbar({
+                messageSection: 'unsnooze_task',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }),
+        ]);
+    }
+};

package/lib/esm/view/taskManager/taskDetailView/taskDetail.js

@@ -31,5 +31,9 @@ export const initialTaskDetail = {
         fetchState: 'Not-Started',
         error: undefined,
     },
+    snoozeStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
     taskDetailLocalData: initialTaskDetailLocalData,
 };