@zeniai/client-epic-state 5.1.41-beta0ND → 5.1.41-betaDI3

package/lib/esm/view/companyTaskManagerView/epics/fetchCompanyTaskManagerViewEpic.js

@@ -18,6 +18,9 @@ export const fetchCompanyTaskManagerViewEpic = (actions$, _state$, zeniAPI) => a
         ...(filters?.categories != null && filters.categories.length > 0
             ? { filter_by: toFilterByPayload(filters) }
             : {}),
+        task_group_scopes: filters?.taskGroupScopes != null && filters.taskGroupScopes.length > 0
+            ? filters.taskGroupScopes
+            : ['internal'],
     };
     return zeniAPI
         .getJSON(`${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/cockpit-panels/tasks-es?query=${encodeURIComponent(JSON.stringify(queryValue))}`)

package/lib/esm/view/companyTaskManagerView/epics/fetchTaskManagerMetricsEpic.js

@@ -3,7 +3,13 @@ import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
 import { isSuccessResponse } from '../../../responsePayload';
 import { fetchTaskManagerMetrics, updateTaskManagerMetrics, updateTaskManagerMetricsOnFailure, } from '../companyTaskManagerViewReducer';
 export const fetchTaskManagerMetricsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchTaskManagerMetrics.match), switchMap(() => {
-    const query = JSON.stringify({ is_filter_by_logged_in_user: true });
+    // Include subtasks so the cockpit count matches the customer dashboard
+    // pending count. The dashboard counts every task (subtasks included);
+    // cockpit's default of include_subtasks=false otherwise undercounts.
+    const query = JSON.stringify({
+        is_filter_by_logged_in_user: true,
+        include_subtasks: true,
+    });
     return zeniAPI
         .getJSON(`${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/cockpit-panels/tasks-es-metrics?query=${encodeURIComponent(query)}`)
         .pipe(mergeMap((response) => {

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

@@ -0,0 +1,96 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { convertHHMMStrToMinutes } from '../../../../commonStateTypes/fiscalYearHelpers/formatMinutesToFromHHMM';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { appendSubTaskId, updateTasks, } from '../../../../entity/task/taskReducer';
+import { getTaskById } from '../../../../entity/task/taskSelector';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { updateTaskListOnNewTaskCreationSuccess } from '../../taskListView/taskListReducer';
+import { createSubTask, createSubTaskSuccessOrFailure, } from '../taskDetailReducer';
+export const createSubTaskEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(createSubTask.match), mergeMap((action) => {
+    const state = state$.value;
+    const parentTask = getTaskById(state.taskState, action.payload.parentTaskId);
+    // Subtasks inherit every parent group membership, not just the first,
+    // so the subtask surfaces in all the same buckets as its parent.
+    const parentTaskGroupIds = parentTask?.taskGroupIds ?? [];
+    const parentTaskGroupId = parentTaskGroupIds[0];
+    const isTaskListFetched = state.taskListState.fetchState === 'Completed';
+    const payload = prepareSubTaskPayload(action.payload, parentTaskGroupIds);
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) &&
+            response.data != null &&
+            response.data.tasks.length > 0) {
+            const newTaskId = response.data.tasks[0].task_id;
+            const actions = [
+                updateTasks(response.data.tasks),
+                appendSubTaskId({
+                    parentTaskId: action.payload.parentTaskId,
+                    subTaskId: newTaskId,
+                }),
+                createSubTaskSuccessOrFailure({
+                    fetchState: 'Completed',
+                    newTaskId,
+                }),
+                openSnackbar({
+                    messageSection: 'create_sub_task',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ];
+            // The task list is keyed on parent tasks (no parent_task_id)
+            // — subtasks belong to their parent's children list, not the
+            // top-level list. Pushing a subtask into the list would
+            // surface it as an orphan row at the top of the group.
+            // Only fire the list-update for actual parent tasks.
+            const createdTask = response.data.tasks[0];
+            const isSubtask = createdTask.parent_task_id != null &&
+                createdTask.parent_task_id !== '';
+            if (!isSubtask &&
+                isTaskListFetched === true &&
+                parentTaskGroupId != null) {
+                actions.push(updateTaskListOnNewTaskCreationSuccess({
+                    taskGroupId: parentTaskGroupId,
+                    task: createdTask,
+                }));
+            }
+            return from(actions);
+        }
+        else {
+            return of(createSubTaskSuccessOrFailure({
+                fetchState: 'Error',
+                error: response.status,
+            }), openSnackbar({
+                messageSection: 'create_sub_task',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }));
+        }
+    }), catchError((error) => of(createSubTaskSuccessOrFailure({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Create Sub Task REST API call errored out' +
+            JSON.stringify(error)),
+    }))));
+}));
+const prepareSubTaskPayload = (subTask, parentTaskGroupIds) => ({
+    name: subTask.name,
+    assignees: subTask.assignee,
+    description: subTask.description,
+    priority: subTask.priority,
+    status: subTask.status,
+    tags: subTask.tagIds,
+    time_spent: convertHHMMStrToMinutes(subTask.timeSpent),
+    group_assignees: subTask.groupAssignees,
+    parent_task_id: subTask.parentTaskId,
+    // Inherit every parent group, not just the first — see callsite for
+    // the two-scope rationale.
+    task_group_ids: parentTaskGroupIds,
+    due_date: subTask.dueDate?.format('YYYY-MM-DD') ?? null,
+});

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

