@zeniai/client-epic-state 4.7.84 → 4.7.85

package/lib/view/spendManagement/spendManagementFilterHelpers.js

@@ -111,7 +111,9 @@ const applyAdvancedFiltersOnList = (entity, allItems, filters, filteredItems = [
         const key = currentFilter.field;
         const categoryValue = entity === 'bill_pay'
             ? getCategoryValueForBill(key, item)
-            : getCategoryValueForReimbursement(key, item);
+            : entity === 'reimbursement'
+                ? getCategoryValueForReimbursement(key, item)
+                : getCategoryValueForTaskList(key, item);
         if (categoryValue == null) {
             if (currentFilter.matchingOperator === 'not-equal') {
                 return true;
@@ -174,6 +176,25 @@ const getCategoryValueForBill = (key, bill) => {
             return undefined;
     }
 };
+const getCategoryValueForTaskList = (key, task) => {
+    var _a;
+    switch (key) {
+        case 'dueDate':
+            return task.dueDate;
+        case 'priority':
+            return task.priority.code;
+        case 'tag':
+            return (_a = task.tag) === null || _a === void 0 ? void 0 : _a.code;
+        case 'status':
+            return task.status.code;
+        case 'createdBy':
+            return task.createdBy;
+        case 'assignee':
+            return task.assignees;
+        default:
+            return undefined;
+    }
+};
 const getAllBillStatus = (bill) => {
     var _a;
     const billStatus = bill.billPayInfo.billStatus.code;

package/lib/view/taskManager/taskDetailView/epics/deleteTaskEpic.d.ts

@@ -0,0 +1,7 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { RootState } from '../../../../reducer';
+import { deleteTask, deleteTaskSuccessOrFailure } from '../taskDetailReducer';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+export declare type ActionType = ReturnType<typeof deleteTask> | ReturnType<typeof openSnackbar> | ReturnType<typeof deleteTaskSuccessOrFailure>;
+export declare const deleteTaskEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<ActionType>;

package/lib/view/taskManager/taskDetailView/epics/deleteTaskEpic.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteTaskEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../../responsePayload");
+const taskDetailReducer_1 = require("../taskDetailReducer");
+const snackbarReducer_1 = require("../../../../entity/snackbar/snackbarReducer");
+const deleteTaskEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskDetailReducer_1.deleteTask.match), (0, operators_1.mergeMap)((action) => {
+    const { taskId } = action.payload;
+    return zeniAPI
+        .deleteAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServicebaseUrl}/1.0/task-manager/tasks/${taskId}`)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessStatus)(response)) {
+            const actions = [];
+            actions.push((0, taskDetailReducer_1.deleteTaskSuccessOrFailure)({ fetchState: 'Completed', taskId }));
+            return (0, rxjs_1.from)(actions);
+        }
+        else {
+            return (0, rxjs_1.from)([
+                (0, taskDetailReducer_1.deleteTaskSuccessOrFailure)({
+                    fetchState: 'Error',
+                    taskId,
+                    error: response.status,
+                }),
+                (0, snackbarReducer_1.openSnackbar)({
+                    messageSection: 'delete_task',
+                    messageText: 'failed',
+                    type: 'error',
+                    variables: [
+                        {
+                            variableName: '_api-error_',
+                            variableValue: response.status.message,
+                        },
+                    ],
+                }),
+            ]);
+        }
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, taskDetailReducer_1.deleteTaskSuccessOrFailure)({
+        fetchState: 'Error',
+        taskId,
+        error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Delete Task REST API call errored out ' +
+            JSON.stringify(error)),
+    }))));
+}));
+exports.deleteTaskEpic = deleteTaskEpic;

package/lib/view/taskManager/taskDetailView/epics/fetchTaskDetailEpic.d.ts

@@ -0,0 +1,9 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { fetchTaskDetail, updateEditTaskFetchStatus, removeTaskDetail, initializeTaskToLocalStore } from '../taskDetailReducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { RootState } from '../../../../reducer';
+import { updateTasks } from '../../../../entity/task/taskReducer';
+import { fetchFileList } from '../../../fileView/fileViewReducer';
+export declare type ActionType = ReturnType<typeof fetchTaskDetail> | ReturnType<typeof updateEditTaskFetchStatus> | ReturnType<typeof removeTaskDetail> | ReturnType<typeof updateTasks> | ReturnType<typeof initializeTaskToLocalStore> | ReturnType<typeof fetchFileList>;
+export declare const fetchTaskDetailEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/taskManager/taskDetailView/epics/fetchTaskDetailEpic.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTaskDetailEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const get_1 = __importDefault(require("lodash/get"));
+const taskDetailReducer_1 = require("../taskDetailReducer");
+const responsePayload_1 = require("../../../../responsePayload");
+const taskReducer_1 = require("../../../../entity/task/taskReducer");
+const fileViewReducer_1 = require("../../../fileView/fileViewReducer");
+const fetchTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskDetailReducer_1.fetchTaskDetail.match), (0, operators_1.mergeMap)((action) => {
+    const { taskId, cacheOverride } = action.payload;
+    const taskActions = [];
+    const state = state$.value;
+    const taskDetail = (0, get_1.default)(state.taskDetailState.editTaskStateById, taskId, undefined);
+    if (cacheOverride === true) {
+        taskActions.push((0, taskDetailReducer_1.removeTaskDetail)(taskId));
+    }
+    if (cacheOverride === true ||
+        taskDetail == null ||
+        taskDetail.fetchTaskStatus.fetchState !== 'In-Progress') {
+        taskActions.push((0, taskDetailReducer_1.updateEditTaskFetchStatus)({ taskId, fetchState: 'In-Progress' }));
+        const getTaskDetail$ = zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.taskMicroServicebaseUrl}/1.0/task-manager/tasks/${taskId}`)
+            .pipe((0, operators_1.mergeMap)((response) => {
+            if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+                const fetchActions = [
+                    (0, taskReducer_1.updateTasks)(response.data.tasks),
+                    (0, taskDetailReducer_1.updateEditTaskFetchStatus)({
+                        taskId,
+                        fetchState: 'Completed',
+                    }),
+                    (0, taskDetailReducer_1.initializeTaskToLocalStore)(taskId),
+                ];
+                const fileIds = response.data.tasks[0].file_ids;
+                if (fileIds.length > 0) {
+                    fetchActions.push((0, fileViewReducer_1.fetchFileList)(fileIds));
+                }
+                return (0, rxjs_1.from)(fetchActions);
+            }
+            else {
+                return (0, rxjs_1.of)((0, taskDetailReducer_1.updateEditTaskFetchStatus)({
+                    taskId,
+                    fetchState: 'Error',
+                    error: response.status,
+                }));
+            }
+        }), (0, operators_1.catchError)((error) => {
+            console.error(`REST API call errored out ${error}`);
+            return (0, rxjs_1.of)((0, taskDetailReducer_1.updateEditTaskFetchStatus)({
+                taskId,
+                fetchState: 'Error',
+                error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch Task detail REST API call errored out' +
+                    JSON.stringify(error)),
+            }));
+        }));
+        return (0, rxjs_1.concat)((0, rxjs_1.from)(taskActions), getTaskDetail$);
+    }
+    else {
+        return (0, rxjs_1.from)(taskActions);
+    }
+}));
+exports.fetchTaskDetailEpic = fetchTaskDetailEpic;

