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

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) => {
@@ -279,6 +311,7 @@ const taskList = createSlice({
                 newTaskGroupName: '',
                 selectedTaskIds: [],
             };
+            syncTopLevelToActiveTab(draft);
         },
         updateTasksListOnBulkUpdateTasksFailure(draft, action) {
             draft.updateTasksFetchState.fetchState = 'Error';
@@ -298,6 +331,7 @@ const taskList = createSlice({
             }
             delete draft.taskIdsByGroupsIds[taskGroupId];
             delete draft.localData.existingTaskGroupNamesByGroupId[taskGroupId];
+            syncTopLevelToActiveTab(draft);
         },
         updateTaskListOnNewTaskCreationSuccess(draft, action) {
             const { task, taskGroupId, currentTaskState } = action.payload;
@@ -332,6 +366,7 @@ const taskList = createSlice({
                     doUpdateTaskList(draft, task, taskGroupId);
                 }
             });
+            syncTopLevelToActiveTab(draft);
         },
         updateTaskListOnTaskGroupNameUpdate(draft, action) {
             const { taskGroupName, taskGroupId } = action.payload;
@@ -395,6 +430,7 @@ const taskList = createSlice({
                     };
                 }
             }
+            syncTopLevelToActiveTab(draft);
         },
         updateTasksListOnUpdateTaskSuccess(draft) {
             draft.updateTasksFetchState.fetchState = 'Completed';
@@ -404,12 +440,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 +527,61 @@ 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 syncTopLevelToActiveTab = (draft) => {
+    const tabData = draft.byTab[draft.currentTab];
+    tabData.taskIds = draft.taskIds;
+    tabData.taskIdsByGroupsIds = draft.taskIdsByGroupsIds;
+    tabData.taskIdsByPriority = draft.taskIdsByPriority;
+    tabData.taskIdsByStatus = draft.taskIdsByStatus;
+    tabData.taskIdsByAssignees = draft.taskIdsByAssignees;
+    tabData.taskIdsByDueDate = draft.taskIdsByDueDate;
+    tabData.taskIdsByTags = draft.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 removedSet = new Set(taskIds);
+    const isRemoved = (id) => removedSet.has(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 = {};

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

@@ -1,5 +1,4 @@
 import { createSelector } from '@reduxjs/toolkit';
-import isEqual from 'lodash/isEqual';
 import orderBy from 'lodash/orderBy';
 import { getSortOrder, } from '../../../commonPayloadTypes/sortOrderPayload';
 import { reduceAnyFetchState } from '../../../commonStateTypes/reduceFetchState';
@@ -15,11 +14,6 @@ import { getUserGroupList } from '../../userGroupListView/userGroupListViewSelec
 import { getUserList, } from '../../userListView/userListViewSelector';
 import { allTaskPriority, allTaskStatus, } from '../taskDetailView/taskDetailSelector';
 import { DUE_DATE_GROUP_KEYS, } from './taskList';
-import { initialState } from './taskListReducer';
-const isDefaultFilters = (taskListState) => {
-    return (isEqual(taskListState.filters, initialState.filters) &&
-        initialState.uiState.searchText === taskListState.uiState.searchText);
-};
 const sortTasksList = (tagState, tasksList, sortKey, sortOrder) => {
     const tasksInOrder = orderBy(tasksList, (task) => {
         const tagsByIds = getTagsByIds(tagState, task.tagIds);
@@ -34,8 +28,12 @@ const sortTasksList = (tagState, tasksList, sortKey, sortOrder) => {
                 return task.status.name;
             case 'priority':
                 return ALL_PRIORITY_CODE.indexOf(task.priority.code);
+            case 'assignee':
+                return task.firstAssigneeSortName;
             case 'timeSpent':
                 return task.timeSpent;
+            case 'visibility':
+                return task.isPrivate === true ? 1 : 0;
             case 'name':
             default:
                 return task.name.toLowerCase();
@@ -43,7 +41,7 @@ const sortTasksList = (tagState, tasksList, sortKey, sortOrder) => {
     }, sortOrder);
     return tasksInOrder;
 };
-const getTasksWithUserDetails = ({ taskListState, taskState, userState, userRoleState, addressState, taskIds, tagState, }) => {
+const getTasksWithUserDetails = ({ taskListState, taskState, userState, userRoleState, addressState, taskIds, tagState, userGroupsState, }) => {
     const { sortKey, searchText } = taskListState.uiState;
     const sortOrder = getSortOrder(taskListState.uiState.sortOrder);
     const tasks = taskIds
@@ -53,7 +51,15 @@ const getTasksWithUserDetails = ({ taskListState, taskState, userState, userRole
             const assigneeUsers = task.assignees
                 .map((userId) => getUserAndUserRole(userState, userRoleState, addressState, userId))
                 .filter((value) => value != null);
-            return { ...task, assigneeUsers };
+            const firstUser = assigneeUsers[0]?.user;
+            const firstUserName = (firstUser != null ? getUserName(firstUser) : '') ||
+                firstUser?.email ||
+                '';
+            const firstGroupName = task.groupAssignees
+                .map((gId) => userGroupsState.userGroupByUserGroupId[gId]?.name)
+                .find((name) => name != null && name !== '');
+            const firstAssigneeSortName = (firstUserName !== '' ? firstUserName : (firstGroupName ?? '')).toLowerCase();
+            return { ...task, assigneeUsers, firstAssigneeSortName };
         }
         return undefined;
     })
@@ -62,7 +68,7 @@ const getTasksWithUserDetails = ({ taskListState, taskState, userState, userRole
     const sortedTaskList = sortTasksList(tagState, filteredTaskList, sortKey, sortOrder);
     return sortedTaskList;
 };
-const getTaskListGroupedByGroupName = ({ taskListState, taskState, taskGroupState, taskGroupViewState, userState, userRoleState, addressState, tagState, }) => {
+const getTaskListGroupedByGroupName = ({ taskListState, taskState, taskGroupState, taskGroupViewState, userState, userRoleState, addressState, tagState, userGroupsState, }) => {
     const { taskGroupsIds } = taskGroupViewState;
     const taskGroupsWithTasksList = taskGroupsIds
         .map((taskGroupId) => {
@@ -76,6 +82,7 @@ const getTaskListGroupedByGroupName = ({ taskListState, taskState, taskGroupStat
             addressState,
             taskIds,
             tagState,
+            userGroupsState,
         });
         if (taskGroup != null) {
             return {
@@ -104,12 +111,9 @@ const getTaskListGroupedByGroupName = ({ taskListState, taskState, taskGroupStat
     if (defaultTaskGroup != null) {
         sortedTaskGroupsWithTasksList.push(defaultTaskGroup);
     }
-    if (isDefaultFilters(taskListState) === false) {
-        return sortedTaskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
-    }
-    return sortedTaskGroupsWithTasksList;
+    return sortedTaskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
 };
-export const getTaskListGroupedByAssignees = ({ taskListState, taskState, userState, userRoleState, addressState, tagState, }) => {
+export const getTaskListGroupedByAssignees = ({ taskListState, taskState, userState, userRoleState, addressState, tagState, userGroupsState, }) => {
     const assigneeGroups = Object.keys(taskListState.taskIdsByAssignees);
     const taskGroupsWithTasksList = assigneeGroups.map((groupKey) => {
         const taskIds = taskListState.taskIdsByAssignees[groupKey];
@@ -121,6 +125,7 @@ export const getTaskListGroupedByAssignees = ({ taskListState, taskState, userSt
             addressState,
             taskIds,
             tagState,
+            userGroupsState,
         });
         const assigneeIds = groupKey.split(',');
         const groupName = getUsersByUserIds(userState, assigneeIds)
@@ -136,12 +141,9 @@ export const getTaskListGroupedByAssignees = ({ taskListState, taskState, userSt
             tasks: tasksWithUserDetails,
         };
     });
-    if (isDefaultFilters(taskListState) === false) {
-        return taskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
-    }
-    return taskGroupsWithTasksList;
+    return taskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
 };
-export const getTaskListGroupedByPriority = ({ taskListState, taskState, userState, userRoleState, addressState, tagState, }) => {
+export const getTaskListGroupedByPriority = ({ taskListState, taskState, userState, userRoleState, addressState, tagState, userGroupsState, }) => {
     const taskGroupsWithTasksList = ALL_PRIORITY_CODE.map((groupKey) => {
         const taskIds = taskListState.taskIdsByPriority[groupKey] ?? [];
         const tasksWithUserDetails = getTasksWithUserDetails({
@@ -152,6 +154,7 @@ export const getTaskListGroupedByPriority = ({ taskListState, taskState, userSta
             addressState,
             taskIds,
             tagState,
+            userGroupsState,
         });
         return {
             groupName: allTaskPriority.find((priority) => priority.code === groupKey)?.name ??
@@ -161,12 +164,9 @@ export const getTaskListGroupedByPriority = ({ taskListState, taskState, userSta
             tasks: tasksWithUserDetails,
         };
     });
-    if (isDefaultFilters(taskListState) === false) {
-        return taskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
-    }
-    return taskGroupsWithTasksList;
+    return taskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
 };
-const getTaskListGroupedByStatus = ({ taskListState, taskState, userState, userRoleState, addressState, tagState, }) => {
+const getTaskListGroupedByStatus = ({ taskListState, taskState, userState, userRoleState, addressState, tagState, userGroupsState, }) => {
     const taskGroupsWithTasksList = ALL_TASK_STATUS_CODE.map((groupKey) => {
         const taskIds = taskListState.taskIdsByStatus[groupKey] ?? [];
         const tasksWithUserDetails = getTasksWithUserDetails({
@@ -177,6 +177,7 @@ const getTaskListGroupedByStatus = ({ taskListState, taskState, userState, userR
             addressState,
             taskIds,
             tagState,
+            userGroupsState,
         });
         return {
             groupName: allTaskStatus.find((taskStatus) => taskStatus.code === groupKey)
@@ -186,12 +187,9 @@ const getTaskListGroupedByStatus = ({ taskListState, taskState, userState, userR
             tasks: tasksWithUserDetails,
         };
     });
-    if (isDefaultFilters(taskListState) === false) {
-        return taskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
-    }
-    return taskGroupsWithTasksList;
+    return taskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
 };
-const getTaskListGroupedByTags = ({ taskListState, taskState, userState, userRoleState, addressState, tagState, }) => {
+const getTaskListGroupedByTags = ({ taskListState, taskState, userState, userRoleState, addressState, tagState, userGroupsState, }) => {
     const tagGroups = Object.keys(taskListState.taskIdsByTags);
     const taskGroupsWithTasksList = tagGroups.map((groupKey) => {
         const taskIds = taskListState.taskIdsByTags[groupKey];
@@ -203,6 +201,7 @@ const getTaskListGroupedByTags = ({ taskListState, taskState, userState, userRol
             addressState,
             taskIds,
             tagState,
+            userGroupsState,
         });
         const tagIds = groupKey.split(',');
         const groupName = getTagsByIds(tagState, tagIds)
@@ -217,12 +216,9 @@ const getTaskListGroupedByTags = ({ taskListState, taskState, userState, userRol
             tasks: tasksWithUserDetails,
         };
     });
-    if (isDefaultFilters(taskListState) === false) {
-        return taskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
-    }
-    return taskGroupsWithTasksList;
+    return taskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
 };
-const getTaskListGroupedByDueDate = ({ taskListState, taskState, userState, userRoleState, addressState, tagState, }) => {
+const getTaskListGroupedByDueDate = ({ taskListState, taskState, userState, userRoleState, addressState, tagState, userGroupsState, }) => {
     const taskGroupsWithTasksList = DUE_DATE_GROUP_KEYS.map((groupKey) => {
         const taskIds = taskListState.taskIdsByDueDate[groupKey];
         const tasksWithUserDetails = getTasksWithUserDetails({
@@ -233,6 +229,7 @@ const getTaskListGroupedByDueDate = ({ taskListState, taskState, userState, user
             addressState,
             taskIds,
             tagState,
+            userGroupsState,
         });
         return {
             groupName: groupKey,
@@ -241,12 +238,9 @@ const getTaskListGroupedByDueDate = ({ taskListState, taskState, userState, user
             tasks: tasksWithUserDetails,
         };
     });
-    if (isDefaultFilters(taskListState) === false) {
-        return taskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
-    }
-    return taskGroupsWithTasksList;
+    return taskGroupsWithTasksList.filter((group) => group.tasks.length > 0);
 };
-const getTaskGroupsWithTaskList = ({ taskListState, taskState, userState, userRoleState, addressState, taskGroupState, taskGroupViewState, tagState, }) => {
+const getTaskGroupsWithTaskList = ({ taskListState, taskState, userState, userRoleState, addressState, taskGroupState, taskGroupViewState, tagState, userGroupsState, }) => {
     const { groupByKey } = taskListState.uiState;
     if (groupByKey === 'groupName') {
         return getTaskListGroupedByGroupName({
@@ -258,6 +252,7 @@ const getTaskGroupsWithTaskList = ({ taskListState, taskState, userState, userRo
             taskGroupState,
             taskGroupViewState,
             tagState,
+            userGroupsState,
         });
     }
     if (groupByKey === 'assignee') {
@@ -268,6 +263,7 @@ const getTaskGroupsWithTaskList = ({ taskListState, taskState, userState, userRo
             userRoleState,
             addressState,
             tagState,
+            userGroupsState,
         });
     }
     if (groupByKey === 'priority') {
@@ -278,6 +274,7 @@ const getTaskGroupsWithTaskList = ({ taskListState, taskState, userState, userRo
             userRoleState,
             addressState,
             tagState,
+            userGroupsState,
         });
     }
     if (groupByKey === 'status') {
@@ -288,6 +285,7 @@ const getTaskGroupsWithTaskList = ({ taskListState, taskState, userState, userRo
             userRoleState,
             addressState,
             tagState,
+            userGroupsState,
         });
     }
     if (groupByKey === 'tag') {
@@ -298,6 +296,7 @@ const getTaskGroupsWithTaskList = ({ taskListState, taskState, userState, userRo
             userRoleState,
             addressState,
             tagState,
+            userGroupsState,
         });
     }
     return getTaskListGroupedByDueDate({
@@ -307,6 +306,7 @@ const getTaskGroupsWithTaskList = ({ taskListState, taskState, userState, userRo
         userRoleState,
         addressState,
         tagState,
+        userGroupsState,
     });
 };
 export const getAllTasks = createSelector((state) => state.taskListState, (state) => state.taskState, (state) => state.userState, (state) => state.userRoleState, (state) => state.userListViewState, (state) => state.addressState, (state) => state.taskGroupState, (state) => state.taskGroupViewState, (state) => state.tagViewState, (state) => state.tagState, (state) => state.taskGroupTemplateState, (state) => state.taskGroupTemplateViewState, (state) => state.userGroupsState, (state) => state.userGroupListViewState, (_state, isTaskTemplatesEnabled) => isTaskTemplatesEnabled, (taskListState, taskState, userState, userRoleState, userListViewState, addressState, taskGroupState, taskGroupViewState, tagViewState, tagState, taskGroupTemplateState, taskGroupTemplateViewState, userGroupsState, userGroupListViewState, isTaskTemplatesEnabled) => {
@@ -320,6 +320,7 @@ export const getAllTasks = createSelector((state) => state.taskListState, (state
         taskGroupState,
         taskGroupViewState,
         tagState,
+        userGroupsState,
     });
     const fetchStateVariables = [
         taskListState,
@@ -331,7 +332,15 @@ export const getAllTasks = createSelector((state) => state.taskListState, (state
     }
     const { fetchState, error } = reduceAnyFetchState(fetchStateVariables);
     const taskGroupTemplates = getTaskGroupTemplateByIds(taskGroupTemplateState, taskGroupTemplateViewState.taskGroupTemplateIds);
+    const tabCounts = {
+        live: taskListState.byTab.live.taskIds.length,
+        archived: taskListState.byTab.archived.taskIds.length,
+        deleted: taskListState.byTab.deleted.taskIds.length,
+        snoozed: taskListState.byTab.snoozed.taskIds.length,
+    };
     return {
+        currentTab: taskListState.currentTab,
+        tabCounts,
         uiState: taskListState.uiState,
         filters: taskListState.filters,
         taskGroupTemplates,

package/lib/esm/view/zeniOAuthView/epics/approveOAuthConsentEpic.js

@@ -0,0 +1,64 @@
+import { from, of } from 'rxjs';
+import { catchError, concatMap, filter, mergeMap, switchMap, } from 'rxjs/operators';
+import { openSnackbar } from '../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus } from '../../../responsePayload';
+import { approveOAuthConsent, approveOAuthConsentFailure, approveOAuthConsentSuccess, } from '../zeniOAuthReducer';
+const failureSnackbar = (reason) => openSnackbar({
+    messageSection: 'oauth_consent_approve',
+    messageText: 'failed',
+    type: 'error',
+    variables: [{ variableName: '__reason__', variableValue: reason }],
+});
+export const approveOAuthConsentEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(approveOAuthConsent.match), switchMap((action) => {
+    if (state$.value.zeniOAuthViewState.fetchState === 'In-Progress') {
+        return from([]);
+    }
+    const { userId, zeniSessionId, tenantId, clientId, redirectUri, codeChallenge, codeChallengeMethod, state, responseType, } = action.payload;
+    const authHeaders = {
+        'zeni-user-id': userId,
+        'zeni-tenant-id': tenantId,
+    };
+    if (zeniSessionId != null) {
+        authHeaders['zeni-session-id'] = zeniSessionId;
+    }
+    return zeniAPI
+        .postJSON(`${zeniAPI.apiEndPoints.authMicroServiceBaseUrl}/oauth/authorize/approve`, {
+        client_id: clientId,
+        redirect_uri: redirectUri,
+        code_challenge: codeChallenge,
+        code_challenge_method: codeChallengeMethod,
+        state,
+        response_type: responseType,
+        tenant_id: tenantId,
+    }, authHeaders)
+        .pipe(concatMap((response) => from(response.json()).pipe(mergeMap((responseJson) => {
+        if (!response.ok) {
+            const errBody = responseJson;
+            const errorMessage = errBody?.error ??
+                errBody?.message ??
+                errBody?.status?.message ??
+                `Authorization failed (${response.status})`;
+            return from([
+                approveOAuthConsentFailure(createZeniAPIStatus(errorMessage)),
+                failureSnackbar(errorMessage),
+            ]);
+        }
+        const body = responseJson;
+        const redirectUrl = body?.redirect_url ?? body?.data?.redirect_url;
+        if (redirectUrl == null || redirectUrl === '') {
+            const noRedirectMessage = 'No redirect URL returned from authorization server';
+            return from([
+                approveOAuthConsentFailure(createZeniAPIStatus(noRedirectMessage)),
+                failureSnackbar(noRedirectMessage),
+            ]);
+        }
+        return of(approveOAuthConsentSuccess({ redirectUrl }));
+    }))), catchError((error) => {
+        const errorDetail = error instanceof Error ? error.message : JSON.stringify(error);
+        const networkErrorMessage = 'OAuth approve request failed: ' + errorDetail;
+        return from([
+            approveOAuthConsentFailure(createZeniAPIStatus(networkErrorMessage)),
+            failureSnackbar(networkErrorMessage),
+        ]);
+    }));
+}));

package/lib/esm/view/zeniOAuthView/zeniOAuthParamsParser.js

@@ -0,0 +1,41 @@
+export function parseOAuthParams(search) {
+    const searchParams = new URLSearchParams(search);
+    const clientId = searchParams.get('client_id');
+    const redirectUri = searchParams.get('redirect_uri');
+    const codeChallenge = searchParams.get('code_challenge');
+    const codeChallengeMethod = searchParams.get('code_challenge_method') ?? 'S256';
+    const state = searchParams.get('state');
+    const responseType = searchParams.get('response_type') ?? 'code';
+    if (clientId == null || clientId === '') {
+        return { params: null, error: 'Missing client_id parameter' };
+    }
+    if (redirectUri == null || redirectUri === '') {
+        return { params: null, error: 'Missing redirect_uri parameter' };
+    }
+    try {
+        void new URL(redirectUri);
+    }
+    catch {
+        return { params: null, error: 'Invalid redirect_uri parameter' };
+    }
+    if (codeChallenge == null || codeChallenge === '') {
+        return {
+            params: null,
+            error: 'Missing code_challenge parameter (PKCE required)',
+        };
+    }
+    if (state == null || state === '') {
+        return { params: null, error: 'Missing state parameter' };
+    }
+    return {
+        params: {
+            clientId,
+            redirectUri,
+            codeChallenge,
+            codeChallengeMethod,
+            state,
+            responseType,
+        },
+        error: null,
+    };
+}

package/lib/esm/view/zeniOAuthView/zeniOAuthReducer.js

@@ -0,0 +1,49 @@
+import { createSlice } from '@reduxjs/toolkit';
+export const initialState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    approveRedirectUrl: undefined,
+};
+const zeniOAuthView = createSlice({
+    name: 'zeniOAuthView',
+    initialState,
+    reducers: {
+        approveOAuthConsent: {
+            prepare(userId, zeniSessionId, tenantId, clientId, redirectUri, codeChallenge, codeChallengeMethod, state, responseType) {
+                return {
+                    payload: {
+                        userId,
+                        zeniSessionId,
+                        tenantId,
+                        clientId,
+                        redirectUri,
+                        codeChallenge,
+                        codeChallengeMethod,
+                        state,
+                        responseType,
+                    },
+                };
+            },
+            reducer(draft) {
+                draft.fetchState = 'In-Progress';
+                draft.error = undefined;
+                draft.approveRedirectUrl = undefined;
+            },
+        },
+        approveOAuthConsentSuccess(draft, action) {
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+            draft.approveRedirectUrl = action.payload.redirectUrl;
+        },
+        approveOAuthConsentFailure(draft, action) {
+            draft.fetchState = 'Error';
+            draft.error = action.payload;
+            draft.approveRedirectUrl = undefined;
+        },
+        clearZeniOAuthView() {
+            return initialState;
+        },
+    },
+});
+export const { approveOAuthConsent, approveOAuthConsentSuccess, approveOAuthConsentFailure, clearZeniOAuthView, } = zeniOAuthView.actions;
+export default zeniOAuthView.reducer;

package/lib/esm/view/zeniOAuthView/zeniOAuthSelector.js

@@ -0,0 +1,3 @@
+export const getZeniOAuthApproveFetchState = (state) => state.zeniOAuthViewState.fetchState;
+export const getZeniOAuthApproveRedirectUrl = (state) => state.zeniOAuthViewState.approveRedirectUrl;
+export const getZeniOAuthApproveError = (state) => state.zeniOAuthViewState.error?.message ?? null;

package/lib/esm/view/zeniOAuthView/zeniOAuthState.js

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