@@ -0,0 +1,53 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { setSubTaskIds, updateTasks } from '../../../../entity/task/taskReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchSubTasks, updateSubTasks, updateSubTasksFetchStatus, } from '../taskDetailReducer';
+export const fetchSubTasksEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchSubTasks.match), 
+// Use mergeMap, not switchMap: switchMap cancels in-flight requests for
+// the previous parent without dispatching success or failure, leaving
+// subTaskListFetchStatusByParentId stuck at In-Progress and blocking the
+// detail page's combined fetchStatus via reduceAnyFetchState. Per-parent
+// races on the same parentTaskId are handled last-write-wins downstream.
+mergeMap((action) => {
+    const { parentTaskId } = action.payload;
+    const query = JSON.stringify({
+        task_type: 'subtasks',
+        parent_task_id: parentTaskId,
+    });
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks?query=${encodeURIComponent(query)}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const { tasks } = response.data;
+            // Keep the parent's `subTasksIds` in sync with the fetched
+            // bucket. Without this, the parent entity record can drift
+            // out of sync with what the children fetch returned —
+            // e.g. a server-side delete won't drop from the parent
+            // record until the next list re-fetch.
+            const fetchedChildIds = tasks
+                .filter((t) => t.parent_task_id === parentTaskId)
+                .map((t) => t.task_id);
+            return of(updateTasks(tasks), setSubTaskIds({
+                parentTaskId,
+                subTaskIds: fetchedChildIds,
+            }), updateSubTasks({
+                parentTaskId,
+            }));
+        }
+        else {
+            return of(updateSubTasksFetchStatus({
+                parentTaskId,
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => {
+        return of(updateSubTasksFetchStatus({
+            parentTaskId,
+            fetchState: 'Error',
+            error: createZeniAPIStatus('Unexpected Error', 'Fetch Sub Tasks REST API call errored out' +
+                JSON.stringify(error)),
+        }));
+    }));
+}));

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

@@ -28,6 +28,7 @@ export const initializeTaskToLocalStoreEpic = (actions$, state$) => actions$.pip
             recurringStartDate: task.recurringStartDate,
             timeSpent: task.timeSpent,
             isPrivate: task.isPrivate,
