foreman-tasks 1.0.0 → 2.0.0

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

@@ -0,0 +1,29 @@
+import { connect } from 'react-redux';
+import { bindActionCreators } from 'redux';
+import { ConfirmModal } from './ConfirmModal';
+import reducer from './ConfirmModalReducer';
+import tasksActions from './ConfirmModalActions';
+import {
+  selectActionText,
+  selectActionState,
+  selectActionType,
+  selectClicked,
+  selectSelectedRowsLen,
+} from './ConfirmModalSelectors';
+import { selectAllRowsSelected } from '../../TasksTableSelectors';
+
+const mapStateToProps = state => ({
+  actionText: selectActionText(state),
+  actionType: selectActionType(state),
+  actionState: selectActionState(state),
+  allRowsSelected: selectAllRowsSelected(state),
+  clicked: selectClicked(state),
+  selectedRowsLen: selectSelectedRowsLen(state),
+});
+
+const mapDispatchToProps = dispatch =>
+  bindActionCreators(tasksActions, dispatch);
+
+export const reducers = { confirmModal: reducer };
+
+export default connect(mapStateToProps, mapDispatchToProps)(ConfirmModal);

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

@@ -0,0 +1,43 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Alert, Button } from 'patternfly-react';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
+
+export const SelectAllAlert = ({
+  itemCount,
+  perPage,
+  selectAllRows,
+  unselectAllRows,
+  allRowsSelected,
+}) => {
+  const selectAllText = (
+    <React.Fragment>
+      {sprintf(
+        'All %s tasks on this page are selected',
+        Math.min(itemCount, perPage)
+      )}
+      <Button bsStyle="link" onClick={selectAllRows}>
+        {__('Select All')}
+        <b> {itemCount} </b> {__('tasks.')}
+      </Button>
+    </React.Fragment>
+  );
+  const undoSelectText = (
+    <React.Fragment>
+      {sprintf(__(`All %s tasks are selected. `), itemCount)}
+      <Button bsStyle="link" onClick={unselectAllRows}>
+        {__('Undo selection')}
+      </Button>
+    </React.Fragment>
+  );
+  const selectAlertText = allRowsSelected ? undoSelectText : selectAllText;
+  return <Alert type="info">{selectAlertText}</Alert>;
+};
+
+SelectAllAlert.propTypes = {
+  allRowsSelected: PropTypes.bool.isRequired,
+  itemCount: PropTypes.number.isRequired,
+  perPage: PropTypes.number.isRequired,
+  selectAllRows: PropTypes.func.isRequired,
+  unselectAllRows: PropTypes.func.isRequired,
+};

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

@@ -1,4 +1,4 @@
-import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
 
 import { ActionSelectButton } from '../ActionSelectButton';
 
@@ -6,6 +6,7 @@ const fixtures = {
   'renders with minimal props': {
     onCancel: jest.fn(),
     onResume: jest.fn(),
+    onForceCancel: jest.fn(),
   },
 };
 

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

@@ -0,0 +1,29 @@
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+
+import { SelectAllAlert } from '../SelectAllAlert';
+
+const baseProps = {
+  itemCount: 7,
+  perPage: 5,
+  selectAllRows: jest.fn(),
+  unselectAllRows: jest.fn(),
+};
+const fixtures = {
+  'renders SelectAllAlert with perPage > itemCout': {
+    allRowsSelected: false,
+    itemCount: 7,
+    perPage: 10,
+    ...baseProps,
+  },
+  'renders SelectAllAlert without all rows selected': {
+    allRowsSelected: false,
+    ...baseProps,
+  },
+  'renders SelectAllAlert with all rows selected': {
+    allRowsSelected: true,
+    ...baseProps,
+  },
+};
+
+describe('SelectAllAlert', () =>
+  testComponentSnapshotsWithFixtures(SelectAllAlert, fixtures));

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

@@ -1,4 +1,4 @@
-import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
 
 import TableSelectionCell from '../TableSelectionCell';
 

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

@@ -1,4 +1,4 @@
-import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
 
 import TableSelectionHeaderCell from '../TableSelectionHeaderCell';
 

data/webpack/ForemanTasks/Components/TasksTable/Components/__test__/__snapshots__/ActionSelectButton.test.js.snap

@@ -28,5 +28,16 @@ exports[`ActionSelectButton renders with minimal props 1`] = `
   >
     Resume Selected
   </MenuItem>
+  <MenuItem
+    bsClass="dropdown"
+    disabled={false}
+    divider={false}
+    eventKey="3"
+    header={false}
+    onClick={[MockFunction]}
+    title="Force Cancel selected tasks"
+  >
+    Force Cancel Selected
+  </MenuItem>
 </DropdownButton>
 `;

data/webpack/ForemanTasks/Components/TasksTable/Components/__test__/__snapshots__/SelectAllAlert.test.js.snap

