foreman-tasks 0.17.6 → 1.2.0

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

@@ -8,6 +8,8 @@ import Pagination from 'foremanReact/components/Pagination/PaginationWrapper';
 import { getURIQuery } from 'foremanReact/common/helpers';
 import createTasksTableSchema from './TasksTableSchema';
 import { updateURlQuery } from './TasksTableHelpers';
+import { RESUME_MODAL, CANCEL_MODAL } from './TasksTableConstants';
+import { FORCE_UNLOCK_MODAL } from '../TaskActions/TaskActionsConstants';
 
 const TasksTable = ({
   getTableItems,
@@ -17,35 +19,46 @@ const TasksTable = ({
   history,
   itemCount,
   pagination,
-  cancelTask,
-  resumeTask,
   selectedRows,
-  selectAllRows,
+  selectPage,
   unselectAllRows,
   selectRow,
   unselectRow,
-  parentTaskID,
+  openClickedModal,
+  openModal,
+  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);
-  }, [history.location.search]);
+  }, [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),
     };
   };
 
@@ -82,11 +95,26 @@ const TasksTable = ({
   };
 
   const taskActions = {
-    cancel: (id, name) => {
-      cancelTask(id, name, url, parentTaskID);
+    cancelTask: (taskId, taskName) => {
+      openClickedModal({
+        taskId,
+        taskName,
+        setModalOpen: () => openModal(CANCEL_MODAL),
+      });
+    },
+    resumeTask: (taskId, taskName) => {
+      openClickedModal({
+        taskId,
+        taskName,
+        setModalOpen: () => openModal(RESUME_MODAL),
+      });
     },
-    resume: (id, name) => {
-      resumeTask(id, name, url, parentTaskID);
+    forceCancelTask: (taskId, taskName) => {
+      openClickedModal({
+        taskId,
+        taskName,
+        setModalOpen: () => openModal(FORCE_UNLOCK_MODAL),
+      });
     },
   };
 
@@ -126,14 +154,14 @@ TasksTable.propTypes = {
     perPage: PropTypes.number,
   }),
   history: PropTypes.object.isRequired,
-  cancelTask: PropTypes.func.isRequired,
-  resumeTask: PropTypes.func.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,
-  parentTaskID: PropTypes.string,
+  openModal: PropTypes.func.isRequired,
+  allRowsSelected: PropTypes.bool,
 };
 
 TasksTable.defaultProps = {
@@ -144,7 +172,7 @@ TasksTable.defaultProps = {
     perPage: 20,
   },
   selectedRows: [],
-  parentTaskID: null,
+  allRowsSelected: false,
 };
 
 export default TasksTable;

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

@@ -1,83 +1,75 @@
 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 __ } from 'foremanReact/common/I18n';
+
 import {
   TASKS_TABLE_ID,
   SELECT_ROWS,
   UNSELECT_ALL_ROWS,
+  SELECT_ALL_ROWS,
   UNSELECT_ROWS,
-  TASKS_TABLE_SELECTED_MODAL,
-  CLOSED,
-  RESUME,
-  CANCEL,
+  UPDATE_CLICKED,
+  OPEN_SELECT_ALL,
+  UPDATE_MODAL,
 } from './TasksTableConstants';
 import { getApiPathname } from './TasksTableHelpers';
 import { fetchTasksSummary } from '../TasksDashboard/TasksDashboardActions';
+import {
+  cancelTaskRequest,
+  resumeTaskRequest,
+  forceCancelTaskRequest,
+} from '../TaskActions';
 
 export const getTableItems = url =>
   getTableItemsAction(TASKS_TABLE_ID, getURIQuery(url), getApiPathname(url));
 
