@zeniai/client-epic-state 5.0.21-betaVR1 → 5.0.22-betaJK1

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

@@ -229,6 +229,56 @@ const taskDetailView = createSlice({
                 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 +320,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

@@ -6,7 +6,7 @@ import { getTaskById } from '../../../entity/task/taskSelector';
 import { getUserAndUserRole, } from '../../companyView/types/userAndRole';
 import { getFileDeleteStatusById, getFileUpdateNameStatusById, } from '../../fileView/fileViewSelector';
 import { getUserList, } from '../../userListView/userListViewSelector';
-import { initialTaskDetail, } from './taskDetail';
+import { initialTaskDetail } from './taskDetail';
 export const getTaskDetail = (state, taskId) => {
     const { taskDetailState, classListState, classState, fileState, fileViewState, userState, userRoleState, userListViewState, addressState, taskState, } = state;
     const deleteFileStatusById = {};
@@ -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,20 @@ 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,
+            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 ?? [],
                 updateType: 'replace',
-            }), updateTags(response.data.tasks.map((task) => task.tags).flat()));
+            }), 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);

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

@@ -29,7 +29,23 @@ const initialTaskIdsByDueDate = {
     today: [],
     upcoming: [],
 };
+const initialTabData = {
+    taskIds: [],
+    taskIdsByAssignees: {},
+    taskIdsByDueDate: { ...initialTaskIdsByDueDate },
+    taskIdsByGroupsIds: {},
+    taskIdsByPriority: { ...initialTaskIdsByPriority },
+    taskIdsByStatus: { ...initialTaskIdsByStatus },
+    taskIdsByTags: {},
+};
 export const initialState = {
+    currentTab: 'live',
+    byTab: {
+        live: { ...initialTabData },
+        archived: { ...initialTabData },
+        deleted: { ...initialTabData },
+        snoozed: { ...initialTabData },
+    },
     taskIds: [],
     taskIdsByGroupsIds: {},
     taskIdsByPriority: initialTaskIdsByPriority,
@@ -86,17 +102,30 @@ const taskList = createSlice({
             draft.error = undefined;
         },
         updateTaskList(draft, action) {
-            const { data } = action.payload;
+            const { data, archived, deleted, snoozed } = action.payload;
             draft.fetchState = 'Completed';
             draft.error = undefined;
-            const { taskIds, taskIdsGroupedByPriority, taskIdsByGroupIds, taskIdsGroupedByStatus, taskIdsByAssignees, taskIdsByDueDate, taskIdsByTags, } = getGroupedTaskIds(data);
-            draft.taskIds = taskIds;
-            draft.taskIdsByGroupsIds = taskIdsByGroupIds;
-            draft.taskIdsByPriority = taskIdsGroupedByPriority;
-            draft.taskIdsByStatus = taskIdsGroupedByStatus;
-            draft.taskIdsByAssignees = taskIdsByAssignees;
-            draft.taskIdsByDueDate = taskIdsByDueDate;
-            draft.taskIdsByTags = taskIdsByTags;
+            // Group live tasks
+            const liveGrouped = getGroupedTaskIds(data);
+            draft.byTab.live = toTabData(liveGrouped);
+            // Group other tabs if provided
+            if (archived != null) {
+                draft.byTab.archived = toTabData(getGroupedTaskIds(archived));
+            }
+            if (deleted != null) {
+                draft.byTab.deleted = toTabData(getGroupedTaskIds(deleted));
+            }
+            if (snoozed != null) {
+                draft.byTab.snoozed = toTabData(getGroupedTaskIds(snoozed));
+            }
+            // Copy active tab data to top-level fields
+            const activeTabData = draft.byTab[draft.currentTab];
+            copyTabDataToTopLevel(draft, activeTabData);
+        },
+        updateTaskListTab(draft, action) {
+            draft.currentTab = action.payload;
+            const activeTabData = draft.byTab[action.payload];
+            copyTabDataToTopLevel(draft, activeTabData);
         },
         initiateTaskListLocalData(draft, action) {
             const { taskGroupById } = action.payload;
@@ -184,10 +213,13 @@ const taskList = createSlice({
             },
         },
         updateTasksListOnBulkUpdateTasksSuccess(draft, action) {
-            const { taskIds, groupId } = action.payload;
+            const { taskIds, groupId, removeFromList } = action.payload;
             draft.updateTasksFetchState.fetchState = 'Completed';
             draft.updateTasksFetchState.error = undefined;
-            if (groupId != null) {
+            if (removeFromList) {
+                removeTaskIds(draft, taskIds);
+            }
+            else if (groupId != null) {
                 const { groupByKey } = draft.uiState;
                 if (groupByKey === 'groupName') {
                     Object.keys(draft.taskIdsByGroupsIds).forEach((gId) => {
@@ -404,12 +436,15 @@ const taskList = createSlice({
             draft.updateTasksFetchState.fetchState = 'Error';
             draft.updateTasksFetchState.error = action.payload.error;
         },
+        removeTaskFromList(draft, action) {
+            removeTaskIds(draft, [action.payload]);
+        },
         clearTaskList(draft) {
             Object.assign(draft, initialState);
         },
     },
 });
-export const { fetchTaskListPage, fetchTaskList, updateTaskList, updateTaskListFetchStatus, updateTaskListSearchText, updateTaskListUIState, updateTaskFilters, updateTaskListOnNewGroupCreationSuccess, bulkUpdateTaskList, updateTasksListOnBulkUpdateTasksSuccess, updateTasksListOnBulkUpdateTasksFailure, initiateTaskListLocalData, updateTaskListLocalData, updateTaskListOnTaskGroupDeletion, dragNDropTasks, updateTaskListOnNewTaskCreationSuccess, updateTaskListOnTaskGroupNameUpdate, updateTaskFromListView, updateTasksListOnUpdateTaskSuccess, updateTasksListOnUpdateTaskFailure, updateTaskListOnCreateTaskFromTemplateSuccess, clearTaskList, } = taskList.actions;
+export const { fetchTaskListPage, fetchTaskList, updateTaskList, updateTaskListTab, updateTaskListFetchStatus, updateTaskListSearchText, updateTaskListUIState, updateTaskFilters, updateTaskListOnNewGroupCreationSuccess, bulkUpdateTaskList, updateTasksListOnBulkUpdateTasksSuccess, updateTasksListOnBulkUpdateTasksFailure, initiateTaskListLocalData, updateTaskListLocalData, updateTaskListOnTaskGroupDeletion, dragNDropTasks, updateTaskListOnNewTaskCreationSuccess, updateTaskListOnTaskGroupNameUpdate, updateTaskFromListView, updateTasksListOnUpdateTaskSuccess, updateTasksListOnUpdateTaskFailure, updateTaskListOnCreateTaskFromTemplateSuccess, removeTaskFromList, clearTaskList, } = taskList.actions;
 export default taskList.reducer;
 /**
  *  helpers
@@ -488,6 +523,50 @@ const getTagsGroupKey = (tags) => {
     tagIds.sort();
     return tagIds.join(',');
 };
+const toTabData = (grouped) => ({
+    taskIds: grouped.taskIds,
+    taskIdsByAssignees: grouped.taskIdsByAssignees,
+    taskIdsByDueDate: grouped.taskIdsByDueDate,
+    taskIdsByGroupsIds: grouped.taskIdsByGroupIds,
+    taskIdsByPriority: grouped.taskIdsGroupedByPriority,
+    taskIdsByStatus: grouped.taskIdsGroupedByStatus,
+    taskIdsByTags: grouped.taskIdsByTags,
+});
+const copyTabDataToTopLevel = (draft, tabData) => {
+    draft.taskIds = tabData.taskIds;
+    draft.taskIdsByGroupsIds = tabData.taskIdsByGroupsIds;
+    draft.taskIdsByPriority = tabData.taskIdsByPriority;
+    draft.taskIdsByStatus = tabData.taskIdsByStatus;
+    draft.taskIdsByAssignees = tabData.taskIdsByAssignees;
+    draft.taskIdsByDueDate = tabData.taskIdsByDueDate;
+    draft.taskIdsByTags = tabData.taskIdsByTags;
+};
+const removeIdsFromTabData = (tabData, taskIds) => {
+    const isRemoved = (id) => taskIds.includes(id);
+    tabData.taskIds = tabData.taskIds.filter((id) => !isRemoved(id));
+    Object.keys(tabData.taskIdsByGroupsIds).forEach((gId) => {
+        tabData.taskIdsByGroupsIds[gId] = tabData.taskIdsByGroupsIds[gId].filter((id) => !isRemoved(id));
+    });
+    Object.keys(tabData.taskIdsByPriority).forEach((key) => {
+        tabData.taskIdsByPriority[key] = tabData.taskIdsByPriority[key].filter((id) => !isRemoved(id));
+    });
+    Object.keys(tabData.taskIdsByStatus).forEach((key) => {
+        tabData.taskIdsByStatus[key] = tabData.taskIdsByStatus[key].filter((id) => !isRemoved(id));
+    });
+    Object.keys(tabData.taskIdsByDueDate).forEach((key) => {
+        tabData.taskIdsByDueDate[key] = tabData.taskIdsByDueDate[key].filter((id) => !isRemoved(id));
+    });
+    Object.keys(tabData.taskIdsByAssignees).forEach((key) => {
+        tabData.taskIdsByAssignees[key] = tabData.taskIdsByAssignees[key].filter((id) => !isRemoved(id));
+    });
+    Object.keys(tabData.taskIdsByTags).forEach((key) => {
+        tabData.taskIdsByTags[key] = tabData.taskIdsByTags[key].filter((id) => !isRemoved(id));
+    });
+};
+const removeTaskIds = (draft, taskIds) => {
+    removeIdsFromTabData(draft, taskIds);
+    removeIdsFromTabData(draft.byTab[draft.currentTab], taskIds);
+};
 const getGroupedTaskIds = (tasks) => {
     const taskIds = [];
     const taskIdsByGroupIds = {};