@@ -0,0 +1,75 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`SelectAllAlert renders SelectAllAlert with all rows selected 1`] = `
+<Alert
+  className=""
+  onDismiss={null}
+  type="info"
+>
+  All 7 tasks are selected. 
+  <Button
+    active={false}
+    block={false}
+    bsClass="btn"
+    bsStyle="link"
+    disabled={false}
+    onClick={[MockFunction]}
+  >
+    Undo selection
+  </Button>
+</Alert>
+`;
+
+exports[`SelectAllAlert renders SelectAllAlert with perPage > itemCout 1`] = `
+<Alert
+  className=""
+  onDismiss={null}
+  type="info"
+>
+  All 5 tasks on this page are selected
+  <Button
+    active={false}
+    block={false}
+    bsClass="btn"
+    bsStyle="link"
+    disabled={false}
+    onClick={[MockFunction]}
+  >
+    Select All
+    <b>
+       
+      7
+       
+    </b>
+     
+    tasks.
+  </Button>
+</Alert>
+`;
+
+exports[`SelectAllAlert renders SelectAllAlert without all rows selected 1`] = `
+<Alert
+  className=""
+  onDismiss={null}
+  type="info"
+>
+  All 5 tasks on this page are selected
+  <Button
+    active={false}
+    block={false}
+    bsClass="btn"
+    bsStyle="link"
+    disabled={false}
+    onClick={[MockFunction]}
+  >
+    Select All
+    <b>
+       
+      7
+       
+    </b>
+     
+    tasks.
+  </Button>
+</Alert>
+`;

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

@@ -1,6 +1,6 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import { translate as __ } from 'foremanReact/common/I18n';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
 import TasksTablePage from './';
 
 export const SubTasksPage = props => {
@@ -15,10 +15,13 @@ export const SubTasksPage = props => {
       { caption: __('Sub tasks') },
     ],
   });
+  const createHeader = actionName =>
+    actionName ? sprintf(__('Sub tasks of %s'), actionName) : __('Sub tasks');
   return (
     <TasksTablePage
       getBreadcrumbs={getBreadcrumbs}
       parentTaskID={parentTaskID}
+      createHeader={createHeader}
       {...props}
     />
   );

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

