katello 3.6.0.1.rc2 → 3.7.0.rc1

data/webpack/move_to_pf/TypeAhead/TypeAheadInput.js

@@ -0,0 +1,47 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { FormControl } from 'patternfly-react';
+
+class TypeAheadInput extends Component {
+  constructor(props) {
+    super(props);
+    this.handleKeyPress = this.handleKeyPress.bind(this);
+  }
+
+  componentDidMount() {
+    if (this.ref) {
+      this.ref.addEventListener('keydown', this.handleKeyPress);
+    }
+  }
+
+  componentWillUnmount() {
+    if (this.ref) {
+      this.ref.removeEventListener('keydown', this.handleKeyPress);
+    }
+  }
+
+  handleKeyPress(e) {
+    this.props.onKeyPress(e);
+  }
+
+  render() {
+    return (
+      <FormControl
+        inputRef={(ref) => {
+          this.ref = ref;
+        }}
+        onFocus={this.props.onInputFocus}
+        type="text"
+        {...this.props.passedProps}
+      />
+    );
+  }
+}
+
+TypeAheadInput.propTypes = {
+  passedProps: PropTypes.shape({}).isRequired,
+  onKeyPress: PropTypes.func.isRequired,
+  onInputFocus: PropTypes.func.isRequired,
+};
+
+export default TypeAheadInput;

data/webpack/move_to_pf/TypeAhead/TypeAheadItems.js

@@ -0,0 +1,60 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Dropdown, MenuItem } from 'patternfly-react';
+
+const TypeAheadItems = ({
+  items, activeItems, getItemProps, highlightedIndex,
+}) => (
+  <Dropdown.Menu className="typeahead-dropdown">
+    {items.map(({ text, type, disabled = false }, index) => {
+      if (type === 'header') {
+        return (
+          <MenuItem key={text} header>
+            {text}
+          </MenuItem>
+        );
+      }
+
+      if (type === 'divider') {
+        // eslint-disable-next-line react/no-array-index-key
+        return <MenuItem key={`divider-${index}`} divider />;
+      }
+
+      if (disabled) {
+        return (
+          <MenuItem key={text} disabled>
+            {text}
+          </MenuItem>
+        );
+      }
+
+      const itemProps = getItemProps({
+        index: activeItems.indexOf(text),
+        item: text,
+        active: activeItems[highlightedIndex] === text,
+        onClick: (e) => {
+          // At this point the event.defaultPrevented
+          // is already set to true by react-bootstrap
+          // MenuItem. We need to set it back to false
+          // So downshift will execute it's own handler
+          e.defaultPrevented = false;
+        },
+      });
+
+      return (
+        <MenuItem {...itemProps} key={text}>
+          {text}
+        </MenuItem>
+      );
+    })}
+  </Dropdown.Menu>
+);
+
+TypeAheadItems.propTypes = {
+  items: PropTypes.arrayOf(PropTypes.object).isRequired,
+  activeItems: PropTypes.arrayOf(PropTypes.string).isRequired,
+  highlightedIndex: PropTypes.number.isRequired,
+  getItemProps: PropTypes.func.isRequired,
+};
+
+export default TypeAheadItems;

data/webpack/move_to_pf/TypeAhead/helpers.js

@@ -0,0 +1,5 @@
+// eslint-disable-next-line import/prefer-default-export
+export const getActiveItems = items =>
+  items
+    .filter(({ disabled, type }) => !disabled && !['header', 'divider'].includes(type))
+    .map(({ text }) => text);

data/webpack/move_to_pf/react-bootstrap-select/index.js

