katello 3.6.0.1.rc2 → 3.7.0.rc1

data/webpack/scenes/Subscriptions/Manifest/__tests__/manifest.fixtures.js

@@ -0,0 +1,216 @@
+import Immutable from 'seamless-immutable';
+
+export const manifestHistoryInitialState = Immutable({
+  loading: true,
+  results: [],
+});
+
+export const manifestHistoryLoadingState = Immutable({
+  loading: true,
+  results: [],
+});
+
+export const manifestHistoryErrorState = Immutable({
+  loading: false,
+  error: 'Unable to process request.',
+  results: [],
+});
+
+export const manifestActionsInitialState = Immutable({
+  pending: false,
+});
+
+export const manifestActionsLoadingState = Immutable({
+  pending: true,
+  progress: 0,
+});
+
+export const manifestActionsErrorState = Immutable({
+  pending: false,
+  error: 'Unable to process request.',
+});
+
+export const manifestHistorySuccessResponse = Immutable([
+  {
+    statusMessage: 'Default_Organization file imported successfully.',
+    status: 'SUCCESS',
+    created: '2018-04-12T18:58:45+0000',
+  },
+  {
+    statusMessage: 'Default_Organization file imported successfully.',
+    status: 'SUCCESS',
+    created: '2018-04-12T14:28:57+0000',
+  },
+  {
+    statusMessage: 'Default_Organization file imported successfully.',
+    status: 'SUCCESS',
+    created: '2018-04-11T14:36:43+0000',
+  },
+  {
+    statusMessage: 'Default_Organization file imported successfully.',
+    status: 'SUCCESS',
+    created: '2018-04-11T04:29:51+0000',
+  },
+  {
+    statusMessage: 'Default_Organization file imported successfully.',
+    status: 'SUCCESS',
+    created: '2018-04-11T04:26:38+0000',
+  },
+  {
+    statusMessage: 'Default_Organization file imported successfully.',
+    status: 'SUCCESS',
+    created: '2018-04-11T04:23:05+0000',
+  },
+  {
+    statusMessage: 'Default_Organization file imported successfully.',
+    status: 'SUCCESS',
+    created: '2018-04-11T04:05:07+0000',
+  },
+  {
+    statusMessage: 'Default_Organization file imported successfully.',
+    status: 'SUCCESS',
+    created: '2018-04-11T03:29:44+0000',
+  },
+  {
+    statusMessage: 'Default_Organization file imported successfully.',
+    status: 'SUCCESS',
+    created: '2018-04-10T18:44:38+0000',
+  },
+  {
+    statusMessage: 'Default_Organization file imported successfully.',
+    status: 'SUCCESS',
+    created: '2018-04-10T18:40:17+0000',
+  },
+]);
+
+export const taskSuccessResponse = Immutable({
+  id: 'c6e7dd0b-1d40-4c75-b1e0-b193c4d0597f',
+  label: 'Actions::Katello::Organization::ManifestRefresh',
+  pending: false,
+  username: 'admin',
+  started_at: '2018-04-15 15:34:37 -0400',
+  ended_at: null,
+  state: 'planned',
+  result: 'pending',
+  progress: 0,
+  input: {
+    organization: {
+      id: 1,
+      name: 'Default Organization',
+      label: 'Default_Organization',
+    },
+    services_checked: [
+      'candlepin',
+      'candlepin_auth',
+      'pulp',
+      'pulp_auth',
+    ],
+    remote_user: 'admin',
+    remote_cp_user: 'admin',
+    locale: 'en',
+    current_user_id: 4,
+  },
+  output: {},
+  humanized: {
+    action: 'Refresh Manifest',
+    input: [
+      [
+        'organization',
+        {
+          text: 'organization \'Default Organization\'',
+          link: '/organizations/1/edit',
+        },
+      ],
+    ],
+    output: '',
+    errors: [],
+  },
+  cli_example: null,
+});
+
+export const manifestHistorySuccessState = Immutable({
+  loading: false,
+  results: manifestHistorySuccessResponse,
+});
+
+export const manifestActionsSuccessState = taskSuccessResponse;
+
+export const manifestHistorySuccessActions = [
+  {
+    type: 'MANIFEST_HISTORY_REQUEST',
+  },
+  {
+    response: manifestHistorySuccessResponse,
+    type: 'MANIFEST_HISTORY_SUCCESS',
+  },
+];
+
+export const manifestHistoryFailureActions = [
+  {
+    type: 'MANIFEST_HISTORY_REQUEST',
+  },
+  {
+    result: new Error('Request failed with status code 422'),
+    type: 'MANIFEST_HISTORY_FAILURE',
+  },
+];
+
+export const uploadManifestSuccessActions = [
+  {
+    type: 'UPLOAD_MANIFEST_REQUEST',
+  },
+  {
+    response: taskSuccessResponse,
+    type: 'UPLOAD_MANIFEST_SUCCESS',
+  },
+];
+
+export const uploadManifestFailureActions = [
+  {
+    type: 'UPLOAD_MANIFEST_REQUEST',
+  },
+  {
+    result: new Error('Request failed with status code 422'),
+    type: 'UPLOAD_MANIFEST_FAILURE',
+  },
+];
+
+export const refreshManifestSuccessActions = [
+  {
+    type: 'REFRESH_MANIFEST_REQUEST',
+  },
+  {
+    response: taskSuccessResponse,
+    type: 'REFRESH_MANIFEST_SUCCESS',
+  },
+];
+
+export const refreshManifestFailureActions = [
+  {
+    type: 'REFRESH_MANIFEST_REQUEST',
+  },
+  {
+    result: new Error('Request failed with status code 422'),
+    type: 'REFRESH_MANIFEST_FAILURE',
+  },
+];
+
+export const deleteManifestSuccessActions = [
+  {
+    type: 'DELETE_MANIFEST_REQUEST',
+  },
+  {
+    response: taskSuccessResponse,
+    type: 'DELETE_MANIFEST_SUCCESS',
+  },
+];
+
+export const deleteManifestFailureActions = [
+  {
+    type: 'DELETE_MANIFEST_REQUEST',
+  },
+  {
+    result: new Error('Request failed with status code 422'),
+    type: 'DELETE_MANIFEST_FAILURE',
+  },
+];