+            taskGroupId: task.taskGroupIds[0],
         };
         const actions = [
             saveTaskUpdatesToLocalStore({ taskDetailLocalData, taskId }),

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

@@ -6,23 +6,52 @@ import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
 import { updateTasks } from '../../../../entity/task/taskReducer';
 import { getTaskById } from '../../../../entity/task/taskSelector';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
-import { updateTaskListOnNewTaskCreationSuccess } from '../../taskListView/taskListReducer';
+import { removeTaskFromGroupBucket, updateTaskListOnNewTaskCreationSuccess, } from '../../taskListView/taskListReducer';
 import { saveTaskDetail, saveTaskSuccessOrFailure } from '../taskDetailReducer';
 export const saveTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(saveTaskDetail.match), mergeMap((action) => {
     const { taskId, taskGroupId } = action.payload;
     const state = state$.value;
     const isTaskListFetched = state.taskListState.fetchState === 'Completed';
-    const updatedTaskGroupId = taskId == null
-        ? taskGroupId
-        : getTaskById(state.taskState, taskId)?.taskGroupIds[0];
-    const payload = prepareTaskPayload(state, taskId, updatedTaskGroupId);
+    // On edit, prefer the locally-edited group; fall back to the entity's
+    // current group. On create, use the taskGroupId from the action payload.
+    const localTaskGroupId = taskId != null
+        ? state.taskDetailState.editTaskStateById[taskId]?.taskDetailLocalData
+            ?.taskGroupId
+        : undefined;
+    // groupWasCleared distinguishes "user explicitly cleared the group"
+    // (localTaskGroupId === null → send []) from "user did not touch it"
+    // (undefined → fall back to entity). Without this, the `??` fallback
+    // would resurrect the stale entity value after a clear.
+    const groupWasCleared = taskId != null && localTaskGroupId === null;
+    const entityTaskGroupIds = taskId != null
+        ? (getTaskById(state.taskState, taskId)?.taskGroupIds ?? [])
+        : [];
+    // Distinguish three save shapes:
+    //   - cleared → []
+    //   - user picked a different group locally → [localTaskGroupId]
+    //   - no local edit → entire entityTaskGroupIds (preserves multi-
+    //     group membership; without this, unrelated field edits silently
+    //     drop extra groups).
+    const localGroupChanged = localTaskGroupId != null;
+    const taskGroupIdsForPayload = groupWasCleared
+        ? []
+        : localGroupChanged
+            ? [localTaskGroupId]
+            : taskId != null
+                ? entityTaskGroupIds
+                : taskGroupId != null
+                    ? [taskGroupId]
+                    : [];
+    // Keep `updatedTaskGroupId` (single id) for downstream list-update
+    // dispatches that still bucket against one group at a time.
+    const updatedTaskGroupId = taskGroupIdsForPayload[0];
+    const payload = prepareTaskPayload(state, taskId, taskGroupIdsForPayload);
     const saveTaskApi = taskId != null
         ? zeniAPI.putAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks/${taskId}`, payload)
         : zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks`, payload);
     return saveTaskApi.pipe(mergeMap((response) => {
         if (isSuccessResponse(response) &&
             response.data != null &&
-            updatedTaskGroupId != null &&
             response.data.tasks.length > 0) {
             const newTaskId = response.data.tasks[0].task_id;
             const actions = [
@@ -33,7 +62,24 @@ export const saveTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(f
                     taskId,
                 }),
             ];
-            if (isTaskListFetched === true) {
+            // Only suppress the list-insert on the live/completed tabs
+            // when the saved task's status no longer matches the tab —
+            // otherwise doUpdateTaskList writes the row back into the
+            // current tab's grouping arrays even after updateTasks moved
+            // it to Completed. Archived/snoozed/deleted are owned by
+            // their dedicated actions and must keep the pre-PR optimistic
+            // update path so their grouping arrays don't go stale.
+            const savedTask = response.data.tasks[0];
+            const savedIsCompleted = savedTask.status?.code === 'resolved';
+            const activeTab = state.taskListState.currentTab;
+            const isLiveOrCompletedTab = activeTab === 'live' || activeTab === 'completed';
+            const statusMatchesActiveTab = !isLiveOrCompletedTab ||
+                (savedIsCompleted && activeTab === 'completed') ||
+                (!savedIsCompleted && activeTab === 'live');
+            if (isTaskListFetched === true &&
+                groupWasCleared === false &&
+                updatedTaskGroupId != null &&
+                statusMatchesActiveTab === true) {
                 actions.push(updateTaskListOnNewTaskCreationSuccess({
                     taskGroupId: updatedTaskGroupId,
                     task: response.data.tasks[0],
@@ -42,6 +88,21 @@ export const saveTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(f
                         : undefined,
                 }));
             }
+            else if (isTaskListFetched === true &&
+                groupWasCleared === true &&
+                taskId != null) {
+                // Group was cleared — skip the list-insert action (no
+                // destination bucket) and explicitly drop the row from every
+                // previously-held group so the list re-renders without the
+                // stale entry under the old group until next refetch.
+                const previousTask = getTaskById(state.taskState, taskId);
+                previousTask?.taskGroupIds.forEach((previousGroupId) => {
+                    actions.push(removeTaskFromGroupBucket({
+                        taskId,
+                        taskGroupId: previousGroupId,
+                    }));
+                });
+            }
             return from(actions);
         }
         else {
@@ -67,7 +128,7 @@ export const saveTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(f
         error: createZeniAPIStatus('Unexpected Error', 'Save Task REST API call errored out' + JSON.stringify(error)),
     }))));
 }));
