foreman-tasks 1.1.2 → 2.0.2

data/webpack/ForemanTasks/Components/TaskActions/__snapshots__/UnlockModals.test.js.snap

@@ -0,0 +1,25 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`ForceUnlockModal render 1`] = `
+<ClickConfirmation
+  body="Resources for 1 task(s) will be unlocked and will not prevent other tasks from being run. As the task(s) might be still running, it should be avoided to use this unless you are really sure the task(s) got stuck."
+  confirmAction="Force Unlock"
+  confirmType="danger"
+  confirmationMessage="I understand that this may cause harm and have working database backups of all backend services."
+  id="forceUnlockModal"
+  onClick={[MockFunction]}
+  title="Force Unlock"
+/>
+`;
+
+exports[`UnlockModal render 1`] = `
+<ClickConfirmation
+  body="This will unlock the resources that the task is running against. Please note that this might lead to inconsistent state and should be used with caution, after making sure that the task can't be resumed."
+  confirmAction="Unlock"
+  confirmType="warning"
+  confirmationMessage="I understand that this may cause harm and have working database backups of all backend services."
+  id="unlockModal"
+  onClick={[MockFunction]}
+  title="Unlock"
+/>
+`;

data/webpack/ForemanTasks/Components/TaskActions/index.js

@@ -0,0 +1,115 @@
+import { sprintf } from 'foremanReact/common/I18n';
+import { API } from 'foremanReact/redux/API';
+import { addToast } from 'foremanReact/redux/actions/toasts';
+import {
+  TASKS_RESUME_REQUEST,
+  TASKS_RESUME_SUCCESS,
+  TASKS_RESUME_FAILURE,
+  TASKS_CANCEL_REQUEST,
+  TASKS_CANCEL_SUCCESS,
+  TASKS_CANCEL_FAILURE,
+  TASKS_FORCE_CANCEL_REQUEST,
+  TASKS_FORCE_CANCEL_SUCCESS,
+  TASKS_FORCE_CANCEL_FAILURE,
+  TASKS_UNLOCK_REQUEST,
+  TASKS_UNLOCK_SUCCESS,
+  TASKS_UNLOCK_FAILURE,
+} from './TaskActionsConstants';
+import { infoToastData } from '../common/ToastsHelpers/';
+import {
+  resumeToastInfo,
+  cancelToastInfo,
+  forceCancelToastInfo,
+  unlockToastInfo,
+  toastDispatch,
+} from './TaskActionHelpers';
+
+export const cancelTaskRequest = (id, name) => async dispatch => {
+  dispatch(addToast(infoToastData(sprintf('Trying to cancel %s task', name))));
+  dispatch({ type: TASKS_CANCEL_REQUEST });
+  try {
+    await API.post(`/foreman_tasks/tasks/${id}/cancel`);
+    dispatch({ type: TASKS_CANCEL_SUCCESS });
+    toastDispatch({
+      type: 'cancelled',
+      name,
+      toastInfo: cancelToastInfo,
+      dispatch,
+    });
+  } catch (error) {
+    dispatch({ type: TASKS_CANCEL_FAILURE, payload: error });
+    toastDispatch({
+      type: 'skipped',
+      name,
+      toastInfo: cancelToastInfo,
+      dispatch,
+    });
+  }
+};
+
+export const resumeTaskRequest = (id, name) => async dispatch => {
+  dispatch({ type: TASKS_RESUME_REQUEST });
+  try {
+    await API.post(`/foreman_tasks/tasks/${id}/resume`);
+
+    dispatch({ type: TASKS_RESUME_SUCCESS });
+    toastDispatch({
+      type: 'resumed',
+      name,
+      toastInfo: resumeToastInfo,
+      dispatch,
+    });
+  } catch (error) {
+    dispatch({ type: TASKS_RESUME_FAILURE, payload: error });
+    toastDispatch({
+      type: 'failed',
+      name,
+      toastInfo: resumeToastInfo,
+      dispatch,
+    });
+  }
+};
+
+export const forceCancelTaskRequest = (id, name) => async dispatch => {
+  dispatch({ type: TASKS_FORCE_CANCEL_REQUEST });
+  try {
+    await API.post(`/foreman_tasks/tasks/${id}/force_unlock`);
+    dispatch({ type: TASKS_FORCE_CANCEL_SUCCESS });
+    toastDispatch({
+      type: 'forceCancelled',
+      name,
+      toastInfo: forceCancelToastInfo,
+      dispatch,
+    });
+  } catch ({ response }) {
+    dispatch({ type: TASKS_FORCE_CANCEL_FAILURE });
+    toastDispatch({
+      type: 'failed',
+      name,
+      toastInfo: forceCancelToastInfo,
+      dispatch,
+    });
+  }
+};
+
+export const unlockTaskRequest = (id, name) => async dispatch => {
+  dispatch({ type: TASKS_UNLOCK_REQUEST });
+  try {
+    await API.post(`/foreman_tasks/tasks/${id}/unlock`);
+    dispatch({ type: TASKS_UNLOCK_SUCCESS });
+    toastDispatch({
+      type: 'unlocked',
+      name,
+      toastInfo: unlockToastInfo,
+      dispatch,
+    });
+  } catch ({ response }) {
+    dispatch({ type: TASKS_UNLOCK_FAILURE });
+    toastDispatch({
+      type: 'failed',
+      name,
+      toastInfo: unlockToastInfo,
+      dispatch,
+    });
+  }
+};

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