data/webpack/scenes/Subscriptions/Manifest/index.js

@@ -0,0 +1,28 @@
+import { bindActionCreators } from 'redux';
+
+import { connect } from 'react-redux';
+
+import * as manifestActions from './ManifestActions';
+import * as organizationActions from '../../Organizations/OrganizationActions';
+
+import history from './ManifestHistoryReducer';
+
+import ManifestModal from './ManageManifestModal';
+
+import './Manifest.scss';
+
+// map state to props
+const mapStateToProps = state => ({
+  organization: state.katello.organization,
+  manifestHistory: state.katello.manifestHistory,
+});
+
+// map action dispatchers to props
+const actions = { ...manifestActions, ...organizationActions };
+const mapDispatchToProps = dispatch => bindActionCreators(actions, dispatch);
+
+// export reducers
+export const manifestHistory = history;
+
+// export connected component
+export default connect(mapStateToProps, mapDispatchToProps)(ManifestModal);

data/webpack/scenes/Subscriptions/SubscriptionActions.js

@@ -0,0 +1,119 @@
+import api, { orgId } from '../../services/api';
+import { propsToSnakeCase } from '../../services/index';
+
+import {
+  SUBSCRIPTIONS_REQUEST,
+  SUBSCRIPTIONS_SUCCESS,
+  SUBSCRIPTIONS_FAILURE,
+  SUBSCRIPTIONS_QUANTITIES_REQUEST,
+  SUBSCRIPTIONS_QUANTITIES_SUCCESS,
+  SUBSCRIPTIONS_QUANTITIES_FAILURE,
+  UPDATE_QUANTITY_REQUEST,
+  UPDATE_QUANTITY_SUCCESS,
+  UPDATE_QUANTITY_FAILURE,
+  DELETE_SUBSCRIPTIONS_REQUEST,
+  DELETE_SUBSCRIPTIONS_SUCCESS,
+  DELETE_SUBSCRIPTIONS_FAILURE,
+} from './SubscriptionConstants';
+import { filterRHSubscriptions } from './SubscriptionHelpers.js';
+
+const getResponseError = ({ data }) => data && (data.displayMessage || data.error);
+
+export const createSubscriptionParams = (extendedParams = {}) => ({
+  ...{ organization_id: orgId },
+  ...propsToSnakeCase(extendedParams),
+});
+
+export const loadAvailableQuantities = (extendedParams = {}) => (dispatch) => {
+  dispatch({ type: SUBSCRIPTIONS_QUANTITIES_REQUEST });
+
+  const params = createSubscriptionParams(extendedParams);
+  return api
+    .get(`/organizations/${orgId}/upstream_subscriptions`, {}, params)
+    .then(({ data }) => {
+      dispatch({
+        type: SUBSCRIPTIONS_QUANTITIES_SUCCESS,
+        response: data,
+      });
+    })
+    .catch((result) => {
+      dispatch({
+        type: SUBSCRIPTIONS_QUANTITIES_FAILURE,
+        error: getResponseError(result.response),
+      });
+    });
+};
+
+export const loadSubscriptions = (extendedParams = {}) => (dispatch) => {
+  dispatch({ type: SUBSCRIPTIONS_REQUEST });
+
+  const params = createSubscriptionParams(extendedParams);
+  return api
+    .get('/subscriptions', {}, params)
+    .then(({ data }) => {
+      dispatch({
+        type: SUBSCRIPTIONS_SUCCESS,
+        response: data,
+        search: extendedParams.search,
+      });
+      const poolIds = filterRHSubscriptions(data.results).map(subs => subs.id);
+      if (poolIds.length > 0) {
+        dispatch(loadAvailableQuantities({ poolIds }));
+      }
+    })
+    .catch((result) => {
+      dispatch({
+        type: SUBSCRIPTIONS_FAILURE,
+        error: getResponseError(result.response),
+      });
+    });
+};
+
+export const updateQuantity = (quantities = {}) => (dispatch) => {
+  dispatch({ type: UPDATE_QUANTITY_REQUEST, quantities });
+
+  const params = {
+    pools: quantities,
+  };
+
+  return api
+    .put(`/organizations/${orgId}/upstream_subscriptions`, params)
+    .then(({ data }) => {
+      dispatch({
+        type: UPDATE_QUANTITY_SUCCESS,
+        response: data,
+      });
+    })
+    .catch((result) => {
+      dispatch({
+        type: UPDATE_QUANTITY_FAILURE,
+        error: getResponseError(result.response),
+      });
+    });
+};
+
+export const deleteSubscriptions = poolIds => (dispatch) => {
+  dispatch({ type: DELETE_SUBSCRIPTIONS_REQUEST });
+
+  const params = {
+    pool_ids: poolIds,
+  };
+
+  return api
+    .delete(`/organizations/${orgId}/upstream_subscriptions`, {}, params)
+    .then(({ data }) => {
+      dispatch({
+        type: DELETE_SUBSCRIPTIONS_SUCCESS,
+        response: data,
+      });
+    })
+    .catch((result) => {
+      dispatch({
+        type: DELETE_SUBSCRIPTIONS_FAILURE,
+        result,
+      });
+    });
+};
+
+
+export default loadSubscriptions;

