@zeniai/client-epic-state 4.11.7 → 4.11.8

package/lib/view/taskManager/taskGroupView/epics/fetchAllTaskGroupsEpic.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAllTaskGroupsEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../../responsePayload");
+const taskGroupViewReducer_1 = require("../taskGroupViewReducer");
+const taskGroupReducer_1 = require("../../../../entity/taskGroup/taskGroupReducer");
+const fetchAllTaskGroupsEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskGroupViewReducer_1.fetchAllTaskGroups.match), (0, operators_1.switchMap)(() => {
+    const queryParam = { filter_type: 'all' };
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/groups?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            return (0, rxjs_1.of)((0, taskGroupReducer_1.updateTaskGroups)(response.data.task_groups), (0, taskGroupViewReducer_1.updateTaskGroupsOnSuccess)({
+                data: response.data.task_groups,
+            }));
+        }
+        else {
+            return (0, rxjs_1.of)((0, taskGroupViewReducer_1.updateTaskGroupsFetchStatus)({
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), (0, operators_1.catchError)((error) => {
+        return (0, rxjs_1.of)((0, taskGroupViewReducer_1.updateTaskGroupsFetchStatus)({
+            fetchState: 'Error',
+            error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch all task groups REST API call errored out' +
+                JSON.stringify(error)),
+        }));
+    }));
+}));
+exports.fetchAllTaskGroupsEpic = fetchAllTaskGroupsEpic;

package/lib/view/taskManager/taskGroupView/epics/updateTaskGroupNameEpic.d.ts