@@ -0,0 +1,65 @@
+// This component should be replaced with a react version
+/* eslint-disable */
+import React from 'react';
+import ReactDOM from 'react-dom';
+import { FormControl } from 'react-bootstrap';
+
+require('jquery');
+require('bootstrap-select');
+
+class BootstrapSelect extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = { open: false };
+  }
+
+  componentDidMount() {
+    this.body = $('body');
+    this.select = $(ReactDOM.findDOMNode(this));
+    this.select.selectpicker();
+
+    this.container = this.select.parent();
+    this.button = this.container.find('button');
+    this.items = this.container.find('ul.dropdown-menu li a');
+
+    this.body.click(() => {
+      this.setState({ open: false });
+    });
+
+    this.button.click(e => {
+      e.stopPropagation();
+      this.setState({ open: !this.state.open });
+    });
+
+    this.items.click(() => {
+      if (this.props.multiple) return;
+      this.setState({ open: !this.state.open });
+    });
+  }
+
+  componentDidUpdate() {
+    this.select.selectpicker('refresh');
+    this.container.toggleClass('open', this.state.open);
+  }
+
+  componentWillUnmount() {
+    this.body.off('click');
+    this.button.off('click');
+    this.items.off('click');
+    this.select.selectpicker('destroy');
+  }
+
+  render() {
+    // TODO: these classes are required because foreman assumes that all selects should use select2 and jquery multiselect
+    // TODO: see also http://projects.theforeman.org/issues/21952
+    return <FormControl {...this.props}
+                        data-none-selected-text={__('Nothing selected')}
+                        data-selected-text-format="count>3"
+                        data-count-selected-text={__('{0} items selected')}
+                        componentClass="select"
+                        className="without_select2 without_jquery_multiselect"
+    />;
+  }
+}
+
+export default BootstrapSelect;

data/webpack/redux/actions/RedHatRepositories/enabled.js

@@ -0,0 +1,53 @@
+import api, { orgId } from '../../../services/api';
+import { normalizeRepositorySets, repoTypeFilterToSearchQuery, joinSearchQueries } from './helpers';
+
+import {
+  ENABLED_REPOSITORIES_REQUEST,
+  ENABLED_REPOSITORIES_SUCCESS,
+  ENABLED_REPOSITORIES_FAILURE,
+  REPOSITORY_DISABLED,
+} from '../../consts';
+import { propsToSnakeCase } from '../../../services/index';
+
+export const setRepositoryDisabled = repository => ({
+  type: REPOSITORY_DISABLED,
+  repository,
+});
+
+export const createEnabledRepoParams = (extendedParams = {}) => {
+  const searchParams = extendedParams.search || {};
+  const search = joinSearchQueries([
+    'redhat = true',
+    repoTypeFilterToSearchQuery(searchParams.filters || []),
+    searchParams.query,
+  ]);
+
+  const repoParams = {
+    ...{ organization_id: orgId, enabled: 'true' },
+    ...propsToSnakeCase(extendedParams),
+    search,
+  };
+
+  return { searchParams, repoParams };
+};
+
+export const loadEnabledRepos = (extendedParams = {}) => (dispatch) => {
+  dispatch({ type: ENABLED_REPOSITORIES_REQUEST, params: extendedParams });
+  const { searchParams, repoParams } = createEnabledRepoParams(extendedParams);
+
+  api
+    .get('/repositories', {}, repoParams)
+    .then(({ data }) => {
+      dispatch({
+        type: ENABLED_REPOSITORIES_SUCCESS,
+        response: normalizeRepositorySets(data),
+        search: searchParams,
+      });
+    })
+    .catch((result) => {
+      dispatch({
+        type: ENABLED_REPOSITORIES_FAILURE,
+        result,
+      });
+    });
+};

data/webpack/redux/actions/RedHatRepositories/helpers.js

