foreman-tasks 1.1.2 → 2.0.2

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

@@ -1,13 +1,14 @@
 import React from 'react';
 
-import API from 'foremanReact/API';
+import { API } from 'foremanReact/redux/API';
 import { IntegrationTestHelper } from '@theforeman/test';
 
 import TaskDetails, { reducers } from '../index';
 import { selectForemanTasks } from '../../../ForemanTasksSelectors';
+import { minProps } from './TaskDetails.fixtures';
 
 jest.mock('../../../ForemanTasksSelectors');
-jest.mock('foremanReact/API');
+jest.mock('foremanReact/redux/API');
 selectForemanTasks.mockImplementation(state => state);
 describe('TaskDetails integration test', () => {
   beforeEach(() => {
@@ -15,6 +16,10 @@ describe('TaskDetails integration test', () => {
     const expectedIntervalId = 1;
     jest.useFakeTimers();
     setInterval.mockImplementation(() => expectedIntervalId);
+    delete window.location;
+    window.location = new URL(
+      'https://foreman.com/foreman_tasks/tasks/a15dd820-32f1-4ced-9ab7-c0fab8234c47/'
+    );
   });
   it('should flow', async () => {
     window.location.reload = jest.fn();
@@ -22,7 +27,9 @@ describe('TaskDetails integration test', () => {
     API.get.mockImplementationOnce();
     const integrationTestHelper = new IntegrationTestHelper(reducers);
 
-    const component = integrationTestHelper.mount(<TaskDetails id="test" />);
+    const component = integrationTestHelper.mount(
+      <TaskDetails {...minProps} id="test" />
+    );
     integrationTestHelper.takeStoreSnapshot('initial state');
 
     const reloadButton = component.find('.reload-button').at(0);
@@ -46,7 +53,9 @@ describe('TaskDetails integration test', () => {
     }));
     const integrationTestHelper = new IntegrationTestHelper(reducers);
 
-    const component = integrationTestHelper.mount(<TaskDetails id="test" />);
+    const component = integrationTestHelper.mount(
+      <TaskDetails {...minProps} id="test" />
+    );
 
     const reloadButton = component.find('.reload-button').at(0);
     reloadButton.simulate('click');

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

@@ -1,7 +1,8 @@
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
 import TaskDetails from './TaskDetails';
-import * as actions from './TaskDetailsActions';
+import * as taskDetailsActions from './TaskDetailsActions';
+import * as taskActions from '../TaskActions';
 import reducer from './TaskDetailsReducer';
 import {
   selectEndedAt,
@@ -22,7 +23,6 @@ import {
   selectFailedSteps,
   selectRunningSteps,
   selectHasSubTasks,
-  selectAllowDangerousActions,
   selectUsernamePath,
   selectAction,
   selectState,
@@ -30,10 +30,9 @@ import {
   selectTimeoutId,
   selectTaskReload,
   selectParentTask,
-  selectShowUnlockModal,
-  selectShowForceUnlockModal,
   selectExternalId,
   selectDynflowEnableConsole,
+  selectCanEdit,
 } from './TaskDetailsSelectors';
 
 const mapStateToProps = state => ({
@@ -54,7 +53,6 @@ const mapStateToProps = state => ({
   runningSteps: selectRunningSteps(state),
   help: selectHelp(state),
   hasSubTasks: selectHasSubTasks(state),
-  allowDangerousActions: selectAllowDangerousActions(state),
   locks: selectLocks(state),
   usernamePath: selectUsernamePath(state),
   action: selectAction(state),
@@ -63,13 +61,13 @@ const mapStateToProps = state => ({
   timeoutId: selectTimeoutId(state),
   taskReload: selectTaskReload(state),
   parentTask: selectParentTask(state),
-  showUnlockModal: selectShowUnlockModal(state),
-  showForceUnlockModal: selectShowForceUnlockModal(state),
   externalId: selectExternalId(state),
   dynflowEnableConsole: selectDynflowEnableConsole(state),
+  canEdit: selectCanEdit(state),
 });
 
-const mapDispatchToProps = dispatch => bindActionCreators(actions, dispatch);
+const mapDispatchToProps = dispatch =>
+  bindActionCreators({ ...taskActions, ...taskDetailsActions }, dispatch);
 
 export const reducers = { taskDetails: reducer };
 

data/webpack/ForemanTasks/Components/TasksDashboard/TasksDashboardActions.js

@@ -1,4 +1,4 @@
-import API from 'foremanReact/API';
+import { API } from 'foremanReact/redux/API';
 import { timeToHoursNumber, resolveQuery } from './TasksDashboardHelper';
 import {
   FOREMAN_TASKS_DASHBOARD_INIT,

data/webpack/ForemanTasks/Components/TasksDashboard/__tests__/TasksDashboardActions.test.js

@@ -1,5 +1,5 @@
 import { testActionSnapshotWithFixtures } from '@theforeman/test';
-import API from 'foremanReact/API';
+import { API } from 'foremanReact/redux/API';
 import { timeToHoursNumber } from '../TasksDashboardHelper';
 import {
   initializeDashboard,
@@ -14,7 +14,7 @@ import {
   apiGetMock,
 } from './TaskDashboard.fixtures';
 
-jest.mock('foremanReact/API');
+jest.mock('foremanReact/redux/API');
 jest.mock('../TasksDashboardHelper');
 
 timeToHoursNumber.mockImplementation(arg => arg);

data/webpack/ForemanTasks/Components/TasksTable/Components/ActionSelectButton.js

@@ -3,7 +3,12 @@ import { DropdownButton, MenuItem } from 'patternfly-react';
 import PropTypes from 'prop-types';
 import { translate as __ } from 'foremanReact/common/I18n';
 
-export const ActionSelectButton = ({ onCancel, onResume, disabled }) => (
+export const ActionSelectButton = ({
+  onCancel,
+  onResume,
+  onForceCancel,
+  disabled,
+}) => (
   <DropdownButton
     title={__('Select Action')}
     disabled={disabled}
@@ -23,6 +28,13 @@ export const ActionSelectButton = ({ onCancel, onResume, disabled }) => (
     >
       {__('Resume Selected')}
     </MenuItem>
+    <MenuItem
+      title={__('Force Cancel selected tasks')}
+      onClick={onForceCancel}
+      eventKey="3"
+    >
+      {__('Force Cancel Selected')}
+    </MenuItem>
   </DropdownButton>
 );
 
@@ -30,6 +42,7 @@ ActionSelectButton.propTypes = {
   disabled: PropTypes.bool,
   onCancel: PropTypes.func.isRequired,
   onResume: PropTypes.func.isRequired,
+  onForceCancel: PropTypes.func.isRequired,
 };
 
 ActionSelectButton.defaultProps = {

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/ConfirmModal.js

@@ -0,0 +1,83 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { startCase } from 'lodash';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
+import { Button } from 'patternfly-react';
+import ForemanModal from 'foremanReact/components/ForemanModal';
+import { FORCE_UNLOCK_MODAL } from '../../../TaskActions/TaskActionsConstants';
+import { FORCE_UNLOCK_SELECTED_MODAL } from '../../TasksTableConstants';
+import { ForceUnlockModal } from '../../../TaskActions/UnlockModals';
+
+export const ConfirmModal = ({
+  actionText,
+  actionState,
+  actionType,
+  selectedRowsLen,
+  id,
+  parentTaskID,
+  url,
+  uriQuery: query,
+  setModalClosed,
+  ...props
+}) => {
+  if ([FORCE_UNLOCK_MODAL, FORCE_UNLOCK_SELECTED_MODAL].includes(actionType)) {
+    return (
+      <ForceUnlockModal
+        onClick={() => {
+          props[actionType]({ url, query, parentTaskID });
+          setModalClosed();
+        }}
+        id={id}
+        selectedRowsLen={selectedRowsLen}
+      />
+    );
+  }
+  return (
+    <ForemanModal
+      title={sprintf(__('%s Selected Tasks'), startCase(actionText))}
+      id={id}
+    >
+      {sprintf(
+        __(
+          `This will %(action)s %(number)s task(s), putting them in the %(state)s state. Are you sure?`
+        ),
+        { action: actionText, number: selectedRowsLen, state: actionState }
+      )}
+      <ForemanModal.Footer>
+        <Button onClick={setModalClosed}>{__('No')}</Button>
+        <Button
+          className="confirm-button"
+          bsStyle="primary"
+          onClick={() => {
+            props[actionType]({ url, query, parentTaskID });
+            setModalClosed();
+          }}
+        >
+          {__('Yes')}
+        </Button>
+      </ForemanModal.Footer>
+    </ForemanModal>
+  );
+};
+
+ConfirmModal.propTypes = {
+  actionText: PropTypes.string,
+  actionState: PropTypes.string,
+  selectedRowsLen: PropTypes.number.isRequired,
+  actionType: PropTypes.string,
+  id: PropTypes.string.isRequired,
+  parentTaskID: PropTypes.string,
+  url: PropTypes.string.isRequired,
+  uriQuery: PropTypes.object,
+  setModalClosed: PropTypes.func.isRequired,
+};
+
+ConfirmModal.defaultProps = {
+  actionType: '',
+  actionText: '',
+  actionState: '',
+  parentTaskID: '',
+  uriQuery: {},
+};
+
+export default ConfirmModal;

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/ConfirmModalActions.js

@@ -0,0 +1,106 @@
+import {
+  resumeTask,
+  cancelTask,
+  forceCancelTask,
+} from '../../TasksTableActions';
+import {
+  bulkCancelBySearch,
+  bulkCancelById,
+  bulkResumeBySearch,
+  bulkResumeById,
+  bulkForceCancelBySearch,
+  bulkForceCancelById,
+} from '../../TasksBulkActions';
+import { selectClicked, selectSelectedTasks } from './ConfirmModalSelectors';
+import { selectAllRowsSelected } from '../../TasksTableSelectors';
+import {
+  CANCEL_MODAL,
+  RESUME_MODAL,
+  CANCEL_SELECTED_MODAL,
+  RESUME_SELECTED_MODAL,
+  FORCE_UNLOCK_SELECTED_MODAL,
+} from '../../TasksTableConstants';
+import { FORCE_UNLOCK_MODAL } from '../../../TaskActions/TaskActionsConstants';
+
+export default {
+  [CANCEL_SELECTED_MODAL]: ({ url, query, parentTaskID }) => (
+    dispatch,
+    getState
+  ) => {
+    if (selectAllRowsSelected(getState())) {
+      return dispatch(bulkCancelBySearch({ query, parentTaskID }));
+    }
+    return dispatch(
+      bulkCancelById({
+        selected: selectSelectedTasks(getState()),
+        url,
+        parentTaskID,
+      })
+    );
+  },
+  [CANCEL_MODAL]: ({ url, parentTaskID }) => (dispatch, getState) => {
+    const { taskId, taskName } = selectClicked(getState());
+    return dispatch(
+      cancelTask({
+        taskId,
+        taskName,
+        url,
+        parentTaskID,
+      })
+    );
+  },
+  [RESUME_SELECTED_MODAL]: ({ url, query, parentTaskID }) => (
+    dispatch,
+    getState
+  ) => {
+    if (selectAllRowsSelected(getState())) {
+      return dispatch(bulkResumeBySearch({ query, parentTaskID }));
+    }
+    return dispatch(
+      bulkResumeById({
+        selected: selectSelectedTasks(getState()),
+        url,
+        parentTaskID,
+      })
+    );
+  },
+
+  [RESUME_MODAL]: ({ url, parentTaskID }) => (dispatch, getState) => {
+    const { taskId, taskName } = selectClicked(getState());
+    return dispatch(
+      resumeTask({
+        taskId,
+        taskName,
+        url,
+        parentTaskID,
+      })
+    );
+  },
+
+  [FORCE_UNLOCK_MODAL]: ({ url, parentTaskID }) => (dispatch, getState) => {
+    const { taskId, taskName } = selectClicked(getState());
+    return dispatch(
+      forceCancelTask({
+        taskId,
+        taskName,
+        url,
+        parentTaskID,
+      })
+    );
+  },
+  [FORCE_UNLOCK_SELECTED_MODAL]: ({ url, query, parentTaskID }) => (
+    dispatch,
+    getState
+  ) => {
+    if (selectAllRowsSelected(getState())) {
+      return dispatch(bulkForceCancelBySearch({ query, parentTaskID }));
+    }
+    return dispatch(
+      bulkForceCancelById({
+        selected: selectSelectedTasks(getState()),
+        url,
+        parentTaskID,
+      })
+    );
+  },
+};

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/ConfirmModalReducer.js

@@ -0,0 +1,38 @@
+import Immutable from 'seamless-immutable';
+import {
+  UPDATE_MODAL,
+  CANCEL_SELECTED_MODAL,
+  RESUME_SELECTED_MODAL,
+  RESUME_MODAL,
+  CANCEL_MODAL,
+} from '../../TasksTableConstants';
+
+const initialState = Immutable({});
+
+export const ConfirmModalReducer = (state = initialState, action) => {
+  const { type, payload } = action;
+  switch (type) {
+    case UPDATE_MODAL:
+      switch (payload.modalID) {
+        case CANCEL_SELECTED_MODAL:
+        case CANCEL_MODAL:
+          return state.merge({
+            actionText: 'cancel',
+            actionState: 'stopped',
+            actionType: payload.modalID,
+          });
+        case RESUME_SELECTED_MODAL:
+        case RESUME_MODAL:
+          return state.merge({
+            actionText: 'resume',
+            actionState: 'running',
+            actionType: payload.modalID,
+          });
+        default:
+          return state.set('actionType', payload.modalID);
+      }
+    default:
+      return state;
+  }
+};
+export default ConfirmModalReducer;

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/ConfirmModalSelectors.js

@@ -0,0 +1,46 @@
+import { selectForemanTasks } from '../../../../ForemanTasksSelectors';
+import {
+  selectTasksTableQuery,
+  selectResults,
+  selectSelectedRows,
+  selectItemCount,
+  selectAllRowsSelected,
+} from '../../TasksTableSelectors';
+import { RESUME_MODAL, CANCEL_MODAL } from '../../TasksTableConstants';
+import { FORCE_UNLOCK_MODAL } from '../../../TaskActions/TaskActionsConstants';
+
+export const selectCofirmModal = state =>
+  selectForemanTasks(state).confirmModal || {};
+
+export const selectActionType = state => selectCofirmModal(state).actionType;
+export const selectActionText = state => selectCofirmModal(state).actionText;
+export const selectActionState = state => selectCofirmModal(state).actionState;
+export const selectClicked = state =>
+  selectTasksTableQuery(state).clicked || {};
+
+export const selectSelectedTasks = state => {
+  const selectedIDs = selectResults(state).filter(item =>
+    selectSelectedRows(state).includes(item.id)
+  );
+  return selectedIDs.map(item => ({
+    name: item.action,
+    id: item.id,
+    isCancellable: item.availableActions.cancellable,
+    isResumable: item.availableActions.resumable,
+    canEdit: item.canEdit,
+  }));
+};
+
+export const selectSelectedRowsLen = state => {
+  if (
+    [CANCEL_MODAL, RESUME_MODAL, FORCE_UNLOCK_MODAL].includes(
+      selectActionType(state)
+    )
+  ) {
+    return 1;
+  }
+  if (selectAllRowsSelected(state)) {
+    return selectItemCount(state);
+  }
+  return selectSelectedRows(state).length;
+};

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/__test__/ConfirmModal.test.js

@@ -0,0 +1,36 @@
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import { ConfirmModal } from '../ConfirmModal';
+import { RESUME_SELECTED_MODAL } from '../../../TasksTableConstants';
+import { FORCE_UNLOCK_MODAL } from '../../../../TaskActions/TaskActionsConstants';
+
+const fixtures = {
+  'renders ConfirmModal': {
+    actionType: RESUME_SELECTED_MODAL,
+    actionText: 'some text',
+    actionState: 'some state',
+    selectedRowsLen: 1,
+    id: 'modalID',
+    parentTaskID: 'parent-id',
+    allRowsSelected: true,
+    url: 'some-url',
+    uriQuery: { state: 'stopped' },
+    setModalClosed: jest.fn(),
+  },
+
+  'renders ConfirmModal for unlock ': {
+    actionType: FORCE_UNLOCK_MODAL,
+    actionText: 'some text',
+    actionState: 'some state',
+    selectedRowsLen: 1,
+    id: 'modalID',
+    parentTaskID: 'parent-id',
+    allRowsSelected: true,
+    url: 'some-url',
+    uriQuery: { state: 'stopped' },
+    setModalClosed: jest.fn(),
+  },
+};
+
+describe('ConfirmModal', () => {
+  testComponentSnapshotsWithFixtures(ConfirmModal, fixtures);
+});