foreman-tasks 1.1.0 → 1.1.1

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

@@ -1,12 +1,22 @@
 import { getControllerSearchProps } from 'foremanReact/constants';
 
 export const TASKS_TABLE_ID = 'TASKS_TABLE';
+
 export const SELECT_ROWS = 'SELECT_ROWS';
 export const UNSELECT_ROWS = 'UNSELECT_ROWS';
 export const UNSELECT_ALL_ROWS = 'UNSELECT_ALL_ROWS';
+export const SELECT_ALL_ROWS = 'SELECT_ALL_ROWS';
+export const OPEN_SELECT_ALL = 'OPEN_SELECT_ALL';
+
 export const TASKS_RESUME_REQUEST = 'TASKS_RESUME_REQUEST';
 export const TASKS_RESUME_SUCCESS = 'TASKS_RESUME_SUCCESS';
 export const TASKS_RESUME_FAILURE = 'TASKS_RESUME_FAILURE';
+export const TASKS_CANCEL_REQUEST = 'TASKS_CANCEL_REQUEST';
+export const TASKS_CANCEL_SUCCESS = 'TASKS_CANCEL_SUCCESS';
+export const TASKS_CANCEL_FAILURE = 'TASKS_CANCEL_FAILURE';
+
+export const BULK_CANCEL_PATH = 'bulk_cancel';
+export const BULK_RESUME_PATH = 'bulk_resume';
 
 export const CANCEL_CONFIRM_MODAL_ID = 'cancelConfirmModal';
 export const RESUME_CONFIRM_MODAL_ID = 'resumeConfirmModal';
@@ -16,5 +26,5 @@ export const UPDATE_CLICKED = 'UPDATE_CLICKED';
 
 export const TASKS_SEARCH_PROPS = {
   ...getControllerSearchProps('tasks'),
-  controller: 'foreman_tasks/tasks'
+  controller: 'foreman_tasks/tasks',
 };

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

@@ -22,9 +22,10 @@ export const resolveSearchQuery = (search, history) => {
   updateURlQuery(uriQuery, history);
 };
 