@@ -0,0 +1,38 @@
+export function normalizeRepositorySets(data) {
+  data.results.forEach((repositorySet) => {
+    /* eslint no-param-reassign: ["error", { "ignorePropertyModificationsFor": ["id"] }] */
+    repositorySet.id = parseInt(repositorySet.id, 10);
+  });
+  return data;
+}
+
+const repoTypeSearchQueryMap = {
+  rpm: '(name ~ rpms) and (name !~ source rpm) and (name !~ debug rpm)',
+  sourceRpm: 'name ~ source rpm',
+  debugRpm: 'name ~ debug rpm',
+  kickstarter: 'name ~ kickstart',
+  ostree: 'name ~ ostree',
+  beta: 'name ~ beta',
+};
+
+const maptToSearchQuery = (filter) => {
+  if (filter === 'other') {
+    const joined = Object.keys(repoTypeSearchQueryMap)
+      .map(k => repoTypeSearchQueryMap[k])
+      .map(q => `(${q})`)
+      .join(' or ');
+    return `not (${joined})`;
+  }
+  return repoTypeSearchQueryMap[filter];
+};
+
+export const repoTypeFilterToSearchQuery = filters => filters
+  .map(f => `(${maptToSearchQuery(f)})`)
+  .join(' or ');
+
+export const joinSearchQueries = parts => parts
+  .filter(v => (v && v !== ''))
+  .map(v => `(${v})`)
+  .join(' and ');
+
+export default normalizeRepositorySets;

data/webpack/redux/actions/RedHatRepositories/repositorySetRepositories.js

@@ -0,0 +1,50 @@
+import api from '../../../services/api';
+
+import {
+  REPOSITORY_SET_REPOSITORIES_REQUEST,
+  REPOSITORY_SET_REPOSITORIES_SUCCESS,
+  REPOSITORY_SET_REPOSITORIES_FAILURE,
+  REPOSITORY_ENABLED,
+} from '../../consts';
+
+export const setRepositoryEnabled = repository => ({
+  type: REPOSITORY_ENABLED,
+  repository,
+});
+
+export function normalizeContentSetRepositories(repos, contentId, productId) {
+  return repos.map(repo => ({
+    contentId: parseInt(contentId, 10),
+    productId: parseInt(productId, 10),
+    arch: repo.substitutions.basearch,
+    releasever: repo.substitutions.releasever,
+    enabled: repo.enabled,
+  }));
+}
+
+const loadRepositorySetRepos = (contentId, productId) => (dispatch) => {
+  dispatch({
+    type: REPOSITORY_SET_REPOSITORIES_REQUEST,
+    contentId,
+  });
+
+  api
+    .get(`/products/${productId}/repository_sets/${contentId}/available_repositories`)
+    .then(({ data }) => {
+      dispatch({
+        type: REPOSITORY_SET_REPOSITORIES_SUCCESS,
+        contentId,
+        productId,
+        results: data.results,
+      });
+    })
+    .catch(({ response: { data: error } }) => {
+      dispatch({
+        type: REPOSITORY_SET_REPOSITORIES_FAILURE,
+        contentId,
+        error,
+      });
+    });
+};
+
+export default loadRepositorySetRepos;

data/webpack/redux/actions/RedHatRepositories/sets.js

@@ -0,0 +1,42 @@
+import api, { orgId } from '../../../services/api';
+import { normalizeRepositorySets, repoTypeFilterToSearchQuery, joinSearchQueries } from './helpers';
+
+import {
+  REPOSITORY_SETS_REQUEST,
+  REPOSITORY_SETS_SUCCESS,
+  REPOSITORY_SETS_FAILURE,
+} from '../../consts';
+import { propsToSnakeCase } from '../../../services/index';
+
+// eslint-disable-next-line import/prefer-default-export
+export const loadRepositorySets = (extendedParams = {}) => (dispatch) => {
+  dispatch({ type: REPOSITORY_SETS_REQUEST, params: extendedParams });
+
+  const searchParams = extendedParams.search || {};
+  const search = joinSearchQueries([
+    repoTypeFilterToSearchQuery(searchParams.filters || []),
+    searchParams.query,
+  ]);
+
+  const params = {
+    ...{ organization_id: orgId },
+    ...propsToSnakeCase(extendedParams),
+    search,
+  };
+
+  api
+    .get('/repository_sets', {}, params)
+    .then(({ data }) => {
+      dispatch({
+        type: REPOSITORY_SETS_SUCCESS,
+        response: normalizeRepositorySets(data),
+        search: searchParams,
+      });
+    })
+    .catch((result) => {
+      dispatch({
+        type: REPOSITORY_SETS_FAILURE,
+        result,
+      });
+    });
+};