@@ -0,0 +1,10 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { updateTaskGroupName, updateTaskGroupFetchStatus } from '../taskGroupViewReducer';
+import { updateTaskListOnTaskGroupNameUpdate } from '../../taskListView/taskListReducer';
+import { updateTaskGroup } from '../../../../entity/taskGroup/taskGroupReducer';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+export declare type ActionType = ReturnType<typeof updateTaskGroupName> | ReturnType<typeof updateTaskGroupFetchStatus> | ReturnType<typeof updateTaskGroup> | ReturnType<typeof updateTaskListOnTaskGroupNameUpdate> | ReturnType<typeof openSnackbar>;
+export declare const updateTaskGroupNameEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/taskManager/taskGroupView/epics/updateTaskGroupNameEpic.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTaskGroupNameEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../../responsePayload");
+const taskGroupViewReducer_1 = require("../taskGroupViewReducer");
+const taskListReducer_1 = require("../../taskListView/taskListReducer");
+const taskGroupReducer_1 = require("../../../../entity/taskGroup/taskGroupReducer");
+const snackbarReducer_1 = require("../../../../entity/snackbar/snackbarReducer");
+const updateTaskGroupNameEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskGroupViewReducer_1.updateTaskGroupName.match), (0, operators_1.switchMap)((action) => {
+    const { taskGroupId, taskGroupName } = action.payload;
+    const payload = {
+        name: taskGroupName,
+    };
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/groups/${taskGroupId}`, payload)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            const actions = [
+                (0, taskGroupReducer_1.updateTaskGroup)(response.data.task_groups[0]),
+                (0, taskGroupViewReducer_1.updateTaskGroupFetchStatus)({
+                    fetchState: 'Completed',
+                }),
+                (0, taskListReducer_1.updateTaskListOnTaskGroupNameUpdate)({
+                    taskGroupId,
+                    taskGroupName,
+                }),
+                (0, snackbarReducer_1.openSnackbar)({
+                    messageSection: 'task_group_update_success',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ];
+            return (0, rxjs_1.from)(actions);
+        }
+        else {
+            return (0, rxjs_1.of)((0, taskGroupViewReducer_1.updateTaskGroupFetchStatus)({
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), (0, operators_1.catchError)((error) => {
+        return (0, rxjs_1.of)((0, taskGroupViewReducer_1.updateTaskGroupFetchStatus)({
+            fetchState: 'Error',
+            error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Update Task Group REST API call errored out' +
+                JSON.stringify(error)),
+        }));
+    }));
+}));
+exports.updateTaskGroupNameEpic = updateTaskGroupNameEpic;

package/lib/view/taskManager/taskGroupView/taskGroupViewPayload.d.ts

@@ -0,0 +1,6 @@
+import { TaskGroupPayload } from '../../../entity/taskGroup/taskGroupPayload';
+import { ZeniAPIResponse } from '../../../responsePayload';
+export interface FetchTaskGroupsPayload {
+    task_groups: TaskGroupPayload[];
+}
+export declare type FetchTaskGroupsResponse = ZeniAPIResponse<FetchTaskGroupsPayload>;

package/lib/view/taskManager/taskGroupView/taskGroupViewPayload.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/view/taskManager/taskGroupView/taskGroupViewReducer.d.ts

@@ -0,0 +1,34 @@
+import { FetchState, ID } from '../../../commonStateTypes/common';
+import { TaskGroupPayload } from '../../../entity/taskGroup/taskGroupPayload';
+import { ZeniAPIStatus } from '../../../responsePayload';
+import { TaskGroupViewState } from './taskGroupViewState';
+export declare const initialState: TaskGroupViewState;
+export declare const fetchAllTaskGroups: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, updateTaskGroupsOnSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    data: TaskGroupPayload[];
+}, string>, updateTaskGroupsFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    error?: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, string>, createNewTaskGroup: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[groupName: string, updateSelectedTasks: boolean], {
+    groupName: string;
+    updateSelectedTasks: boolean;
+}, string, never, never>, updateTaskGroupCreationFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    error?: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, string>, updateTaskGroupViewOnTaskGroupCreationSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    newTaskGroupId: ID;
+}, string>, deleteTaskGroup: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskGroupId: string], {
+    taskGroupId: string;
+}, string, never, never>, updateTaskGroupDeletionFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    error?: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, string>, updateTaskGroupViewOnTaskDeletionSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    deletedTaskGroupId: ID;
+}, string>, updateTaskGroupName: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskGroupId: any, taskGroupName: any], {
+    taskGroupId: any;
+    taskGroupName: any;
+}, string, never, never>, updateTaskGroupFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    error?: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, string>, clearTaskGroupView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+declare const _default: import("@reduxjs/toolkit").Reducer<TaskGroupViewState, import("@reduxjs/toolkit").AnyAction>;
+export default _default;

package/lib/view/taskManager/taskGroupView/taskGroupViewReducer.js

@@ -0,0 +1,123 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearTaskGroupView = exports.updateTaskGroupFetchStatus = exports.updateTaskGroupName = exports.updateTaskGroupViewOnTaskDeletionSuccess = exports.updateTaskGroupDeletionFetchStatus = exports.deleteTaskGroup = exports.updateTaskGroupViewOnTaskGroupCreationSuccess = exports.updateTaskGroupCreationFetchStatus = exports.createNewTaskGroup = exports.updateTaskGroupsFetchStatus = exports.updateTaskGroupsOnSuccess = exports.fetchAllTaskGroups = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+exports.initialState = {
+    taskGroupsIds: [],
+    fetchState: 'Not-Started',
+    error: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+    taskGroupCreationStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    taskGroupDeleteStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    taskGroupUpdateStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+};
+const taskGroupView = (0, toolkit_1.createSlice)({
+    name: 'taskGroupView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchAllTaskGroups(draft) {
+            draft.fetchState = 'In-Progress';
+            draft.error = undefined;
+        },
+        updateTaskGroupsOnSuccess(draft, action) {
+            const { data } = action.payload;
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+            draft.taskGroupsIds = data.map((task) => task.task_group_id);
+        },
+        updateTaskGroupsFetchStatus(draft, action) {
+            draft.fetchState = action.payload.fetchState;
+            draft.error = action.payload.error;
+        },
+        createNewTaskGroup: {
+            reducer(draft) {
+                draft.taskGroupCreationStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(groupName, updateSelectedTasks) {
+                return {
+                    payload: {
+                        groupName,
+                        updateSelectedTasks,
+                    },
+                };
+            },
+        },
+        updateTaskGroupViewOnTaskGroupCreationSuccess(draft, action) {
+            const { newTaskGroupId } = action.payload;
+            draft.taskGroupsIds = [...draft.taskGroupsIds, newTaskGroupId];
+            draft.taskGroupCreationStatus.fetchState = 'Completed';
+            draft.taskGroupCreationStatus.error = undefined;
+        },
+        updateTaskGroupCreationFetchStatus(draft, action) {
+            draft.taskGroupCreationStatus.fetchState = action.payload.fetchState;
+            draft.taskGroupCreationStatus.error = action.payload.error;
+        },
+        deleteTaskGroup: {
+            reducer(draft) {
+                draft.taskGroupDeleteStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(taskGroupId) {
+                return {
+                    payload: {
+                        taskGroupId,
+                    },
+                };
+            },
+        },
+        updateTaskGroupViewOnTaskDeletionSuccess(draft, action) {
+            const { deletedTaskGroupId } = action.payload;
+            draft.taskGroupsIds = draft.taskGroupsIds.filter((groupId) => groupId !== deletedTaskGroupId);
+            draft.taskGroupDeleteStatus.fetchState = 'Completed';
+            draft.taskGroupDeleteStatus.error = undefined;
+        },
+        updateTaskGroupDeletionFetchStatus(draft, action) {
+            draft.taskGroupDeleteStatus.fetchState = action.payload.fetchState;
+            draft.taskGroupDeleteStatus.error = action.payload.error;
+        },
+        updateTaskGroupName: {
+            reducer(draft) {
+                draft.taskGroupUpdateStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(taskGroupId, taskGroupName) {
+                return {
+                    payload: {
+                        taskGroupId,
+                        taskGroupName,
+                    },
+                };
+            },
+        },
+        updateTaskGroupFetchStatus(draft, action) {
+            draft.taskGroupUpdateStatus = {
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        clearTaskGroupView(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_a = taskGroupView.actions, exports.fetchAllTaskGroups = _a.fetchAllTaskGroups, exports.updateTaskGroupsOnSuccess = _a.updateTaskGroupsOnSuccess, exports.updateTaskGroupsFetchStatus = _a.updateTaskGroupsFetchStatus, exports.createNewTaskGroup = _a.createNewTaskGroup, exports.updateTaskGroupCreationFetchStatus = _a.updateTaskGroupCreationFetchStatus, exports.updateTaskGroupViewOnTaskGroupCreationSuccess = _a.updateTaskGroupViewOnTaskGroupCreationSuccess, exports.deleteTaskGroup = _a.deleteTaskGroup, exports.updateTaskGroupDeletionFetchStatus = _a.updateTaskGroupDeletionFetchStatus, exports.updateTaskGroupViewOnTaskDeletionSuccess = _a.updateTaskGroupViewOnTaskDeletionSuccess, exports.updateTaskGroupName = _a.updateTaskGroupName, exports.updateTaskGroupFetchStatus = _a.updateTaskGroupFetchStatus, exports.clearTaskGroupView = _a.clearTaskGroupView;
+exports.default = taskGroupView.reducer;

package/lib/view/taskManager/taskGroupView/taskGroupViewState.d.ts

@@ -0,0 +1,7 @@
+import { ID, FetchedState, FetchStateAndError } from '../../../commonStateTypes/common';
+export interface TaskGroupViewState extends FetchedState {
+    taskGroupsIds: ID[];
+    taskGroupCreationStatus: FetchStateAndError;
+    taskGroupDeleteStatus: FetchStateAndError;
+    taskGroupUpdateStatus: FetchStateAndError;
+}

package/lib/view/taskManager/taskGroupView/taskGroupViewState.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { bulkUpdateTaskList, updateTasksListOnBulkUpdateTasksSuccess, updateTasksListOnBulkUpdateTasksFailure } from './taskListReducer';
+import { updateTasks } from '../../../entity/task/taskReducer';
+export declare type ActionType = ReturnType<typeof bulkUpdateTaskList> | ReturnType<typeof updateTasks> | ReturnType<typeof updateTasksListOnBulkUpdateTasksFailure> | ReturnType<typeof updateTasksListOnBulkUpdateTasksSuccess>;
+export declare const bulkUpdateTaskListEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

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

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkUpdateTaskListEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const get_1 = __importDefault(require("lodash/get"));
+const responsePayload_1 = require("../../../responsePayload");
+const taskListReducer_1 = require("./taskListReducer");
+const taskReducer_1 = require("../../../entity/task/taskReducer");
+const formatZeniDateFY_1 = require("../../../commonStateTypes/fiscalYearHelpers/formatZeniDateFY");
+const bulkUpdateTaskListEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskListReducer_1.bulkUpdateTaskList.match), (0, operators_1.switchMap)((action) => {
+    const state = state$.value;
+    const { taskIds, updates } = action.payload;
+    const payload = {
+        tasks: getTasksListPayload(state, taskIds, updates),
+    };
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks`, payload)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            return (0, rxjs_1.of)((0, taskReducer_1.updateTasks)(response.data.tasks), (0, taskListReducer_1.updateTasksListOnBulkUpdateTasksSuccess)({
+                taskIds,
+                groupId: updates.taskGroupIds != null &&
+                    updates.taskGroupIds.length > 0
+                    ? updates.taskGroupIds[0]
+                    : null,
+            }));
+        }
+        else {
+            return (0, rxjs_1.of)((0, taskListReducer_1.updateTasksListOnBulkUpdateTasksFailure)({
+                error: response.status,
+            }));
+        }
+    }), (0, operators_1.catchError)((error) => {
+        return (0, rxjs_1.of)((0, taskListReducer_1.updateTasksListOnBulkUpdateTasksFailure)({
+            error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Bulk update task list REST API call errored out' +
+                JSON.stringify(error)),
+        }));
+    }));
+}));
+exports.bulkUpdateTaskListEpic = bulkUpdateTaskListEpic;
+const getTasksListPayload = (state, taskIds, updates) => {
+    const { taskState } = state;
+    const tasksList = taskIds
+        .map((taskId) => {
+        const task = (0, get_1.default)(taskState.taskByID, taskId);
+        return Object.assign(Object.assign({}, task), updates);
+    })
+        .filter((task) => task != null);
+    const tasksPayload = tasksList.map((task) => toTaskPayload(state, task));
+    return tasksPayload;
+};
+const toTaskPayload = (state, task) => {
+    var _a;
+    const { tagState } = state;
+    const tags = task.tagIds
+        .map((tagId) => {
+        return (0, get_1.default)(tagState.tagByID, tagId);
+    })
+        .filter((tag) => tag != null);
+    const tagPayload = tags.map((tag) => {
+        return tag.tagId;
+    });
+    const taskPayload = {
+        task_id: task.id,
+        name: task.name,
+        assignees: task.assignees,
+        description: task.description,
+        due_date: task.dueDate != null ? task.dueDate.format(formatZeniDateFY_1.DEFAULT_DATE_FORMAT) : null,
+        priority: task.priority.code,
+        status: task.status.code,
+        tags: tagPayload,
+        type: task.type.code,
+        file_ids: task.fileIds,
+        recurring_end_date: task.recurringEndDate != null
+            ? task.recurringEndDate.format(formatZeniDateFY_1.DEFAULT_DATE_FORMAT)
+            : null,
+        recurring_frequency: (_a = task.recurringFrequency) !== null && _a !== void 0 ? _a : null,
+        recurring_start_date: task.recurringStartDate != null
+            ? task.recurringStartDate.format(formatZeniDateFY_1.DEFAULT_DATE_FORMAT)
+            : null,
+        task_group_ids: task.taskGroupIds,
+        sync_token: task.syncToken,
+    };
+    return taskPayload;
+};

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

