@zeniai/client-epic-state 5.0.32 → 5.0.33-betaRR0

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,
 };

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

@@ -149,11 +149,11 @@ const taskDetailView = createSlice({
         },
         saveTaskSuccessOrFailure(draft, action) {
             const { taskId, fetchState, error, newTaskId } = action.payload;
-            if (taskId != null) {
+            if (taskId != null && draft.editTaskStateById[taskId] != null) {
                 draft.editTaskStateById[taskId].saveStatus.fetchState = fetchState;
                 draft.editTaskStateById[taskId].saveStatus.error = error;
             }
-            else {
+            else if (taskId == null) {
                 if (newTaskId != null) {
                     draft.newTaskState.taskId = newTaskId;
                 }
@@ -182,8 +182,10 @@ const taskDetailView = createSlice({
         },
         archiveTaskSuccessOrFailure(draft, action) {
             const { taskId, fetchState, error } = action.payload;
-            draft.editTaskStateById[taskId].archiveStatus.fetchState = fetchState;
-            draft.editTaskStateById[taskId].archiveStatus.error = error;
+            if (draft.editTaskStateById[taskId] != null) {
+                draft.editTaskStateById[taskId].archiveStatus.fetchState = fetchState;
+                draft.editTaskStateById[taskId].archiveStatus.error = error;
+            }
         },
         deleteTask: {
             reducer(draft, action) {
@@ -216,19 +218,70 @@ const taskDetailView = createSlice({
             },
         },
         deleteTaskSuccessOrFailure(draft, action) {
-            if (action.payload.taskId != null) {
+            if (action.payload.taskId != null &&
+                draft.editTaskStateById[action.payload.taskId] != null) {
                 const { taskId } = action.payload;
                 draft.editTaskStateById[taskId].deleteTaskStatus.fetchState =
                     action.payload.fetchState;
                 draft.editTaskStateById[taskId].deleteTaskStatus.error =
                     action.payload.error;
             }
-            else {
+            else if (action.payload.taskId == null) {
                 draft.newTaskState.deleteTaskStatus.fetchState =
                     action.payload.fetchState;
                 draft.newTaskState.deleteTaskStatus.error = action.payload.error;
             }
         },
+        snoozeTask: {
+            reducer(draft, action) {
+                const { taskId } = action.payload;
+                draft.editTaskStateById[taskId] = {
+                    ...(draft.editTaskStateById[taskId] != null
+                        ? draft.editTaskStateById[taskId]
+                        : initialTaskDetail),
+                    snoozeStatus: {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    },
+                };
+            },
+            prepare(taskId, snoozedUntil) {
+                return {
+                    payload: {
+                        taskId,
+                        snoozedUntil,
+                    },
+                };
+            },
+        },
+        snoozeTaskSuccessOrFailure(draft, action) {
+            const { taskId, fetchState, error } = action.payload;
+            if (draft.editTaskStateById[taskId] != null) {
+                draft.editTaskStateById[taskId].snoozeStatus.fetchState = fetchState;
+                draft.editTaskStateById[taskId].snoozeStatus.error = error;
+            }
+        },
+        unsnoozeTask: {
+            reducer(draft, action) {
+                const { taskId } = action.payload;
+                draft.editTaskStateById[taskId] = {
+                    ...(draft.editTaskStateById[taskId] != null
+                        ? draft.editTaskStateById[taskId]
+                        : initialTaskDetail),
+                    snoozeStatus: {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    },
+                };
+            },
+            prepare(taskId) {
+                return {
+                    payload: {
+                        taskId,
+                    },
+                };
+            },
+        },
         fetchTaskHistory: {
             reducer(draft, action) {
                 const { taskId, cacheOverride } = action.payload;
@@ -270,5 +323,5 @@ const taskDetailView = createSlice({
         },
     },
 });
-export const { fetchTaskDetailPage, fetchTaskDetail, initializeTaskToLocalStore, updateEditTaskFetchStatus, saveTaskUpdatesToLocalStore, discardTaskUpdatesInLocalStore, saveTaskDetail, archiveTask, archiveTaskSuccessOrFailure, saveTaskSuccessOrFailure, deleteTask, removeTaskDetail, deleteTaskSuccessOrFailure, fetchTaskHistory, updateTaskHistory, updateTaskHistoryFetchStatus, clearTaskDetail, updateCreatedTagToLocalStore, updateDeletedTagToLocalStore, } = taskDetailView.actions;
+export const { fetchTaskDetailPage, fetchTaskDetail, initializeTaskToLocalStore, updateEditTaskFetchStatus, saveTaskUpdatesToLocalStore, discardTaskUpdatesInLocalStore, saveTaskDetail, archiveTask, archiveTaskSuccessOrFailure, saveTaskSuccessOrFailure, deleteTask, removeTaskDetail, deleteTaskSuccessOrFailure, snoozeTask, snoozeTaskSuccessOrFailure, unsnoozeTask, fetchTaskHistory, updateTaskHistory, updateTaskHistoryFetchStatus, clearTaskDetail, updateCreatedTagToLocalStore, updateDeletedTagToLocalStore, } = taskDetailView.actions;
 export default taskDetailView.reducer;

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

@@ -22,11 +22,19 @@ export const getTaskDetail = (state, taskId) => {
     };
     let taskHistory = [];
     let createdByUser = undefined;
+    let isArchived = undefined;
+    let isDeleted = undefined;
+    let recurringSourceTaskId = undefined;
+    let snoozedUntil = undefined;
     if (taskId != null && sourceTaskDetail != null) {
         const taskEntity = getTaskById(taskState, taskId);
         const fileIdsInEntity = taskEntity?.fileIds ?? [];
         if (taskEntity != null) {
             createdByUser = getUserAndUserRole(userState, userRoleState, addressState, taskEntity.createdBy);
+            isArchived = taskEntity.isArchived;
+            isDeleted = taskEntity.isDeleted;
+            recurringSourceTaskId = taskEntity.recurringSourceTaskId;
+            snoozedUntil = taskEntity.snoozedUntil;
         }
         if (fileIdsInEntity.length > 0) {
             fetchStatus = reduceFetchState([
@@ -74,7 +82,11 @@ export const getTaskDetail = (state, taskId) => {
         error: fetchStatus.error,
         version: 0,
         createdByUser,
+        isArchived,
+        isDeleted,
+        recurringSourceTaskId,
         showTaskDetailFormFooter,
+        snoozedUntil,
     };
 };
 export const allTaskStatus = [

package/lib/esm/view/taskManager/taskListView/epics/bulkUpdateTaskListEpic.js

@@ -5,21 +5,26 @@ import { convertHHMMStrToMinutes } from '../../../../commonStateTypes/fiscalYear
 import { DEFAULT_DATE_FORMAT } from '../../../../commonStateTypes/fiscalYearHelpers/formatZeniDateFY';
 import { updateTasks } from '../../../../entity/task/taskReducer';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
-import { bulkUpdateTaskList, updateTasksListOnBulkUpdateTasksFailure, updateTasksListOnBulkUpdateTasksSuccess, } from '../taskListReducer';
-export const bulkUpdateTaskListEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(bulkUpdateTaskList.match), switchMap((action) => {
-    const state = state$.value;
+import { bulkUpdateTaskList, fetchTaskList, updateTasksListOnBulkUpdateTasksFailure, updateTasksListOnBulkUpdateTasksSuccess, } from '../taskListReducer';
+export const bulkUpdateTaskListEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(bulkUpdateTaskList.match), switchMap((action) => {
     const { taskIds, updates, groupId } = action.payload;
-    const payload = {
-        tasks: getTasksListPayload(state, taskIds, updates),
-    };
+    const bulkUpdates = toBulkUpdatesPayload(updates);
+    if (groupId != null) {
+        bulkUpdates.task_group_ids = [groupId];
+    }
+    const payload = { task_ids: taskIds, updates: bulkUpdates };
     return zeniAPI
-        .putAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks`, payload)
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks/bulk-update`, payload)
         .pipe(mergeMap((response) => {
         if (isSuccessResponse(response) && response.data != null) {
+            const removeFromList = updates.isArchived === true ||
+                updates.isDeleted === true ||
+                ('snoozedUntil' in updates && updates.snoozedUntil == null);
             return of(updateTasks(response.data.tasks), updateTasksListOnBulkUpdateTasksSuccess({
                 taskIds,
                 groupId,
-            }));
+                removeFromList,
+            }), fetchTaskList());
         }
         else {
             return of(updateTasksListOnBulkUpdateTasksFailure({
@@ -33,19 +38,46 @@ export const bulkUpdateTaskListEpic = (actions$, state$, zeniAPI) => actions$.pi
         }));
     }));
 }));
-export const getTasksListPayload = (state, taskIds, updates) => {
-    const { taskState } = state;
-    const tasksList = taskIds
-        .map((taskId) => {
-        const task = get(taskState.taskByID, taskId);
-        return {
-            ...task,
-            ...updates,
-        };
-    })
-        .filter((task) => task != null);
-    const tasksPayload = tasksList.map((task) => toTaskPayload(state, task));
-    return tasksPayload;
+/**
+ * Helpers
+ */
+const toBulkUpdatesPayload = (updates) => {
+    const payload = {};
+    if (updates.status != null) {
+        payload.status = updates.status.code;
+    }
+    if (updates.priority != null) {
+        payload.priority = updates.priority.code;
+    }
+    if (updates.assignees != null) {
+        payload.assignees = updates.assignees;
+    }
+    if (updates.groupAssignees != null) {
+        payload.group_assignees = updates.groupAssignees;
+    }
+    if (updates.dueDate != null) {
+        payload.due_date = updates.dueDate.format(DEFAULT_DATE_FORMAT);
+    }
+    if (updates.tagIds != null) {
+        payload.tags = updates.tagIds;
+    }
+    if (updates.timeSpent != null) {
+        payload.time_spent = convertHHMMStrToMinutes(updates.timeSpent.replace(/\D/g, ''));
+    }
+    if (updates.isArchived != null) {
+        payload.is_archived = updates.isArchived;
+    }
+    if (updates.isDeleted != null) {
+        payload.is_deleted = updates.isDeleted;
+    }
+    // Bulk snooze is not supported — only bulk unsnooze (clear all snooze fields)
+    if ('snoozedUntil' in updates) {
+        payload.snoozed_until = null;
+        payload.snoozed_by = null;
+        payload.snoozed_at = null;
+        payload.is_snooze_notification_sent = false;
+    }
+    return payload;
 };
 export const getTaskPayload = (state, taskId, updates) => {
     const { taskState } = state;
@@ -71,6 +103,9 @@ const toTaskPayload = (state, task) => {
         assignees: task.assignees,
         description: task.description,
         group_assignees: task.groupAssignees,
+        is_archived: task.isArchived,
+        is_deleted: task.isDeleted,
+        snoozed_until: task.snoozedUntil != null ? task.snoozedUntil.toISOString() : null,
         due_date: task.dueDate != null ? task.dueDate.format(DEFAULT_DATE_FORMAT) : null,
         priority: task.priority.code,
         status: task.status.code,

package/lib/esm/view/taskManager/taskListView/epics/dragNDropTasksEpic.js

@@ -11,6 +11,7 @@ export const dragNDropTasksEpic = (actions$, state$) => actions$.pipe(filter(dra
         updateTasksListOnBulkUpdateTasksSuccess({
             taskIds,
             groupId,
+            removeFromList: false,
         }),
         bulkUpdateTaskList(taskIds, groupId, updates),
     ];

package/lib/esm/view/taskManager/taskListView/epics/fetchTaskListEpic.js

@@ -9,10 +9,19 @@ export const fetchTaskListEpic = (actions$, _state$, zeniAPI) => actions$.pipe(f
         .getJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks?query=${encodeURIComponent(`{"task_type": "all"}`)}`)
         .pipe(mergeMap((response) => {
         if (isSuccessResponse(response) && response.data != null) {
-            return of(updateTasks(response.data.tasks), updateTaskList({
-                data: response.data.tasks,
-                updateType: 'replace',
-            }), updateTags(response.data.tasks.map((task) => task.tags).flat()));
+            const { tasks, deleted, archived, snoozed } = response.data;
+            const allTasks = [
+                ...tasks,
+                ...(deleted ?? []),
+                ...(archived ?? []),
+                ...(snoozed ?? []),
+            ];
+            return of(updateTasks(allTasks), updateTaskList({
+                data: tasks,
+                deleted: deleted ?? [],
+                archived: archived ?? [],
+                snoozed: snoozed ?? [],
+            }), updateTags(allTasks.map((task) => task.tags).flat()));
         }
         else {
             return of(updateTaskListFetchStatus({

package/lib/esm/view/taskManager/taskListView/epics/updateTaskFromListViewEpic.js

@@ -8,9 +8,10 @@ export const updateTaskFromListViewEpic = (actions$, state$, zeniAPI) => actions
     const state = state$.value;
     const { task, updates } = action.payload;
     const taskId = task.id;
-    const taskData = getTaskPayload(state, taskId, updates);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { snoozed_until: _snoozedUntil, ...taskData } = getTaskPayload(state, taskId, updates);
     return zeniAPI
-        .putAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks/${taskId}`, { ...taskData })
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks/${taskId}`, taskData)
         .pipe(mergeMap((response) => {
         if (isSuccessResponse(response) && response.data != null) {
             return from([

package/lib/esm/view/taskManager/taskListView/taskList.js

@@ -1,4 +1,10 @@
 import { stringToUnion, stringToUnionStrict, } from '../../../commonStateTypes/stringToUnion';
+export const ALL_TASK_LIST_TABS = [
+    'live',
+    'archived',
+    'deleted',
+    'snoozed',
+];
 export const DUE_DATE_GROUP_KEYS = [
     'overdue',
     'today',
@@ -26,6 +32,7 @@ const ALL_TASK_LIST_SORT_KEYS = [
     'status',
     'priority',
     'timeSpent',
+    'visibility',
 ];
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const toTaskListSortKeyType = (v) => stringToUnion(v, ALL_TASK_LIST_SORT_KEYS);