@zeniai/client-epic-state 5.0.37 → 5.0.38

package/lib/esm/init.js

@@ -1,4 +1,3 @@
-import Pusher from 'pusher-js';
 import configureNewStore from './configureStore';
 import { ZeniAPIClient } from './zeniAPI';
 export let zeniAPI;
@@ -24,10 +23,23 @@ export default function initialize(restEndPoints, userId, sessionId, tenantId, i
     return store;
 }
 let isPusherInitialized = false;
+// Caches an in-flight initializePusher() promise so that concurrent callers
+// share a single Pusher instance instead of each constructing their own and
+// leaking WebSocket connections (see Bugbot review on PR #2983). Cleared in
+// the IIFE's `finally` once construction settles.
+let pusherInitPromise;
 /**
  * Call initializePusher before using pusher in web-app
  */
-export function initializePusher(pusherClientSecret, options, headers, reInitialize = false) {
+export async function initializePusher(pusherClientSecret, options, headers, reInitialize = false) {
+    // Pusher subscribes/decrypts only make sense in the browser. `pusher-js/
+    // with-encryption` resolves to a browser-only bundle that references
+    // `window` at module init, so even *importing* it on the server crashes.
+    // Bail out early on SSR/Node so the dynamic import below never executes.
+    if (typeof window === 'undefined') {
+        console.warn(`initializePusher called on server-side; pusher-js/with-encryption is browser-only — skipping.`);
+        return undefined;
+    }
     if (Boolean(zeniAPI.userId) === false ||
         Boolean(zeniAPI.tenantId) === false ||
         !initialized) {
@@ -38,19 +50,59 @@ export function initializePusher(pusherClientSecret, options, headers, reInitial
         console.warn(`Already initialized pusher`);
         return pusher;
     }
-    const endpoint = `${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/notifications/push_notification/auth`;
-    pusher = new Pusher(pusherClientSecret, {
-        ...options,
-        channelAuthorization: {
-            endpoint,
-            transport: 'ajax',
-            customHandler: (params, callback) => customHandler(params, headers, callback),
-        },
-    }).bind('error', function (err) {
-        console.warn('Pusher error', err);
-    });
-    console.info(`initializing with ${JSON.stringify(options)}`);
-    return pusher;
+    // De-dupe concurrent in-flight calls so we don't construct multiple Pusher
+    // instances (each one a live WebSocket) and leak the older ones. We don't
+    // de-dupe when reInitialize=true — that's the caller asking for a fresh
+    // instance, which is the existing contract.
+    if (pusherInitPromise && !reInitialize) {
+        return pusherInitPromise;
+    }
+    // The IIFE captures `currentInit` so that, when its `finally` runs, it can
+    // identity-check before clearing the module-level `pusherInitPromise`. This
+    // matters when a reInitialize=true call overwrites `pusherInitPromise`
+    // while we're still in flight: without the identity check, our finally
+    // would clobber the newer call's slot and the next concurrent caller
+    // would bypass the dedup guard. Capture is safe because the first action
+    // inside the try is `await import(...)`, which always yields control —
+    // so the finally runs in a future microtask, after `currentInit` has
+    // already been assigned below. We declare it as `let … | undefined` so
+    // TS's definite-assignment analysis (which doesn't model the await) accepts
+    // the closure read; at runtime it's always the IIFE promise by then.
+    let currentInit = undefined;
+    currentInit = (async () => {
+        try {
+            // Dynamic import so the browser-only bundle is loaded only when this
+            // function actually runs (browser path). Works in both build outputs:
+            //   • ESM (lib/esm): preserved as native `import()` → Vite/Rollup code-split
+            //   • CJS (lib): TypeScript lowers to `Promise.resolve().then(() => require(...))`
+            // The pusher-js UMD wrapper does `module.exports = factory()` for CJS,
+            // so the module result is the Pusher class directly. Some bundlers wrap
+            // CJS in `{ default: ... }` for ESM interop — fall back to the module
+            // itself when `.default` is absent.
+            const pusherModule = (await import('pusher-js/with-encryption'));
+            const PusherConstructor = 'default' in pusherModule ? pusherModule.default : pusherModule;
+            const endpoint = `${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/notifications/push_notification/auth`;
+            pusher = new PusherConstructor(pusherClientSecret, {
+                ...options,
+                channelAuthorization: {
+                    endpoint,
+                    transport: 'ajax',
+                    customHandler: (params, callback) => customHandler(params, headers, callback),
+                },
+            }).bind('error', function (err) {
+                console.warn('Pusher error', err);
+            });
+            console.info(`initializing with ${JSON.stringify(options)}`);
+            return pusher;
+        }
+        finally {
+            if (pusherInitPromise === currentInit) {
+                pusherInitPromise = undefined;
+            }
+        }
+    })();
+    pusherInitPromise = currentInit;
+    return currentInit;
 }
 const customHandler = async (params, headers, callback) => {
     const { socketId, channelName } = params;
@@ -64,7 +116,10 @@ const customHandler = async (params, headers, callback) => {
         .toPromise()
         .then((response) => {
         if (response.data != null) {
-            callback(null, { auth: response.data.auth });
+            callback(null, {
+                auth: response.data.auth,
+                shared_secret: response.data.shared_secret,
+            });
             isPusherInitialized = true;
         }
     })

package/lib/esm/reducer.js

@@ -107,6 +107,7 @@ import expenseAutomationReconciliationView, { initialState as initialExpenseAuto
 import expenseAutomationTransactionsView, { initialState as initialExpenseAutomationTransactionsViewState, } from './view/expenseAutomationView/reducers/transactionsViewReducer';
 import fileView from './view/fileView/fileViewReducer';
 import { initialFileViewState, } from './view/fileView/fileViewState';
+import featureNotificationView, { initialState as initialFeatureNotificationViewState, } from './view/featureNotificationView/featureNotificationViewReducer';
 import financeStatement, { initialFinanceStatementState, } from './view/financeStatement/financeStatementReducer';
 import forecastList, { initialState as initialForecastListState, } from './view/forecastList/forecastListReducer';
 import globalMerchantAutoComplete, { initialState as initialGlobalMerchantAutoCompleteState, } from './view/globalMerchantView/globalMerchantAutoCompleteView/globalMerchantAutoCompleteViewReducer';
@@ -192,6 +193,7 @@ import zeniAccountSetupView, { initialState as initialZeniAccountSetupViewState,
 import zeniAccountsConfig, { initialState as initialZeniAccountsConfigState, } from './view/spendManagement/zeniAccounts/zeniAccountsConfig/zeniAccountsConfigReducer';
 import subscriptionView, { initialState as initialSubscriptionViewState, } from './view/subscriptionView/subscriptionViewReducer';
 import tagView, { initialState as initialTagListState, } from './view/tagView/tagViewReducer';
+import cannedResponsesView, { initialState as initialCannedResponsesState, } from './view/taskManager/cannedResponsesView/cannedResponsesReducer';
 import taskDetailView, { initialState as initialTaskDetailState, } from './view/taskManager/taskDetailView/taskDetailReducer';
 import taskGroupTemplateView, { initialState as initialTaskGroupTemplateViewState, } from './view/taskManager/taskGroupTemplateView/taskGroupTemplateViewReducer';
 import taskGroupView, { initialState as initialTaskGroupViewState, } from './view/taskManager/taskGroupView/taskGroupViewReducer';
@@ -218,6 +220,7 @@ import vendorTabView, { initialState as initialVendorTabViewState, } from './vie
 import vendorTypeList, { initialState as initialVendorTypeListState, } from './view/vendorTypeList/vendorTypeListReducer';
 import zeniAccStatementList, { initialState as initialZeniAccStatementListState, } from './view/zeniAccStatementList/zeniAccStatementListReducer';
 import zeniAccountsPromoCard, { initialState as initialZeniAccountsPromoCardState, } from './view/zeniAccountsPromoCard/zeniAccountsPromoCardReducer';
+import zeniOAuthView, { initialState as initialZeniOAuthViewState, } from './view/zeniOAuthView/zeniOAuthReducer';
 // Note: Please maintain strict alphabetical order
 const initialEntitiesState = {
     accountGroupState: initialAccountGroupState,
@@ -353,6 +356,7 @@ const initialViewsState = {
     expenseAutomationTransactionsViewState: initialExpenseAutomationTransactionsViewState,
     expenseAutomationViewState: initialExpenseAutomationViewState,
     expressPayState: initialExpressPayState,
+    featureNotificationViewState: initialFeatureNotificationViewState,
     fileViewState: initialFileViewState,
     financeStatementState: initialFinanceStatementState,
     forecastListState: initialForecastListState,
@@ -403,6 +407,7 @@ const initialViewsState = {
     setupViewState: initialSetupViewState,
     subscriptionViewState: initialSubscriptionViewState,
     tagViewState: initialTagListState,
+    cannedResponsesState: initialCannedResponsesState,
     taskDetailState: initialTaskDetailState,
     taskGroupTemplateViewState: initialTaskGroupTemplateViewState,
     taskGroupViewState: initialTaskGroupViewState,
@@ -442,6 +447,7 @@ const initialViewsState = {
     zeniAccountSetupViewState: initialZeniAccountSetupViewState,
     zeniAccStatementListState: initialZeniAccStatementListState,
     zeniAccountsPromoCardState: initialZeniAccountsPromoCardState,
+    zeniOAuthViewState: initialZeniOAuthViewState,
 };
 export const initialRootState = {
     ...initialEntitiesState,
@@ -582,6 +588,7 @@ const viewReducers = {
     expenseAutomationTransactionsViewState: expenseAutomationTransactionsView,
     expenseAutomationViewState: expenseAutomationView,
     expressPayState: expressPay,
+    featureNotificationViewState: featureNotificationView,
     fileViewState: fileView,
     financeStatementState: financeStatement,
     forecastListState: forecastList,
@@ -632,6 +639,7 @@ const viewReducers = {
     settingsViewState: settings,
     setupViewState: setupView,
     subscriptionViewState: subscriptionView,
+    cannedResponsesState: cannedResponsesView,
     taskDetailState: taskDetailView,
     taskGroupTemplateViewState: taskGroupTemplateView,
     taskGroupViewState: taskGroupView,
@@ -672,6 +680,7 @@ const viewReducers = {
     zeniAccountSetupViewState: zeniAccountSetupView,
     zeniAccStatementListState: zeniAccStatementList,
     zeniAccountsPromoCardState: zeniAccountsPromoCard,
+    zeniOAuthViewState: zeniOAuthView,
 };
 const reducers = combineReducers({
     ...entityReducers,

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,
+                    },
+                ],
+            }),
+        ]);
+    }
+};