@zeniai/client-epic-state 4.9.30 → 4.9.31

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,79 @@
+"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 } = action.payload;
+    const state = state$.value;
+    const payload = prepareTaskPayload(state, 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 &&
+            response.data.tasks.length > 0) {
+            const newTaskId = response.data.tasks[0].task_id;
+            const fetchActions = [
+                (0, taskReducer_1.updateTasks)(response.data.tasks),
+                (0, taskDetailReducer_1.saveTaskSuccessOrFailure)({
+                    fetchState: 'Completed',
+                    newTaskId,
+                    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: '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, 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,
+    };
+};

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

@@ -0,0 +1,25 @@
+import { FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { Class } from '../../../entity/class/classState';
+import { TaskTag, TaskStatus, TaskPriority } from '../../../entity/task/task';
+import { RootState } from '../../../reducer';
+import { File } from '../../../entity/file/fileState';
+import { UserListSelectorView } from '../../userListView/userListViewSelector';
+import { EditTaskDetail } from './taskDetail';
+import { HistoricEvent } from '../../spendManagement/commonHistoryView/commonHistory';
+import { UserAndRole } from '../../companyView/types/userAndRole';
+export interface TaskDetailSelectorView extends SelectorView {
+    taskDetailView: EditTaskDetail;
+    userList: UserListSelectorView;
+    allAccountingClasses: Class[];
+    deleteFileStatusById: Record<ID, FetchStateAndError | undefined>;
+    updateFileStatusById: Record<ID, FetchStateAndError | undefined>;
+    files: File[];
+    taskHistory: HistoricEvent[];
+    showTaskDetailFormFooter: boolean;
+    createdByUser?: UserAndRole;
+}
+export declare const getTaskDetail: (state: RootState, taskId?: string | undefined) => TaskDetailSelectorView;
+export declare const allTaskTags: TaskTag[];
+export declare const allTaskStatus: TaskStatus[];
+export declare const allTaskPriority: TaskPriority[];

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

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allTaskPriority = exports.allTaskStatus = exports.allTaskTags = exports.getTaskDetail = void 0;
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const reduceFetchState_1 = require("../../../commonStateTypes/reduceFetchState");
+const classSelector_1 = require("../../../entity/class/classSelector");
+const fileViewSelector_1 = require("../../fileView/fileViewSelector");
+const userListViewSelector_1 = require("../../userListView/userListViewSelector");
+const fileSelector_1 = require("../../../entity/file/fileSelector");
+const taskSelector_1 = require("../../../entity/task/taskSelector");
+const userAndRole_1 = require("../../companyView/types/userAndRole");
+const getTaskDetail = (state, taskId) => {
+    var _a;
+    const { taskDetailState, classListState, classState, fileState, fileViewState, userState, userRoleState, addressState, taskState, } = state;
+    const deleteFileStatusById = {};
+    const updateFileStatusById = {};
+    let showTaskDetailFormFooter = false;
+    const sourceTaskDetail = taskId != null
+        ? taskDetailState.editTaskStateById[taskId]
+        : taskDetailState.newTaskState;
+    const userList = (0, userListViewSelector_1.getUserList)(state, 'taskManagerCandidate');
+    let fetchStatus = {
+        fetchState: 'Not-Started',
+        error: undefined,
+    };
+    let taskHistory = [];
+    let createdByUser = undefined;
+    if (taskId != null && sourceTaskDetail != null) {
+        const taskEntity = (0, taskSelector_1.getTaskById)(taskState, taskId);
+        const fileIdsInEntity = (_a = taskEntity === null || taskEntity === void 0 ? void 0 : taskEntity.fileIds) !== null && _a !== void 0 ? _a : [];
+        if (taskEntity != null) {
+            createdByUser = (0, userAndRole_1.getUserAndUserRole)(userState, userRoleState, addressState, taskEntity.createdBy);
+        }
+        if (fileIdsInEntity.length > 0) {
+            fetchStatus = (0, reduceFetchState_1.reduceFetchState)([
+                fileViewState.fetchFilesStatus,
+                sourceTaskDetail.fetchTaskStatus,
+                userList,
+                classListState,
+            ]);
+        }
+        else {
+            fetchStatus = (0, reduceFetchState_1.reduceFetchState)([
+                sourceTaskDetail.fetchTaskStatus,
+                userList,
+                classListState,
+            ]);
+        }
+        showTaskDetailFormFooter = showFormFooter(sourceTaskDetail.taskDetailLocalData, taskEntity);
+        taskHistory = taskDetailState.taskHistoryById[taskId].historicEvents;
+    }
+    else if (taskId == null) {
+        fetchStatus = (0, reduceFetchState_1.reduceFetchState)([userList, classListState]);
+    }
+    const { classIds } = classListState;
+    const allAccountingClasses = (0, classSelector_1.getClassesByIds)(classState, {
+        classIds: classIds,
+        reportId: 'class_list',
+    });
+    let files = [];
+    if (sourceTaskDetail != null) {
+        sourceTaskDetail.taskDetailLocalData.fileIds.forEach((fileId) => {
+            deleteFileStatusById[fileId] = (0, fileViewSelector_1.getFileDeleteStatusById)(state, fileId);
+            updateFileStatusById[fileId] = (0, fileViewSelector_1.getFileUpdateNameStatusById)(state, fileId);
+        });
+        files = (0, fileSelector_1.getFilesByFileIds)(fileState, sourceTaskDetail.taskDetailLocalData.fileIds);
+    }
+    return {
+        taskDetailView: sourceTaskDetail,
+        allAccountingClasses,
+        userList,
+        deleteFileStatusById,
+        updateFileStatusById,
+        files,
+        taskHistory,
+        fetchState: fetchStatus.fetchState,
+        error: fetchStatus.error,
+        version: 0,
+        createdByUser,
+        showTaskDetailFormFooter,
+    };
+};
+exports.getTaskDetail = getTaskDetail;
+exports.allTaskTags = [
+    {
+        code: 'invoices',
+        name: 'Invoices',
+    },
+    {
+        code: 'receipts',
+        name: 'Receipts',
+    },
+    {
+        code: 'tax_equity',
+        name: 'Tax',
+    },
+    {
+        code: 'payroll_statements',
+        name: 'Payroll',
+    },
+    {
+        code: 'accrual',
+        name: 'Accrual',
+    },
+    {
+        code: 'ap',
+        name: 'AP',
+    },
+    {
+        code: 'ar',
+        name: 'AR',
+    },
+    {
+        code: 'loan',
+        name: 'Loan',
+    },
+    {
+        code: 'uncategorized_transactions',
+        name: 'Uncat txns',
+    },
+    {
+        code: 'access',
+        name: 'Access',
+    },
+];
+exports.allTaskStatus = [
+    {
+        code: 'todo',
+        name: 'To Do',
+    },
+    {
+        code: 'in_progress',
+        name: 'In Progress',
+    },
+    {
+        code: 'on_hold',
+        name: 'On Hold',
+    },
+    {
+        code: 'done',
+        name: 'Done',
+    },
+    {
+        code: 'resolved',
+        name: 'Resolved',
+    },
+];
+exports.allTaskPriority = [
+    {
+        code: 'urgent',
+        name: 'Urgent',
+    },
+    {
+        code: 'high',
+        name: 'High',
+    },
+    {
+        code: 'medium',
+        name: 'Normal',
+    },
+    {
+        code: 'low',
+        name: 'Low',
+    },
+];
+const showFormFooter = (taskDetailLocalData, taskDetailInStore) => {
+    var _a, _b, _c;
+    if (taskDetailLocalData.name !== (taskDetailInStore === null || taskDetailInStore === void 0 ? void 0 : taskDetailInStore.name) ||
+        taskDetailLocalData.description !== (taskDetailInStore === null || taskDetailInStore === void 0 ? void 0 : taskDetailInStore.description) ||
+        taskDetailLocalData.priority !== (taskDetailInStore === null || taskDetailInStore === void 0 ? void 0 : taskDetailInStore.priority.code) ||
+        taskDetailLocalData.status !== (taskDetailInStore === null || taskDetailInStore === void 0 ? void 0 : taskDetailInStore.status.code) ||
+        !(0, isEqual_1.default)(taskDetailLocalData.tag, (_a = taskDetailInStore === null || taskDetailInStore === void 0 ? void 0 : taskDetailInStore.tag) === null || _a === void 0 ? void 0 : _a.code) ||
+        !(0, isEqual_1.default)(taskDetailLocalData.assignee, (_b = taskDetailInStore === null || taskDetailInStore === void 0 ? void 0 : taskDetailInStore.assignees) !== null && _b !== void 0 ? _b : []) ||
+        !(0, isEqual_1.default)(taskDetailLocalData.fileIds, (_c = taskDetailInStore === null || taskDetailInStore === void 0 ? void 0 : taskDetailInStore.fileIds) !== null && _c !== void 0 ? _c : []) ||
+        !(0, isEqual_1.default)(taskDetailLocalData.dueDate, taskDetailInStore === null || taskDetailInStore === void 0 ? void 0 : taskDetailInStore.dueDate)) {
+        return true;
+    }
+    return false;
+};

package/lib/view/taskManager/taskListView/fetchTaskListEpic.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 { fetchTaskList, updateTaskList, updateTaskListFetchStatus } from './taskListReducer';
+import { updateTasks } from '../../../entity/task/taskReducer';
+export declare type ActionType = ReturnType<typeof fetchTaskList> | ReturnType<typeof updateTasks> | ReturnType<typeof updateTaskList> | ReturnType<typeof updateTaskListFetchStatus>;
+export declare const fetchTaskListEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTaskListEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../responsePayload");
+const taskListReducer_1 = require("./taskListReducer");
+const taskReducer_1 = require("../../../entity/task/taskReducer");
+const fetchTaskListEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(taskListReducer_1.fetchTaskList.match), (0, operators_1.switchMap)(() => {
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks?query=${encodeURIComponent(`{"task_type": "all"}`)}`)
+        .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.updateTaskList)({
+                data: response.data.tasks,
+                updateType: 'replace',
+            }));
+        }
+        else {
+            return (0, rxjs_1.of)((0, taskListReducer_1.updateTaskListFetchStatus)({
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), (0, operators_1.catchError)((error) => {
+        return (0, rxjs_1.of)((0, taskListReducer_1.updateTaskListFetchStatus)({
+            fetchState: 'Error',
+            error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch Task List REST API call errored out' +
+                JSON.stringify(error)),
+        }));
+    }));
+}));
+exports.fetchTaskListEpic = fetchTaskListEpic;

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

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+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>;
+export declare const fetchTaskListPageEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>) => Observable<ActionType>;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTaskListPageEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const taskListReducer_1 = require("./taskListReducer");
+const userListViewReducer_1 = require("../../userListView/userListViewReducer");
+const classListReducer_1 = require("../../classList/classListReducer");
+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 = [];
+    const state = state$.value;
+    if (cacheOverride === true) {
+        taskListPageActions.push((0, taskListReducer_1.fetchTaskList)());
+        taskListPageActions.push((0, classListReducer_1.fetchClassList)());
+        taskListPageActions.push((0, userListViewReducer_1.fetchUserListByType)('taskManagerCandidate', true));
+    }
+    else {
+        taskListPageActions.push((0, taskListReducer_1.fetchTaskList)());
+        if (state.classListState.hasValidState() === false &&
+            state.classListState.fetchState !== 'In-Progress') {
+            taskListPageActions.push((0, classListReducer_1.fetchClassList)());
+        }
+        const taskManageUsers = state.userListViewState.userListByType.taskManagerCandidate;
+        if (taskManageUsers.hasValidState() === false &&
+            taskManageUsers.fetchState !== 'In-Progress') {
+            taskListPageActions.push((0, userListViewReducer_1.fetchUserListByType)('taskManagerCandidate', false));
+        }
+    }
+    return (0, rxjs_1.concat)((0, rxjs_1.from)(taskListPageActions));
+}));
+exports.fetchTaskListPageEpic = fetchTaskListPageEpic;

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

@@ -0,0 +1,6 @@
+import { TaskPayload } from '../../../entity/task/taskPayload';
+import { ZeniAPIResponse } from '../../../responsePayload';
+export interface FetchTaskListPayload {
+    tasks: TaskPayload[];
+}
+export declare type FetchTaskListResponse = ZeniAPIResponse<FetchTaskListPayload>;

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

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

package/lib/view/tasksCard/fetchTasksCardEpic.d.ts

@@ -0,0 +1,14 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { RootState } from '../../reducer';
+import { ZeniReportData } from '../../responsePayload';
+import { ZeniAPI } from '../../zeniAPI';
+import { TasksCardPayload } from './tasksCardPayload';
+import { fetchTasksCard, updateTasksCard, updateTasksCardFailure } from './tasksCardReducer';
+export declare type ActionType = ReturnType<typeof fetchTasksCard> | ReturnType<typeof updateTasksCard> | ReturnType<typeof updateTasksCardFailure>;
+export declare const fetchTasksCardEpic: (actions$: ActionsObservable<ActionType>, _: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<{
+    payload: import("../../responsePayload").ZeniAPIStatus<Record<string, unknown>>;
+    type: string;
+} | {
+    payload: ZeniReportData<TasksCardPayload>;
+    type: string;
+}>;