data/webpack/scenes/Subscriptions/SubscriptionConstants.js

@@ -0,0 +1,27 @@
+export const SUBSCRIPTIONS_REQUEST = 'SUBSCRIPTIONS_REQUEST';
+export const SUBSCRIPTIONS_SUCCESS = 'SUBSCRIPTIONS_SUCCESS';
+export const SUBSCRIPTIONS_FAILURE = 'SUBSCRIPTIONS_FAILURE';
+
+export const UPDATE_QUANTITY_REQUEST = 'UPDATE_QUANTITY_REQUEST';
+export const UPDATE_QUANTITY_SUCCESS = 'UPDATE_QUANTITY_SUCCESS';
+export const UPDATE_QUANTITY_FAILURE = 'UPDATE_QUANTITY_FAILURE';
+
+export const SUBSCRIPTIONS_QUANTITIES_REQUEST = 'SUBSCRIPTIONS_QUANTITIES_REQUEST';
+export const SUBSCRIPTIONS_QUANTITIES_SUCCESS = 'SUBSCRIPTIONS_QUANTITIES_SUCCESS';
+export const SUBSCRIPTIONS_QUANTITIES_FAILURE = 'SUBSCRIPTIONS_QUANTITIES_FAILURE';
+
+export const DELETE_SUBSCRIPTIONS_REQUEST = 'DELETE_SUBSCRIPTIONS_REQUEST';
+export const DELETE_SUBSCRIPTIONS_SUCCESS = 'DELETE_SUBSCRIPTIONS_SUCCESS';
+export const DELETE_SUBSCRIPTIONS_FAILURE = 'DELETE_SUBSCRIPTIONS_FAILURE';
+
+export const BLOCKING_FOREMAN_TASK_TYPES = [
+  'Actions::Katello::Organization::ManifestImport',
+  'Actions::Katello::Organization::ManifestRefresh',
+  'Actions::Katello::Organization::ManifestDelete',
+  'Actions::Katello::UpstreamSubscriptions::BindEntitlements',
+  'Actions::Katello::UpstreamSubscriptions::UpdateEntitlement',
+  'Actions::Katello::UpstreamSubscriptions::RemoveEntitlements',
+];
+
+export const MANIFEST_TASKS_BULK_SEARCH_ID = 'activeManifestTasksSearch';
+export const BULK_TASK_SEARCH_INTERVAL = 10000;

