foreman-tasks 0.17.6 → 1.2.0

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/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/Task.js

@@ -1,14 +1,17 @@
-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 Task = props => {
+  const taskProgressToggle = () => {
     const {
       timeoutId,
       refetchTaskDetails,
@@ -16,7 +19,7 @@ class Task extends Component {
       loading,
       taskReloadStop,
       taskReloadStart,
-    } = this.props;
+    } = props;
     if (timeoutId) {
       taskReloadStop(timeoutId);
     } else {
@@ -24,153 +27,139 @@ class Task extends Component {
     }
   };
 
-  render() {
-    const {
-      taskReload,
-      externalId,
-      id,
-      state,
-      allowDangerousActions,
-      resumable,
-      cancellable,
-      hasSubTasks,
-      parentTask,
-      showUnlockModal,
-      showForceUnlockModal,
-      toggleUnlockModal,
-      toggleForceUnlockModal,
-      cancelTaskRequest,
-      resumeTaskRequest,
-      action,
-    } = 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 unlockModalActions = useForemanModal({
+    id: UNLOCK_MODAL,
+  });
+  const forceUnlockModalActions = useForemanModal({
+    id: FORCE_UNLOCK_MODAL,
+  });
 
-    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 {
+    taskReload,
+    externalId,
+    id,
+    state,
+    resumable,
+    cancellable,
+    hasSubTasks,
+    parentTask,
+    cancelTaskRequest,
+    resumeTaskRequest,
+    forceCancelTaskRequest,
+    unlockTaskRequest,
+    action,
+    dynflowEnableConsole,
+  } = props;
+  const forceUnlock = () => {
+    if (!taskReload) {
+      taskProgressToggle();
+    }
+    forceCancelTaskRequest(id, action);
+  };
+  const unlock = () => {
+    if (!taskReload) {
+      taskProgressToggle();
+    }
+    unlockTaskRequest(id, action);
+  };
+  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}
+            >
+              {__('Dynflow console')}
+            </Button>
+            <Button
+              className="resume-button"
+              bsSize="small"
+              disabled={!resumable}
+              onClick={() => {
+                if (!taskReload) {
+                  taskProgressToggle();
+                }
+                resumeTaskRequest(id, action);
+              }}
+            >
+              {__('Resume')}
+            </Button>
+            <Button
+              className="cancel-button"
+              bsSize="small"
+              disabled={!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}`}
+                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={state !== 'paused'}
+              onClick={unlockModalActions.setModalOpen}
+            >
+              {__('Unlock')}
+            </Button>
+            <Button
+              className="force-unlock-button"
+              bsSize="small"
+              disabled={state === 'stopped'}
+              onClick={forceUnlockModalActions.setModalOpen}
+            >
+              {__('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,
@@ -182,18 +171,14 @@ Task.propTypes = {
   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,
 };
 
 Task.defaultProps = {
   ...TaskInfo.defaultProps,
   state: '',
-  allowDangerousActions: false,
   resumable: false,
   cancellable: false,
   refetchTaskDetails: () => null,
@@ -204,12 +189,9 @@ Task.defaultProps = {
   taskReloadStart: () => null,
   timeoutId: null,
   externalId: '',
-  showUnlockModal: false,
-  showForceUnlockModal: false,
-  toggleUnlockModal: () => null,
-  toggleForceUnlockModal: () => null,
   cancelTaskRequest: () => null,
   resumeTaskRequest: () => null,
+  dynflowEnableConsole: false,
 };
 
 export default Task;