@@ -0,0 +1,6 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { dragNDropTasks, bulkUpdateTaskList, updateTasksListOnBulkUpdateTasksSuccess } from './taskListReducer';
+import { RootState } from '../../../reducer';
+export declare type ActionType = ReturnType<typeof dragNDropTasks> | ReturnType<typeof bulkUpdateTaskList> | ReturnType<typeof updateTasksListOnBulkUpdateTasksSuccess>;
+export declare const dragNDropTasksEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>) => Observable<ActionType>;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dragNDropTasksEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const taskListReducer_1 = require("./taskListReducer");
+const dragNDropTasksEpic = (actions$, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_state$) => actions$.pipe((0, operators_1.filter)(taskListReducer_1.dragNDropTasks.match), (0, operators_1.mergeMap)((action) => {
+    const { taskIds, groupId } = action.payload;
+    const actions = [
+        (0, taskListReducer_1.updateTasksListOnBulkUpdateTasksSuccess)({
+            taskIds,
+            groupId,
+        }),
+        (0, taskListReducer_1.bulkUpdateTaskList)(taskIds, { taskGroupIds: [groupId] }),
+    ];
+    return (0, rxjs_1.from)(actions);
+}));
+exports.dragNDropTasksEpic = dragNDropTasksEpic;

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