data/webpack/scenes/Subscriptions/SubscriptionHelpers.js

@@ -0,0 +1,3 @@
+// eslint-disable-next-line import/prefer-default-export
+export const filterRHSubscriptions = subscriptions =>
+  subscriptions.filter(sub => sub.available >= 0);

data/webpack/scenes/Subscriptions/SubscriptionReducer.js

@@ -0,0 +1,123 @@
+import find from 'lodash/find';
+import Immutable from 'seamless-immutable';
+import { initialApiState } from '../../services/api';
+import { TASK_BULK_SEARCH_SUCCESS } from '../Tasks/TaskConstants';
+
+import {
+  SUBSCRIPTIONS_REQUEST,
+  SUBSCRIPTIONS_SUCCESS,
+  SUBSCRIPTIONS_FAILURE,
+  SUBSCRIPTIONS_QUANTITIES_REQUEST,
+  SUBSCRIPTIONS_QUANTITIES_SUCCESS,
+  SUBSCRIPTIONS_QUANTITIES_FAILURE,
+  UPDATE_QUANTITY_REQUEST,
+  UPDATE_QUANTITY_SUCCESS,
+  UPDATE_QUANTITY_FAILURE,
+  DELETE_SUBSCRIPTIONS_REQUEST,
+  DELETE_SUBSCRIPTIONS_SUCCESS,
+  DELETE_SUBSCRIPTIONS_FAILURE,
+  MANIFEST_TASKS_BULK_SEARCH_ID,
+} from './SubscriptionConstants';
+import { GET_SETTING_SUCCESS } from '../../move_to_foreman/Settings/SettingsConstants';
+
+const initialState = Immutable({
+  ...initialApiState,
+  quantitiesLoading: false,
+  availableQuantities: {},
+});
+
+const mapQuantities = (pools) => {
+  const quantityMap = {};
+  pools.forEach(pool =>
+    pool.local_pool_ids && pool.local_pool_ids.forEach((localId) => {
+      if (quantityMap[localId]) {
+        quantityMap[localId] += pool.available;
+      } else {
+        quantityMap[localId] = pool.available;
+      }
+    }));
+  return quantityMap;
+};
+
+export default (state = initialState, action) => {
+  switch (action.type) {
+    case SUBSCRIPTIONS_REQUEST:
+    case UPDATE_QUANTITY_REQUEST:
+    case DELETE_SUBSCRIPTIONS_REQUEST:
+      return state.set('loading', true);
+
+    case SUBSCRIPTIONS_SUCCESS: {
+      const {
+        page, per_page, subtotal, results, // eslint-disable-line camelcase
+      } = action.response;
+
+      return state.merge({
+        results,
+        loading: false,
+        searchIsActive: !!action.search,
+        search: action.search,
+        pagination: {
+          page: Number(page),
+          // eslint-disable-next-line camelcase
+          perPage: Number(per_page || state.pagination.perPage),
+        },
+        itemCount: Number(subtotal),
+      });
+    }
+
+    case DELETE_SUBSCRIPTIONS_SUCCESS:
+      return state.set('loading', false);
+
+    case UPDATE_QUANTITY_SUCCESS:
+      return state.set('loading', false);
+
+    case SUBSCRIPTIONS_FAILURE:
+    case UPDATE_QUANTITY_FAILURE:
+    case DELETE_SUBSCRIPTIONS_FAILURE:
+      return state.merge({
+        error: action.error,
+        loading: false,
+      });
+
+    case SUBSCRIPTIONS_QUANTITIES_REQUEST:
+      return state.set('quantitiesLoading', true);
+
+    case SUBSCRIPTIONS_QUANTITIES_SUCCESS: {
+      return state.merge({
+        quantitiesLoading: false,
+        availableQuantities: mapQuantities(action.response.results),
+      });
+    }
+
+    case SUBSCRIPTIONS_QUANTITIES_FAILURE: {
+      return state.merge({
+        quantitiesLoading: false,
+        quantitiesError: action.error,
+      });
+    }
+
+    case TASK_BULK_SEARCH_SUCCESS: {
+      let tasks = [];
+
+      const search = find(action.response, bulkSearch =>
+        bulkSearch.search_params.search_id === MANIFEST_TASKS_BULK_SEARCH_ID);
+
+      if (search) {
+        tasks = search.results;
+      }
+
+      return state.set('tasks', tasks);
+    }
+
+    case GET_SETTING_SUCCESS: {
+      if (action.response.name === 'content_disconnected') {
+        return state.set('disconnected', action.response.value);
+      }
+
+      return state;
+    }
+
+    default:
+      return state;
+  }
+};