-export const addSearchToURL = (path, query) => {
-  const url = new URI(path);
-  url.addSearch({ ...query, include_permissions: true });
+export const getCSVurl = (path, query) => {
+  let url = new URI(path);
+  url = url.pathname(`${url.pathname()}.csv`);
+  url.addSearch(query);
   return url.toString();
 };
 

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

@@ -10,7 +10,7 @@ import { STATUS } from 'foremanReact/constants';
 import { useForemanModal } from 'foremanReact/components/ForemanModal/ForemanModalHooks';
 import TasksDashboard from '../TasksDashboard';
 import TasksTable from './TasksTable';
-import { resolveSearchQuery, addSearchToURL } from './TasksTableHelpers';
+import { resolveSearchQuery, getCSVurl } from './TasksTableHelpers';
 import { ConfirmationModals } from './Components/ConfirmationModals';
 import {
   TASKS_SEARCH_PROPS,
@@ -21,8 +21,17 @@ import {
 } from './TasksTableConstants';
 import { ActionSelectButton } from './Components/ActionSelectButton';
 import './TasksTablePage.scss';
+import { SelectAllAlert } from './Components/SelectAllAlert';
 
-const TasksTablePage = ({ getBreadcrumbs, history, clicked, createHeader, ...props }) => {
+const TasksTablePage = ({
+  getBreadcrumbs,
+  history,
+  clicked,
+  createHeader,
+  selectAllRows,
+  showSelectAll,
+  ...props
+}) => {
   const url = history.location.pathname + history.location.search;
   const uriQuery = getURIQuery(url);
   const onSearch = searchQuery => {
@@ -53,15 +62,23 @@ const TasksTablePage = ({ getBreadcrumbs, history, clicked, createHeader, ...pro
   };
 
   const {
-    bulkCancel,
-    bulkResume,
+    bulkCancelById,
+    bulkCancelBySearch,
+    bulkResumeById,
+    bulkResumeBySearch,
     cancelTask,
     resumeTask,
     parentTaskID,
   } = props;
   const tasksActions = {
     cancelSelectedTasks: () => {
-      bulkCancel({ selected: getSelectedTasks(), url, parentTaskID });
+      props.allRowsSelected
+        ? bulkCancelBySearch({ query: uriQuery, parentTaskID })
+        : bulkCancelById({
+            selected: getSelectedTasks(),
+            url,
+            parentTaskID,
+          });
     },
     cancelTask: () => {
       cancelTask({
@@ -72,7 +89,13 @@ const TasksTablePage = ({ getBreadcrumbs, history, clicked, createHeader, ...pro
       });
     },
     resumeSelectedTasks: () => {
-      bulkResume({ selected: getSelectedTasks(), url, parentTaskID });
+      props.allRowsSelected
+        ? bulkResumeBySearch({ query: uriQuery, parentTaskID })
+        : bulkResumeById({
+            selected: getSelectedTasks(),
+            url,
+            parentTaskID,
+          });
     },
     resumeTask: () => {
       resumeTask({
@@ -88,7 +111,9 @@ const TasksTablePage = ({ getBreadcrumbs, history, clicked, createHeader, ...pro
     <div className="tasks-table-wrapper">
       <ConfirmationModals
         tasksActions={tasksActions}
-        selectedRowsLen={props.selectedRows.length}
+        selectedRowsLen={
+          props.allRowsSelected ? props.itemCount : props.selectedRows.length
+        }
         modalProps={modalProps}
       />
       <PageLayout
@@ -102,11 +127,11 @@ const TasksTablePage = ({ getBreadcrumbs, history, clicked, createHeader, ...pro
           <React.Fragment>
             {props.status === STATUS.PENDING && <Spinner size="lg" loading />}
             <ExportButton
-              url={addSearchToURL('/foreman_tasks/tasks.csv', uriQuery)}
+              url={getCSVurl(url, uriQuery)}
               title={__('Export All')}
             />
             <ActionSelectButton
-              disabled={props.selectedRows.length < 1}
+              disabled={!(props.selectedRows.length || props.allRowsSelected)}
               onCancel={modalProps.cancelSelectedModal.setModalOpen}
               onResume={modalProps.resumeSelectedModal.setModalOpen}
             />
@@ -117,13 +142,30 @@ const TasksTablePage = ({ getBreadcrumbs, history, clicked, createHeader, ...pro
           <TasksDashboard history={history} parentTaskID={props.parentTaskID} />
         }
       >
-        <TasksTable history={history} {...props} modalProps={modalProps} />
+        <React.Fragment>
+          {showSelectAll && props.itemCount >= props.pagination.perPage && (
+            <SelectAllAlert
+              itemCount={props.itemCount}
+              perPage={props.pagination.perPage}
+              selectAllRows={selectAllRows}
+              unselectAllRows={props.unselectAllRows}
+              allRowsSelected={props.allRowsSelected}
+            />
+          )}
+          <TasksTable history={history} {...props} modalProps={modalProps} />
+        </React.Fragment>
       </PageLayout>
     </div>
   );
 };
 
 TasksTablePage.propTypes = {
+  allRowsSelected: PropTypes.bool,
+  itemCount: PropTypes.number.isRequired,
+  pagination: PropTypes.shape({
+    perPage: PropTypes.number,
+  }),
+  selectAllRows: PropTypes.func.isRequired,
   results: PropTypes.array.isRequired,
   getTableItems: PropTypes.func.isRequired,
   getBreadcrumbs: PropTypes.func.isRequired,
@@ -132,8 +174,10 @@ TasksTablePage.propTypes = {
   history: PropTypes.object.isRequired,
   cancelTask: PropTypes.func.isRequired,
   resumeTask: PropTypes.func.isRequired,
-  bulkCancel: PropTypes.func.isRequired,
-  bulkResume: PropTypes.func.isRequired,
+  bulkCancelById: PropTypes.func.isRequired,
+  bulkCancelBySearch: PropTypes.func.isRequired,
+  bulkResumeById: PropTypes.func.isRequired,
+  bulkResumeBySearch: PropTypes.func.isRequired,
   selectedRows: PropTypes.arrayOf(PropTypes.string),
   parentTaskID: PropTypes.string,
   createHeader: PropTypes.func,
@@ -142,15 +186,23 @@ TasksTablePage.propTypes = {
     taskName: PropTypes.string,
     parentTaskID: PropTypes.string,
   }),
+  showSelectAll: PropTypes.bool,
+  unselectAllRows: PropTypes.func.isRequired,
 };
 
 TasksTablePage.defaultProps = {
+  pagination: {
+    page: 1,
+    perPage: 20,
+  },
+  allRowsSelected: false,
   actionName: '',
   status: STATUS.PENDING,
   selectedRows: [],
   parentTaskID: null,
   clicked: {},
   createHeader: () => __('Tasks'),
+  showSelectAll: false,
 };
 
 export default TasksTablePage;

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

@@ -9,6 +9,8 @@ import {
   UNSELECT_ROWS,
   UNSELECT_ALL_ROWS,
   UPDATE_CLICKED,
+  SELECT_ALL_ROWS,
+  OPEN_SELECT_ALL,
 } from './TasksTableConstants';
 
 const initialState = Immutable({
@@ -21,6 +23,8 @@ export const TasksTableQueryReducer = (state = initialState, action) => {
     response || {};
   const ACTION_TYPES = createTableActionTypes(TASKS_TABLE_ID);
   switch (type) {
+    case SELECT_ALL_ROWS:
+      return state.set('allRowsSelected', true);
     case ACTION_TYPES.SUCCESS:
       return Immutable.merge(state, {
         itemCount: subtotal,
@@ -33,13 +37,28 @@ export const TasksTableQueryReducer = (state = initialState, action) => {
       });
     case SELECT_ROWS:
       return state.set('selectedRows', union(payload, state.selectedRows));
+    case OPEN_SELECT_ALL:
+      return state.set('showSelectAll', true);
     case UNSELECT_ROWS:
+      if (state.allRowsSelected) {
+        // User can unselect rows if only the page rows are selected
+        return state
+          .set(
+            'selectedRows',
+            payload.results.map(row => row.id).filter(row => row !== payload.id)
+          )
+          .set('allRowsSelected', false)
+          .set('showSelectAll', false);
+      }
       return state.set(
         'selectedRows',
-        state.selectedRows.filter(row => row !== payload)
+        state.selectedRows.filter(row => row !== payload.id)
       );
     case UNSELECT_ALL_ROWS:
-      return state.set('selectedRows', []);
+      return state
+        .set('selectedRows', [])
+        .set('allRowsSelected', false)
+        .set('showSelectAll', false);
     case UPDATE_CLICKED:
       return state.set('clicked', payload.clicked);
     default:

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

@@ -48,3 +48,9 @@ export const selectError = state => selectTasksTableContent(state).error;
 
 export const selectSort = state =>
   selectTasksTableQuery(state).sort || { by: 'started_at', order: 'DESC' };
+
+export const selectAllRowsSelected = state =>
+  selectTasksTableQuery(state).allRowsSelected;
+
+export const selectShowSelectAll = state =>
+  selectTasksTableQuery(state).showSelectAll;

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

@@ -0,0 +1,112 @@
+import { testActionSnapshotWithFixtures } from '@theforeman/test';
+import API from 'foremanReact/API';
+import {
+  bulkCancelById,
+  bulkCancelBySearch,
+  bulkResumeById,
+  bulkResumeBySearch,
+} from '../TasksBulkActions';
+
+jest.mock('foremanReact/components/common/table', () => ({
+  getTableItemsAction: jest.fn(controller => controller),
+}));
+
+jest.mock('foremanReact/API');
+
+const task = {
+  id: 'some-id',
+  name: 'some-name',
+};
+
+const fixtures = {
+  'handles bulkResumeById requests that fail': () => {
+    const selected = [{ ...task, isResumable: true }];
+
+    API.post.mockImplementation(() =>
+      Promise.reject(new Error('Network Error'))
+    );
+    return bulkResumeById({ selected, url: 'some-url' });
+  },
+  'handles resumable bulkResumeById requests': () => {
+    const selected = [{ ...task, isResumable: true }];
+
+    API.post.mockImplementation(() => ({
+      data: {
+        resumed: [{ action: 'I am resumed' }],
+        failed: [{ action: 'I am failed' }],
+      },
+    }));
+    return bulkResumeById({ selected, url: 'some-url' });
+  },
+  'handles bulkCancelById requests': () => {
+    const selected = [{ ...task, isCancellable: true }];
+
+    API.post.mockImplementation(() => ({
+      data: {
+        cancelled: [{ action: 'I am cancelled' }],
+      },
+    }));
+    return bulkCancelById({ selected, url: 'some-url' });
+  },
+  'handles skipped bulkResumeById requests': () => {
+    const selected = [{ ...task, isResumable: true }];
+
+    API.post.mockImplementation(() => ({
+      data: {
+        skipped: [{ action: 'I am skipped' }],
+      },
+    }));
+    return bulkResumeById({ selected, url: 'some-url' });
+  },
+  'handles skipped bulkCancelById requests': () => {
+    const selected = [{ ...task, isCancellable: true }];
+
+    API.post.mockImplementation(() => ({
+      data: {
+        skipped: [{ action: 'I am skipped' }],
+      },
+    }));
+    return bulkCancelById({ selected, url: 'some-url' });
+  },
+  'handles bulkCancelById requests that are not cancellable': () => {
+    const selected = [{ ...task, isCancellable: false }];
+    return bulkCancelById({ selected, url: 'some-url' });
+  },
+  'handles bulkResumeById requests that are not resumable': () => {
+    const selected = [{ ...task, isResumable: false, isCancellable: false }];
+    return bulkResumeById({ selected, url: 'some-url' });
+  },
+
+  'handles bulkCancelBySearch requests': () => {
+    API.post.mockImplementation(() => ({
+      data: {
+        cancelled: [{ action: 'I am cancelled' }],
+        skipped: [{ action: 'I am skipped' }],
+      },
+    }));
+    return bulkCancelBySearch({
+      query: { search: {} },
+      url: 'some-url',
+      parentTaskID: 'parent',
+    });
+  },
+
+  'handles bulkResumeBySearch requests': () => {
+    API.post.mockImplementation(() => ({
+      data: {
+        cancelled: [{ action: 'I am cancelled' }],
+        skipped: [{ action: 'I am skipped' }],
+        failed: [{ action: 'I am failed' }],
+      },
+    }));
+    return bulkResumeBySearch({
+      query: { search: {} },
+      url: 'some-url',
+      parentTaskID: 'parent',
+    });
+  },
+};
+
+describe('TasksTable bulk actions', () => {
+  testActionSnapshotWithFixtures(fixtures);
+});

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

@@ -6,8 +6,11 @@ export const minProps = {
   itemCount: 2,
   cancelTask: jest.fn(),
   resumeTask: jest.fn(),
-  bulkCancel: jest.fn(),
-  bulkResume: jest.fn(),
+  bulkResumeById: jest.fn(),
+  bulkCancelById: jest.fn(),
+  bulkResumeBySearch: jest.fn(),
+  bulkCancelBySearch: jest.fn(),
+  selectPage: jest.fn(),
   selectAllRows: jest.fn(),
   unselectAllRows: jest.fn(),
   selectRow: jest.fn(),
@@ -18,7 +21,6 @@ export const minProps = {
     perPage: 10,
   },
   history: { location: { search: '' } },
-  status: STATUS.RESOLVED,
   results: ['a', 'b'],
   sort: {
     by: 'q',

data/webpack/ForemanTasks/Components/TasksTable/__tests__/TasksTableActionHelpers.test.js

@@ -0,0 +1,46 @@
+import { convertDashboardQuery } from '../TasksTableActionHelpers';
+import {
+  TASKS_DASHBOARD_JS_QUERY_MODES,
+  TASKS_DASHBOARD_AVAILABLE_TIMES,
+} from '../../TasksDashboard/TasksDashboardConstants';
+
+let realDate;
+
+describe('convertDashboardQuery', () => {
+  it('convertDashboardQuery should work with full query', () => {
+    // Setup
+    const currentDate = new Date('2020-05-08T11:01:58.135Z');
+    realDate = Date;
+    global.Date = class extends Date {
+      constructor(date) {
+        if (date) {
+          // eslint-disable-next-line constructor-super
+          return super(date);
+        }
+        return currentDate;
+      }
+    };
+    const query = {
+      time_mode: TASKS_DASHBOARD_JS_QUERY_MODES.RECENT,
+      time_horizon: TASKS_DASHBOARD_AVAILABLE_TIMES.WEEK,
+      state: 'stopped',
+      result: 'error',
+      search: 'action~job',
+    };
+    expect(convertDashboardQuery(query)).toEqual(
+      'state=stopped and result=error and action~job and (state_updated_at>2020-05-01T11:01:58.135Z or state_updated_at = NULL)'
+    );
+    // Cleanup
+    global.Date = realDate;
+  });
+  it('convertDashboardQuery should work with only search query', () => {
+    const query = {
+      search: 'action~job',
+    };
+    expect(convertDashboardQuery(query)).toEqual('action~job');
+  });
+  it('convertDashboardQuery should work with no query', () => {
+    const query = {};
+    expect(convertDashboardQuery(query)).toEqual('');
+  });
+});

data/webpack/ForemanTasks/Components/TasksTable/__tests__/TasksTableActions.test.js

@@ -1,4 +1,7 @@
-import { testActionSnapshotWithFixtures } from '@theforeman/test';
+import {
+  testActionSnapshotWithFixtures,
+  IntegrationTestHelper,
+} from '@theforeman/test';
 import API from 'foremanReact/API';
 import { TASKS_TABLE_ID } from '../TasksTableConstants';
 import {
@@ -7,8 +10,7 @@ import {
   cancelTaskRequest,
   resumeTask,
   resumeTaskRequest,
-  bulkCancel,
-  bulkResume,
+  selectPage,
 } from '../TasksTableActions';
 
 jest.mock('foremanReact/components/common/table', () => ({
@@ -24,13 +26,7 @@ const taskInfo = {
   taskName: 'some-name',
 };
 
-const task = {
-  id: 'some-id',
-  name: 'some-name',
-};
-
 const fixtures = {
-  'should cancelTask': () => cancelTask({ ...taskInfo, url: 'some-url' }),
   'should cancelTaskRequest and succeed': () =>
     cancelTaskRequest('some-id', 'some-name'),
   'should cancelTaskRequest and fail': () => {
@@ -40,7 +36,6 @@ const fixtures = {
     return cancelTaskRequest('some-id', 'some-name');
   },
 
-  'should resumeTask': () => resumeTask({ ...taskInfo, url: 'some-url' }),
   'should resumeTaskRequest and succeed': () => {
     API.post.mockImplementation(() => ({ data: 'some-data' }));
     return resumeTaskRequest('some-id', 'some-name');
@@ -51,41 +46,24 @@ const fixtures = {
     );
     return resumeTaskRequest('some-id', 'some-name');
   },
-  'handles bulkResume requests that fail': () => {
-    const selected = [{ ...task, isResumable: true, isCancellable: false }];
-
-    API.post.mockImplementation(() =>
-      Promise.reject(new Error('Network Error'))
-    );
-    return bulkResume({ selected, url: 'some-url' });
-  },
-  'handles resumable bulkResume requests': () => {
-    const selected = [{ ...task, isResumable: true, isCancellable: false }];
-
-    API.post.mockImplementation(() => ({
-      data: {
-        resumed: [{ action: 'I am resumed' }],
-        failed: [{ action: 'I am failed' }],
-      },
-    }));
-    return bulkResume({ selected, url: 'some-url' });
-  },
-  'handles bulkCancel requests': () => {
-    const selected = [{ ...task, isResumable: false, isCancellable: true }];
-    return bulkCancel({ selected, url: 'some-url' });
-  },
-  'handles bulkCancel requests that are not cancellable': () => {
-    const selected = [{ ...task, isResumable: false, isCancellable: false }];
-    return bulkCancel({ selected, url: 'some-url' });
-  },
-  'handles bulkResume requests that are not resumable': () => {
-    const selected = [{ ...task, isResumable: false, isCancellable: false }];
-    return bulkResume({ selected, url: 'some-url' });
-  },
+  'should selectPage and succeed': () => selectPage([{ id: 'some-id' }]),
 };
 describe('TasksTable actions', () => {
   it('getTableItems should reuse common/table/getTableItemsAction', () => {
     expect(getTableItems('')).toEqual(TASKS_TABLE_ID);
   });
+
+  it('should resumeTask', async () => {
+    const dispatch = jest.fn();
+    resumeTask({ ...taskInfo, url: 'some-url' })(dispatch);
+    await IntegrationTestHelper.flushAllPromises();
+    expect(dispatch.mock.calls).toHaveLength(3);
+  });
+  it('should cancelTask', async () => {
+    const dispatch = jest.fn();
+    cancelTask({ ...taskInfo, url: 'some-url' })(dispatch);
+    await IntegrationTestHelper.flushAllPromises();
+    expect(dispatch.mock.calls).toHaveLength(3);
+  });
   testActionSnapshotWithFixtures(fixtures);
 });