@@ -4,5 +4,7 @@ import { fetchTaskListPage, fetchTaskList } from './taskListReducer';
 import { RootState } from '../../../reducer';
 import { fetchUserListByType } from '../../userListView/userListViewReducer';
 import { fetchClassList } from '../../classList/classListReducer';
-export declare type ActionType = ReturnType<typeof fetchTaskListPage> | ReturnType<typeof fetchTaskList> | ReturnType<typeof fetchUserListByType> | ReturnType<typeof fetchClassList>;
+import { fetchTagList } from '../../tagView/tagViewReducer';
+import { fetchAllTaskGroups } from '../taskGroupView/taskGroupViewReducer';
+export declare type ActionType = ReturnType<typeof fetchTaskListPage> | ReturnType<typeof fetchTaskList> | ReturnType<typeof fetchUserListByType> | ReturnType<typeof fetchTagList> | ReturnType<typeof fetchAllTaskGroups> | ReturnType<typeof fetchClassList>;
 export declare const fetchTaskListPageEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>) => Observable<ActionType>;

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

@@ -6,6 +6,8 @@ const operators_1 = require("rxjs/operators");
 const taskListReducer_1 = require("./taskListReducer");
 const userListViewReducer_1 = require("../../userListView/userListViewReducer");
 const classListReducer_1 = require("../../classList/classListReducer");
