@zeniai/client-epic-state 4.7.84 → 4.7.86

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

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearTaskDetail = exports.updateTaskHistoryFetchStatus = exports.updateTaskHistory = exports.fetchTaskHistory = exports.deleteTaskSuccessOrFailure = exports.removeTaskDetail = exports.deleteTask = exports.saveTaskSuccessOrFailure = exports.saveTaskDetail = exports.discardTaskUpdatesInLocalStore = exports.saveTaskUpdatesToLocalStore = exports.updateEditTaskFetchStatus = exports.initializeTaskToLocalStore = exports.fetchTaskDetail = exports.fetchTaskDetailPage = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const get_1 = __importDefault(require("lodash/get"));
+const taskDetail_1 = require("./taskDetail");
+const commonHistory_1 = require("../../spendManagement/commonHistoryView/commonHistory");
+const commonHistoryPayload_1 = require("../../spendManagement/commonHistoryView/commonHistoryPayload");
+exports.initialState = {
+    newTaskState: taskDetail_1.initialTaskDetail,
+    editTaskStateById: {},
+    taskHistoryById: {},
+};
+const taskDetailView = (0, toolkit_1.createSlice)({
+    name: 'taskDetailView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchTaskDetailPage: {
+            reducer(draft, action) {
+                const { taskId } = action.payload;
+                if (taskId != null) {
+                    const detail = (0, get_1.default)(draft.editTaskStateById, taskId, undefined);
+                    if (action.payload.cacheOverride === true ||
+                        detail == null ||
+                        detail.fetchTaskStatus.fetchState !== 'In-Progress') {
+                        draft.editTaskStateById[taskId] = Object.assign({}, taskDetail_1.initialTaskDetail);
+                    }
+                }
+            },
+            prepare(cacheOverride, taskId) {
+                return { payload: { cacheOverride, taskId } };
+            },
+        },
+        fetchTaskDetail: {
+            reducer() {
+                //do nothing
+            },
+            prepare(taskId, cacheOverride = false) {
+                return {
+                    payload: {
+                        taskId,
+                        cacheOverride,
+                    },
+                };
+            },
+        },
+        removeTaskDetail(draft, action) {
+            const key = action.payload;
+            delete draft.editTaskStateById[key];
+        },
+        updateEditTaskFetchStatus(draft, action) {
+            const { taskId, fetchState, error } = action.payload;
+            draft.editTaskStateById[taskId] = Object.assign(Object.assign({}, draft.editTaskStateById[taskId]), { fetchTaskStatus: {
+                    fetchState,
+                    error: fetchState === 'Error' ? error : undefined,
+                } });
+        },
+        initializeTaskToLocalStore: {
+            reducer(draft, action) {
+                const key = action.payload.taskId;
+                draft.editTaskStateById[key] = Object.assign(Object.assign({}, draft.editTaskStateById[key]), { taskId: key });
+            },
+            prepare(taskId) {
+                return { payload: { taskId } };
+            },
+        },
+        saveTaskUpdatesToLocalStore(draft, action) {
+            if (action.payload.taskId != null) {
+                const key = action.payload.taskId;
+                draft.editTaskStateById[key].taskDetailLocalData = Object.assign(Object.assign({}, draft.editTaskStateById[key].taskDetailLocalData), action.payload.taskDetailLocalData);
+                draft.editTaskStateById[key].taskId = key;
+            }
+            else {
+                draft.newTaskState.taskDetailLocalData = Object.assign(Object.assign({}, draft.newTaskState.taskDetailLocalData), action.payload.taskDetailLocalData);
+            }
+        },
+        discardTaskUpdatesInLocalStore(draft, action) {
+            if (action.payload.taskId != null) {
+                const key = action.payload.taskId;
+                draft.editTaskStateById[key] = taskDetail_1.initialTaskDetail;
+            }
+            else {
+                draft.newTaskState = taskDetail_1.initialTaskDetail;
+            }
+        },
+        saveTaskDetail: {
+            reducer(draft, action) {
+                const { taskId } = action.payload;
+                if (taskId != null) {
+                    draft.editTaskStateById[taskId] = Object.assign(Object.assign({}, draft.editTaskStateById[taskId]), { saveStatus: {
+                            fetchState: 'In-Progress',
+                            error: undefined,
+                        } });
+                }
+                else {
+                    draft.newTaskState = Object.assign(Object.assign({}, draft.newTaskState), { saveStatus: {
+                            fetchState: 'In-Progress',
+                            error: undefined,
+                        } });
+                }
+            },
+            prepare(isArchive, taskId) {
+                return {
+                    payload: {
+                        isArchive,
+                        taskId,
+                    },
+                };
+            },
+        },
+        saveTaskSuccessOrFailure(draft, action) {
+            if (action.payload.taskId != null) {
+                const { taskId } = action.payload;
+                draft.editTaskStateById[taskId].saveStatus.fetchState =
+                    action.payload.fetchState;
+                draft.editTaskStateById[taskId].saveStatus.error = action.payload.error;
+            }
+            else {
+                draft.newTaskState.saveStatus.fetchState = action.payload.fetchState;
+                draft.newTaskState.saveStatus.error = action.payload.error;
+            }
+        },
+        deleteTask: {
+            reducer(draft, action) {
+                const { taskId } = action.payload;
+                if (taskId != null) {
+                    draft.editTaskStateById[taskId] = Object.assign(Object.assign({}, draft.editTaskStateById[taskId]), { deleteTaskStatus: {
+                            fetchState: 'In-Progress',
+                            error: undefined,
+                        } });
+                }
+                else {
+                    draft.newTaskState = Object.assign(Object.assign({}, draft.newTaskState), { deleteTaskStatus: {
+                            fetchState: 'In-Progress',
+                            error: undefined,
+                        } });
+                }
+            },
+            prepare(taskId) {
+                return {
+                    payload: {
+                        taskId,
+                    },
+                };
+            },
+        },
+        deleteTaskSuccessOrFailure(draft, action) {
+            if (action.payload.taskId != null) {
+                const { taskId } = action.payload;
+                draft.editTaskStateById[taskId].deleteTaskStatus.fetchState =
+                    action.payload.fetchState;
+                draft.editTaskStateById[taskId].deleteTaskStatus.error =
+                    action.payload.error;
+            }
+            else {
+                draft.newTaskState.deleteTaskStatus.fetchState =
+                    action.payload.fetchState;
+                draft.newTaskState.deleteTaskStatus.error = action.payload.error;
+            }
+        },
+        fetchTaskHistory: {
+            reducer(draft, action) {
+                const { taskId, cacheOverride } = action.payload;
+                const detail = (0, get_1.default)(draft.taskHistoryById, taskId, undefined);
+                if (cacheOverride === true ||
+                    detail == null ||
+                    detail.fetchState !== 'In-Progress') {
+                    draft.taskHistoryById[taskId] = Object.assign({}, commonHistory_1.initialCommonHistory);
+                }
+            },
+            prepare(taskId, cacheOverride = true) {
+                return {
+                    payload: { taskId, cacheOverride },
+                };
+            },
+        },
+        updateTaskHistory(draft, action) {
+            const { taskId, historicEventsPayload } = action.payload;
+            const historicEvents = historicEventsPayload.map((historicEventPayload) => (0, commonHistoryPayload_1.toHistoricEvent)(historicEventPayload));
+            draft.taskHistoryById[taskId] = Object.assign(Object.assign({}, commonHistory_1.initialCommonHistory), { fetchState: 'Completed', error: undefined, historicEvents });
+        },
+        updateTaskHistoryFetchStatus(draft, action) {
+            const { taskId, fetchState, error } = action.payload;
+            draft.taskHistoryById[taskId] = Object.assign(Object.assign({}, commonHistory_1.initialCommonHistory), { fetchState,
+                error });
+        },
+        clearTaskDetail(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_a = taskDetailView.actions, exports.fetchTaskDetailPage = _a.fetchTaskDetailPage, exports.fetchTaskDetail = _a.fetchTaskDetail, exports.initializeTaskToLocalStore = _a.initializeTaskToLocalStore, exports.updateEditTaskFetchStatus = _a.updateEditTaskFetchStatus, exports.saveTaskUpdatesToLocalStore = _a.saveTaskUpdatesToLocalStore, exports.discardTaskUpdatesInLocalStore = _a.discardTaskUpdatesInLocalStore, exports.saveTaskDetail = _a.saveTaskDetail, exports.saveTaskSuccessOrFailure = _a.saveTaskSuccessOrFailure, exports.deleteTask = _a.deleteTask, exports.removeTaskDetail = _a.removeTaskDetail, exports.deleteTaskSuccessOrFailure = _a.deleteTaskSuccessOrFailure, exports.fetchTaskHistory = _a.fetchTaskHistory, exports.updateTaskHistory = _a.updateTaskHistory, exports.updateTaskHistoryFetchStatus = _a.updateTaskHistoryFetchStatus, exports.clearTaskDetail = _a.clearTaskDetail;
+exports.default = taskDetailView.reducer;

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

@@ -0,0 +1,23 @@
+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';
+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;
+}
+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,176 @@
+"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 getTaskDetail = (state, taskId) => {
+    var _a;
+    const { taskDetailState, classListState, classState, fileState, fileViewState, 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 = [];
+    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 (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,
+        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/taskList.d.ts

@@ -0,0 +1,33 @@
+import { FetchedState, ID } from '../../../commonStateTypes/common';
+import { ZeniDate } from '../../../zeniDayJS';
+import { SpendManagementUIState } from '../../spendManagement/billPay/billList/billListState';
+import { CategoryCombinationOperator, FilterCategoryType } from '../../spendManagement/spendManagementFilterHelpers';
+export interface TaskListState extends FetchedState {
+    taskIds: ID[];
+    uiState: TaskListUIState;
+    searchText: string;
+    filters: TaskListFilters;
+}
+export interface TaskListFilters {
+    categoryCombinationOperator: CategoryCombinationOperator;
+    categories: TaskFilterCategory[];
+}
+export interface TaskFilterCategory {
+    field: TaskListFilterCategoryField;
+    matchingOperator: 'equal' | 'not-equal';
+    values: (string | ZeniDate)[];
+    valuesCombinationOperator: 'ANY';
+}
+export declare type TaskListFilterCategoryField = 'status' | 'dueDate' | 'assignee' | 'createdBy' | 'priority' | 'tag';
+export interface TaskListUIState extends SpendManagementUIState {
+    sortKey: TaskListViewSortKey;
+}
+export declare const ALL_TASK_LIST_SORT_KEYS: readonly ["name", "dueDate", "assignee", "tag", "status", "priority", "createdBy"];
+export declare const toTaskListSortKeyType: (v: string) => "priority" | "name" | "status" | "dueDate" | "createdBy" | "assignee" | "tag";
+export declare type TaskListViewSortKey = ReturnType<typeof toTaskListSortKeyType>;
+export declare const TASK_LIST_FILTER_CATEGORIES: TaskListFilterCategoryOption[];
+export interface TaskListFilterCategoryOption {
+    value: TaskListFilterCategoryField;
+    multiple?: boolean;
+    type?: FilterCategoryType;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_LIST_FILTER_CATEGORIES = exports.toTaskListSortKeyType = exports.ALL_TASK_LIST_SORT_KEYS = void 0;
+const stringToUnion_1 = require("../../../commonStateTypes/stringToUnion");
+exports.ALL_TASK_LIST_SORT_KEYS = [
+    'name',
+    'dueDate',
+    'assignee',
+    'tag',
+    'status',
+    'priority',
+    'createdBy',
+];
+const toTaskListSortKeyType = (v) => (0, stringToUnion_1.stringToUnion)(v, exports.ALL_TASK_LIST_SORT_KEYS);
+exports.toTaskListSortKeyType = toTaskListSortKeyType;
+exports.TASK_LIST_FILTER_CATEGORIES = [
+    { value: 'status', multiple: true, type: 'dropdown' },
+    { value: 'priority', type: 'dropdown', multiple: true },
+    { value: 'tag', type: 'dropdown', multiple: true },
+    { value: 'dueDate', type: 'dateRange', multiple: false },
+    { value: 'createdBy', type: 'user', multiple: true },
+    {
+        value: 'assignee',
+        type: 'user',
+        multiple: true,
+    },
+];

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/taskManager/taskListView/taskListReducer.d.ts

@@ -0,0 +1,22 @@
+import { FetchState, UpdateType } from '../../../commonStateTypes/common';
+import { TaskPayload } from '../../../entity/task/taskPayload';
+import { ZeniAPIStatus } from '../../../responsePayload';
+import { TaskListFilters, TaskListState, TaskListUIState } from './taskList';
+export declare const initialState: TaskListState;
+export declare const fetchTaskListPage: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[cacheOverride: boolean], {
+    cacheOverride: boolean;
+}, string, never, never>, fetchTaskList: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, updateTaskList: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    data: TaskPayload[];
+    updateType: UpdateType;
+}, string>, updateTaskListFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    fetchState: FetchState;
+    error?: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, string>, updateTaskListSearchText: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    searchText: string;
+}, string>, updateTaskListUIState: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    uiState: Partial<TaskListUIState>;
+}, string>, updateTaskFilters: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    filters: TaskListFilters;
+}, string>, clearTaskList: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+declare const _default: import("@reduxjs/toolkit").Reducer<TaskListState, import("@reduxjs/toolkit").AnyAction>;
+export default _default;

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

