@zeniai/client-epic-state 5.0.96 → 5.0.98-betaJK1

package/lib/esm/view/spendManagement/reimbursement/remiSetupApproverView/remiSetupApproverViewReducer.js

@@ -13,6 +13,7 @@ export const initialState = {
     newApprovalRuleId: undefined,
     approvalRulesDeleteStatusById: {},
     remiSetupApproverViewUpdateData: undefined,
+    reorderStatus: { fetchState: 'Not-Started', error: undefined },
     hasValidState() {
         return this.fetchState === 'Completed';
     },
@@ -26,12 +27,17 @@ const remiSetupApproverView = createSlice({
                 draft.fetchState = 'In-Progress';
                 draft.error = undefined;
             },
-            prepare(cacheOverride = false, resolveAttributeToUser = false, includeImplicitActors = false) {
+            // Approval Rules 3.0 — `useV3` arrives from the screen connector
+            // ('approval_rule_v3_config' dynamic config) and picks v1 vs v2
+            // endpoint in the fetch epic. Required (no default) so a missing
+            // connector wire surfaces at compile time.
+            prepare(cacheOverride = false, resolveAttributeToUser = false, includeImplicitActors = false, useV3) {
                 return {
                     payload: {
                         cacheOverride,
                         resolveAttributeToUser,
                         includeImplicitActors,
+                        useV3,
                     },
                 };
             },
@@ -134,8 +140,12 @@ const remiSetupApproverView = createSlice({
                     error: undefined,
                 };
             },
-            prepare(approvalRuleId) {
-                return { payload: { approvalRuleId } };
+            // Approval Rules 3.0 — `useV3` flows from the screen connector
+            // ('approval_rule_v3_config' dynamic config) so the delete epic
+            // can pick the v1 vs v2 endpoint. Required (no default) so a
+            // missing connector wire surfaces at compile time.
+            prepare(approvalRuleId, useV3) {
+                return { payload: { approvalRuleId, useV3 } };
             },
         },
         deleteRemiApprovalRuleSuccess: {
@@ -167,13 +177,72 @@ const remiSetupApproverView = createSlice({
                 };
             },
         },
-        saveRemiSetupApproverViewUpdates(draft) {
-            if (draft.remiSetupApproverViewUpdateData != null) {
-                draft.remiSetupApproverViewUpdateData.updateStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            }
+        /**
+         * Approval Rules 3.0 — list-page drag-and-drop reorder.
+         * See BillPay equivalent for the longer rationale.
+         */
+        reorderRemiApprovalRules: {
+            reducer(draft, action) {
+                const { approvalRuleIds } = action.payload;
+                const wasReorderInFlight = draft.reorderStatus.fetchState === 'In-Progress';
+                draft.reorderStatus = { fetchState: 'In-Progress', error: undefined };
+                // Stash the pre-reorder order for synchronous rollback on
+                // 'Failure'. See the BillPay reducer for the rationale,
+                // including the in-flight guard: a second drag before the
+                // first PUT lands must not overwrite the snapshot.
+                if (!wasReorderInFlight) {
+                    draft.reorderRollbackIds = draft.approvalRuleIds;
+                }
+                draft.approvalRuleIds = approvalRuleIds;
+            },
+            // Approval Rules 3.0 — `useV3` required so a missing wire
+            // surfaces at compile time. Mirror of BillPay's reorder.prepare.
+            prepare(approvalRuleIds, useV3) {
+                return { payload: { approvalRuleIds, useV3 } };
+            },
+        },
+        reorderRemiApprovalRulesSuccess: {
+            reducer(draft, action) {
+                const { approvalRuleIds } = action.payload;
+                draft.reorderStatus = { fetchState: 'Completed', error: undefined };
+                draft.approvalRuleIds = approvalRuleIds;
+                draft.reorderRollbackIds = undefined;
+            },
+            prepare(approvalRuleIds) {
+                return { payload: { approvalRuleIds } };
+            },
+        },
+        reorderRemiApprovalRulesFailure: {
+            reducer(draft, action) {
+                const { status } = action.payload;
+                draft.reorderStatus = { fetchState: 'Error', error: status };
+                if (draft.reorderRollbackIds != null) {
+                    draft.approvalRuleIds = draft.reorderRollbackIds;
+                    draft.reorderRollbackIds = undefined;
+                }
+            },
+            prepare(status) {
+                return { payload: { status } };
+            },
+        },
+        saveRemiSetupApproverViewUpdates: {
+            // Approval Rules 3.0 — `useV3` sourced from
+            // `approval_rule_v3_config` dynamic config in the screen
+            // connector; epic uses it to pick v1 vs v2 URL + mapper. The
+            // reducer doesn't read the action but the parameter must be
+            // declared so the action payload type carries downstream.
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            reducer(draft, _action) {
+                if (draft.remiSetupApproverViewUpdateData != null) {
+                    draft.remiSetupApproverViewUpdateData.updateStatus = {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                }
+            },
+            prepare(useV3) {
+                return { payload: { useV3 } };
+            },
         },
         saveRemiSetupApproverViewUpdatesSuccess: {
             reducer(draft, action) {
@@ -262,5 +331,5 @@ const remiSetupApproverView = createSlice({
         },
     },
 });
-export const { fetchRemiSetupApproverView, fetchRemiSetupApproverViewSuccess, fetchRemiSetupApproverViewFailure, fetchRemiApproversDetails, fetchRemiApproversList, fetchRemiApproversListSuccess, fetchRemiApproversListFailure, deleteRemiApprovalRule, deleteRemiApprovalRuleSuccess, deleteRemiApprovalRuleFailure, saveRemiSetupApproverViewUpdates, saveRemiSetupApproverViewUpdatesSuccess, saveRemiSetupApproverViewUpdatesFailure, initializeRemiSetupApproverViewUpdateData, saveRemiSetupApproverViewUpdateData, setListeningToPusherEvent, clearRemiSetupApproverViewUpdateData, clearRemiSetupApproverView, } = remiSetupApproverView.actions;
+export const { fetchRemiSetupApproverView, fetchRemiSetupApproverViewSuccess, fetchRemiSetupApproverViewFailure, fetchRemiApproversDetails, fetchRemiApproversList, fetchRemiApproversListSuccess, fetchRemiApproversListFailure, deleteRemiApprovalRule, deleteRemiApprovalRuleSuccess, deleteRemiApprovalRuleFailure, reorderRemiApprovalRules, reorderRemiApprovalRulesSuccess, reorderRemiApprovalRulesFailure, saveRemiSetupApproverViewUpdates, saveRemiSetupApproverViewUpdatesSuccess, saveRemiSetupApproverViewUpdatesFailure, initializeRemiSetupApproverViewUpdateData, saveRemiSetupApproverViewUpdateData, setListeningToPusherEvent, clearRemiSetupApproverViewUpdateData, clearRemiSetupApproverView, } = remiSetupApproverView.actions;
 export default remiSetupApproverView.reducer;

package/lib/esm/view/taskManager/taskDetailView/epics/createSubTaskEpic.js

@@ -0,0 +1,80 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { convertHHMMStrToMinutes } from '../../../../commonStateTypes/fiscalYearHelpers/formatMinutesToFromHHMM';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { appendSubTaskId, updateTasks, } from '../../../../entity/task/taskReducer';
+import { getTaskById } from '../../../../entity/task/taskSelector';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { updateTaskListOnNewTaskCreationSuccess } from '../../taskListView/taskListReducer';
+import { createSubTask, createSubTaskSuccessOrFailure, } from '../taskDetailReducer';
+export const createSubTaskEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(createSubTask.match), mergeMap((action) => {
+    const state = state$.value;
+    const parentTask = getTaskById(state.taskState, action.payload.parentTaskId);
+    const parentTaskGroupId = parentTask?.taskGroupIds[0];
+    const isTaskListFetched = state.taskListState.fetchState === 'Completed';
+    const payload = prepareSubTaskPayload(action.payload, parentTaskGroupId);
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) &&
+            response.data != null &&
+            response.data.tasks.length > 0) {
+            const newTaskId = response.data.tasks[0].task_id;
+            const actions = [
+                updateTasks(response.data.tasks),
+                appendSubTaskId({
+                    parentTaskId: action.payload.parentTaskId,
+                    subTaskId: newTaskId,
+                }),
+                createSubTaskSuccessOrFailure({
+                    fetchState: 'Completed',
+                    newTaskId,
+                }),
+                openSnackbar({
+                    messageSection: 'create_sub_task',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ];
+            if (isTaskListFetched === true && parentTaskGroupId != null) {
+                actions.push(updateTaskListOnNewTaskCreationSuccess({
+                    taskGroupId: parentTaskGroupId,
+                    task: response.data.tasks[0],
+                }));
+            }
+            return from(actions);
+        }
+        else {
+            return of(createSubTaskSuccessOrFailure({
+                fetchState: 'Error',
+                error: response.status,
+            }), openSnackbar({
+                messageSection: 'create_sub_task',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }));
+        }
+    }), catchError((error) => of(createSubTaskSuccessOrFailure({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Create Sub Task REST API call errored out' +
+            JSON.stringify(error)),
+    }))));
+}));
+const prepareSubTaskPayload = (subTask, parentTaskGroupId) => ({
+    name: subTask.name,
+    assignees: subTask.assignee,
+    description: subTask.description,
+    priority: subTask.priority,
+    status: subTask.status,
+    tags: subTask.tagIds,
+    time_spent: convertHHMMStrToMinutes(subTask.timeSpent),
+    group_assignees: subTask.groupAssignees,
+    parent_task_id: subTask.parentTaskId,
+    task_group_ids: parentTaskGroupId == null ? [] : [parentTaskGroupId],
+});

