@zeniai/client-epic-state 4.11.72 → 4.11.73

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

@@ -1,23 +1,52 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearTaskList = exports.updateTaskListOnTaskGroupNameUpdate = exports.updateTaskListOnNewTaskCreationSuccess = exports.dragNDropTasks = exports.updateTaskListOnTaskGroupDeletion = exports.updateTaskListLocalData = exports.initiateTaskListLocalData = exports.updateTasksListOnBulkUpdateTasksFailure = exports.updateTasksListOnBulkUpdateTasksSuccess = exports.bulkUpdateTaskList = exports.updateTaskListOnNewGroupCreationSuccess = exports.updateTaskFilters = exports.updateTaskListUIState = exports.updateTaskListSearchText = exports.updateTaskListFetchStatus = exports.updateTaskList = exports.fetchTaskList = exports.fetchTaskListPage = exports.initialState = exports.initialLocalData = void 0;
+exports.clearTaskList = exports.updateTaskListOnTaskGroupNameUpdate = exports.updateTaskListOnNewTaskCreationSuccess = exports.dragNDropTasks = exports.updateTaskListOnTaskGroupDeletion = exports.updateTaskListLocalData = exports.initiateTaskListLocalData = exports.updateTasksListOnBulkUpdateTasksFailure = exports.updateTasksListOnBulkUpdateTasksSuccess = exports.bulkUpdateTaskList = exports.updateTaskListOnNewGroupCreationSuccess = exports.updateTaskFilters = exports.updateTaskListUIState = exports.updateTaskListSearchText = exports.updateTaskListFetchStatus = exports.updateTaskList = exports.fetchTaskList = exports.fetchTaskListPage = exports.initialState = void 0;
 const toolkit_1 = require("@reduxjs/toolkit");