@@ -0,0 +1,81 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearTaskList = 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.initialState = {
+    taskIds: [],
+    fetchState: 'Not-Started',
+    searchText: '',
+    error: undefined,
+    uiState: {
+        sortOrder: 'ascending',
+        sortKey: 'name',
+    },
+    filters: {
+        categoryCombinationOperator: 'AND',
+        categories: [],
+    },
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const taskList = (0, toolkit_1.createSlice)({
+    name: 'taskList',
+    initialState: exports.initialState,
+    reducers: {
+        fetchTaskListPage: {
+            reducer() {
+                //do nothing
+            },
+            prepare(cacheOverride) {
+                return { payload: { cacheOverride } };
+            },
+        },
+        fetchTaskList(draft) {
+            const existingTasks = draft.taskIds;
+            // if Tasks are already there do background fetch and don't show loader
+            draft.fetchState = existingTasks.length > 0 ? 'Completed' : 'In-Progress';
+            draft.error = undefined;
+        },
+        updateTaskList(draft, action) {
+            var _a;
+            const { data, updateType } = action.payload;
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+            const newAccounts = (_a = data.map((task) => task.task_id)) !== null && _a !== void 0 ? _a : [];
+            draft.taskIds =
+                updateType === 'merge'
+                    ? [...new Set([...draft.taskIds, ...newAccounts])]
+                    : newAccounts;
+        },
+        updateTaskListFetchStatus(draft, action) {
+            draft.fetchState = action.payload.fetchState;
+            draft.error = action.payload.error;
+        },
+        updateTaskListSearchText(draft, action) {
+            draft.searchText = action.payload.searchText;
+        },
+        updateTaskListUIState(draft, action) {
+            if (action.payload.uiState.sortKey != null) {
+                draft.uiState.sortKey = action.payload.uiState.sortKey;
+            }
+            if (action.payload.uiState.sortOrder != null) {
+                draft.uiState.sortOrder = action.payload.uiState.sortOrder;
+            }
+            if (action.payload.uiState.scrollYOffset != null) {
+                draft.uiState.scrollYOffset = action.payload.uiState.scrollYOffset;
+            }
+        },
+        updateTaskFilters(draft, action) {
+            if (action.payload.filters != null) {
+                draft.filters = action.payload.filters;
+            }
+        },
+        clearTaskList(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_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.clearTaskList = _a.clearTaskList;
+exports.default = taskList.reducer;