@@ -3,7 +3,13 @@ import PropTypes from 'prop-types';
 import { Alert, Button } from 'patternfly-react';
 import { translate as __ } from 'foremanReact/common/I18n';
 
-const RunningSteps = ({ runningSteps }) => {
+const RunningSteps = ({
+  runningSteps,
+  id,
+  cancelStep,
+  taskReload,
+  taskProgressToggle,
+}) => {
   if (!runningSteps.length) return <span>{__('No running steps')}</span>;
   return (
     <div>
@@ -13,8 +19,12 @@ const RunningSteps = ({ runningSteps }) => {
             <p>
               <Button
                 bsSize="small"
-                data-method="post"
-                href={`/foreman_tasks/tasks/${step.id}/cancel_step`}
+                onClick={() => {
+                  if (!taskReload) {
+                    taskProgressToggle();
+                  }
+                  cancelStep(id, step.id);
+                }}
               >
                 {__('Cancel')}
               </Button>
@@ -46,6 +56,10 @@ const RunningSteps = ({ runningSteps }) => {
 
 RunningSteps.propTypes = {
   runningSteps: PropTypes.array,
+  id: PropTypes.string.isRequired,
+  cancelStep: PropTypes.func.isRequired,
+  taskReload: PropTypes.bool.isRequired,
+  taskProgressToggle: PropTypes.func.isRequired,
 };
 
 RunningSteps.defaultProps = {

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

@@ -1,178 +1,169 @@
-import React, { Component } from 'react';
+import React from 'react';
 import PropTypes from 'prop-types';
 import { Grid, Row, Col, Button } from 'patternfly-react';
 import { translate as __ } from 'foremanReact/common/I18n';
+import { useForemanModal } from 'foremanReact/components/ForemanModal/ForemanModalHooks';
 import TaskInfo from './TaskInfo';
-import { ClickConfirmation } from '../../common/ClickConfirmation';
-import { ResumeButton } from '../../common/ActionButtons/ResumeButton';
-import { CancelButton } from '../../common/ActionButtons/CancelButton';
+import {
+  UNLOCK_MODAL,
+  FORCE_UNLOCK_MODAL,
+} from '../../TaskActions/TaskActionsConstants';
+import { ForceUnlockModal, UnlockModal } from '../../TaskActions/UnlockModals';
 
-class Task extends Component {
-  taskProgressToggle = () => {
-    const {
-      timeoutId,
-      refetchTaskDetails,
-      id,
-      loading,
-      taskReloadStop,
-      taskReloadStart,
-    } = this.props;
-    if (timeoutId) {
-      taskReloadStop(timeoutId);
-    } else {
-      taskReloadStart(timeoutId, refetchTaskDetails, id, loading);
+const Task = props => {
+  const unlockModalActions = useForemanModal({
+    id: UNLOCK_MODAL,
+  });
+  const forceUnlockModalActions = useForemanModal({
+    id: FORCE_UNLOCK_MODAL,
+  });
+
+  const {
+    taskReload,
+    externalId,
+    id,
+    state,
+    resumable,
+    cancellable,
+    hasSubTasks,
+    parentTask,
+    cancelTaskRequest,
+    resumeTaskRequest,
+    forceCancelTaskRequest,
+    unlockTaskRequest,
+    action,
+    dynflowEnableConsole,
+    taskProgressToggle,
+    canEdit,
+  } = props;
+  const forceUnlock = () => {
+    if (!taskReload) {
+      taskProgressToggle();
     }
+    forceCancelTaskRequest(id, action);
   };
-
-  render() {
-    const {
-      taskReload,
-      externalId,
-      id,
-      state,
-      allowDangerousActions,
-      resumable,
-      cancellable,
-      hasSubTasks,
-      parentTask,
-      showUnlockModal,
-      showForceUnlockModal,
-      toggleUnlockModal,
-      toggleForceUnlockModal,
-      cancelTaskRequest,
-      resumeTaskRequest,
-      action,
-      dynflowEnableConsole,
-    } = this.props;
-    const modalUnlock = (
-      <ClickConfirmation
-        showModal={showUnlockModal}
-        title={__('Unlock')}
-        body={__(
-          "This will unlock the resources that the task is running against. Please note that this might lead to inconsistent state and should be used with caution, after making sure that the task can't be resumed."
-        )}
-        confirmationMessage={__(
-          'I understand that this may cause harm and have working database backups of all backend services.'
-        )}
-        confirmAction={__('Unlock')}
-        path={`/foreman_tasks/tasks/${id}/unlock`}
-        confirmType="warning"
-        closeModal={toggleUnlockModal}
-      />
-    );
-
-    const modalForceUnlock = (
-      <ClickConfirmation
-        showModal={showForceUnlockModal}
-        title={__('Force Unlock')}
-        body={__(
-          'Resources will be unlocked and will not prevent other tasks from being run. As the task might be still running, it should be avoided to use this unless you are really sure the task got stuck'
-        )}
-        confirmationMessage={__(
-          'I understand that this may cause harm and have working database backups of all backend services.'
-        )}
-        confirmAction={__('Force Unlock')}
-        path={`/foreman_tasks/tasks/${id}/force_unlock`}
-        confirmType="danger"
-        closeModal={toggleForceUnlockModal}
-      />
-    );
-    return (
-      <React.Fragment>
-        {modalUnlock}
-        {modalForceUnlock}
-        <Grid>
-          <Row>
-            <Col xs={12}>
+  const unlock = () => {
+    if (!taskReload) {
+      taskProgressToggle();
+    }
+    unlockTaskRequest(id, action);
+  };
+  const editActionsTitle = canEdit
+    ? undefined
+    : __('You do not have permission');
+  const dynflowTitle = dynflowEnableConsole
+    ? undefined
+    : `dynflow_enable_console ${__('Setting is off')}`;
+  return (
+    <React.Fragment>
+      <UnlockModal onClick={unlock} />
+      <ForceUnlockModal onClick={forceUnlock} />
+      <Grid>
+        <Row>
+          <Col xs={12}>
+            <Button
+              className="reload-button"
+              bsSize="small"
+              onClick={taskProgressToggle}
+            >
+              <span
+                className={`glyphicon glyphicon-refresh ${
+                  taskReload ? 'spin' : ''
+                }`}
+              />
+              {__(`${taskReload ? 'Stop' : 'Start'}  auto-reloading`)}
+            </Button>
+            <Button
+              className="dynflow-button"
+              bsSize="small"
+              href={`/foreman_tasks/dynflow/${externalId}`}
+              disabled={!dynflowEnableConsole}
+              rel="noopener noreferrer"
+              target="_blank"
+            >
+              <span title={dynflowTitle} data-original-title={dynflowTitle}>
+                {__('Dynflow console')}
+              </span>
+            </Button>
+            <Button
+              className="resume-button"
+              bsSize="small"
+              title={editActionsTitle}
+              data-original-title={editActionsTitle}
+              disabled={!canEdit || !resumable}
+              onClick={() => {
+                if (!taskReload) {
+                  taskProgressToggle();
+                }
+                resumeTaskRequest(id, action);
+              }}
+            >
+              {__('Resume')}
+            </Button>
+            <Button
+              className="cancel-button"
+              bsSize="small"
+              title={editActionsTitle}
+              data-original-title={editActionsTitle}
+              disabled={!canEdit || !cancellable}
+              onClick={() => {
+                if (!taskReload) {
+                  taskProgressToggle();
+                }
+                cancelTaskRequest(id, action);
+              }}
+            >
+              {__('Cancel')}
+            </Button>
+            {parentTask && (
               <Button
-                hidden={!allowDangerousActions}
-                className="reload-button"
+                className="parent-button"
                 bsSize="small"
-                onClick={this.taskProgressToggle}
+                href={`/foreman_tasks/tasks/${parentTask}`}
               >
-                <span
-                  className={`glyphicon glyphicon-refresh ${
-                    taskReload ? 'spin' : ''
-                  }`}
-                />
-                {__(`${taskReload ? 'Stop' : 'Start'}  auto-reloading`)}
+                {__('Parent task')}
               </Button>
+            )}
+            {hasSubTasks && (
               <Button
+                className="subtask-button"
                 bsSize="small"
-                href={`/foreman_tasks/dynflow/${externalId}`}
-                disabled={!dynflowEnableConsole}
+                href={`/foreman_tasks/tasks/${id}/sub_tasks`}
               >
-                {__('Dynflow console')}
+                {__('Sub tasks')}
               </Button>
-              <ResumeButton
-                id={id}
-                onClick={() => {
-                  if (!taskReload) {
-                    this.taskProgressToggle();
-                  }
-                  resumeTaskRequest(id, action);
-                }}
-                name={action}
-                disabled={!resumable}
-              />
-              <CancelButton
-                id={id}
-                name={action}
-                disabled={!cancellable}
-                onClick={() => {
-                  if (!taskReload) {
-                    this.taskProgressToggle();
-                  }
-                  cancelTaskRequest(id, action);
-                }}
-              />
-              {parentTask && (
-                <Button
-                  bsSize="small"
-                  href={`/foreman_tasks/tasks/${parentTask}`}
-                >
-                  {__('Parent task')}
-                </Button>
-              )}
-              {hasSubTasks && (
-                <Button
-                  bsSize="small"
-                  href={`/foreman_tasks/tasks/${id}/sub_tasks`}
-                >
-                  {__('Sub tasks')}
-                </Button>
-              )}
-              {allowDangerousActions && (
-                <Button
-                  bsSize="small"
-                  disabled={state !== 'paused'}
-                  onClick={toggleUnlockModal}
-                >
-                  {__('Unlock')}
-                </Button>
-              )}
-              {allowDangerousActions && (
-                <Button
-                  bsSize="small"
-                  disabled={state === 'stopped'}
-                  onClick={toggleForceUnlockModal}
-                >
-                  {__('Force Unlock')}
-                </Button>
-              )}
-            </Col>
-          </Row>
-          <TaskInfo {...this.props} />
-        </Grid>
-      </React.Fragment>
-    );
-  }
-}
+            )}
+            <Button
+              className="unlock-button"
+              bsSize="small"
+              disabled={!canEdit || state !== 'paused'}
+              onClick={unlockModalActions.setModalOpen}
+              title={editActionsTitle}
+              data-original-title={editActionsTitle}
+            >
+              {__('Unlock')}
+            </Button>
+            <Button
+              className="force-unlock-button"
+              bsSize="small"
+              disabled={!canEdit || state === 'stopped'}
+              onClick={forceUnlockModalActions.setModalOpen}
+              title={editActionsTitle}
+              data-original-title={editActionsTitle}
+            >
+              {__('Force Unlock')}
+            </Button>
+          </Col>
+        </Row>
+        <TaskInfo {...props} />
+      </Grid>
+    </React.Fragment>
+  );
+};
 
 Task.propTypes = {
   ...TaskInfo.PropTypes,
   state: PropTypes.string,
-  allowDangerousActions: PropTypes.bool,
   resumable: PropTypes.bool,
   cancellable: PropTypes.bool,
   refetchTaskDetails: PropTypes.func,
@@ -180,23 +171,18 @@ Task.propTypes = {
   parentTask: PropTypes.string,
   taskReload: PropTypes.bool,
   taskReloadStop: PropTypes.func,
-  taskReloadStart: PropTypes.func,
   timeoutId: PropTypes.number,
   externalId: PropTypes.string,
   id: PropTypes.string.isRequired,
-  showUnlockModal: PropTypes.bool,
-  showForceUnlockModal: PropTypes.bool,
-  toggleUnlockModal: PropTypes.func,
-  toggleForceUnlockModal: PropTypes.func,
   cancelTaskRequest: PropTypes.func,
   resumeTaskRequest: PropTypes.func,
   dynflowEnableConsole: PropTypes.bool,
+  canEdit: PropTypes.bool,
 };
 
 Task.defaultProps = {
   ...TaskInfo.defaultProps,
   state: '',
-  allowDangerousActions: false,
   resumable: false,
   cancellable: false,
   refetchTaskDetails: () => null,
@@ -204,16 +190,12 @@ Task.defaultProps = {
   parentTask: '',
   taskReload: false,
   taskReloadStop: () => null,
-  taskReloadStart: () => null,
   timeoutId: null,
   externalId: '',
-  showUnlockModal: false,
-  showForceUnlockModal: false,
-  toggleUnlockModal: () => null,
-  toggleForceUnlockModal: () => null,
   cancelTaskRequest: () => null,
   resumeTaskRequest: () => null,
   dynflowEnableConsole: false,
+  canEdit: false,
 };
 
 export default Task;