-export const cancelTask = (id, name, url, parentTaskID) => async dispatch => {
-  await dispatch(cancelTaskRequest(id, name));
+export const reloadPage = (url, parentTaskID, dispatch) => {
   dispatch(getTableItems(url));
   dispatch(fetchTasksSummary(getURIQuery(url).time, parentTaskID));
 };
 
-export const cancelTaskRequest = (id, name) => async dispatch => {
-  dispatch(
-    addToast({
-      type: 'info',
-      message: `${__('Trying to cancel')} "${name}" ${__('task')}`,
-    })
-  );
-  try {
-    await API.post(`/foreman_tasks/tasks/${id}/cancel`);
-    dispatch(
-      addToast({
-        type: 'success',
-        message: `"${name}" ${__('Task cancelled')}`,
-      })
-    );
-  } catch ({ response }) {
-    dispatch(
-      addToast({
-        type: 'error',
-        message: `"${name}" ${__('Task cannot be cancelled at the moment.')}`,
-      })
-    );
-  }
+export const cancelTask = ({
+  taskId,
+  taskName,
+  url,
+  parentTaskID,
+}) => async dispatch => {
+  await dispatch(cancelTaskRequest(taskId, taskName));
+  reloadPage(url, parentTaskID, dispatch);
+};
+
+export const resumeTask = ({
+  taskId,
+  taskName,
+  url,
+  parentTaskID,
+}) => async dispatch => {
+  await dispatch(resumeTaskRequest(taskId, taskName));
+  reloadPage(url, parentTaskID, dispatch);
 };
 
-export const resumeTask = (id, name, url, parentTaskID) => async dispatch => {
-  await dispatch(resumeTaskRequest(id, name));
+export const forceCancelTask = ({
+  taskId,
+  taskName,
+  url,
+  parentTaskID,
+}) => async dispatch => {
+  await dispatch(forceCancelTaskRequest(taskId, taskName));
   dispatch(getTableItems(url));
-  dispatch(fetchTasksSummary(getURIQuery(url).time), parentTaskID);
+  dispatch(fetchTasksSummary(getURIQuery(url).time, parentTaskID));
 };
 
-export const resumeTaskRequest = (id, name) => async dispatch => {
-  try {
-    await API.post(`/foreman_tasks/tasks/${id}/resume`);
-    dispatch(
-      addToast({
-        type: 'success',
-        message: __(`"${name}" ${__('Task execution was resumed')}`),
-      })
-    );
-  } catch ({ response }) {
-    dispatch(
-      addToast({
-        type: 'error',
-        message: __(`Task "${name}" has to be resumable.`),
-      })
-    );
-  }
+export const selectPage = results => dispatch => {
+  dispatch({
+    type: SELECT_ROWS,
+    payload: results.map(row => row.id),
+  });
+  dispatch({
+    type: OPEN_SELECT_ALL,
+  });
 };
 
-export const selectAllRows = results => ({
-  type: SELECT_ROWS,
-  payload: results.map(row => row.id),
+export const selectAllRows = () => ({
+  type: SELECT_ALL_ROWS,
 });
 
 export const unselectAllRows = () => ({
@@ -89,54 +81,23 @@ 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 actionSelected = (actionType, selected, url) => async dispatch => {
-  let notAllActionable = false;
-  let someActionable = false;
-  const promises = selected.map(task => {
-    if (actionType === RESUME && task.isResumeble) {
-      someActionable = true;
-      return dispatch(resumeTaskRequest(task.id, task.name, url));
-    } else if (actionType === CANCEL && task.isCancelleble) {
-      someActionable = true;
-      return dispatch(cancelTaskRequest(task.id, task.name, url));
-    }
-    notAllActionable = true;
-    return null;
-  });
-  if (notAllActionable)
-    dispatch(
-      addToast({
-        type: 'warning',
-        message: __(
-          `Not all the selected tasks can be ${
-            actionType === RESUME ? 'resumed' : 'canceled'
-          }`
-        ),
-      })
-    );
-  if (someActionable) {
-    await Promise.all(promises);
-    dispatch(getTableItems(url));
-    dispatch(fetchTasksSummary(getURIQuery(url).time));
-  }
+export const openClickedModal = ({ taskId, taskName, setModalOpen }) => {
+  setModalOpen();
+  return {
+    type: UPDATE_CLICKED,
+    payload: { clicked: { taskId, taskName } },
+  };
 };
 
-export const showCancelSelcetedModal = () => ({
-  type: TASKS_TABLE_SELECTED_MODAL,
-  payload: CANCEL,
-});
-
-export const showResumeSelcetedModal = () => ({
-  type: TASKS_TABLE_SELECTED_MODAL,
-  payload: RESUME,
-});
-
-export const hideSelcetedModal = () => ({
-  type: TASKS_TABLE_SELECTED_MODAL,
-  payload: CLOSED,
-});
+export const openModalAction = (modalID, setModalOpen) => {
+  setModalOpen();
+  return {
+    type: UPDATE_MODAL,
+    payload: { modalID },
+  };
+};

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

@@ -1,15 +1,28 @@
 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 CANCEL = 'CANCEL';
-export const RESUME = 'RESUME';
-export const CLOSED = 'CLOSED';
+export const SELECT_ALL_ROWS = 'SELECT_ALL_ROWS';
+export const OPEN_SELECT_ALL = 'OPEN_SELECT_ALL';
+
+export const BULK_CANCEL_PATH = 'bulk_cancel';
+export const BULK_RESUME_PATH = 'bulk_resume';
+export const BULK_FORCE_CANCEL_PATH = 'bulk_stop';
+
+export const CANCEL_MODAL = 'cancelConfirmModal';
+export const RESUME_MODAL = 'resumeConfirmModal';
+export const CANCEL_SELECTED_MODAL = 'cancelSelectedConfirmModal';
+export const RESUME_SELECTED_MODAL = 'resumeSelectedConfirmModal';
+export const CONFIRM_MODAL = 'ConfirmModal';
+export const FORCE_UNLOCK_SELECTED_MODAL = 'forceUnlockSelectedConfirmModal';
+
+export const UPDATE_CLICKED = 'UPDATE_CLICKED';
+export const UPDATE_MODAL = 'UPDATE_MODAL';
 
-export const TASKS_TABLE_SELECTED_MODAL = 'TASKS_TABLE_SELECTED_MODAL';
 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

@@ -7,69 +7,72 @@ import { translate as __ } from 'foremanReact/common/I18n';
 import { getURIQuery } from 'foremanReact/common/helpers';
 import ExportButton from 'foremanReact/routes/common/PageLayout/components/ExportButton/ExportButton';
 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 { CancelResumeConfirm } from './Components/CancelResumeConfirm';
+import { resolveSearchQuery, getCSVurl } from './TasksTableHelpers';
+import ConfirmModal from './Components/ConfirmModal/';
 import {
   TASKS_SEARCH_PROPS,
-  RESUME,
-  CANCEL,
-  CLOSED,
+  CANCEL_SELECTED_MODAL,
+  RESUME_SELECTED_MODAL,
+  FORCE_UNLOCK_SELECTED_MODAL,
+  CONFIRM_MODAL,
 } from './TasksTableConstants';
 import { ActionSelectButton } from './Components/ActionSelectButton';
 import './TasksTablePage.scss';
+import { SelectAllAlert } from './Components/SelectAllAlert';
 
-const TasksTablePage = ({ getBreadcrumbs, history, ...props }) => {
+const TasksTablePage = ({
+  getBreadcrumbs,
+  history,
+  createHeader,
+  selectAllRows,
+  showSelectAll,
+  modalID,
+  openModalAction,
+  ...props
+}) => {
   const url = history.location.pathname + history.location.search;
   const uriQuery = getURIQuery(url);
   const onSearch = searchQuery => {
     resolveSearchQuery(searchQuery, history);
-    props.getTableItems(url);
   };
 
-  const getSelected = () => {
-    const selected = props.results.filter(item =>
-      props.selectedRows.includes(item.id)
-    );
-    return selected.map(item => ({
-      name: item.action,
-      id: item.id,
-      isCancelleble: item.availableActions.cancellable,
-      isResumeble: item.availableActions.resumable,
-    }));
-  };
+  const { setModalOpen, setModalClosed } = useForemanModal({
+    id: CONFIRM_MODAL,
+  });
 
-  const TaskSelectedAction = (id, name) => {
-    props.actionSelected(id, name, url);
-  };
+  const openModal = id => openModalAction(id, setModalOpen);
 
   return (
     <div className="tasks-table-wrapper">
-      <CancelResumeConfirm
-        closeModal={props.hideSelcetedModal}
-        action={TaskSelectedAction}
-        selected={getSelected()}
-        modalStatus={props.modalStatus}
-        selectedRowsLen={props.selectedRows.length}
+      <ConfirmModal
+        id={CONFIRM_MODAL}
+        url={url}
+        parentTaskID={props.parentTaskID}
+        uriQuery={uriQuery}
+        setModalClosed={setModalClosed}
       />
       <PageLayout
         searchable
         searchProps={TASKS_SEARCH_PROPS}
         onSearch={onSearch}
+        header={createHeader(props.actionName)}
         breadcrumbOptions={getBreadcrumbs(props.actionName)}
         toastNotifications="foreman-tasks-cancel"
         toolbarButtons={
           <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}
-              onCancel={props.showCancelSelcetedModal}
-              onResume={props.showResumeSelcetedModal}
+              disabled={!(props.selectedRows.length || props.allRowsSelected)}
+              onCancel={() => openModal(CANCEL_SELECTED_MODAL)}
+              onResume={() => openModal(RESUME_SELECTED_MODAL)}
+              onForceCancel={() => openModal(FORCE_UNLOCK_SELECTED_MODAL)}
             />
           </React.Fragment>
         }
@@ -78,34 +81,58 @@ const TasksTablePage = ({ getBreadcrumbs, history, ...props }) => {
           <TasksDashboard history={history} parentTaskID={props.parentTaskID} />
         }
       >
-        <TasksTable history={history} {...props} />
+        <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} openModal={openModal} />
+        </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,
   actionName: PropTypes.string,
   status: PropTypes.oneOf(Object.keys(STATUS)),
   history: PropTypes.object.isRequired,
-  actionSelected: PropTypes.func.isRequired,
   selectedRows: PropTypes.arrayOf(PropTypes.string),
-  showResumeSelcetedModal: PropTypes.func.isRequired,
-  showCancelSelcetedModal: PropTypes.func.isRequired,
-  hideSelcetedModal: PropTypes.func.isRequired,
-  modalStatus: PropTypes.oneOf([CANCEL, RESUME, CLOSED]),
   parentTaskID: PropTypes.string,
+  createHeader: PropTypes.func,
+  modalID: PropTypes.string,
+  openModalAction: PropTypes.func.isRequired,
+  showSelectAll: PropTypes.bool,
+  unselectAllRows: PropTypes.func.isRequired,
 };
 
 TasksTablePage.defaultProps = {
+  pagination: {
+    page: 1,
+    perPage: 20,
+  },
+  allRowsSelected: false,
   actionName: '',
   status: STATUS.PENDING,
   selectedRows: [],
-  modalStatus: CLOSED,
   parentTaskID: null,
+  createHeader: () => __('Tasks'),
+  showSelectAll: false,
+  modalID: '',
 };
 
 export default TasksTablePage;