data/webpack/redux/consts.js

@@ -0,0 +1,18 @@
+export const REPOSITORY_SETS_REQUEST = 'REPOSITORY_SETS_REQUEST';
+export const REPOSITORY_SETS_SUCCESS = 'REPOSITORY_SETS_SUCCESS';
+export const REPOSITORY_SETS_FAILURE = 'REPOSITORY_SETS_FAILURE';
+
+export const PRODUCT_REPOSITORY_SETS_REQUEST = 'PRODUCT_REPOSITORY_SETS_REQUEST';
+export const PRODUCT_REPOSITORY_SETS_SUCCESS = 'PRODUCT_REPOSITORY_SETS_SUCCESS';
+export const PRODUCT_REPOSITORY_SETS_FAILURE = 'PRODUCT_REPOSITORY_SETS_FAILURE';
+
+export const ENABLED_REPOSITORIES_REQUEST = 'ENABLED_REPOSITORIES_REQUEST';
+export const ENABLED_REPOSITORIES_SUCCESS = 'ENABLED_REPOSITORIES_SUCCESS';
+export const ENABLED_REPOSITORIES_FAILURE = 'ENABLED_REPOSITORIES_FAILURE';
+
+export const REPOSITORY_SET_REPOSITORIES_REQUEST = 'REPOSITORY_SET_REPOSITORIES_REQUEST';
+export const REPOSITORY_SET_REPOSITORIES_SUCCESS = 'REPOSITORY_SET_REPOSITORIES_SUCCESS';
+export const REPOSITORY_SET_REPOSITORIES_FAILURE = 'REPOSITORY_SET_REPOSITORIES_FAILURE';
+
+export const REPOSITORY_ENABLED = 'REPOSITORY_ENABLED';
+export const REPOSITORY_DISABLED = 'REPOSITORY_DISABLED';

data/webpack/redux/index.js

@@ -0,0 +1,9 @@
+/* eslint import/no-unresolved: [2, { ignore: [foremanReact/*] }] */
+/* eslint-disable import/no-extraneous-dependencies */
+/* eslint-disable import/extensions */
+/* eslint-disable import/no-unresolved */
+
+import { registerReducer } from 'foremanReact/common/MountingService';
+import rootReducer from './reducers';
+
+registerReducer('katello', rootReducer);

data/webpack/redux/reducers/RedHatRepositories/enabled.fixtures.js