package/lib/view/taskManager/taskDetailView/epics/fetchTaskDetailPageEpic.d.ts

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { fetchTaskDetailPage, fetchTaskDetail, initializeTaskToLocalStore, fetchTaskHistory } from '../taskDetailReducer';
+import { RootState } from '../../../../reducer';
+import { fetchUserListByType } from '../../../userListView/userListViewReducer';
+import { fetchClassList } from '../../../classList/classListReducer';
+export declare type ActionType = ReturnType<typeof fetchTaskDetailPage> | ReturnType<typeof fetchTaskDetail> | ReturnType<typeof fetchUserListByType> | ReturnType<typeof initializeTaskToLocalStore> | ReturnType<typeof fetchClassList> | ReturnType<typeof fetchTaskHistory>;
+export declare const fetchTaskDetailPageEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>) => Observable<ActionType>;

package/lib/view/taskManager/taskDetailView/epics/fetchTaskDetailPageEpic.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTaskDetailPageEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const taskDetailReducer_1 = require("../taskDetailReducer");
+const userListViewReducer_1 = require("../../../userListView/userListViewReducer");
+const classListReducer_1 = require("../../../classList/classListReducer");
+const fetchTaskDetailPageEpic = (actions$, state$) => actions$.pipe((0, operators_1.filter)(taskDetailReducer_1.fetchTaskDetailPage.match), (0, operators_1.mergeMap)((action) => {
+    const { cacheOverride, taskId } = action.payload;
+    const taskDetailActions = [];
+    const state = state$.value;
+    if (cacheOverride === true) {
+        taskDetailActions.push((0, userListViewReducer_1.fetchUserListByType)('taskManagerCandidate', true));
+        taskDetailActions.push((0, classListReducer_1.fetchClassList)());
+        if (taskId != null) {
+            taskDetailActions.push((0, taskDetailReducer_1.fetchTaskDetail)(taskId, true));
+            taskDetailActions.push((0, taskDetailReducer_1.fetchTaskHistory)(taskId, true));
+        }
+    }
+    else {
+        const taskManageUsers = state.userListViewState.userListByType.taskManagerCandidate;
+        if (taskManageUsers.hasValidState() === false &&
+            taskManageUsers.fetchState !== 'In-Progress') {
+            taskDetailActions.push((0, userListViewReducer_1.fetchUserListByType)('taskManagerCandidate', false));
+        }
+        if (state.classListState.hasValidState() === false &&
+            state.classListState.fetchState !== 'In-Progress') {
+            taskDetailActions.push((0, classListReducer_1.fetchClassList)());
+        }
+        if (taskId != null) {
+            taskDetailActions.push((0, taskDetailReducer_1.fetchTaskDetail)(taskId, false));
+            taskDetailActions.push((0, taskDetailReducer_1.fetchTaskHistory)(taskId, false));
+        }
+    }
+    return (0, rxjs_1.concat)((0, rxjs_1.from)(taskDetailActions));
+}));
+exports.fetchTaskDetailPageEpic = fetchTaskDetailPageEpic;