@@ -0,0 +1,247 @@
+import API from 'foremanReact/API';
+import { addToast } from 'foremanReact/redux/actions/toasts';
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import {
+  BULK_CANCEL_PATH,
+  BULK_RESUME_PATH,
+  BULK_FORCE_CANCEL_PATH,
+} from './TasksTableConstants';
+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,
+} from '../TaskActions/TaskActionsConstants';
+import { reloadPage } from './TasksTableActions';
+import {
+  convertDashboardQuery,
+  resumeToastInfo,
+  cancelToastInfo,
+  toastDispatch,
+} from '../TaskActions/TaskActionHelpers';
+import {
+  successToastData,
+  errorToastData,
+  warningToastData,
+  infoToastData,
+} from '../common/ToastsHelpers';
+
+export const bulkByIdRequest = (resumeTasks, path) => {
+  const ids = resumeTasks.map(task => task.id);
+  const url = `/foreman_tasks/api/tasks/${path}`;
+  const data = { task_ids: ids };
+  return API.post(url, data);
+};
+
+export const bulkBySearchRequest = ({ query, parentTaskID, path }) => {
+  const url = `/foreman_tasks/api/tasks/${path}`;
+  if (parentTaskID) {
+    query.search = query.search
+      ? ` ${query.search} and parent_task_id=${parentTaskID}`
+      : `parent_task_id=${parentTaskID}`;
+  }
+  const searchParam = { search: convertDashboardQuery(query) };
+  return API.post(url, searchParam);
+};
+
+const handleErrorResume = (error, dispatch) => {
+  dispatch({ type: TASKS_RESUME_FAILURE, error });
+  dispatch(
+    addToast(
+      errorToastData(`${__(`Cannot resume tasks at the moment`)} ${error}`)
+    )
+  );
+};
+
+export const bulkResumeById = ({
+  selected,
+  url,
+  parentTaskID,
+}) => async dispatch => {
+  const resumeTasks = selected.filter(task => task.isResumable);
+  if (resumeTasks.length < selected.length)
+    dispatch(
+      addToast(
+        warningToastData(__('Not all the selected tasks can be resumed'))
+      )
+    );
+  if (resumeTasks.length) {
+    dispatch({ type: TASKS_RESUME_REQUEST });
+    try {
+      const { data } = await bulkByIdRequest(resumeTasks, BULK_RESUME_PATH);
+      dispatch({ type: TASKS_RESUME_SUCCESS });
+      ['resumed', 'failed', 'skipped'].forEach(type => {
+        data[type] &&
+          data[type].forEach(task => {
+            toastDispatch({
+              type,
+              name: task.action,
+              toastInfo: resumeToastInfo,
+              dispatch,
+            });
+          });
+      });
+      if (data.resumed) {
+        reloadPage(url, parentTaskID, dispatch);
+      }
+    } catch (error) {
+      handleErrorResume(error, dispatch);
+    }
+  }
+};
+
+export const bulkResumeBySearch = ({
+  query,
+  parentTaskID,
+}) => async dispatch => {
+  dispatch({ type: TASKS_RESUME_REQUEST });
+  dispatch(
+    addToast(
+      infoToastData(__('Resuming selected tasks, this might take a while'))
+    )
+  );
+  await bulkBySearchRequest({ query, path: BULK_RESUME_PATH, parentTaskID });
+};
+
+const handleErrorCancel = (error, dispatch) => {
+  dispatch({ type: TASKS_CANCEL_FAILURE, error });
+  dispatch(
+    addToast(
+      errorToastData(`${__(`Cannot cancel tasks at the moment`)} ${error}`)
+    )
+  );
+};
+
+export const bulkCancelBySearch = ({
+  query,
+  parentTaskID,
+}) => async dispatch => {
+  dispatch({ type: TASKS_CANCEL_REQUEST });
+  dispatch(
+    addToast(
+      infoToastData(__('Canceling selected tasks, this might take a while'))
+    )
+  );
+  await bulkBySearchRequest({ query, path: BULK_CANCEL_PATH, parentTaskID });
+};
+
+export const bulkCancelById = ({
+  selected,
+  url,
+  parentTaskID,
+}) => async dispatch => {
+  const cancelTasks = selected.filter(task => task.isCancellable);
+  if (cancelTasks.length < selected.length)
+    dispatch(
+      addToast(
+        warningToastData(__('Not all the selected tasks can be cancelled'))
+      )
+    );
+  if (cancelTasks.length) {
+    dispatch({ type: TASKS_CANCEL_REQUEST });
+    try {
+      const { data } = await bulkByIdRequest(cancelTasks, BULK_CANCEL_PATH);
+      dispatch({ type: TASKS_CANCEL_SUCCESS });
+
+      ['cancelled', 'skipped'].forEach(type => {
+        data[type] &&
+          data[type].forEach(task => {
+            toastDispatch({
+              type,
+              name: task.action,
+              toastInfo: cancelToastInfo,
+              dispatch,
+            });
+          });
+      });
+      if (data.cancelled) {
+        reloadPage(url, parentTaskID, dispatch);
+      }
+    } catch (error) {
+      handleErrorCancel(error, dispatch);
+    }
+  }
+};
+
+const handleErrorForceCancel = (error, dispatch) => {
+  dispatch({ type: TASKS_FORCE_CANCEL_FAILURE, error });
+  dispatch(
+    addToast(
+      errorToastData(
+        `${__(`Cannot force cancel tasks at the moment`)} ${error}`
+      )
+    )
+  );
+};
+
+export const bulkForceCancelById = ({
+  selected,
+  url,
+  parentTaskID,
+}) => async dispatch => {
+  const stopTasks = selected.filter(task => task.state !== 'stopped');
+  if (stopTasks.length < selected.length)
+    dispatch(
+      addToast(
+        warningToastData(
+          sprintf(
+            '%s task(s) are already stopped',
+            selected.length - stopTasks.length
+          )
+        )
+      )
+    );
+  if (stopTasks.length > 0) {
+    dispatch({ type: TASKS_FORCE_CANCEL_REQUEST });
+    try {
+      const { data } = await bulkByIdRequest(stopTasks, BULK_FORCE_CANCEL_PATH);
+      dispatch({ type: TASKS_FORCE_CANCEL_SUCCESS });
+      if (data.stopped_length) {
+        dispatch(
+          addToast(
+            successToastData(
+              sprintf('%s task(s) cancelled with force', data.stopped_length)
+            )
+          )
+        );
+      }
+      if (data.skipped_length > 0)
+        dispatch(
+          addToast(
+            warningToastData(
+              sprintf('%s task(s) are already stopped', data.skipped_length)
+            )
+          )
+        );
+      if (data.stopped_length > 0) {
+        reloadPage(url, parentTaskID, dispatch);
+      }
+    } catch (error) {
+      handleErrorForceCancel(error, dispatch);
+    }
+  }
+};
+
+export const bulkForceCancelBySearch = ({
+  query,
+  parentTaskID,
+}) => async dispatch => {
+  dispatch({ type: TASKS_FORCE_CANCEL_REQUEST });
+  dispatch(
+    addToast(
+      infoToastData(
+        __('Canceling with force selected tasks, this might take a while')
+      )
+    )
+  );
+  await bulkBySearchRequest({
+    query,
+    path: BULK_FORCE_CANCEL_PATH,
+    parentTaskID,
+  });
+};