+const tagViewReducer_1 = require("../../tagView/tagViewReducer");
+const taskGroupViewReducer_1 = require("../taskGroupView/taskGroupViewReducer");
 const fetchTaskListPageEpic = (actions$, state$) => actions$.pipe((0, operators_1.filter)(taskListReducer_1.fetchTaskListPage.match), (0, operators_1.mergeMap)((action) => {
     const { cacheOverride } = action.payload;
     const taskListPageActions = [];
@@ -14,6 +16,8 @@ const fetchTaskListPageEpic = (actions$, state$) => actions$.pipe((0, operators_
         taskListPageActions.push((0, taskListReducer_1.fetchTaskList)());
         taskListPageActions.push((0, classListReducer_1.fetchClassList)());
         taskListPageActions.push((0, userListViewReducer_1.fetchUserListByType)('taskManagerCandidate', true));
+        taskListPageActions.push((0, tagViewReducer_1.fetchTagList)());
+        taskListPageActions.push((0, taskGroupViewReducer_1.fetchAllTaskGroups)());
     }
     else {
         taskListPageActions.push((0, taskListReducer_1.fetchTaskList)());
@@ -26,6 +30,14 @@ const fetchTaskListPageEpic = (actions$, state$) => actions$.pipe((0, operators_
             taskManageUsers.fetchState !== 'In-Progress') {
             taskListPageActions.push((0, userListViewReducer_1.fetchUserListByType)('taskManagerCandidate', false));
         }
+        if (state.tagViewState.hasValidState() === false &&
+            state.tagViewState.fetchState !== 'In-Progress') {
+            taskListPageActions.push((0, tagViewReducer_1.fetchTagList)());
+        }
+        if (state.taskGroupViewState.hasValidState() === false &&
+            state.taskGroupViewState.fetchState !== 'In-Progress') {
+            taskListPageActions.push((0, taskGroupViewReducer_1.fetchAllTaskGroups)());
+        }
     }
     return (0, rxjs_1.concat)((0, rxjs_1.from)(taskListPageActions));
 }));

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

@@ -1,12 +1,25 @@
-import { FetchedState, ID } from '../../../commonStateTypes/common';
+import { FetchedState, FetchStateAndError, ID } from '../../../commonStateTypes/common';
 import { ZeniDate } from '../../../zeniDayJS';
 import { SpendManagementUIState } from '../../spendManagement/billPay/billList/billListState';
 import { CategoryCombinationOperator, FilterCategoryType } from '../../spendManagement/spendManagementFilterHelpers';
+export interface NewTaskGroupLocalData {
+    taskIds: ID[];
+    groupName: string;
+}
+export interface TaskListLocalData {
+    newTaskGroupName: string;
+    selectedTaskIds: ID[];
+    existingTaskGroupNamesByGroupId: Record<ID, string>;
+    defaultTaskGroupId: ID | null;
+}
 export interface TaskListState extends FetchedState {
     taskIds: ID[];
+    taskIdsByGroupsIds: Record<ID, ID[]>;
     uiState: TaskListUIState;
     searchText: string;
     filters: TaskListFilters;
+    localData: TaskListLocalData;
+    updateTasksFetchState: FetchStateAndError;
 }
 export interface TaskListFilters {
     categoryCombinationOperator: CategoryCombinationOperator;

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

@@ -1,7 +1,11 @@
-import { FetchState, UpdateType } from '../../../commonStateTypes/common';
+import { FetchState, ID, UpdateType } from '../../../commonStateTypes/common';
 import { TaskPayload } from '../../../entity/task/taskPayload';
 import { ZeniAPIStatus } from '../../../responsePayload';
-import { TaskListFilters, TaskListState, TaskListUIState } from './taskList';
+import { TaskListFilters, TaskListLocalData, TaskListState, TaskListUIState } from './taskList';
+import { TaskGroup } from '../../../entity/taskGroup/taskGroupState';
+import { Task } from '../../../entity/task/taskState';
+import { TaskGroupPayload } from '../../../entity/taskGroup/taskGroupPayload';
+export declare const initialLocalData: TaskListLocalData;
 export declare const initialState: TaskListState;
 export declare const fetchTaskListPage: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[cacheOverride: boolean], {
     cacheOverride: boolean;
@@ -17,6 +21,31 @@ export declare const fetchTaskListPage: import("@reduxjs/toolkit").ActionCreator
     uiState: Partial<TaskListUIState>;
 }, string>, updateTaskFilters: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     filters: TaskListFilters;
+}, string>, updateTaskListOnNewGroupCreationSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    newTaskGroup: TaskGroupPayload;
+}, string>, bulkUpdateTaskList: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskIds: string[], updates: Partial<Task>], {
+    taskIds: string[];
+    updates: Partial<Task>;
+}, string, never, never>, updateTasksListOnBulkUpdateTasksSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskIds: ID[];
+    groupId: ID | null;
+}, string>, updateTasksListOnBulkUpdateTasksFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    error: ZeniAPIStatus;
+}, string>, initiateTaskListLocalData: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskGroupById: Record<ID, TaskGroup>;
+}, string>, updateTaskListLocalData: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    localData: TaskListLocalData;
+}, string>, updateTaskListOnTaskGroupDeletion: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskGroupId: ID;
+}, string>, dragNDropTasks: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskIds: string[], groupId: any], {
+    taskIds: string[];
+    groupId: any;
+}, string, never, never>, updateTaskListOnNewTaskCreationSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskId: ID;
+    taskGroupId: ID;
+}, string>, updateTaskListOnTaskGroupNameUpdate: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskGroupName: ID;
+    taskGroupId: ID;
 }, string>, clearTaskList: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
 declare const _default: import("@reduxjs/toolkit").Reducer<TaskListState, import("@reduxjs/toolkit").AnyAction>;
 export default _default;