package/lib/esm/view/taskManager/taskDetailView/epics/fetchSubTasksEpic.js

@@ -0,0 +1,36 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { updateTasks } from '../../../../entity/task/taskReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchSubTasks, updateSubTasks, updateSubTasksFetchStatus, } from '../taskDetailReducer';
+export const fetchSubTasksEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchSubTasks.match), switchMap((action) => {
+    const { parentTaskId } = action.payload;
+    const query = JSON.stringify({
+        task_type: 'subtasks',
+        parent_task_id: parentTaskId,
+    });
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.taskMicroServiceBaseUrl}/1.0/task-manager/tasks?query=${encodeURIComponent(query)}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const { tasks } = response.data;
+            return of(updateTasks(tasks), updateSubTasks({
+                parentTaskId,
+            }));
+        }
+        else {
+            return of(updateSubTasksFetchStatus({
+                parentTaskId,
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => {
+        return of(updateSubTasksFetchStatus({
+            parentTaskId,
+            fetchState: 'Error',
+            error: createZeniAPIStatus('Unexpected Error', 'Fetch Sub Tasks REST API call errored out' +
+                JSON.stringify(error)),
+        }));
+    }));
+}));

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

@@ -4,13 +4,16 @@ import { catchError, filter, mergeMap } from 'rxjs/operators';
 import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
 import { updateTags } from '../../../../entity/tag/tagReducer';
 import { updateTasks } from '../../../../entity/task/taskReducer';
