foreman-tasks 2.0.1 → 3.0.3

data/webpack/ForemanTasks/Components/TaskDetails/TaskDetailsActions.js

@@ -1,135 +1,62 @@
-import { API } from 'foremanReact/redux/API';
-import {
-  showLoading,
-  hideLoading,
-} from 'foremanReact/components/Layout/LayoutActions';
+import { post, get } from 'foremanReact/redux/API';
 import { addToast } from 'foremanReact/redux/actions/toasts';
 import { translate as __ } from 'foremanReact/common/I18n';
 import {
-  FOREMAN_TASK_DETAILS_FETCH_TASK_REQUEST,
-  FOREMAN_TASK_DETAILS_FETCH_TASK_SUCCESS,
-  FOREMAN_TASK_DETAILS_FETCH_TASK_FAILURE,
-  FOREMAN_TASK_DETAILS_STOP_POLLING,
-  FOREMAN_TASK_DETAILS_START_POLLING,
-  TASK_STEP_CANCEL_REQUEST,
-  TASK_STEP_CANCEL_FAILURE,
-  TASK_STEP_CANCEL_SUCCESS,
-} from './TaskDetailsConstants';
+  withInterval,
+  stopInterval,
+} from 'foremanReact/redux/middlewares/IntervalMiddleware';
+import { foremanTasksApiPath, foremanTasksPath } from '../common/urlHelpers';
+import { TASK_STEP_CANCEL, FOREMAN_TASK_DETAILS } from './TaskDetailsConstants';
 import {
   errorToastData,
   infoToastData,
   successToastData,
 } from '../common/ToastsHelpers';
 