package/lib/view/taskManager/taskDetailView/epics/fetchTaskHistoryEpic.d.ts

@@ -0,0 +1,7 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { RootState } from '../../../../reducer';
+import { fetchTaskHistory, updateTaskHistory, updateTaskHistoryFetchStatus } from '../taskDetailReducer';
+export declare type ActionType = ReturnType<typeof fetchTaskHistory> | ReturnType<typeof updateTaskHistory> | ReturnType<typeof updateTaskHistoryFetchStatus>;
+export declare const fetchTaskHistoryEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/taskManager/taskDetailView/epics/fetchTaskHistoryEpic.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTaskHistoryEpic = 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 taskDetailReducer_1 = require("../taskDetailReducer");
+const fetchTaskHistoryEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskDetailReducer_1.fetchTaskHistory.match), (0, operators_1.mergeMap)((action) => {
+    const { taskId, cacheOverride } = action.payload;
+    const historyActions = [];
+    const state = state$.value;
+    const taskHistoryDetail = (0, get_1.default)(state.taskDetailState.taskHistoryById, taskId, undefined);
+    if (cacheOverride === true ||
+        taskHistoryDetail == null ||
+        taskHistoryDetail.fetchState !== 'In-Progress') {
+        historyActions.push((0, taskDetailReducer_1.updateTaskHistoryFetchStatus)({
+            taskId,
+            fetchState: 'In-Progress',
+        }));
+        const getHistoryDetail$ = zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.taskMicroServicebaseUrl}/1.0/task-manager/tasks/${taskId}/history`)
+            .pipe((0, operators_1.mergeMap)((response) => {
+            if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+                return (0, rxjs_1.of)((0, taskDetailReducer_1.updateTaskHistory)({
+                    taskId,
+                    historicEventsPayload: response.data.activities,
+                }));
+            }
+            else {
+                return (0, rxjs_1.of)((0, taskDetailReducer_1.updateTaskHistoryFetchStatus)({
+                    taskId,
+                    fetchState: 'Error',
+                    error: response.status,
+                }));
+            }
+        }), (0, operators_1.catchError)((error) => {
+            return (0, rxjs_1.of)((0, taskDetailReducer_1.updateTaskHistoryFetchStatus)({
+                taskId,
+                fetchState: 'Error',
+                error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch Task history REST API call errored out' +
+                    JSON.stringify(error)),
+            }));
+        }));
+        return (0, rxjs_1.concat)((0, rxjs_1.from)(historyActions), getHistoryDetail$);
+    }
+    else {
+        return (0, rxjs_1.from)(historyActions);
+    }
+}));
+exports.fetchTaskHistoryEpic = fetchTaskHistoryEpic;

package/lib/view/taskManager/taskDetailView/epics/initializeTaskToLocalStoreEpic.d.ts

@@ -0,0 +1,6 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { initializeTaskToLocalStore, saveTaskUpdatesToLocalStore, updateEditTaskFetchStatus } from '../taskDetailReducer';
+import { RootState } from '../../../../reducer';
+export declare type ActionType = ReturnType<typeof initializeTaskToLocalStore> | ReturnType<typeof saveTaskUpdatesToLocalStore> | ReturnType<typeof updateEditTaskFetchStatus>;
+export declare const initializeTaskToLocalStoreEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>) => Observable<ActionType>;

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

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeTaskToLocalStoreEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const get_1 = __importDefault(require("lodash/get"));
+const taskDetailReducer_1 = require("../taskDetailReducer");
+const initializeTaskToLocalStoreEpic = (actions$, state$) => actions$.pipe((0, operators_1.filter)(taskDetailReducer_1.initializeTaskToLocalStore.match), (0, operators_1.mergeMap)((action) => {
+    const { taskId } = action.payload;
+    const state = state$.value;
+    const task = (0, get_1.default)(state.taskState.taskByID, taskId, undefined);
+    if (task != null) {
+        const taskDetailLocalData = {
+            name: task.name,
+            description: task.description,
+            status: task.status.code,
+            assignee: task.assignees,
+            dueDate: task.dueDate,
+            priority: task.priority.code,
+            tag: task.tag != null ? task.tag.code : undefined,
+            fileIds: task.fileIds,
+        };
+        const actions = [
+            (0, taskDetailReducer_1.saveTaskUpdatesToLocalStore)({ taskDetailLocalData, taskId }),
+            (0, taskDetailReducer_1.updateEditTaskFetchStatus)({ taskId, fetchState: 'Completed' }),
+        ];
+        return (0, rxjs_1.from)(actions);
+    }
+    return (0, rxjs_1.from)([
+        (0, taskDetailReducer_1.updateEditTaskFetchStatus)({ taskId, fetchState: 'Completed' }),
+    ]);
+}));
+exports.initializeTaskToLocalStoreEpic = initializeTaskToLocalStoreEpic;

package/lib/view/taskManager/taskDetailView/epics/saveTaskDetailEpic.d.ts

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { RootState } from '../../../../reducer';
+import { saveTaskDetail, saveTaskSuccessOrFailure } from '../taskDetailReducer';
+import { updateTasks } from '../../../../entity/task/taskReducer';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+export declare type ActionType = ReturnType<typeof saveTaskDetail> | ReturnType<typeof updateTasks> | ReturnType<typeof openSnackbar> | ReturnType<typeof saveTaskSuccessOrFailure>;
+export declare const saveTaskDetailEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<ActionType>;

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveTaskDetailEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../../responsePayload");
+const taskDetailReducer_1 = require("../taskDetailReducer");
+const taskReducer_1 = require("../../../../entity/task/taskReducer");
+const taskSelector_1 = require("../../../../entity/task/taskSelector");
+const snackbarReducer_1 = require("../../../../entity/snackbar/snackbarReducer");
+const saveTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskDetailReducer_1.saveTaskDetail.match), (0, operators_1.mergeMap)((action) => {
+    const { taskId, isArchive } = action.payload;
+    const state = state$.value;
+    const payload = prepareTaskPayload(state, isArchive, taskId);
+    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((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            const fetchActions = [
+                (0, taskReducer_1.updateTasks)(response.data.tasks),
+                (0, taskDetailReducer_1.saveTaskSuccessOrFailure)({
+                    fetchState: 'Completed',
+                    taskId,
+                }),
+            ];
+            return (0, rxjs_1.from)(fetchActions);
+        }
+        else {
+            return (0, rxjs_1.from)([
+                (0, taskDetailReducer_1.saveTaskSuccessOrFailure)({
+                    fetchState: 'Error',
+                    taskId,
+                    error: response.status,
+                }),
+                (0, snackbarReducer_1.openSnackbar)({
+                    messageSection: isArchive === true ? 'archive_task' : 'save_task_detail',
+                    messageText: 'failed',
+                    type: 'error',
+                    variables: [
+                        {
+                            variableName: '_api-error_',
+                            variableValue: response.status.message,
+                        },
+                    ],
+                }),
+            ]);
+        }
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, taskDetailReducer_1.saveTaskSuccessOrFailure)({
+        fetchState: 'Error',
+        taskId,
+        error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Save Task REST API call errored out' + JSON.stringify(error)),
+    }))));
+}));
+exports.saveTaskDetailEpic = saveTaskDetailEpic;
+const prepareTaskPayload = (state, isArchive, taskId) => {
+    var _a, _b, _c, _d;
+    const { taskDetailState, taskState } = state;
+    const syncToken = taskId != null ? (_b = (_a = (0, taskSelector_1.getTaskById)(taskState, taskId)) === null || _a === void 0 ? void 0 : _a.syncToken) !== null && _b !== void 0 ? _b : '' : '';
+    const sourceState = taskId != null
+        ? taskDetailState.editTaskStateById[taskId]
+        : taskDetailState.newTaskState;
+    const localData = sourceState.taskDetailLocalData;
+    return {
+        name: localData.name,
+        assignees: localData.assignee,
+        description: localData.description,
+        due_date: (_d = (_c = localData.dueDate) === null || _c === void 0 ? void 0 : _c.format('YYYY-MM-DD')) !== null && _d !== void 0 ? _d : null,
+        priority: localData.priority,
+        status: localData.status,
+        tag: localData.tag,
+        file_ids: localData.fileIds,
+        sync_token: syncToken,
+        is_archived: isArchive,
+    };
+};

package/lib/view/taskManager/taskDetailView/taskDetail.d.ts

@@ -0,0 +1,27 @@
+import { FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { TaskStatusCodeType, PriorityCodeType, TaskTagCodeType } from '../../../entity/task/task';
+import { ZeniDate } from '../../../zeniDayJS';
+import { CommonHistoryView } from '../../spendManagement/commonHistoryView/commonHistory';
+export interface TaskDetailViewState {
+    newTaskState: EditTaskDetail;
+    editTaskStateById: Record<ID, EditTaskDetail>;
+    taskHistoryById: Record<ID, CommonHistoryView>;
+}
+export interface EditTaskDetail {
+    taskId?: ID;
+    taskDetailLocalData: EditTaskLocalData;
+    saveStatus: FetchStateAndError;
+    fetchTaskStatus: FetchStateAndError;
+    deleteTaskStatus: FetchStateAndError;
+}
+export interface EditTaskLocalData {
+    name: string;
+    description: string;
+    status: TaskStatusCodeType;
+    assignee: ID[];
+    dueDate?: ZeniDate;
+    priority: PriorityCodeType;
+    tag?: TaskTagCodeType;
+    fileIds: ID[];
+}
+export declare const initialTaskDetail: EditTaskDetail;

package/lib/view/taskManager/taskDetailView/taskDetail.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialTaskDetail = void 0;
+exports.initialTaskDetail = {
+    fetchTaskStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    saveStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    deleteTaskStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    taskDetailLocalData: {
+        name: '',
+        description: '',
+        status: 'todo',
+        assignee: [],
+        dueDate: undefined,
+        priority: 'low',
+        tag: undefined,
+        fileIds: [],
+    },
+};

package/lib/view/taskManager/taskDetailView/taskDetailReducer.d.ts

@@ -0,0 +1,48 @@
+import { FetchState, ID } from '../../../commonStateTypes/common';
+import { ZeniAPIStatus } from '../../../responsePayload';
+import { EditTaskLocalData, TaskDetailViewState } from './taskDetail';
+import { HistoricEventPayload } from '../../spendManagement/commonHistoryView/commonHistoryPayload';
+export declare const initialState: TaskDetailViewState;
+export declare const fetchTaskDetailPage: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[cacheOverride: boolean, taskId?: string | undefined], {
+    cacheOverride: boolean;
+    taskId: string | undefined;
+}, string, never, never>, fetchTaskDetail: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId: string, cacheOverride?: any], {
+    taskId: string;
+    cacheOverride: any;
+}, string, never, never>, initializeTaskToLocalStore: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId: string], {
+    taskId: string;
+}, string, never, never>, updateEditTaskFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskId: ID;
+    fetchState: FetchState;
+    error?: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, string>, saveTaskUpdatesToLocalStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskDetailLocalData: EditTaskLocalData;
+    taskId?: string | undefined;
+}, string>, discardTaskUpdatesInLocalStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskId?: string | undefined;
+}, string>, saveTaskDetail: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[isArchive: boolean, taskId?: string | undefined], {
+    isArchive: boolean;
+    taskId: string | undefined;
+}, string, never, never>, saveTaskSuccessOrFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    taskId?: string | undefined;
+    error?: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, string>, deleteTask: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId?: string | undefined], {
+    taskId: string | undefined;
+}, string, never, never>, removeTaskDetail: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>, deleteTaskSuccessOrFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    taskId?: string | undefined;
+    error?: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, string>, fetchTaskHistory: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskId: string, cacheOverride?: any], {
+    taskId: string;
+    cacheOverride: any;
+}, string, never, never>, updateTaskHistory: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskId: ID;
+    historicEventsPayload: HistoricEventPayload[];
+}, string>, updateTaskHistoryFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    taskId: ID;
+    fetchState: FetchState;
+    error?: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, string>, clearTaskDetail: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+declare const _default: import("@reduxjs/toolkit").Reducer<TaskDetailViewState, import("@reduxjs/toolkit").AnyAction>;
+export default _default;