@@ -0,0 +1,149 @@
+import Immutable from 'seamless-immutable';
+
+export const initialState = Immutable({
+  loading: true,
+  repositories: [],
+  pagination: {},
+});
+
+export const loadingState = Immutable({
+  loading: true,
+  repositories: [],
+  pagination: {},
+});
+
+export const requestSuccessResponse = Immutable({
+  total: 15,
+  subtotal: 2,
+  page: 1,
+  per_page: 5,
+  error: null,
+  search: 'name ~ Server',
+  sort: {
+    by: null,
+    order: null,
+  },
+  results: [
+    {
+      content_type: 'yum',
+      url: 'https://cdn.redhat.com/content/dist/rhel/server/7/7.0/x86_64/ceph-tools/1.3/os',
+      relative_path: 'Default_Organization/Library/content/dist/rhel/server/7/7.0/x86_64/ceph-tools/1.3/os',
+      arch: 'x86_64',
+      backend_identifier: '24d30d8e-7e94-4744-9b1a-0c78b60ad66c',
+      content_label: 'rhel-7-server-rhceph-1.3-tools-rpms',
+      id: 2,
+      name: 'Red Hat Ceph Storage Tools 1.3 for Red Hat Enterprise Linux 7 Server RPMs x86_64 7.0',
+      label: 'Red_Hat_Ceph_Storage_Tools_1_3_for_Red_Hat_Enterprise_Linux_7_Server_RPMs_x86_64_7_0',
+      product: {
+        id: 20,
+        cp_id: '69',
+        name: 'Red Hat Enterprise Linux Server',
+        sync_plan: [
+          'name',
+          'description',
+          'sync_date',
+          'interval',
+          'next_sync',
+        ],
+      },
+      last_sync: null,
+      content_counts: {
+        ostree_branch: 0,
+        docker_manifest: 0,
+        docker_manifest_list: 0,
+        docker_tag: 0,
+        rpm: 0,
+        srpm: 0,
+        package: 0,
+        package_group: 0,
+        erratum: 0,
+        puppet_module: 0,
+        file: 0,
+        deb: 0,
+      },
+      content_id: '4455',
+      major: '7',
+      minor: '7.0',
+      last_sync_words: null,
+    },
+    {
+      content_type: 'yum',
+      url: 'https://cdn.redhat.com/content/dist/rhel/server/7/7.1/x86_64/ceph-tools/1.3/os',
+      relative_path: 'Default_Organization/Library/content/dist/rhel/server/7/7.1/x86_64/ceph-tools/1.3/os',
+      arch: 'x86_64',
+      backend_identifier: '70040489-7acf-47c8-89a2-1a29f664aab6',
+      content_label: 'rhel-7-server-rhceph-1.3-tools-rpms',
+      id: 4,
+      name: 'Red Hat Ceph Storage Tools 1.3 for Red Hat Enterprise Linux 7 Server RPMs x86_64 7.1',
+      label: 'Red_Hat_Ceph_Storage_Tools_1_3_for_Red_Hat_Enterprise_Linux_7_Server_RPMs_x86_64_7_1',
+      product: {
+        id: 20,
+        cp_id: '69',
+        name: 'Red Hat Enterprise Linux Server',
+        sync_plan: [
+          'name',
+          'description',
+          'sync_date',
+          'interval',
+          'next_sync',
+        ],
+      },
+      last_sync: null,
+      content_counts: {
+        ostree_branch: 0,
+        docker_manifest: 0,
+        docker_manifest_list: 0,
+        docker_tag: 0,
+        rpm: 0,
+        srpm: 0,
+        package: 0,
+        package_group: 0,
+        erratum: 0,
+        puppet_module: 0,
+        file: 0,
+        deb: 0,
+      },
+      content_id: '4456',
+      major: '7',
+      minor: '7.1',
+      last_sync_words: null,
+    },
+  ],
+});
+
+export const successState = Immutable({
+  loading: false,
+  repositories: [
+    {
+      arch: 'x86_64',
+      contentId: 4455,
+      id: 2,
+      name: 'Red Hat Ceph Storage Tools 1.3 for Red Hat Enterprise Linux 7 Server RPMs x86_64 7.0',
+      productId: 20,
+      releasever: '7.0',
+      type: 'yum',
+    },
+    {
+      arch: 'x86_64',
+      contentId: 4456,
+      id: 4,
+      name: 'Red Hat Ceph Storage Tools 1.3 for Red Hat Enterprise Linux 7 Server RPMs x86_64 7.1',
+      productId: 20,
+      releasever: '7.1',
+      type: 'yum',
+    },
+  ],
+  searchIsActive: false,
+  search: undefined,
+  pagination: {
+    page: 1,
+    perPage: 5,
+  },
+  itemCount: 2,
+});
+
+export const errorState = Immutable({
+  loading: false,
+  repositories: [],
+  error: 'Unable to process request.',
+});