katello 3.13.4 → 3.14.0.rc1

data/webpack/scenes/Subscriptions/SubscriptionReducer.js

@@ -1,6 +1,8 @@
 import Immutable from 'seamless-immutable';
+import { get } from 'lodash';
 import { GET_SETTING_SUCCESS } from 'foremanReact/components/Settings/SettingsConstants';
 import { initialApiState } from '../../services/api';
+
 import { TASK_BULK_SEARCH_SUCCESS, RESET_TASKS, GET_TASK_SUCCESS } from '../Tasks/TaskConstants';
 
 import {
@@ -58,11 +60,24 @@ export default (state = initialState, action) => {
         .set('selectedTableColumns', action.payload.enabledColumns);
     case SUBSCRIPTIONS_SUCCESS: {
       const {
-        page, per_page, subtotal, results, // eslint-disable-line camelcase
+        page,
+        per_page, // eslint-disable-line camelcase
+        subtotal,
+        results,
+        can_import_manifest, // eslint-disable-line camelcase
+        can_delete_manifest, // eslint-disable-line camelcase
+        can_manage_subscription_allocations, // eslint-disable-line camelcase
+        can_edit_organizations, // eslint-disable-line camelcase
       } = action.response;
 
       return state.merge({
         results,
+        activePermissions: {
+          can_import_manifest,
+          can_delete_manifest,
+          can_manage_subscription_allocations,
+          can_edit_organizations,
+        },
         loading: false,
         searchIsActive: !!action.search,
         search: action.search,
@@ -85,7 +100,11 @@ export default (state = initialState, action) => {
       return state
         .set('loading', false)
         .set('results', [])
-        .set('itemCount', 0);
+        .set('itemCount', 0)
+        .set(
+          'missingPermissions',
+          get(action, ['payload', 'messages', 0, 'missing_permissions']),
+        );
 
     case UPDATE_QUANTITY_FAILURE:
     case DELETE_SUBSCRIPTIONS_FAILURE:

data/webpack/scenes/Subscriptions/SubscriptionsPage.js

@@ -2,9 +2,11 @@ import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import Immutable from 'seamless-immutable';
 import { translate as __ } from 'foremanReact/common/I18n';
+import { propsToCamelCase } from 'foremanReact/common/helpers';
 import { isEmpty, isEqual } from 'lodash';
 import { Grid, Row, Col } from 'patternfly-react';
 import ModalProgressBar from 'foremanReact/components/common/ModalProgressBar';
+import PermissionDenied from 'foremanReact/components/PermissionDenied';
 import { renderTaskFinishedToast, renderTaskStartedToast } from '../Tasks/helpers';
 import ManageManifestModal from './Manifest/';
 import { SubscriptionsTable } from './components/SubscriptionsTable';
@@ -12,7 +14,6 @@ import SubscriptionsToolbar from './components/SubscriptionsToolbar';
 import { manifestExists } from './SubscriptionHelpers';
 import api, { orgId } from '../../services/api';
 
-
 import { createSubscriptionParams } from './SubscriptionActions.js';
 import {
   BLOCKING_FOREMAN_TASK_TYPES,
@@ -23,17 +24,10 @@ import {
 import './SubscriptionsPage.scss';
 
 class SubscriptionsPage extends Component {
-  constructor(props) {
-    super(props);
-
-    this.uploadManifest = this.uploadManifest.bind(this);
-    this.deleteManifest = this.deleteManifest.bind(this);
-    this.refreshManifest = this.refreshManifest.bind(this);
-  }
-
   componentDidMount() {
     this.props.resetTasks();
     this.props.loadSetting('content_disconnected');
+    this.props.loadSubscriptions();
   }
 
   componentDidUpdate(prevProps) {
@@ -100,7 +94,7 @@ class SubscriptionsPage extends Component {
     return disabledReason;
   }
 
-  pollTasks() {
+  async pollTasks() {
     const { pollBulkSearch, organization } = this.props;
 
     if (organization && organization.owner_details) {
@@ -113,51 +107,53 @@ class SubscriptionsPage extends Component {
 
     this.props.loadSetting('content_disconnected');
     this.props.loadSubscriptions();
-    this.props.loadTables().then(() => {
-      const { subscriptionTableSettings, loadTableColumns } = this.props;
-      loadTableColumns(subscriptionTableSettings);
-    });
+    await this.props.loadTables();
+    const { subscriptionTableSettings, loadTableColumns } = this.props;
+    loadTableColumns(subscriptionTableSettings);
   }
 
-  handleDoneTask(taskToPoll) {
+  async handleDoneTask(taskToPoll) {
     const POLL_TASK_INTERVAL = 5000;
     const { pollTaskUntilDone, loadSubscriptions, organization } = this.props;
 
-    pollTaskUntilDone(taskToPoll.id, {}, POLL_TASK_INTERVAL, organization.id)
-      .then((task) => {
-        renderTaskFinishedToast(task);
-        loadSubscriptions();
-        this.setState({ pollingATask: false });
-      });
+    const task = await pollTaskUntilDone(taskToPoll.id, {}, POLL_TASK_INTERVAL, organization.id);
+    renderTaskFinishedToast(task);
+    loadSubscriptions();
+    this.setState({ pollingATask: false });
   }
 
-  manifestAction(callback, file = undefined) {
-    const { openTaskModal } = this.props;
-
-    openTaskModal();
-
+  startManifestTask = () => {
+    this.props.openTaskModal();
     this.setState({
       pollingATask: true,
     });
-    callback(file)
-      .then(() => renderTaskStartedToast(this.props.taskDetails))
-      .then(() =>
-        setTimeout(() => this.props.bulkSearch({
-          action: `organization '${this.props.organization.owner_details.displayName}'`,
-          result: 'pending',
-          label: BLOCKING_FOREMAN_TASK_TYPES.join(' or '),
-        })), 100);
-  }
-  uploadManifest = (file) => {
-    this.manifestAction(this.props.uploadManifest, file);
   };
 
-  deleteManifest = () => {
-    this.manifestAction(this.props.deleteManifest);
+  cleanUpManifestTask = async () => {
+    await renderTaskStartedToast(this.props.taskDetails);
+    setTimeout(() => this.props.bulkSearch({
+      action: `organization '${this.props.organization.owner_details.displayName}'`,
+      result: 'pending',
+      label: BLOCKING_FOREMAN_TASK_TYPES.join(' or '),
+    }), 100);
+  };
+
+  uploadManifest = async (file) => {
+    this.startManifestTask();
+    await this.props.uploadManifest(file);
+    this.cleanUpManifestTask();
+  };
+
+  deleteManifest = async () => {
+    this.startManifestTask();
+    await this.props.deleteManifest();
+    this.cleanUpManifestTask();
   };
 
-  refreshManifest = () => {
-    this.manifestAction(this.props.refreshManifest);
+  refreshManifest = async () => {
+    this.startManifestTask();
+    await this.props.refreshManifest();
+    this.cleanUpManifestTask();
   };
 
   render() {
@@ -168,8 +164,20 @@ class SubscriptionsPage extends Component {
       deleteButtonDisabled, disableDeleteButton, enableDeleteButton,
       searchQuery, updateSearchQuery,
       taskModalOpened,
-      tasks = [], subscriptions, organization, subscriptionTableSettings,
+      tasks = [], activePermissions, subscriptions, organization, subscriptionTableSettings,
     } = this.props;
+    // Basic permissions - should we even show this page?
+    if (subscriptions.missingPermissions && subscriptions.missingPermissions.length > 0) {
+      return <PermissionDenied missingPermissions={subscriptions.missingPermissions} />;
+    }
+    // Granular permissions
+    const permissions = propsToCamelCase(activePermissions);
+    const {
+      canDeleteManifest,
+      canManageSubscriptionAllocations,
+      canImportManifest,
+      canEditOrganizations,
+    } = permissions;
     const { disconnected } = subscriptions;
     const taskInProgress = tasks.length > 0;
     const disableManifestActions = taskInProgress || disconnected;
@@ -246,6 +254,7 @@ class SubscriptionsPage extends Component {
             <h1>{__('Subscriptions')}</h1>
 
             <SubscriptionsToolbar
+              canManageSubscriptionAllocations={canManageSubscriptionAllocations}
               disableManifestActions={disableManifestActions}
               disableManifestReason={this.getDisabledReason()}
               disableDeleteButton={deleteButtonDisabled}
@@ -263,6 +272,9 @@ class SubscriptionsPage extends Component {
             />
 
             <ManageManifestModal
+              canImportManifest={canImportManifest}
+              canDeleteManifest={canDeleteManifest}
+              canEditOrganizations={canEditOrganizations}
               showModal={manifestModalOpened}
               taskInProgress={taskInProgress}
               disableManifestActions={disableManifestActions}
@@ -275,6 +287,7 @@ class SubscriptionsPage extends Component {
 
             <div id="subscriptions-table" className="modal-container">
               <SubscriptionsTable
+                canManageSubscriptionAllocations={canManageSubscriptionAllocations}
                 loadSubscriptions={this.props.loadSubscriptions}
                 tableColumns={columns}
                 updateQuantity={this.props.updateQuantity}
@@ -313,7 +326,12 @@ SubscriptionsPage.propTypes = {
     disconnected: PropTypes.bool,
     tableColumns: PropTypes.array,
     selectedTableColumns: PropTypes.array,
+    missingPermissions: PropTypes.array,
   }).isRequired,
+  activePermissions: PropTypes.shape({
+    can_delete_manifest: PropTypes.bool,
+    can_manage_subscription_allocations: PropTypes.bool,
+  }),
   organization: PropTypes.shape({
     id: PropTypes.number,
     owner_details: PropTypes.shape({
@@ -358,6 +376,10 @@ SubscriptionsPage.defaultProps = {
   taskModalOpened: false,
   deleteButtonDisabled: true,
   subscriptionTableSettings: {},
+  activePermissions: {
+    can_import_manifest: false,
+    can_manage_subscription_allocations: false,
+  },
 };
 
 export default SubscriptionsPage;

data/webpack/scenes/Subscriptions/SubscriptionsSelectors.js

@@ -16,6 +16,9 @@ export const selectTaskModalOpened = state =>
 export const selectDeleteButtonDisabled = state =>
   selectSubscriptionsState(state).deleteButtonDisabled;
 
+export const selectActivePermissions = state =>
+  selectSubscriptionsState(state).activePermissions;
+
 export const selectSubscriptionsTasks = state =>
   selectSubscriptionsState(state).tasks;
 

data/webpack/scenes/Subscriptions/UpstreamSubscriptions/UpstreamSubscriptionsActions.js

@@ -12,7 +12,7 @@ import {
   SAVE_UPSTREAM_SUBSCRIPTIONS_FAILURE,
 } from './UpstreamSubscriptionsContstants';
 
-export const loadUpstreamSubscriptions = (extendedParams = {}) => (dispatch) => {
+export const loadUpstreamSubscriptions = (extendedParams = {}) => async (dispatch) => {
   dispatch({ type: UPSTREAM_SUBSCRIPTIONS_REQUEST });
 
   const params = {
@@ -20,34 +20,34 @@ export const loadUpstreamSubscriptions = (extendedParams = {}) => (dispatch) =>
     ...propsToSnakeCase(extendedParams),
   };
 
-  return api
-    .get(`/organizations/${orgId()}/upstream_subscriptions`, {}, params)
-    .then(({ data }) => {
-      dispatch({
-        type: UPSTREAM_SUBSCRIPTIONS_SUCCESS,
-        response: data,
-        search: extendedParams.search,
-      });
-    })
-    .catch(result => dispatch(apiError(UPSTREAM_SUBSCRIPTIONS_FAILURE, result)));
+  try {
+    const { data } = await api.get(`/organizations/${orgId()}/upstream_subscriptions`, {}, params);
+    return dispatch({
+      type: UPSTREAM_SUBSCRIPTIONS_SUCCESS,
+      response: data,
+      search: extendedParams.search,
+    });
+  } catch (error) {
+    return dispatch(apiError(UPSTREAM_SUBSCRIPTIONS_FAILURE, error));
+  }
 };
 
-export const saveUpstreamSubscriptions = upstreamSubscriptions => (dispatch) => {
+export const saveUpstreamSubscriptions = upstreamSubscriptions => async (dispatch) => {
   dispatch({ type: SAVE_UPSTREAM_SUBSCRIPTIONS_REQUEST });
 
   const params = {
     ...propsToSnakeCase(upstreamSubscriptions),
   };
 
-  return api
-    .post(`/organizations/${orgId()}/upstream_subscriptions`, params)
-    .then(({ data }) => {
-      dispatch({
-        type: SAVE_UPSTREAM_SUBSCRIPTIONS_SUCCESS,
-        response: data,
-      });
-    })
-    .catch(result => dispatch(apiError(SAVE_UPSTREAM_SUBSCRIPTIONS_FAILURE, result)));
+  try {
+    const { data } = await api.post(`/organizations/${orgId()}/upstream_subscriptions`, params);
+    return dispatch({
+      type: SAVE_UPSTREAM_SUBSCRIPTIONS_SUCCESS,
+      response: data,
+    });
+  } catch (error) {
+    return dispatch(apiError(SAVE_UPSTREAM_SUBSCRIPTIONS_FAILURE, error));
+  }
 };
 
 export default loadUpstreamSubscriptions;

data/webpack/scenes/Subscriptions/UpstreamSubscriptions/UpstreamSubscriptionsPage.js

@@ -78,7 +78,6 @@ class UpstreamSubscriptionsPage extends Component {
     );
   }
 
-
   quantityValidationInput = (pool) => {
     if (!pool || pool.updatedQuantity === undefined) return null;
     if (this.quantityValidation(pool)[0]) {
@@ -91,7 +90,7 @@ class UpstreamSubscriptionsPage extends Component {
     this.state.selectedRows.length &&
     this.state.selectedRows.every(pool => this.quantityValidation(pool)[0]);
 
-  saveUpstreamSubscriptions = () => {
+  saveUpstreamSubscriptions = async () => {
     const updatedPools = _.map(
       this.state.selectedRows,
       pool => ({ ...pool, quantity: parseInt(pool.updatedQuantity, 10) }),
@@ -99,24 +98,23 @@ class UpstreamSubscriptionsPage extends Component {
 
     const updatedSubscriptions = { pools: updatedPools };
 
-    this.props.saveUpstreamSubscriptions(updatedSubscriptions).then(() => {
-      const { task } = this.props.upstreamSubscriptions;
-
-      // TODO: could probably factor this out into a task response component
-      if (task) {
-        const message = (
-          <span>
-            <span>{__('Subscriptions have been saved and are being updated. ')}</span>
-            <a href={urlBuilder('foreman_tasks/tasks', '', task.id)}>
-              {__('Click here to go to the tasks page for the task.')}
-            </a>
-          </span>
-        );
-
-        window.tfm.toastNotifications.notify({ message, type: 'success' });
-        this.props.history.push('/subscriptions');
-      }
-    });
+    await this.props.saveUpstreamSubscriptions(updatedSubscriptions);
+    const { task } = this.props.upstreamSubscriptions;
+
+    // TODO: could probably factor this out into a task response component
+    if (task) {
+      const message = (
+        <span>
+          <span>{__('Subscriptions have been saved and are being updated. ')}</span>
+          <a href={urlBuilder('foreman_tasks/tasks', '', task.id)}>
+            {__('Click here to go to the tasks page for the task.')}
+          </a>
+        </span>
+      );
+
+      window.tfm.toastNotifications.notify({ message, type: 'success' });
+      this.props.history.push('/subscriptions');
+    }
   };
 
   loadData() {
@@ -134,6 +132,7 @@ class UpstreamSubscriptionsPage extends Component {
           <Row>
             <Col sm={12}>
               <Button
+                style={{ marginTop: '10px', marginRight: '5px' }}
                 bsStyle="primary"
                 type="submit"
                 disabled={upstreamSubscriptions.loading ||
@@ -143,7 +142,7 @@ class UpstreamSubscriptionsPage extends Component {
                 {__('Submit')}
               </Button>
 
-              <LinkContainer to="/subscriptions">
+              <LinkContainer to="/subscriptions" style={{ marginTop: '10px' }}>
                 <Button>
                   {__('Cancel')}
                 </Button>

data/webpack/scenes/Subscriptions/UpstreamSubscriptions/UpstreamSubscriptionsTableSchema.js

@@ -4,23 +4,9 @@ import { translate as __ } from 'foremanReact/common/I18n';
 import {
   headerFormatter,
   cellFormatter,
-  selectionHeaderCellFormatter,
-  selectionCellFormatter,
 } from '../../../move_to_foreman/components/common/table';
 
-export const columns = (controller, selectionController) => [
-  {
-    property: 'select',
-    header: {
-      label: __('Select all rows'),
-      formatters: [label => selectionHeaderCellFormatter(selectionController, label)],
-    },
-    cell: {
-      formatters: [
-        (value, additionalData) => selectionCellFormatter(selectionController, additionalData),
-      ],
-    },
-  },
+export const columns = controller => [
   {
     property: 'id',
     header: {

data/webpack/scenes/Subscriptions/UpstreamSubscriptions/__tests__/UpstreamSubscriptionsActions.test.js

@@ -25,21 +25,20 @@ describe('upstream subscription actions', () => {
   const url = '/katello/api/v2/organizations/1/upstream_subscriptions';
 
   describe('creates UPSTREAM_SUBSCRIPTIONS_REQUEST', () => {
-    it('and then fails with 422', () => {
+    it('and then fails with 422', async () => {
       mockErrorRequest({
         url,
         status: 422,
       });
-
-      return store.dispatch(loadUpstreamSubscriptions())
-        .then(() => expect(store.getActions()).toEqual(getFailureActions));
+      await store.dispatch(loadUpstreamSubscriptions());
+      expect(store.getActions()).toEqual(getFailureActions);
     });
 
-    it('and ends with success', () => {
+    it('and ends with success', async () => {
       mockApi.onGet(url).reply(200, requestSuccessResponse);
 
-      return store.dispatch(loadUpstreamSubscriptions())
-        .then(() => expect(store.getActions()).toEqual(getSuccessActions));
+      await store.dispatch(loadUpstreamSubscriptions());
+      expect(store.getActions()).toEqual(getSuccessActions);
     });
   });
 
@@ -48,22 +47,22 @@ describe('upstream subscription actions', () => {
       pools: [{ id: 'abcde', quantity: 100 }],
     };
 
-    it('and then fails with 422', () => {
+    it('and then fails with 422', async () => {
       mockErrorRequest({
         url,
         status: 422,
         method: 'POST',
       });
 
-      return store.dispatch(saveUpstreamSubscriptions(subscriptionData))
-        .then(() => expect(store.getActions()).toEqual(saveFailureActions));
+      await store.dispatch(saveUpstreamSubscriptions(subscriptionData));
+      expect(store.getActions()).toEqual(saveFailureActions);
     });
 
-    it('and ends with success', () => {
+    it('and ends with success', async () => {
       mockApi.onPost(url).reply(200, getTaskSuccessResponse);
 
-      return store.dispatch(saveUpstreamSubscriptions(subscriptionData))
-        .then(() => expect(store.getActions()).toEqual(saveSuccessActions));
+      await store.dispatch(saveUpstreamSubscriptions(subscriptionData));
+      expect(store.getActions()).toEqual(saveSuccessActions);
     });
   });
 });