-export const taskReloadStop = timeoutId => {
-  if (timeoutId) {
-    clearTimeout(timeoutId);
-  }
-  return {
-    type: FOREMAN_TASK_DETAILS_STOP_POLLING,
-    payload: { timeoutId },
-  };
-};
-
-export const taskReloadStart = (
-  timeoutId,
-  refetchTaskDetails,
-  id,
-  loading = false
-) => {
-  if (!timeoutId) {
-    timeoutId = setInterval(() => refetchTaskDetails(id, loading), 5000);
-  }
-  return {
-    type: FOREMAN_TASK_DETAILS_START_POLLING,
-    payload: { timeoutId },
-  };
-};
-
-export const refetchTaskDetails = (id, loading) => dispatch => {
-  if (!loading) {
-    showLoading();
-    dispatch(startRequest());
-    reloadTasksDetails(id, dispatch);
-  }
-};
-
-const reloadTasksDetails = async (id, dispatch) => {
-  try {
-    const { data } = await API.get(`/foreman_tasks/api/tasks/${id}/details`);
-    dispatch(requestSuccess(data));
-  } catch (error) {
-    dispatch(requestFailure(error));
-    document.location.reload();
-  } finally {
-    hideLoading();
-  }
+export const taskReloadStop = () => stopInterval(FOREMAN_TASK_DETAILS);
+
+export const taskReloadStart = id => dispatch => {
+  dispatch(
+    withInterval(
+      get({
+        key: FOREMAN_TASK_DETAILS,
+        url: foremanTasksApiPath(`${id}/details?include_permissions`),
+        handleSuccess: ({ data }) => {
+          if (data.state === 'stopped') {
+            dispatch(stopInterval(FOREMAN_TASK_DETAILS));
+          }
+        },
+        handleError: () => {
+          dispatch(stopInterval(FOREMAN_TASK_DETAILS));
+        },
+      }),
+      5000
+    )
+  );
 };
 
-export const fetchTaskDetails = (
-  id,
-  timeoutId,
-  refetchTaskDetailsAction
-) => async dispatch => {
-  showLoading();
-  dispatch(startRequest());
-  await getTasksDetails(id, dispatch, timeoutId, refetchTaskDetailsAction);
-};
-
-const getTasksDetails = async (
-  id,
-  dispatch,
-  timeoutId,
-  refetchTaskDetailsAction
-) => {
-  try {
-    const { data } = await API.get(`/foreman_tasks/api/tasks/${id}/details`);
-    dispatch(requestSuccess(data));
-    if (data.state !== 'stopped') {
-      dispatch(taskReloadStart(timeoutId, refetchTaskDetailsAction, id));
-    }
-  } catch (error) {
-    dispatch(requestFailure(error));
-  } finally {
-    hideLoading();
-  }
-};
-
-const startRequest = () => ({
-  type: FOREMAN_TASK_DETAILS_FETCH_TASK_REQUEST,
-});
-
-const requestSuccess = data => ({
-  type: FOREMAN_TASK_DETAILS_FETCH_TASK_SUCCESS,
-  payload: data,
-});
-
-const requestFailure = error => ({
-  type: FOREMAN_TASK_DETAILS_FETCH_TASK_FAILURE,
-  payload: error,
-});
-
 export const cancelStep = (taskId, stepId) => async dispatch => {
-  dispatch({ type: TASK_STEP_CANCEL_REQUEST });
   dispatch(addToast(infoToastData(`${__('Trying to cancel step')} ${stepId}`)));
-  try {
-    await API.post(
-      `/foreman_tasks/tasks/${taskId}/cancel_step?step_id=${stepId}`
-    );
-    dispatch({ type: TASK_STEP_CANCEL_SUCCESS });
-    dispatch(addToast(successToastData(`${stepId} {__('Step Canceled')}`)));
-  } catch (error) {
-    dispatch({ type: TASK_STEP_CANCEL_FAILURE, payload: error });
-    dispatch(
-      addToast(
-        errorToastData(
-          `${__('Could not cancel step.')} ${__(
-            'Error:'
-          )} ${stepId} ${error.response &&
-            error.response.data &&
-            error.response.data.error}`
-        )
-      )
-    );
-  }
+  dispatch(
+    post({
+      key: TASK_STEP_CANCEL,
+      url: foremanTasksPath(`${taskId}/cancel_step?step_id=${stepId}`),
+      handleSuccess: () => {
+        dispatch(addToast(successToastData(`${stepId} {__('Step Canceled')}`)));
+      },
+      handleError: error => {
+        dispatch(
+          addToast(
+            errorToastData(
+              `${__('Could not cancel step.')} ${__(
+                'Error:'
+              )} ${stepId} ${error.response &&
+                error.response.data &&
+                error.response.data.error}`
+            )
+          )
+        );
+      },
+    })
+  );
 };

data/webpack/ForemanTasks/Components/TaskDetails/TaskDetailsConstants.js

@@ -1,17 +1,4 @@
-export const FOREMAN_TASK_DETAILS_INIT = 'FOREMAN_TASK_DETAILS_INIT';
+export const FOREMAN_TASK_DETAILS = 'FOREMAN_TASK_DETAILS';
+export const FOREMAN_TASK_DETAILS_SUCCESS = 'FOREMAN_TASK_DETAILS_SUCCESS';
 
-export const FOREMAN_TASK_DETAILS_FETCH_TASK_REQUEST =
-  'FOREMAN_TASK_DETAILS_FETCH_TASK_REQUEST';
-export const FOREMAN_TASK_DETAILS_FETCH_TASK_SUCCESS =
-  'FOREMAN_TASK_DETAILS_FETCH_TASK_SUCCESS';
-export const FOREMAN_TASK_DETAILS_FETCH_TASK_FAILURE =
-  'FOREMAN_TASK_DETAILS_FETCH_TASK_FAILURE';
-
-export const FOREMAN_TASK_DETAILS_STOP_POLLING =
-  'FOREMAN_TASK_DETAILS_STOP_POLLING';
-export const FOREMAN_TASK_DETAILS_START_POLLING =
-  'FOREMAN_TASK_DETAILS_START_POLLING';
-
-export const TASK_STEP_CANCEL_REQUEST = 'TASK_STEP_CANCEL_REQUEST';
-export const TASK_STEP_CANCEL_FAILURE = 'TASK_STEP_CANCEL_FAILURE';
-export const TASK_STEP_CANCEL_SUCCESS = 'TASK_STEP_CANCEL_SUCCESS';
+export const TASK_STEP_CANCEL = 'TASK_STEP_CANCEL';

data/webpack/ForemanTasks/Components/TaskDetails/TaskDetailsSelectors.js

@@ -1,79 +1,108 @@
+/* eslint-disable camelcase */
+import {
+  selectAPIResponse,
+  selectAPIByKey,
+} from 'foremanReact/redux/API/APISelectors';
+import { selectDoesIntervalExist } from 'foremanReact/redux/middlewares/IntervalMiddleware/IntervalSelectors';
+import { STATUS } from 'foremanReact/constants';
 import { selectForemanTasks } from '../../ForemanTasksSelectors';
+import { FOREMAN_TASK_DETAILS } from './TaskDetailsConstants';
 
 export const selectTaskDetails = state =>
   selectForemanTasks(state).taskDetails || {};
 
-export const selectStartAt = state => selectTaskDetails(state).start_at || null;
+export const selectTaskDetailsResponse = state =>
+  selectAPIResponse(state, FOREMAN_TASK_DETAILS);
+
+export const selectStartAt = state =>
+  selectTaskDetailsResponse(state)?.start_at;
 
 export const selectStartBefore = state =>
-  selectTaskDetails(state).start_before || null;
+  selectTaskDetailsResponse(state)?.start_before;
 
 export const selectStartedAt = state =>
-  selectTaskDetails(state).started_at || null;
+  selectTaskDetailsResponse(state)?.started_at;
 
-export const selectEndedAt = state => selectTaskDetails(state).ended_at || null;
+export const selectEndedAt = state =>
+  selectTaskDetailsResponse(state)?.ended_at;
 
-export const selectInput = state => selectTaskDetails(state).input || [];
+export const selectInput = state =>
+  selectTaskDetailsResponse(state).input || [];
 
-export const selectOutput = state => selectTaskDetails(state).output || {};
+export const selectOutput = state =>
+  selectTaskDetailsResponse(state).output || {};
 
 export const selectResumable = state =>
-  selectTaskDetails(state).resumable || false;
+  selectTaskDetailsResponse(state).resumable || false;
 
 export const selectCancellable = state =>
-  selectTaskDetails(state).cancellable || false;
+  selectTaskDetailsResponse(state).cancellable || false;
 
 export const selectErrors = state => {
-  const { humanized } = selectTaskDetails(state);
+  const { humanized } = selectTaskDetailsResponse(state);
   return humanized ? humanized.errors : [];
 };
 
 export const selectProgress = state =>
-  selectTaskDetails(state).progress
-    ? parseFloat((selectTaskDetails(state).progress * 100).toFixed(2))
+  selectTaskDetailsResponse(state).progress
+    ? Math.trunc(selectTaskDetailsResponse(state).progress * 100)
     : 0;
 
 export const selectUsername = state =>
-  selectTaskDetails(state).username || null;
+  selectTaskDetailsResponse(state)?.username;
 
-export const selectLabel = state => selectTaskDetails(state).label || null;
+export const selectLabel = state => selectTaskDetailsResponse(state)?.label;
 
 export const selectExecutionPlan = state =>
-  selectTaskDetails(state).execution_plan || {};
+  selectTaskDetailsResponse(state).execution_plan || {};
 
 export const selectFailedSteps = state =>
-  selectTaskDetails(state).failed_steps || [];
+  selectTaskDetailsResponse(state).failed_steps || [];
 
 export const selectRunningSteps = state =>
-  selectTaskDetails(state).running_steps || [];
+  selectTaskDetailsResponse(state).running_steps || [];
 
-export const selectHelp = state => selectTaskDetails(state).help || null;
+export const selectHelp = state => selectTaskDetailsResponse(state)?.help;
 
 export const selectHasSubTasks = state =>
-  selectTaskDetails(state).has_sub_tasks || false;
+  selectTaskDetailsResponse(state).has_sub_tasks || false;
 
-export const selectLocks = state => selectTaskDetails(state).locks || [];
+export const selectLocks = state =>
+  selectTaskDetailsResponse(state).locks || [];
 
 export const selectUsernamePath = state =>
-  selectTaskDetails(state).username_path || null;
+  selectTaskDetailsResponse(state)?.username_path;
 
-export const selectAction = state => selectTaskDetails(state).action || '';
+export const selectAction = state =>
+  selectTaskDetailsResponse(state).action || '';
 
-export const selectState = state => selectTaskDetails(state).state || null;
+export const selectState = state => selectTaskDetailsResponse(state)?.state;
 
-export const selectResult = state => selectTaskDetails(state).result || null;
+export const selectResult = state => selectTaskDetailsResponse(state)?.result;
 
 export const selectTimeoutId = state =>
-  selectTaskDetails(state).timeoutId || null;
+  selectTaskDetailsResponse(state)?.timeoutId;
 
 export const selectTaskReload = state =>
-  selectTaskDetails(state).taskReload || false;
+  !!selectDoesIntervalExist(state, FOREMAN_TASK_DETAILS);
 
 export const selectParentTask = state =>
-  selectTaskDetails(state).parent_task_id || '';
+  selectTaskDetailsResponse(state).parent_task_id || '';
 
 export const selectExternalId = state =>
-  selectTaskDetails(state).external_id || null;
+  selectTaskDetailsResponse(state)?.external_id;
 
 export const selectDynflowEnableConsole = state =>
-  selectTaskDetails(state).dynflow_enable_console || false;
+  selectTaskDetailsResponse(state).dynflow_enable_console || false;
+
+export const selectCanEdit = state =>
+  selectTaskDetailsResponse(state).can_edit || false;
+
+export const selectStatus = state => selectTaskDetailsResponse(state).status;
+
+export const selectAPIError = state =>
+  selectTaskDetailsResponse(state)?.APIerror;
+
+export const selectIsLoading = state =>
+  !!selectAPIByKey(state, FOREMAN_TASK_DETAILS).response &&
+  selectStatus(state) === STATUS.PENDING;

data/webpack/ForemanTasks/Components/TaskDetails/__tests__/TaskDetails.fixtures.js

@@ -1,8 +1,8 @@
 export const minProps = {
   cancelStep: jest.fn(),
+  taskReload: false,
   taskReloadStop: jest.fn(),
   taskReloadStart: jest.fn(),
-  refetchTaskDetails: jest.fn(),
-  fetchTaskDetails: jest.fn(),
   taskProgressToggle: jest.fn(),
+  status: 'RESOLVED',
 };

data/webpack/ForemanTasks/Components/TaskDetails/__tests__/TaskDetails.test.js

@@ -4,6 +4,12 @@ import TaskDetails from '../TaskDetails';
 import { minProps } from './TaskDetails.fixtures';
 
 const fixtures = {
+  'render with loading Props': { ...minProps, isLoading: true },
+  'render with error Props': {
+    ...minProps,
+    status: 'ERROR',
+    APIerror: { message: 'some-error' },
+  },
   'render with min Props': minProps,
 };
 

data/webpack/ForemanTasks/Components/TaskDetails/__tests__/TaskDetailsActions.test.js

@@ -3,33 +3,17 @@ import { API } from 'foremanReact/redux/API';
 import {
   taskReloadStop,
   taskReloadStart,
-  fetchTaskDetails,
   cancelStep,
 } from '../TaskDetailsActions';
 
 jest.mock('foremanReact/redux/API');
 
-API.get.mockImplementation(async () => ({ data: 'some-data' }));
 API.post.mockImplementation(async () => ({ data: 'some-data' }));
 
 const fixtures = {
   'should start reload': () => taskReloadStart(1),
-  'should stop reload': () => taskReloadStop(2),
-  'should fetch-task-details and success': () => fetchTaskDetails(),
-  'should cancelStep and success': () => cancelStep('task-id', 'step-id'),
-
-  'should fetch-task-details and fail': () => {
-    API.get.mockImplementationOnce(() =>
-      Promise.reject(new Error('Network Error'))
-    );
-    return fetchTaskDetails();
-  },
-  'should cancelStep and fail': () => {
-    API.post.mockImplementationOnce(() =>
-      Promise.reject(new Error('Network Error'))
-    );
-    return cancelStep('task-id', 'step-id');
-  },
+  'should stop reload': () => taskReloadStop(),
+  'should cancelStep': () => cancelStep('task-id', 'step-id'),
 };
 
 describe('TaskDetails - Actions', () =>

data/webpack/ForemanTasks/Components/TaskDetails/__tests__/__snapshots__/TaskDetails.test.js.snap

@@ -1,5 +1,79 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`TaskDetails rendering render with error Props 1`] = `
+<MessageBox
+  icontype="error-circle-o"
+  key="task-details-error"
+  msg="Could not receive data: some-error"
+/>
+`;
+
+exports[`TaskDetails rendering render with loading Props 1`] = `
+<div
+  className="task-details-react well"
+>
+  <ForwardRef
+    animation={false}
+    defaultActiveKey={1}
+    id="task-details-tabs"
+  >
+    <Tab
+      eventKey={1}
+      title="Task"
+    >
+      <TaskSkeleton />
+    </Tab>
+    <Tab
+      disabled={true}
+      eventKey={2}
+      title="Running Steps"
+    >
+      <RunningSteps
+        cancelStep={[MockFunction]}
+        id="a15dd820-32f1-4ced-9ab7-c0fab8234c47"
+        runningSteps={Array []}
+        taskReload={false}
+        taskReloadStart={[MockFunction]}
+      />
+    </Tab>
+    <Tab
+      disabled={true}
+      eventKey={3}
+      title="Errors"
+    >
+      <Errors
+        executionPlan={Object {}}
+        failedSteps={Array []}
+      />
+    </Tab>
+    <Tab
+      disabled={true}
+      eventKey={4}
+      title="Locks"
+    >
+      <Locks
+        locks={Array []}
+      />
+    </Tab>
+    <Tab
+      disabled={true}
+      eventKey={5}
+      title="Raw"
+    >
+      <Raw
+        endedAt=""
+        externalId=""
+        id="a15dd820-32f1-4ced-9ab7-c0fab8234c47"
+        input={Array []}
+        label=""
+        output={Object {}}
+        startedAt=""
+      />
+    </Tab>
+  </ForwardRef>
+</div>
+`;
+
 exports[`TaskDetails rendering render with min Props 1`] = `
 <div
   className="task-details-react well"
@@ -15,55 +89,32 @@ exports[`TaskDetails rendering render with min Props 1`] = `
     >
       <Task
         action=""
-        cancelStep={[MockFunction]}
+        canEdit={false}
         cancelTaskRequest={[Function]}
         cancellable={false}
         dynflowEnableConsole={false}
         endedAt=""
-        error={Array []}
-        executionPlan={Object {}}
+        errors={Array []}
         externalId=""
-        failedSteps={Array []}
-        fetchTaskDetails={
-          [MockFunction] {
-            "calls": Array [
-              Array [
-                "a15dd820-32f1-4ced-9ab7-c0fab8234c47",
-                null,
-                [MockFunction],
-              ],
-            ],
-            "results": Array [
-              Object {
-                "type": "return",
-                "value": undefined,
-              },
-            ],
-          }
-        }
         hasSubTasks={false}
         help=""
         id="a15dd820-32f1-4ced-9ab7-c0fab8234c47"
         input={Array []}
         label=""
-        locks={Array []}
         output={Object {}}
         parentTask=""
         progress={0}
-        refetchTaskDetails={[MockFunction]}
         result="error"
         resumable={false}
         resumeTaskRequest={[Function]}
-        runningSteps={Array []}
         startAt=""
         startBefore=""
         startedAt=""
         state=""
+        status="RESOLVED"
         taskProgressToggle={[Function]}
         taskReload={false}
         taskReloadStart={[MockFunction]}
-        taskReloadStop={[MockFunction]}
-        timeoutId={null}
         username=""
         usernamePath=""
       />
@@ -76,8 +127,8 @@ exports[`TaskDetails rendering render with min Props 1`] = `
         cancelStep={[MockFunction]}
         id="a15dd820-32f1-4ced-9ab7-c0fab8234c47"
         runningSteps={Array []}
-        taskProgressToggle={[Function]}
         taskReload={false}
+        taskReloadStart={[MockFunction]}
       />
     </Tab>
     <Tab