-exports.initialLocalData = {
+const taskList_1 = require("./taskList");
+const taskState_1 = require("../../../entity/task/taskState");
+const zeniDayJS_1 = require("../../../zeniDayJS");
+const initialLocalData = {
     newTaskGroupName: '',
     existingTaskGroupNamesByGroupId: {},
     selectedTaskIds: [],
     defaultTaskGroupId: null,
 };
+const initialTaskIdsByPriority = {
+    urgent: [],
+    high: [],
+    medium: [],
+    low: [],
+};
+const initialTaskIdsByStatus = {
+    done: [],
+    in_progress: [],
+    on_hold: [],
+    resolved: [],
+    todo: [],
+};
+const initialTaskIdsByDueDate = {
+    overdue: [],
+    this_month: [],
+    this_week: [],
+    today: [],
+    upcoming: [],
+};
 exports.initialState = {
     taskIds: [],
     taskIdsByGroupsIds: {},
+    taskIdsByPriority: initialTaskIdsByPriority,
+    taskIdsByStatus: initialTaskIdsByStatus,
+    taskIdsByDueDate: initialTaskIdsByDueDate,
+    taskIdsByAssignees: {},
+    taskIdsByTags: {},
     fetchState: 'Not-Started',
-    searchText: '',
     error: undefined,
     uiState: {
         sortOrder: 'ascending',
         sortKey: 'dueDate',
+        groupByKey: 'groupName',
+        searchText: '',
     },
     filters: {
         categoryCombinationOperator: 'AND',
@@ -33,7 +62,7 @@ exports.initialState = {
     hasValidState() {
         return this.fetchState == 'Completed';
     },
-    localData: Object.assign({}, exports.initialLocalData),
+    localData: Object.assign({}, initialLocalData),
     updateTasksFetchState: {
         fetchState: 'Not-Started',
         error: undefined,
@@ -61,21 +90,14 @@ const taskList = (0, toolkit_1.createSlice)({
             const { data } = action.payload;
             draft.fetchState = 'Completed';
             draft.error = undefined;
-            const taskIdsByGroupsIds = {};
-            data.forEach((task) => {
-                draft.taskIds.push(task.task_id);
-                if (task.task_group_ids != null) {
-                    task.task_group_ids.forEach((groupId) => {
-                        if (taskIdsByGroupsIds[groupId] != null) {
-                            taskIdsByGroupsIds[groupId].push(task.task_id);
-                        }
-                        else {
-                            taskIdsByGroupsIds[groupId] = [task.task_id];
-                        }
-                    });
-                }
-            });
-            draft.taskIdsByGroupsIds = taskIdsByGroupsIds;
+            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;
         },
         initiateTaskListLocalData(draft, action) {
             const { taskGroupById } = action.payload;
@@ -87,7 +109,7 @@ const taskList = (0, toolkit_1.createSlice)({
                     defaultTaskGroupId = groupId;
                 }
             });
-            draft.localData = Object.assign(Object.assign({}, exports.initialLocalData), { defaultTaskGroupId,
+            draft.localData = Object.assign(Object.assign({}, initialLocalData), { defaultTaskGroupId,
                 existingTaskGroupNamesByGroupId });
         },
         updateTaskListLocalData(draft, action) {
@@ -98,7 +120,7 @@ const taskList = (0, toolkit_1.createSlice)({
             draft.error = action.payload.error;
         },
         updateTaskListSearchText(draft, action) {
-            draft.searchText = action.payload.searchText;
+            draft.uiState.searchText = action.payload.searchText;
         },
         updateTaskListUIState(draft, action) {
             if (action.payload.uiState.sortKey != null) {
@@ -107,6 +129,9 @@ const taskList = (0, toolkit_1.createSlice)({
             if (action.payload.uiState.sortOrder != null) {
                 draft.uiState.sortOrder = action.payload.uiState.sortOrder;
             }
+            if (action.payload.uiState.groupByKey != null) {
+                draft.uiState.groupByKey = action.payload.uiState.groupByKey;
+            }
             if (action.payload.uiState.scrollYOffset != null) {
                 draft.uiState.scrollYOffset = action.payload.uiState.scrollYOffset;
             }
@@ -127,11 +152,12 @@ const taskList = (0, toolkit_1.createSlice)({
                     error: undefined,
                 };
             },
-            prepare(taskIds, updates) {
+            prepare(taskIds, groupId, updates) {
                 return {
                     payload: {
                         taskIds,
                         updates,
+                        groupId,
                     },
                 };
             },
@@ -153,18 +179,82 @@ const taskList = (0, toolkit_1.createSlice)({
             const { taskIds, groupId } = action.payload;
             draft.updateTasksFetchState.fetchState = 'Completed';
             draft.updateTasksFetchState.error = undefined;
-            Object.keys(draft.taskIdsByGroupsIds).forEach((groupId) => {
-                draft.taskIdsByGroupsIds[groupId] = draft.taskIdsByGroupsIds[groupId].filter((taskId) => taskIds.includes(taskId) === false);
-            });
             if (groupId != null) {
-                if (draft.taskIdsByGroupsIds[groupId] != null) {
-                    draft.taskIdsByGroupsIds[groupId] = [
-                        ...draft.taskIdsByGroupsIds[groupId],
+                const { groupByKey } = draft.uiState;
+                if (groupByKey === 'groupName') {
+                    Object.keys(draft.taskIdsByGroupsIds).forEach((gId) => {
+                        draft.taskIdsByGroupsIds[gId] = draft.taskIdsByGroupsIds[gId].filter((taskId) => taskIds.includes(taskId) === false);
+                    });
+                    if (draft.taskIdsByGroupsIds[groupId] != null) {
+                        draft.taskIdsByGroupsIds[groupId] = [
+                            ...draft.taskIdsByGroupsIds[groupId],
+                            ...taskIds,
+                        ];
+                    }
+                    else {
+                        draft.taskIdsByGroupsIds = Object.assign(Object.assign({}, draft.taskIdsByGroupsIds), { [groupId]: taskIds });
+                    }
+                }
+                else if (groupByKey === 'assignee') {
+                    Object.keys(draft.taskIdsByAssignees).forEach((gId) => {
+                        draft.taskIdsByAssignees[gId] = draft.taskIdsByAssignees[gId].filter((taskId) => taskIds.includes(taskId) === false);
+                    });
+                    if (draft.taskIdsByAssignees[groupId] != null) {
+                        draft.taskIdsByAssignees[groupId] = [
+                            ...draft.taskIdsByAssignees[groupId],
+                            ...taskIds,
+                        ];
+                    }
+                    else {
+                        draft.taskIdsByAssignees = Object.assign(Object.assign({}, draft.taskIdsByAssignees), { [groupId]: taskIds });
+                    }
+                }
+                else if (groupByKey === 'tag') {
+                    Object.keys(draft.taskIdsByTags).forEach((gId) => {
+                        draft.taskIdsByTags[gId] = draft.taskIdsByTags[gId].filter((taskId) => taskIds.includes(taskId) === false);
+                    });
+                    if (draft.taskIdsByTags[groupId] != null) {
+                        draft.taskIdsByTags[groupId] = [
+                            ...draft.taskIdsByTags[groupId],
+                            ...taskIds,
+                        ];
+                    }
+                    else {
+                        draft.taskIdsByTags = Object.assign(Object.assign({}, draft.taskIdsByTags), { [groupId]: taskIds });
+                    }
+                }
+                else if (groupByKey === 'dueDate') {
+                    Object.keys(draft.taskIdsByDueDate).forEach((gId) => {
+                        const groupKey = (0, taskList_1.toDueDateGroupKeyType)(gId);
+                        draft.taskIdsByDueDate[groupKey] = draft.taskIdsByDueDate[groupKey].filter((taskId) => taskIds.includes(taskId) === false);
+                    });
+                    const groupKey = (0, taskList_1.toDueDateGroupKeyType)(groupId);
+                    draft.taskIdsByDueDate[groupKey] = [
+                        ...draft.taskIdsByDueDate[groupKey],
                         ...taskIds,
                     ];
                 }
-                else {
-                    draft.taskIdsByGroupsIds = Object.assign(Object.assign({}, draft.taskIdsByGroupsIds), { [groupId]: taskIds });
+                else if (groupByKey === 'priority') {
+                    Object.keys(draft.taskIdsByPriority).forEach((gId) => {
+                        const groupKey = (0, taskState_1.toPriorityCodeType)(gId);
+                        draft.taskIdsByPriority[groupKey] = draft.taskIdsByPriority[groupKey].filter((taskId) => taskIds.includes(taskId) === false);
+                    });
+                    const groupKey = (0, taskState_1.toPriorityCodeType)(groupId);
+                    draft.taskIdsByPriority[groupKey] = [
+                        ...draft.taskIdsByPriority[groupKey],
+                        ...taskIds,
+                    ];
+                }
+                else if (groupByKey === 'status') {
+                    Object.keys(draft.taskIdsByStatus).forEach((gId) => {
+                        const groupKey = (0, taskState_1.toTaskStatusCodeType)(gId);
+                        draft.taskIdsByStatus[groupKey] = draft.taskIdsByStatus[groupKey].filter((taskId) => taskIds.includes(taskId) === false);
+                    });
+                    const groupKey = (0, taskState_1.toTaskStatusCodeType)(groupId);
+                    draft.taskIdsByStatus[groupKey] = [
+                        ...draft.taskIdsByStatus[groupKey],
+                        ...taskIds,
+                    ];
                 }
             }
             draft.localData = Object.assign(Object.assign({}, draft.localData), { newTaskGroupName: '', selectedTaskIds: [] });
@@ -190,8 +280,44 @@ const taskList = (0, toolkit_1.createSlice)({
             delete draft.localData.existingTaskGroupNamesByGroupId[taskGroupId];
         },
         updateTaskListOnNewTaskCreationSuccess(draft, action) {
-            const { taskId, taskGroupId } = action.payload;
+            const { task, taskGroupId } = action.payload;
+            const taskId = task.task_id;
             draft.taskIds.push(taskId);
+            const priorityKey = (0, taskState_1.toPriorityCodeType)(task.priority.code);
+            const statusKey = (0, taskState_1.toTaskStatusCodeType)(task.status.code);
+            const assigneeKey = getAssigneesGroupKey(task.assignees);
+            const dueDateKey = getDueDateGroupKey(task.due_date);
+            const tagsKey = getTagsGroupKey(task.tags);
+            draft.taskIdsByPriority[priorityKey] = [
+                taskId,
+                ...draft.taskIdsByPriority[priorityKey],
+            ];
+            draft.taskIdsByStatus[statusKey] = [
+                taskId,
+                ...draft.taskIdsByStatus[statusKey],
+            ];
+            draft.taskIdsByDueDate[dueDateKey] = [
+                taskId,
+                ...draft.taskIdsByDueDate[dueDateKey],
+            ];
+            if (draft.taskIdsByAssignees[assigneeKey] != null) {
+                draft.taskIdsByAssignees[assigneeKey] = [
+                    taskId,
+                    ...draft.taskIdsByAssignees[assigneeKey],
+                ];
+            }
+            else {
+                draft.taskIdsByAssignees[assigneeKey] = [taskId];
+            }
+            if (draft.taskIdsByTags[tagsKey] != null) {
+                draft.taskIdsByTags[tagsKey] = [
+                    taskId,
+                    ...draft.taskIdsByTags[tagsKey],
+                ];
+            }
+            else {
+                draft.taskIdsByTags[tagsKey] = [taskId];
+            }
             if (draft.taskIdsByGroupsIds[taskGroupId] != null) {
                 draft.taskIdsByGroupsIds[taskGroupId] = [
                     taskId,
@@ -213,3 +339,96 @@ const taskList = (0, toolkit_1.createSlice)({
 });
 _a = taskList.actions, exports.fetchTaskListPage = _a.fetchTaskListPage, exports.fetchTaskList = _a.fetchTaskList, exports.updateTaskList = _a.updateTaskList, exports.updateTaskListFetchStatus = _a.updateTaskListFetchStatus, exports.updateTaskListSearchText = _a.updateTaskListSearchText, exports.updateTaskListUIState = _a.updateTaskListUIState, exports.updateTaskFilters = _a.updateTaskFilters, exports.updateTaskListOnNewGroupCreationSuccess = _a.updateTaskListOnNewGroupCreationSuccess, exports.bulkUpdateTaskList = _a.bulkUpdateTaskList, exports.updateTasksListOnBulkUpdateTasksSuccess = _a.updateTasksListOnBulkUpdateTasksSuccess, exports.updateTasksListOnBulkUpdateTasksFailure = _a.updateTasksListOnBulkUpdateTasksFailure, exports.initiateTaskListLocalData = _a.initiateTaskListLocalData, exports.updateTaskListLocalData = _a.updateTaskListLocalData, exports.updateTaskListOnTaskGroupDeletion = _a.updateTaskListOnTaskGroupDeletion, exports.dragNDropTasks = _a.dragNDropTasks, exports.updateTaskListOnNewTaskCreationSuccess = _a.updateTaskListOnNewTaskCreationSuccess, exports.updateTaskListOnTaskGroupNameUpdate = _a.updateTaskListOnTaskGroupNameUpdate, exports.clearTaskList = _a.clearTaskList;
 exports.default = taskList.reducer;
+/**
+ *  helpers
+ */
+const getDueDateGroupKey = (due_date) => {
+    if (due_date != null) {
+        const dueDate = (0, zeniDayJS_1.date)(due_date);
+        const today = (0, zeniDayJS_1.dateNow)();
+        if (dueDate.isBefore(today.startOf('day'))) {
+            return 'overdue';
+        }
+        if (today.isSame(dueDate, 'day')) {
+            return 'today';
+        }
+        if (today.isSame(dueDate, 'week')) {
+            return 'this_week';
+        }
+        if (today.isSame(dueDate, 'month')) {
+            return 'this_month';
+        }
+        if (today.isAfter(today.endOf('month'))) {
+            return 'upcoming';
+        }
+    }
+    return 'upcoming';
+};
+const getAssigneesGroupKey = (assignees) => {
+    return [...assignees].sort().join(',');
+};
+const getTagsGroupKey = (tags) => {
+    const tagIds = tags.map((tag) => tag.tag_id);
+    tagIds.sort();
+    return tagIds.join(',');
+};
+const getGroupedTaskIds = (tasks) => {
+    const taskIds = [];
+    const taskIdsByGroupIds = {};
+    const taskIdsByAssignees = {};
+    const taskIdsGroupedByPriority = Object.assign({}, initialTaskIdsByPriority);
+    const taskIdsGroupedByStatus = Object.assign({}, initialTaskIdsByStatus);
+    const taskIdsByDueDate = Object.assign({}, initialTaskIdsByDueDate);
+    const taskIdsByTags = {};
+    tasks.forEach((task) => {
+        taskIds.push(task.task_id);
+        const priorityKey = (0, taskState_1.toPriorityCodeType)(task.priority.code);
+        const statusKey = (0, taskState_1.toTaskStatusCodeType)(task.status.code);
+        const assigneeKey = getAssigneesGroupKey(task.assignees);
+        const dueDateKey = getDueDateGroupKey(task.due_date);
+        const tagsKey = getTagsGroupKey(task.tags);
+        taskIdsGroupedByPriority[priorityKey] = [
+            ...taskIdsGroupedByPriority[priorityKey],
+            task.task_id,
+        ];
+        taskIdsGroupedByStatus[statusKey] = [
+            ...taskIdsGroupedByStatus[statusKey],
+            task.task_id,
+        ];
+        taskIdsByDueDate[dueDateKey] = [
+            ...taskIdsByDueDate[dueDateKey],
+            task.task_id,
+        ];
+        if (task.task_group_ids != null) {
+            task.task_group_ids.forEach((groupId) => {
+                if (taskIdsByGroupIds[groupId] != null) {
+                    taskIdsByGroupIds[groupId].push(task.task_id);
+                }
+                else {
+                    taskIdsByGroupIds[groupId] = [task.task_id];
+                }
+            });
+        }
+        if (taskIdsByAssignees[assigneeKey] != null) {
+            taskIdsByAssignees[assigneeKey].push(task.task_id);
+        }
+        else {
+            taskIdsByAssignees[assigneeKey] = [task.task_id];
+        }
+        if (taskIdsByTags[tagsKey] != null) {
+            taskIdsByTags[tagsKey].push(task.task_id);
+        }
+        else {
+            taskIdsByTags[tagsKey] = [task.task_id];
+        }
+    });
+    return {
+        taskIds,
+        taskIdsGroupedByPriority,
+        taskIdsByGroupIds,
+        taskIdsGroupedByStatus,
+        taskIdsByTags,
+        taskIdsByAssignees,
+        taskIdsByDueDate,
+    };
+};

package/lib/view/taskManager/taskListView/taskListSelector.d.ts

@@ -1,20 +1,25 @@
 import { FetchStateAndError } from '../../../commonStateTypes/common';
 import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
-import { Task } from '../../../entity/task/taskState';
+import { Task, TaskState } from '../../../entity/task/taskState';
 import { RootState } from '../../../reducer';
 import { UserAndRole } from '../../companyView/types/userAndRole';
-import { TaskListFilters, TaskListUIState, TaskListLocalData } from './taskList';
+import { TaskListFilters, TaskListUIState, TaskListLocalData, TaskListState } from './taskList';
 import { UserListSelectorView } from '../../userListView/userListViewSelector';
-import { TaskGroup } from '../../../entity/taskGroup/taskGroupState';
+import { UserState } from '../../../entity/user/userState';
+import { UserRoleState } from '../../../entity/userRole/userRoleState';
+import { AddressState } from '../../../entity/address/addressState';
+import { TagState } from '../../../entity/tag/tagState';
 export interface TaskWithUserDetails extends Task {
     assigneeUsers: UserAndRole[];
 }
-export interface TaskGroupWithTasksList extends TaskGroup {
+export interface TaskGroupWithTasksList {
+    groupName: string;
+    id: string;
     tasks: TaskWithUserDetails[];
+    isDefault: boolean;
 }
 export interface TaskListSelectorView extends SelectorView {
     taskGroupsWithTasksList: TaskGroupWithTasksList[];
-    searchText: string;
     uiState: TaskListUIState;
     filters: TaskListFilters;
     userList: UserListSelectorView;
@@ -24,4 +29,30 @@ export interface TaskListSelectorView extends SelectorView {
     taskGroupUpdateStatus: FetchStateAndError;
     taskGroupCreationStatus: FetchStateAndError;
 }
+export declare const getTaskListGroupedByAssignees: ({ taskListState, taskState, userState, userRoleState, addressState, tagState, }: {
+    taskListState: TaskListState;
+    taskState: TaskState;
+    userState: UserState;
+    userRoleState: UserRoleState;
+    addressState: AddressState;
+    tagState: TagState;
+}) => {
+    groupName: string;
+    id: string;
+    isDefault: boolean;
+    tasks: TaskWithUserDetails[];
+}[];
+export declare const getTaskListGroupedByPriority: ({ taskListState, taskState, userState, userRoleState, addressState, tagState, }: {
+    taskListState: TaskListState;
+    taskState: TaskState;
+    userState: UserState;
+    userRoleState: UserRoleState;
+    addressState: AddressState;
+    tagState: TagState;
+}) => {
+    groupName: string;
+    id: "high" | "low" | "medium" | "urgent";
+    isDefault: boolean;
+    tasks: TaskWithUserDetails[];
+}[];
 export declare const getAllTasks: (state: RootState) => TaskListSelectorView;