foreman-tasks 0.17.0 → 0.17.1

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

@@ -0,0 +1,67 @@
+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 } from './TasksTableConstants';
+import { getApiPathname } from './TasksTableHelpers';
+import { fetchTasksSummary } from '../TasksDashboard/TasksDashboardActions';
+
+export const getTableItems = url =>
+  getTableItemsAction(TASKS_TABLE_ID, getURIQuery(url), getApiPathname(url));
+
+export const cancelTask = (id, name, url) => async dispatch => {
+  await dispatch(cancelTaskRequest(id, name));
+  dispatch(getTableItems(url));
+  dispatch(fetchTasksSummary(getURIQuery(url).time));
+};
+
+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 resumeTask = (id, name, url) => async dispatch => {
+  await dispatch(resumeTaskRequest(id, name));
+  dispatch(getTableItems(url));
+  dispatch(fetchTasksSummary(getURIQuery(url).time));
+};
+
+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.`),
+      })
+    );
+  }
+};

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

@@ -0,0 +1,5 @@
+import { getControllerSearchProps } from 'foremanReact/constants';
+
+export const TASKS_TABLE_ID = 'TASKS_TABLE';
+
+export const TASKS_SEARCH_PROPS = getControllerSearchProps('tasks');

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

@@ -0,0 +1,64 @@
+import URI from 'urijs';
+import { translate as __, documentLocale } from 'foremanReact/common/I18n';
+import humanizeDuration from 'humanize-duration';
+import { isoCompatibleDate } from 'foremanReact/common/helpers';
+
+export const updateURlQuery = (query, history) => {
+  const uri = new URI(history.location.pathname + history.location.search);
+  uri.setSearch(query);
+  history.push(uri.search());
+};
+
+export const getApiPathname = url => {
+  const uri = new URI(url);
+  return uri.pathname().replace('foreman_tasks/', 'foreman_tasks/api/');
+};
+
+export const resolveSearchQuery = (search, history) => {
+  const uriQuery = {
+    search,
+    page: 1,
+  };
+  updateURlQuery(uriQuery, history);
+};
+
+export const addSearchToURL = (path, query) => {
+  const url = new URI(path);
+  url.addSearch({ ...query, include_permissions: true });
+  return url.toString();
+};
+
+export const getDuration = (start, finish) => {
+  if (!start && !finish)
+    return { text: __('N/A'), tooltip: __('No start or end dates') };
+
+  if (!start && finish) {
+    return { text: __('N/A'), tooltip: __('Task was canceled') };
+  }
+
+  const dateOptions = {
+    largest: 1,
+    language: documentLocale(),
+    fallbacks: ['en'],
+    round: true,
+  };
+
+  const startDate = new Date(isoCompatibleDate(start));
+
+  if (!finish) {
+    const finishDate = new Date();
+    const duration = finishDate - startDate;
+    return {
+      text: `${__('More than')} ${humanizeDuration(duration, dateOptions)}`,
+    };
+  }
+
+  const finishDate = new Date(isoCompatibleDate(finish));
+  const duration = finishDate - startDate;
+  return {
+    text:
+      duration > 0 && duration < 1000
+        ? __('Less than a second')
+        : humanizeDuration(duration, dateOptions),
+  };
+};

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

@@ -0,0 +1,63 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { getURIsearch } from 'foremanReact/common/urlHelpers';
+import { Spinner } from 'patternfly-react';
+import PageLayout from 'foremanReact/routes/common/PageLayout/PageLayout';
+import { getURIQuery } from 'foremanReact/common/helpers';
+import ExportButton from 'foremanReact/routes/common/PageLayout/components/ExportButton/ExportButton';
+import { STATUS } from 'foremanReact/constants';
+import TasksDashboard from '../TasksDashboard';
+import TasksTable from './TasksTable';
+import { resolveSearchQuery, addSearchToURL } from './TasksTableHelpers';
+import { TASKS_SEARCH_PROPS } from './TasksTableConstants';
+import './TasksTablePage.scss';
+
+const TasksTablePage = ({ getBreadcrumbs, history, ...props }) => {
+  const url = history.location.pathname + history.location.search;
+  const uriQuery = getURIQuery(url);
+  const onSearch = searchQuery => {
+    resolveSearchQuery(searchQuery, history);
+    props.getTableItems(url);
+  };
+
+  return (
+    <div className="tasks-table-wrapper">
+      <PageLayout
+        searchable
+        searchProps={TASKS_SEARCH_PROPS}
+        onSearch={onSearch}
+        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)}
+            />
+          </React.Fragment>
+        }
+        searchQuery={getURIsearch()}
+        beforeToolbarComponent={<TasksDashboard history={history} />}
+      >
+        <TasksTable history={history} {...props} />
+      </PageLayout>
+    </div>
+  );
+};
+
+TasksTablePage.propTypes = {
+  getTableItems: PropTypes.func.isRequired,
+  getBreadcrumbs: PropTypes.func.isRequired,
+  actionName: PropTypes.string,
+  isSubTask: PropTypes.bool,
+  status: PropTypes.oneOf(Object.keys(STATUS)),
+  history: PropTypes.object.isRequired,
+};
+
+TasksTablePage.defaultProps = {
+  actionName: '',
+  isSubTask: false,
+  status: STATUS.PENDING,
+};
+
+export default TasksTablePage;

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

@@ -0,0 +1,29 @@
+.tasks-pagination {
+  margin-top: -6px;
+}
+.tasks-table {
+  margin-bottom: 70px;
+}
+
+.tasks-table-wrapper {
+  .export-csv {
+    float: right;
+  }
+  .search-bar {
+    padding-bottom: 20px;
+  }
+}
+
+.param-name {
+  display: inline-block;
+  width: 10em;
+}
+
+.task-details pre {
+  white-space: pre;
+  word-break: normal;
+}
+
+.tasks-time-row .time-label {
+  float: left;
+}

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

@@ -0,0 +1,35 @@
+import Immutable from 'seamless-immutable';
+import { combineReducers } from 'redux';
+import { createTableReducer } from 'foremanReact/components/common/table';
+import createTableActionTypes from 'foremanReact/components/common/table/actionsHelpers/actionTypeCreator';
+import { TASKS_TABLE_ID } from './TasksTableConstants';
+
+export const TasksTableQueryReducer = (state = {}, action) => {
+  const {
+    type,
+    payload: {
+      subtotal,
+      page,
+      per_page: perPageString,
+      action_name: actionName,
+    } = {},
+  } = action;
+  const ACTION_TYPES = createTableActionTypes(TASKS_TABLE_ID);
+  switch (type) {
+    case ACTION_TYPES.SUCCESS:
+      return Immutable.merge(state, {
+        itemCount: subtotal,
+        actionName,
+        pagination: {
+          page: Number(page),
+          perPage: Number(perPageString),
+        },
+      });
+    default:
+      return state;
+  }
+};
+export default combineReducers({
+  tasksTableContent: createTableReducer(TASKS_TABLE_ID),
+  tasksTableQuery: TasksTableQueryReducer,
+});

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

@@ -0,0 +1,67 @@
+import {
+  column,
+  sortableColumn,
+  headerFormatterWithProps,
+  cellFormatter,
+} from 'foremanReact/components/common/table';
+import { translate as __ } from 'foremanReact/common/I18n';
+import {
+  dateCellFormmatter,
+  actionCellFormatter,
+  actionNameCellFormatter,
+  durationCellFormmatter,
+} from './TaskTableFormmatters';
+
+const headFormat = [headerFormatterWithProps];
+const cellFormat = [cellFormatter];
+
+/**
+ * Generate a table schema to the Hardware Tasks page.
+ * @param  {Function} setSort          a Redux async action that sets new sort values
+ * @param  {String}   by               by which column the table is sorted.
+ *                                     If none then set it to undefined/null.
+ * @param  {String}   order            in what order to sort a column. If none then set it to undefined/null.
+ *                                     Otherwise, 'ASC' for ascending and 'DESC' for descending
+ * @param  {function} cancelTask       A function to run when the cancel cell is clicked
+ * @return {Array}
+ */
+const createTasksTableSchema = (setSort, by, order, taskActions) => {
+  const sortController = {
+    apply: setSort,
+    property: by,
+    order,
+  };
+
+  return [
+    column(
+      'action',
+      __('Action'),
+      headFormat,
+      [actionNameCellFormatter('foreman_tasks/tasks')],
+      { className: 'col-md-4' }
+    ),
+    column('state', __('State'), headFormat, cellFormat, {
+      className: 'col-md-1',
+    }),
+    column('result', __('Result'), headFormat, cellFormat, {
+      className: 'col-md-1',
+    }),
+    sortableColumn('started_at', __('Started at'), 3, sortController, [
+      dateCellFormmatter,
+    ]),
+    sortableColumn('duration', __('Duration'), 3, sortController, [
+      durationCellFormmatter,
+    ]),
+    column(
+      'available_actions',
+      __('Operation'),
+      headFormat,
+      [actionCellFormatter(taskActions)],
+      {
+        className: 'col-md-1',
+      }
+    ),
+  ];
+};
+
+export default createTasksTableSchema;

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

@@ -0,0 +1,39 @@
+import { translate as __ } from 'foremanReact/common/I18n';
+import { selectForemanTasks } from '../../ForemanTasksSelectors';
+import { getDuration } from './TasksTableHelpers';
+
+export const selectTasksTable = state =>
+  selectForemanTasks(state).tasksTable || {};
+
+export const selectTasksTableContent = state =>
+  selectTasksTable(state).tasksTableContent || {};
+
+export const selectTasksTableQuery = state =>
+  selectTasksTable(state).tasksTableQuery || {};
+
+export const selectPagitation = state =>
+  selectTasksTableQuery(state).pagination || {};
+
+export const selectItemCount = state =>
+  selectTasksTableQuery(state).itemCount || 0;
+
+export const selectActionName = state =>
+  selectTasksTableQuery(state).actionName || '';
+
+export const selectResults = state => {
+  const { results } = selectTasksTableContent(state);
+  if (!results) return [];
+  return results.map(result => ({
+    ...result,
+    username: result.username || '',
+    state: result.state + (result.frozen ? ` ${__('Disabled')}` : ''),
+    duration: getDuration(result.started_at, result.ended_at),
+  }));
+};
+
+export const selectStatus = state => selectTasksTableContent(state).status;
+
+export const selectError = state => selectTasksTableContent(state).error;
+
+export const selectSort = state =>
+  selectTasksTableQuery(state).sort || { by: 'started_at', order: 'DESC' };

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

@@ -0,0 +1,20 @@
+import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+import { SubTasksPage } from '../SubTasksPage';
+import { minProps } from './TasksTable.fixtures';
+
+const fixtures = {
+  'render with minimal props': {
+    ...minProps,
+
+    match: {
+      params: {
+        id: 'some-id',
+      },
+    },
+  },
+};
+
+describe('SubTasksPage', () => {
+  describe('rendering', () =>
+    testComponentSnapshotsWithFixtures(SubTasksPage, fixtures));
+});

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

@@ -0,0 +1,12 @@
+import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+import { TasksIndexPage } from '../TasksIndexPage';
+import { minProps } from './TasksTable.fixtures';
+
+const fixtures = {
+  'render with minimal props': minProps,
+};
+
+describe('TasksIndexPage', () => {
+  describe('rendering', () =>
+    testComponentSnapshotsWithFixtures(TasksIndexPage, fixtures));
+});

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

@@ -0,0 +1,42 @@
+import { STATUS } from 'foremanReact/constants';
+
+export const minProps = {
+  getTableItems: jest.fn(),
+  getBreadcrumbs: jest.fn(),
+  itemCount: 2,
+  cancelTask: jest.fn(),
+  resumeTask: jest.fn(),
+  pagination: {
+    page: 1,
+    perPage: 10,
+  },
+  history: { location: { search: '' } },
+  location: { pathname: '' },
+  status: STATUS.RESOLVED,
+  results: ['a', 'b'],
+  sort: {
+    by: 'q',
+    order: 'w',
+  },
+};
+
+export default {
+  'render with minimal Props': {
+    ...minProps,
+  },
+  'render with no results': {
+    ...minProps,
+    results: [],
+    status: STATUS.RESOLVED,
+  },
+  'render with error Props': {
+    ...minProps,
+    results: ['a'],
+    status: STATUS.ERROR,
+  },
+  'render with loading Props': {
+    ...minProps,
+    results: ['a'],
+    status: STATUS.PENDING,
+  },
+};