+import { getTaskById } from '../../../../entity/task/taskSelector';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
 import { fetchFileList } from '../../../fileView/fileViewReducer';
+import { updateTaskListOnNewTaskCreationSuccess } from '../../taskListView/taskListReducer';
 import { fetchTaskDetail, initializeTaskToLocalStore, removeTaskDetail, updateEditTaskFetchStatus, } from '../taskDetailReducer';
 export const fetchTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchTaskDetail.match), mergeMap((action) => {
     const { taskId, cacheOverride } = action.payload;
     const taskActions = [];
     const state = state$.value;
+    const isTaskListFetched = state.taskListState.fetchState === 'Completed';
     const taskDetail = recordGet(state.taskDetailState.editTaskStateById, taskId, undefined);
     if (cacheOverride === true) {
         taskActions.push(removeTaskDetail(taskId));
@@ -32,6 +35,16 @@ export const fetchTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(
                     updateTags(response.data.tasks.map((task) => task.tags).flat()),
                     initializeTaskToLocalStore(taskId),
                 ];
+                if (isTaskListFetched === true) {
+                    const taskGroupId = response.data.tasks[0].task_group_ids?.[0];
+                    if (taskGroupId != null) {
+                        fetchActions.push(updateTaskListOnNewTaskCreationSuccess({
+                            taskGroupId,
+                            task: response.data.tasks[0],
+                            currentTaskState: getTaskById(state.taskState, taskId),
+                        }));
+                    }
+                }
                 const fileIds = response.data.tasks[0].file_ids;
                 if (fileIds.length > 0) {
                     fetchActions.push(fetchFileList(fileIds));

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

@@ -6,6 +6,11 @@ import { initialTaskDetail, } from './taskDetail';
 export const initialState = {
     newTaskState: initialTaskDetail,
     editTaskStateById: {},
+    subTaskCreateStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    subTaskListFetchStatusByParentId: {},
     taskHistoryById: {},
 };
 const taskDetailView = createSlice({
@@ -50,7 +55,7 @@ const taskDetailView = createSlice({
         updateEditTaskFetchStatus(draft, action) {
             const { taskId, fetchState, error } = action.payload;
             draft.editTaskStateById[taskId] = {
-                ...draft.editTaskStateById[taskId],
+                ...(draft.editTaskStateById[taskId] ?? initialTaskDetail),
                 fetchTaskStatus: {
                     fetchState,
                     error: fetchState === 'Error' ? error : undefined,
@@ -318,10 +323,54 @@ const taskDetailView = createSlice({
                 error,
             };
         },
+        createSubTask: {
+            reducer(draft) {
+                draft.subTaskCreateStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        createSubTaskSuccessOrFailure(draft, action) {
+            const { fetchState, error } = action.payload;
+            draft.subTaskCreateStatus = {
+                fetchState,
+                error,
+            };
+        },
+        fetchSubTasks: {
+            reducer(draft, action) {
+                const { parentTaskId } = action.payload;
+                draft.subTaskListFetchStatusByParentId[parentTaskId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(parentTaskId) {
+                return { payload: { parentTaskId } };
+            },
+        },
+        updateSubTasks(draft, action) {
+            const { parentTaskId } = action.payload;
+            draft.subTaskListFetchStatusByParentId[parentTaskId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        updateSubTasksFetchStatus(draft, action) {
+            const { parentTaskId, fetchState, error } = action.payload;
+            draft.subTaskListFetchStatusByParentId[parentTaskId] = {
+                fetchState,
+                error,
+            };
+        },
         clearTaskDetail(draft) {
             Object.assign(draft, initialState);
         },
     },
 });
-export const { fetchTaskDetailPage, fetchTaskDetail, initializeTaskToLocalStore, updateEditTaskFetchStatus, saveTaskUpdatesToLocalStore, discardTaskUpdatesInLocalStore, saveTaskDetail, archiveTask, archiveTaskSuccessOrFailure, saveTaskSuccessOrFailure, deleteTask, removeTaskDetail, deleteTaskSuccessOrFailure, snoozeTask, snoozeTaskSuccessOrFailure, unsnoozeTask, fetchTaskHistory, updateTaskHistory, updateTaskHistoryFetchStatus, clearTaskDetail, updateCreatedTagToLocalStore, updateDeletedTagToLocalStore, } = taskDetailView.actions;
+export const { fetchTaskDetailPage, fetchTaskDetail, initializeTaskToLocalStore, updateEditTaskFetchStatus, saveTaskUpdatesToLocalStore, discardTaskUpdatesInLocalStore, saveTaskDetail, archiveTask, archiveTaskSuccessOrFailure, saveTaskSuccessOrFailure, createSubTask, createSubTaskSuccessOrFailure, fetchSubTasks, updateSubTasks, updateSubTasksFetchStatus, deleteTask, removeTaskDetail, deleteTaskSuccessOrFailure, snoozeTask, snoozeTaskSuccessOrFailure, unsnoozeTask, fetchTaskHistory, updateTaskHistory, updateTaskHistoryFetchStatus, clearTaskDetail, updateCreatedTagToLocalStore, updateDeletedTagToLocalStore, } = taskDetailView.actions;
 export default taskDetailView.reducer;

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

@@ -1,8 +1,8 @@
 import isEqual from 'lodash/isEqual';
-import { reduceFetchState } from '../../../commonStateTypes/reduceFetchState';
+import { reduceAnyFetchState } from '../../../commonStateTypes/reduceFetchState';
 import { getClassesByIds } from '../../../entity/class/classSelector';
 import { getFilesByFileIds } from '../../../entity/file/fileSelector';
-import { getTaskById } from '../../../entity/task/taskSelector';
+import { getTaskById, getTasksByIds } from '../../../entity/task/taskSelector';
 import { getUserAndUserRole, } from '../../companyView/types/userAndRole';
 import { getFileDeleteStatusById, getFileUpdateNameStatusById, } from '../../fileView/fileViewSelector';
 import { getUserList, } from '../../userListView/userListViewSelector';
@@ -27,8 +27,13 @@ export const getTaskDetail = (state, taskId) => {
     let recurringSourceTaskId = undefined;
     let snoozedUntil = undefined;
     let taskGroupId = undefined;
+    let subtasks = [];
     if (taskId != null && sourceTaskDetail != null) {
         const taskEntity = getTaskById(taskState, taskId);
+        subtasks =
+            taskEntity != null
+                ? getTasksByIds(taskState, taskEntity.subTasksIds)
+                : [];
         const fileIdsInEntity = taskEntity?.fileIds ?? [];
         if (taskEntity != null) {
             createdByUser = getUserAndUserRole(userState, userRoleState, addressState, taskEntity.createdBy);
@@ -39,25 +44,27 @@ export const getTaskDetail = (state, taskId) => {
             taskGroupId = taskEntity.taskGroupIds[0];
         }
         if (fileIdsInEntity.length > 0) {
-            fetchStatus = reduceFetchState([
+            fetchStatus = reduceAnyFetchState([
                 fileViewState.fetchFilesStatus,
                 sourceTaskDetail.fetchTaskStatus,
                 userList,
                 classListState,
+                taskDetailState.subTaskListFetchStatusByParentId[taskId] ?? fetchStatus,
             ]);
         }
         else {
-            fetchStatus = reduceFetchState([
+            fetchStatus = reduceAnyFetchState([
                 sourceTaskDetail.fetchTaskStatus,
                 userList,
                 classListState,
+                taskDetailState.subTaskListFetchStatusByParentId[taskId] ?? fetchStatus,
             ]);
         }
         showTaskDetailFormFooter = showFormFooter(sourceTaskDetail.taskDetailLocalData, taskEntity);
         taskHistory = taskDetailState.taskHistoryById[taskId]?.historicEvents ?? [];
     }
     else if (taskId == null) {
-        fetchStatus = reduceFetchState([userList, classListState]);
+        fetchStatus = reduceAnyFetchState([userList, classListState]);
     }
     const { classIds } = classListState;
     const allAccountingClasses = getClassesByIds(classState, {
@@ -90,6 +97,7 @@ export const getTaskDetail = (state, taskId) => {
         showTaskDetailFormFooter,
         snoozedUntil,
         taskGroupId,
+        subtasks,
     };
 };
 export const allTaskStatus = [
@@ -137,13 +145,16 @@ export const allTaskPriority = [
     },
 ];
 const showFormFooter = (taskDetailLocalData, taskDetailInStore) => {
-    if (taskDetailLocalData.name !== taskDetailInStore?.name ||
+    if (taskDetailInStore == null) {
+        return false;
+    }
+    if (taskDetailLocalData.name !== taskDetailInStore.name ||
         taskDetailLocalData.description !== taskDetailInStore.description ||
         taskDetailLocalData.priority !== taskDetailInStore.priority.code ||
         taskDetailLocalData.status !== taskDetailInStore.status.code ||
         !isEqual(taskDetailInStore.tagIds, taskDetailLocalData.tagIds) ||
-        !isEqual(taskDetailLocalData.assignee, taskDetailInStore?.assignees ?? []) ||
-        !isEqual(taskDetailLocalData.groupAssignees, taskDetailInStore?.groupAssignees ?? []) ||
+        !isEqual(taskDetailLocalData.assignee, taskDetailInStore.assignees ?? []) ||
+        !isEqual(taskDetailLocalData.groupAssignees, taskDetailInStore.groupAssignees ?? []) ||
         !isEqual(taskDetailLocalData.fileIds, taskDetailInStore.fileIds ?? []) ||
         !isEqual(taskDetailLocalData.dueDate, taskDetailInStore.dueDate) ||
         !isEqual(taskDetailLocalData.type, taskDetailInStore.type) ||