-const prepareTaskPayload = (state, taskId, taskGroupId) => {
+const prepareTaskPayload = (state, taskId, taskGroupIds) => {
     const { taskDetailState, taskState } = state;
     const syncToken = taskId != null ? (getTaskById(taskState, taskId)?.syncToken ?? '') : '';
     const sourceState = taskId != null
@@ -96,7 +157,7 @@ const prepareTaskPayload = (state, taskId, taskGroupId) => {
             ? (localData.recurringDaysOfWeek ?? [])
             : [],
         sync_token: syncToken,
-        task_group_ids: taskGroupId != null ? [taskGroupId] : [],
+        task_group_ids: taskGroupIds,
         time_spent: convertHHMMStrToMinutes(localData.timeSpent),
         group_assignees: localData.groupAssignees,
         ...(taskId == null ? { is_private: localData.isPrivate ?? false } : {}),

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

@@ -6,6 +6,11 @@ import { initialTaskDetail, } from './taskDetail';
 export const initialState = {
     newTaskState: initialTaskDetail,
     editTaskStateById: {},
+    subTaskCreateStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    subTaskListFetchStatusByParentId: {},
     taskHistoryById: {},
 };
 const taskDetailView = createSlice({
@@ -50,7 +55,7 @@ const taskDetailView = createSlice({
         updateEditTaskFetchStatus(draft, action) {
             const { taskId, fetchState, error } = action.payload;
             draft.editTaskStateById[taskId] = {
-                ...draft.editTaskStateById[taskId],
+                ...(draft.editTaskStateById[taskId] ?? initialTaskDetail),
                 fetchTaskStatus: {
                     fetchState,
                     error: fetchState === 'Error' ? error : undefined,
@@ -318,10 +323,59 @@ const taskDetailView = createSlice({
                 error,
             };
         },
+        createSubTask: {
+            reducer(draft) {
+                draft.subTaskCreateStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        createSubTaskSuccessOrFailure(draft, action) {
+            const { fetchState, error } = action.payload;
+            draft.subTaskCreateStatus = {
+                fetchState,
+                error,
+            };
+        },
+        resetSubTaskCreateStatus(draft) {
+            draft.subTaskCreateStatus = {
+                ...initialState.subTaskCreateStatus,
+            };
+        },
+        fetchSubTasks: {
+            reducer(draft, action) {
+                const { parentTaskId } = action.payload;
+                draft.subTaskListFetchStatusByParentId[parentTaskId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(parentTaskId) {
+                return { payload: { parentTaskId } };
+            },
+        },
+        updateSubTasks(draft, action) {
+            const { parentTaskId } = action.payload;
+            draft.subTaskListFetchStatusByParentId[parentTaskId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        updateSubTasksFetchStatus(draft, action) {
+            const { parentTaskId, fetchState, error } = action.payload;
+            draft.subTaskListFetchStatusByParentId[parentTaskId] = {
+                fetchState,
+                error,
+            };
+        },
         clearTaskDetail(draft) {
             Object.assign(draft, initialState);
         },
     },
 });
-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 const { fetchTaskDetailPage, fetchTaskDetail, initializeTaskToLocalStore, updateEditTaskFetchStatus, saveTaskUpdatesToLocalStore, discardTaskUpdatesInLocalStore, saveTaskDetail, archiveTask, archiveTaskSuccessOrFailure, saveTaskSuccessOrFailure, createSubTask, createSubTaskSuccessOrFailure, resetSubTaskCreateStatus, fetchSubTasks, updateSubTasks, updateSubTasksFetchStatus, 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

@@ -1,8 +1,8 @@
 import isEqual from 'lodash/isEqual';
-import { reduceFetchState } from '../../../commonStateTypes/reduceFetchState';
+import { reduceAnyFetchState } from '../../../commonStateTypes/reduceFetchState';
 import { getClassesByIds } from '../../../entity/class/classSelector';
 import { getFilesByFileIds } from '../../../entity/file/fileSelector';
-import { getTaskById } from '../../../entity/task/taskSelector';
+import { getTaskById, getTasksByIds } from '../../../entity/task/taskSelector';
 import { getUserAndUserRole, } from '../../companyView/types/userAndRole';
 import { getFileDeleteStatusById, getFileUpdateNameStatusById, } from '../../fileView/fileViewSelector';
 import { getUserList, } from '../../userListView/userListViewSelector';
@@ -27,8 +27,13 @@ export const getTaskDetail = (state, taskId) => {
     let recurringSourceTaskId = undefined;
     let snoozedUntil = undefined;
     let taskGroupId = undefined;
+    let subtasks = [];
     if (taskId != null && sourceTaskDetail != null) {
         const taskEntity = getTaskById(taskState, taskId);
+        subtasks =
+            taskEntity != null
+                ? getTasksByIds(taskState, taskEntity.subTasksIds)
+                : [];
         const fileIdsInEntity = taskEntity?.fileIds ?? [];
         if (taskEntity != null) {
             createdByUser = getUserAndUserRole(userState, userRoleState, addressState, taskEntity.createdBy);
@@ -38,26 +43,37 @@ export const getTaskDetail = (state, taskId) => {
             snoozedUntil = taskEntity.snoozedUntil;
             taskGroupId = taskEntity.taskGroupIds[0];
         }
+        // Treat "no entry" as Completed so it doesn't block the combined
+        // fetch state. The Not-Started default would pin the detail page
+        // below Completed forever before the first fetchSubTasks dispatches.
+        const completedSubTaskStatus = {
+            fetchState: 'Completed',
+            error: undefined,
+        };
+        const subTaskStatus = taskDetailState.subTaskListFetchStatusByParentId[taskId] ??
+            completedSubTaskStatus;
         if (fileIdsInEntity.length > 0) {
-            fetchStatus = reduceFetchState([
+            fetchStatus = reduceAnyFetchState([
                 fileViewState.fetchFilesStatus,
                 sourceTaskDetail.fetchTaskStatus,
                 userList,
                 classListState,
+                subTaskStatus,
             ]);
         }
         else {
-            fetchStatus = reduceFetchState([
+            fetchStatus = reduceAnyFetchState([
                 sourceTaskDetail.fetchTaskStatus,
                 userList,
                 classListState,
+                subTaskStatus,
             ]);
         }
         showTaskDetailFormFooter = showFormFooter(sourceTaskDetail.taskDetailLocalData, taskEntity);
         taskHistory = taskDetailState.taskHistoryById[taskId]?.historicEvents ?? [];
     }
     else if (taskId == null) {
-        fetchStatus = reduceFetchState([userList, classListState]);
+        fetchStatus = reduceAnyFetchState([userList, classListState]);
     }
     const { classIds } = classListState;
     const allAccountingClasses = getClassesByIds(classState, {
@@ -90,6 +106,7 @@ export const getTaskDetail = (state, taskId) => {
         showTaskDetailFormFooter,
         snoozedUntil,
         taskGroupId,
+        subtasks,
     };
 };
 export const allTaskStatus = [
@@ -137,13 +154,16 @@ export const allTaskPriority = [
     },
 ];
 const showFormFooter = (taskDetailLocalData, taskDetailInStore) => {
-    if (taskDetailLocalData.name !== taskDetailInStore?.name ||
+    if (taskDetailInStore == null) {
+        return false;
+    }
+    if (taskDetailLocalData.name !== taskDetailInStore.name ||
         taskDetailLocalData.description !== taskDetailInStore.description ||
         taskDetailLocalData.priority !== taskDetailInStore.priority.code ||
         taskDetailLocalData.status !== taskDetailInStore.status.code ||
         !isEqual(taskDetailInStore.tagIds, taskDetailLocalData.tagIds) ||
-        !isEqual(taskDetailLocalData.assignee, taskDetailInStore?.assignees ?? []) ||
-        !isEqual(taskDetailLocalData.groupAssignees, taskDetailInStore?.groupAssignees ?? []) ||
+        !isEqual(taskDetailLocalData.assignee, taskDetailInStore.assignees ?? []) ||
+        !isEqual(taskDetailLocalData.groupAssignees, taskDetailInStore.groupAssignees ?? []) ||
         !isEqual(taskDetailLocalData.fileIds, taskDetailInStore.fileIds ?? []) ||
         !isEqual(taskDetailLocalData.dueDate, taskDetailInStore.dueDate) ||
         !isEqual(taskDetailLocalData.type, taskDetailInStore.type) ||
@@ -151,7 +171,10 @@ const showFormFooter = (taskDetailLocalData, taskDetailInStore) => {
         !isEqual(taskDetailLocalData.recurringFrequency, taskDetailInStore.recurringFrequency) ||
         !isEqual(taskDetailLocalData.recurringDaysOfWeek, taskDetailInStore.recurringDaysOfWeek) ||
         !isEqual(taskDetailLocalData.recurringStartDate, taskDetailInStore.recurringStartDate) ||
-        !isEqual(taskDetailLocalData.timeSpent, taskDetailInStore.timeSpent)) {
+        !isEqual(taskDetailLocalData.timeSpent, taskDetailInStore.timeSpent) ||
+        !isEqual(taskDetailLocalData.taskGroupId, taskDetailInStore.taskGroupIds.length > 0
+            ? taskDetailInStore.taskGroupIds[0]
+            : undefined)) {
         return true;
     }
     return false;

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

@@ -9,15 +9,17 @@ 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) {
-            const { tasks, deleted, archived, snoozed } = response.data;
+            const { tasks, deleted, archived, snoozed, completed } = response.data;
             const allTasks = [
                 ...tasks,
+                ...(completed ?? []),
                 ...(deleted ?? []),
                 ...(archived ?? []),
                 ...(snoozed ?? []),
             ];
             return of(updateTasks(allTasks), updateTaskList({
                 data: tasks,
+                completed: completed ?? [],
                 deleted: deleted ?? [],
                 archived: archived ?? [],
                 snoozed: snoozed ?? [],

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

@@ -1,6 +1,7 @@
 import { stringToUnion, stringToUnionStrict, } from '../../../commonStateTypes/stringToUnion';
 export const ALL_TASK_LIST_TABS = [
     'live',
+    'completed',
     'archived',
     'deleted',
     'snoozed',