foreman-tasks 1.1.0 → 1.1.1

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

@@ -0,0 +1,164 @@
+import API from 'foremanReact/API';
+import { addToast } from 'foremanReact/redux/actions/toasts';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { TOAST_TYPES } from '../common/ToastTypesConstants';
+import {
+  TASKS_RESUME_REQUEST,
+  TASKS_RESUME_SUCCESS,
+  TASKS_RESUME_FAILURE,
+  TASKS_CANCEL_REQUEST,
+  TASKS_CANCEL_SUCCESS,
+  TASKS_CANCEL_FAILURE,
+  BULK_CANCEL_PATH,
+  BULK_RESUME_PATH,
+} from './TasksTableConstants';
+import { reloadPage } from './TasksTableActions';
+import {
+  convertDashboardQuery,
+  resumeToastInfo,
+  cancelToastInfo,
+  toastDispatch,
+} from './TasksTableActionHelpers';
+
+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({
+      type: TOAST_TYPES.ERROR,
+      message: `${__(`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({
+        type: TOAST_TYPES.WARNING,
+        message: __('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({
+      type: 'info',
+      message: __('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({
+      type: TOAST_TYPES.ERROR,
+      message: `${__(`Cannot cancel tasks at the moment`)} ${error}`,
+    })
+  );
+};
+
+export const bulkCancelBySearch = ({
+  query,
+  parentTaskID,
+}) => async dispatch => {
+  dispatch({ type: TASKS_CANCEL_REQUEST });
+  dispatch(
+    addToast({
+      type: 'info',
+      message: __('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({
+        type: TOAST_TYPES.WARNING,
+        message: __('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);
+    }
+  }
+};

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

@@ -18,33 +18,45 @@ const TasksTable = ({
   itemCount,
   pagination,
   selectedRows,
-  selectAllRows,
+  selectPage,
   unselectAllRows,
   selectRow,
   unselectRow,
   openClickedModal,
   modalProps,
+  allRowsSelected,
 }) => {
-  const url = history.location.pathname + history.location.search;
+  const { search, pathname } = history.location;
+  const url = pathname + search;
   const uriQuery = getURIQuery(url);
 
   useEffect(() => {
     getTableItems(url);
   }, [getTableItems, url]);
 
+  useEffect(() => {
+    unselectAllRows();
+  }, [unselectAllRows, search]);
+
   const getSelectionController = () => {
-    const checkAllRowsSelected = () => results.length === selectedRows.length;
+    const checkAllPageSelected = () =>
+      allRowsSelected || results.length === selectedRows.length;
     return {
-      allRowsSelected: () => checkAllRowsSelected(),
-      selectAllRows: () => {
-        if (checkAllRowsSelected()) unselectAllRows();
-        else selectAllRows(results);
+      allRowsSelected,
+      allPageSelected: () => checkAllPageSelected(),
+      selectPage: () => {
+        if (checkAllPageSelected()) unselectAllRows();
+        else {
+          selectPage(results);
+        }
       },
       selectRow: ({ rowData: { id } }) => {
-        if (selectedRows.includes(id)) unselectRow(id);
+        if (selectedRows.includes(id) || allRowsSelected)
+          unselectRow(id, allRowsSelected && results);
         else selectRow(id);
       },
-      isSelected: ({ rowData }) => selectedRows.includes(rowData.id),
+      isSelected: ({ rowData }) =>
+        allRowsSelected || selectedRows.includes(rowData.id),
     };
   };
 
@@ -135,7 +147,7 @@ TasksTable.propTypes = {
   history: PropTypes.object.isRequired,
   openClickedModal: PropTypes.func.isRequired,
   selectedRows: PropTypes.array,
-  selectAllRows: PropTypes.func.isRequired,
+  selectPage: PropTypes.func.isRequired,
   unselectAllRows: PropTypes.func.isRequired,
   selectRow: PropTypes.func.isRequired,
   unselectRow: PropTypes.func.isRequired,
@@ -145,6 +157,7 @@ TasksTable.propTypes = {
     cancelModal: PropTypes.object,
     resumeModal: PropTypes.object,
   }).isRequired,
+  allRowsSelected: PropTypes.bool,
 };
 
 TasksTable.defaultProps = {
@@ -155,6 +168,7 @@ TasksTable.defaultProps = {
     perPage: 20,
   },
   selectedRows: [],
+  allRowsSelected: false,
 };
 
 export default TasksTable;

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

@@ -0,0 +1,52 @@
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import { addToast } from 'foremanReact/redux/actions/toasts';
+import { TASKS_DASHBOARD_JS_QUERY_MODES } from '../TasksDashboard/TasksDashboardConstants';
+import { timeToHoursNumber } from '../TasksDashboard/TasksDashboardHelper';
+
+export const convertDashboardQuery = query => {
+  const {
+    time_mode: timeMode,
+    time_horizon: timeHorizon,
+    state,
+    result,
+    search,
+  } = query;
+
+  const hours = timeToHoursNumber(timeHorizon);
+  const timestamp = new Date(new Date() - hours * 60 * 60 * 1000);
+  let dashboardTime = '';
+  const stateQuery = state ? `state=${state}` : '';
+  const resultQuery = result ? `result=${result}` : '';
+  if (timeMode === TASKS_DASHBOARD_JS_QUERY_MODES.RECENT) {
+    dashboardTime = `(state_updated_at>${timestamp.toISOString()} or state_updated_at = NULL)`;
+  } else if (timeMode === TASKS_DASHBOARD_JS_QUERY_MODES.OLDER) {
+    dashboardTime = `(state_updated_at>${timestamp.toISOString()})`;
+  }
+  const newQuery = [stateQuery, resultQuery, search, dashboardTime]
+    .filter(Boolean)
+    .join(' and ');
+  return newQuery;
+};
+
+export const resumeToastInfo = {
+  resumed: { type: 'success', text: __('was resumed') },
+  failed: { type: 'error', text: __('could not be resumed') },
+  skipped: { type: 'warning', text: __('task has to be resumable') },
+};
+
+export const cancelToastInfo = {
+  cancelled: { type: 'success', text: __('was cancelled') },
+  skipped: { type: 'warning', text: __('task has to be cancellable') },
+};
+
+export const toastDispatch = ({ type, name, toastInfo, dispatch }) => {
+  dispatch(
+    addToast({
+      type: toastInfo[type].type,
+      message: sprintf('%(name)s Task execution %(type)s', {
+        name,
+        type: toastInfo[type].text,
+      }),
+    })
+  );
+};

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

@@ -2,24 +2,39 @@ import { getURIQuery } from 'foremanReact/common/helpers';
 import { getTableItemsAction } from 'foremanReact/components/common/table';
 import API from 'foremanReact/API';
 import { addToast } from 'foremanReact/redux/actions/toasts';
-import { translate as __, sprintf } from 'foremanReact/common/I18n';
-import URI from 'urijs';
+import { sprintf } from 'foremanReact/common/I18n';
 import {
   TASKS_TABLE_ID,
   SELECT_ROWS,
   UNSELECT_ALL_ROWS,
+  SELECT_ALL_ROWS,
   UNSELECT_ROWS,
   UPDATE_CLICKED,
+  OPEN_SELECT_ALL,
   TASKS_RESUME_REQUEST,
   TASKS_RESUME_SUCCESS,
   TASKS_RESUME_FAILURE,
+  TASKS_CANCEL_REQUEST,
+  TASKS_CANCEL_SUCCESS,
+  TASKS_CANCEL_FAILURE,
 } from './TasksTableConstants';
+import { TOAST_TYPES } from '../common/ToastTypesConstants';
 import { getApiPathname } from './TasksTableHelpers';
 import { fetchTasksSummary } from '../TasksDashboard/TasksDashboardActions';
+import {
+  resumeToastInfo,
+  cancelToastInfo,
+  toastDispatch,
+} from './TasksTableActionHelpers';
 
 export const getTableItems = url =>
   getTableItemsAction(TASKS_TABLE_ID, getURIQuery(url), getApiPathname(url));
 
+export const reloadPage = (url, parentTaskID, dispatch) => {
+  dispatch(getTableItems(url));
+  dispatch(fetchTasksSummary(getURIQuery(url).time, parentTaskID));
+};
+
 export const cancelTask = ({
   taskId,
   taskName,
@@ -27,32 +42,34 @@ export const cancelTask = ({
   parentTaskID,
 }) => async dispatch => {
   await dispatch(cancelTaskRequest(taskId, taskName));
-  dispatch(getTableItems(url));
-  dispatch(fetchTasksSummary(getURIQuery(url).time, parentTaskID));
+  reloadPage(url, parentTaskID, dispatch);
 };
 
 export const cancelTaskRequest = (id, name) => async dispatch => {
   dispatch(
     addToast({
-      type: 'info',
-      message: `${__('Trying to cancel')} "${name}" ${__('task')}`,
+      type: TOAST_TYPES.INFO,
+      message: sprintf('Trying to cancel %s task', name),
     })
   );
+  dispatch({ type: TASKS_CANCEL_REQUEST });
   try {
     await API.post(`/foreman_tasks/tasks/${id}/cancel`);
-    dispatch(
-      addToast({
-        type: 'success',
-        message: `"${name}" ${__('Task cancelled')}`,
-      })
-    );
+    dispatch({ type: TASKS_CANCEL_SUCCESS });
+    toastDispatch({
+      type: 'cancelled',
+      name,
+      toastInfo: cancelToastInfo,
+      dispatch,
+    });
   } catch ({ response }) {
-    dispatch(
-      addToast({
-        type: 'error',
-        message: `"${name}" ${__('Task cannot be cancelled at the moment.')}`,
-      })
-    );
+    dispatch({ type: TASKS_CANCEL_FAILURE, payload: response });
+    toastDispatch({
+      type: 'skipped',
+      name,
+      toastInfo: cancelToastInfo,
+      dispatch,
+    });
   }
 };
 
@@ -63,32 +80,44 @@ export const resumeTask = ({
   parentTaskID,
 }) => async dispatch => {
   await dispatch(resumeTaskRequest(taskId, taskName));
-  dispatch(getTableItems(url));
-  dispatch(fetchTasksSummary(getURIQuery(url).time), parentTaskID);
+  reloadPage(url, parentTaskID, dispatch);
 };
 
 export const resumeTaskRequest = (id, name) => async dispatch => {
+  dispatch({ type: TASKS_RESUME_REQUEST });
   try {
     await API.post(`/foreman_tasks/tasks/${id}/resume`);
-    dispatch(
-      addToast({
-        type: 'success',
-        message: __(`"${name}" ${__('Task execution was resumed')}`),
-      })
-    );
+
+    dispatch({ type: TASKS_RESUME_SUCCESS });
+    toastDispatch({
+      type: 'resumed',
+      name,
+      toastInfo: resumeToastInfo,
+      dispatch,
+    });
   } catch ({ response }) {
-    dispatch(
-      addToast({
-        type: 'error',
-        message: __(`Task "${name}" has to be resumable.`),
-      })
-    );
+    dispatch({ type: TASKS_RESUME_FAILURE, payload: response });
+    toastDispatch({
+      type: 'failed',
+      name,
+      toastInfo: resumeToastInfo,
+      dispatch,
+    });
   }
 };
 
-export const selectAllRows = results => ({
-  type: SELECT_ROWS,
-  payload: results.map(row => row.id),
+export const selectPage = results => dispatch => {
+  dispatch({
+    type: SELECT_ROWS,
+    payload: results.map(row => row.id),
+  });
+  dispatch({
+    type: OPEN_SELECT_ALL,
+  });
+};
+
+export const selectAllRows = () => ({
+  type: SELECT_ALL_ROWS,
 });
 
 export const unselectAllRows = () => ({
@@ -100,102 +129,11 @@ export const selectRow = id => ({
   payload: [id],
 });
 
-export const unselectRow = id => ({
+export const unselectRow = (id, results) => ({
   type: UNSELECT_ROWS,
-  payload: id,
+  payload: { id, results },
 });
 
-export const bulkResumeRequest = resumeTasks => {
-  const ids = resumeTasks.map(task => task.id);
-  const url = new URI('/foreman_tasks/api/tasks/bulk_resume');
-  url.setSearch('task_ids[]', ids);
-  return API.post(url);
-};
-
-export const bulkResume = ({
-  selected,
-  url,
-  parentTaskID,
-}) => async dispatch => {
-  const resumeTasks = selected.filter(task => task.isResumable);
-  if (resumeTasks.length < selected.length)
-    dispatch(
-      addToast({
-        type: 'warning',
-        message: __('Not all the selected tasks can be resumed'),
-      })
-    );
-  if (resumeTasks.length) {
-    try {
-      dispatch({ type: TASKS_RESUME_REQUEST });
-      const { data } = await bulkResumeRequest(resumeTasks);
-      dispatch({ type: TASKS_RESUME_SUCCESS });
-      const toastInfo = {
-        resumed: { type: 'success', text: 'was resumed' },
-        failed: { type: 'error', text: 'could not be resumed' },
-      };
-      const toastDispatch = (type, name) =>
-        dispatch(
-          addToast({
-            type: toastInfo[type].type,
-            message: sprintf(__('%(name)s Task execution %(type)s'), {
-              name,
-              type: toastInfo[type].text,
-            }),
-          })
-        );
-
-      ['resumed', 'failed'].forEach(type => {
-        data[type].forEach(task => {
-          toastDispatch(type, task.action);
-        });
-      });
-      if (data.resumed.length) {
-        dispatch(getTableItems(url));
-        dispatch(fetchTasksSummary(getURIQuery(url).time, parentTaskID));
-      }
-    } catch (error) {
-      dispatch({ type: TASKS_RESUME_FAILURE, error });
-      dispatch(
-        addToast({
-          type: 'error',
-          message: `${__(`Cannot resume tasks at the moment`)} ${error}`,
-        })
-      );
-    }
-  }
-};
-
-export const bulkCancel = ({
-  selected,
-  url,
-  parentTaskID,
-}) => async dispatch => {
-  let notAllActionable = false;
-  let someActionable = false;
-  const promises = selected.map(task => {
-    if (task.isCancellable) {
-      someActionable = true;
-      return dispatch(cancelTaskRequest(task.id, task.name));
-    }
-    notAllActionable = true;
-    return null;
-  });
-
-  if (notAllActionable)
-    dispatch(
-      addToast({
-        type: 'warning',
-        message: __('Not all the selected tasks can be canceled'),
-      })
-    );
-  if (someActionable) {
-    await Promise.all(promises);
-    dispatch(getTableItems(url));
-    dispatch(fetchTasksSummary(getURIQuery(url).time, parentTaskID));
-  }
-};
-
 export const openClickedModal = ({ taskId, taskName, setModalOpen }) => {
   setModalOpen();
   return {