katello 3.16.2 → 3.17.0.rc1

data/webpack/scenes/ContentViews/Table/tableDataGenerator.js

@@ -1,39 +1,40 @@
 import React from 'react';
-import { compoundExpand } from '@patternfly/react-table';
-import { ScreenIcon, RepositoryIcon, ContainerNodeIcon } from '@patternfly/react-icons';
+import { compoundExpand, fitContent } from '@patternfly/react-table';
+import {
+  ScreenIcon,
+  ContainerNodeIcon,
+} from '@patternfly/react-icons';
+import { Link } from 'react-router-dom';
+import { urlBuilder } from 'foremanReact/common/urlHelpers';
 import { translate as __ } from 'foremanReact/common/I18n';
 
 import IconWithCount from '../components/IconWithCount';
 import DetailsExpansion from '../expansions/DetailsExpansion';
-import RepositoriesExpansion from '../expansions/RepositoriesExpansion';
 import EnvironmentsExpansion from '../expansions/EnvironmentsExpansion';
 import VersionsExpansion from '../expansions/VersionsExpansion';
-import ContentViewName from '../components/ContentViewName';
-import DetailsContainer from '../details/DetailsContainer';
+import ContentViewIcon from '../components/ContentViewIcon';
+import DetailsContainer from '../Details/DetailsContainer';
 
 export const buildColumns = () => [
+  { title: __('Type'), transforms: [fitContent] },
   __('Name'), __('Last published'), __('Details'),
   { title: __('Environments'), cellTransforms: [compoundExpand] },
-  { title: __('Repositories'), cellTransforms: [compoundExpand] },
   { title: __('Versions'), cellTransforms: [compoundExpand] },
 ];
 
 const buildRow = (contentView, openColumn) => {
   const {
-    id, composite, name, environments, repositories, versions, last_published: lastPublished,
+    id, composite, name, environments, versions, last_published: lastPublished,
   } = contentView;
   const row = [
-    { title: <ContentViewName composite={composite ? true : undefined} name={name} cvId={id} /> },
+    { title: <ContentViewIcon composite={composite ? true : undefined} /> },
+    { title: <Link to={urlBuilder('labs/content_views', '', id)}>{name}</Link> },
     lastPublished || 'Not yet published',
     { title: __('Details'), props: { isOpen: false, ariaControls: `cv-details-expansion-${id}` } },
     {
       title: <IconWithCount Icon={ScreenIcon} count={environments.length} title={`environments-icon-${id}`} />,
       props: { isOpen: false, ariaControls: `cv-environments-expansion-${id}` },
     },
-    {
-      title: <IconWithCount Icon={RepositoryIcon} count={repositories.length} title={`repositories-icon-${id}`} />,
-      props: { isOpen: false, ariaControls: `cv-repositories-expansion-${id}` },
-    },
     {
       title: <IconWithCount Icon={ContainerNodeIcon} count={versions.length} title={`versions-icon-${id}`} />,
       props: { isOpen: false, ariaControls: `cv-versions-expansion-${id}` },
@@ -48,14 +49,15 @@ const buildDetailDropdowns = (id, rowIndex, openColumn) => {
   const cvId = { cvId: id };
   const expansionProps = { ...cvId, className: 'pf-m-no-padding' };
   const containerProps = column => ({ ...cvId, isOpen: openColumn === column });
+  const offsetColumn = 3; // index of first expandable column
 
   let detailDropdowns = [
     {
-      compoundParent: 2,
+      compoundParent: offsetColumn,
       cells: [
         {
           title: (
-            <DetailsContainer {...containerProps(3)}>
+            <DetailsContainer {...containerProps(offsetColumn + 1)}>
               <DetailsExpansion {...expansionProps} />
             </DetailsContainer>),
           props: { colSpan: 6 },
@@ -63,11 +65,11 @@ const buildDetailDropdowns = (id, rowIndex, openColumn) => {
       ],
     },
     {
-      compoundParent: 3,
+      compoundParent: offsetColumn + 1,
       cells: [
         {
           title: (
-            <DetailsContainer {...containerProps(4)}>
+            <DetailsContainer {...containerProps(offsetColumn + 2)}>
               <EnvironmentsExpansion {...expansionProps} />
             </DetailsContainer>),
           props: { colSpan: 6 },
@@ -75,23 +77,11 @@ const buildDetailDropdowns = (id, rowIndex, openColumn) => {
       ],
     },
     {
-      compoundParent: 4,
-      cells: [
-        {
-          title: (
-            <DetailsContainer {...containerProps(5)}>
-              <RepositoriesExpansion {...expansionProps} />
-            </DetailsContainer>),
-          props: { colSpan: 6 },
-        },
-      ],
-    },
-    {
-      compoundParent: 5,
+      compoundParent: offsetColumn + 2,
       cells: [
         {
           title: (
-            <DetailsContainer {...containerProps(6)}>
+            <DetailsContainer {...containerProps(offsetColumn + 3)}>
               <VersionsExpansion {...expansionProps} />
             </DetailsContainer>),
           props: { colSpan: 6 },
@@ -100,26 +90,22 @@ const buildDetailDropdowns = (id, rowIndex, openColumn) => {
     },
   ];
 
-  // The rows are indexed along with the hidden dropdown rows, so we need to offset the parent row
-  const rowOffset = detailDropdowns.length + 1;
-  detailDropdowns = detailDropdowns.map(detail => ({ ...detail, parent: rowIndex * rowOffset }));
+  detailDropdowns = detailDropdowns.map(detail => ({ ...detail, parent: rowIndex }));
 
   return detailDropdowns;
 };
 
-const tableDataGenerator = (results, rowMapping) => {
-  const updatedRowMapping = { ...rowMapping };
-  const contentViews = results || [];
-  const columns = buildColumns();
+const buildRowsAndMapping = (contentViews, newRowMapping) => {
+  const updatedRowMap = { ...newRowMapping };
   const rows = [];
 
-  contentViews.forEach((contentView, rowIndex) => {
+  contentViews.forEach((contentView) => {
     const { id } = contentView;
-    // hasOwnProperty syntax because of https://eslint.org/docs/rules/no-prototype-builtins
-    if (!Object.prototype.hasOwnProperty.call(updatedRowMapping, id)) {
-      updatedRowMapping[id] = { expandedColumn: null, rowIndex: rows.length };
-    }
-    const openColumn = updatedRowMapping[id].expandedColumn;
+    const rowIndex = rows.length;
+    const needsUpdate = !Object.keys(updatedRowMap).find(i => updatedRowMap[i].id === id) ||
+                        !Object.keys(updatedRowMap[rowIndex] || {}).includes('expandedColumn');
+    if (needsUpdate) updatedRowMap[rowIndex] = { expandedColumn: null, id };
+    const openColumn = updatedRowMap[rowIndex].expandedColumn;
     const cells = buildRow(contentView, openColumn);
     const isOpen = !!openColumn;
 
@@ -127,7 +113,24 @@ const tableDataGenerator = (results, rowMapping) => {
     rows.push(...buildDetailDropdowns(id, rowIndex, openColumn));
   });
 
-  return { updatedRowMapping, rows, columns };
+  return { rows, updatedRowMap };
+};
+
+const tableDataGenerator = (results, rowMapping) => {
+  // If a search was performed or perPage has changed, we can clear mapping
+  const prevRowMapping = (results.length === Object.keys(rowMapping).length) ? rowMapping : {};
+  const newRowMapping = {};
+  const contentViews = results || [];
+  const columns = buildColumns();
+  const contentViewIds = contentViews.map(cv => cv.id);
+
+  // Only keep the relevant rows to keep the table status check accurate
+  Object.entries(prevRowMapping).forEach(([rowId, value]) => {
+    if (contentViewIds.includes(value.id)) newRowMapping[rowId] = value;
+  });
+  const { updatedRowMap, rows } = buildRowsAndMapping(contentViews, newRowMapping);
+
+  return { updatedRowMap, rows, columns };
 };
 
 export default tableDataGenerator;

data/webpack/scenes/ContentViews/__tests__/basicContentViews.fixtures.js

@@ -0,0 +1,31 @@
+const buildContentView = id => ({
+  id,
+  composite: 'false',
+  name: `contentView${id}`,
+  environments: [],
+  repositories: [],
+  versions: [],
+  last_published: 'Not Yet Published',
+});
+
+const createBasicCVs = (amount) => {
+  const response = {
+    total: 100,
+    subtotal: 100,
+    page: 1,
+    per_page: 20,
+    error: null,
+    search: null,
+    sort: {
+      by: 'name',
+      order: 'asc',
+    },
+    results: [],
+  };
+
+  [...Array(amount).keys()].forEach((_, i) => response.results.push(buildContentView(i)));
+
+  return response;
+};
+
+export default createBasicCVs;

data/webpack/scenes/ContentViews/__tests__/contentViewList.fixtures.json

@@ -1,6 +1,7 @@
 {
   "total": 2,
-  "subtotal": 2, "page": 1,
+  "subtotal": 2,
+  "page": 1,
   "per_page": 20,
   "error": null,
   "search": null,

data/webpack/scenes/ContentViews/__tests__/contentViewPage.test.js

@@ -1,24 +1,41 @@
+/* eslint-disable no-useless-escape */
 import React from 'react';
-import { renderWithApiRedux, waitFor } from 'react-testing-lib-wrapper';
+import { renderWithRedux, patientlyWaitFor, fireEvent } from 'react-testing-lib-wrapper';
 
 import CONTENT_VIEWS_KEY from '../ContentViewsConstants';
+import { createContentViewsParams } from '../ContentViewsActions';
 import ContentViewsPage from '../../ContentViews';
 import api from '../../../services/api';
-import { nockInstance, assertNockRequest } from '../../../test-utils/nockWrapper';
-
+import nock, {
+  nockInstance, assertNockRequest, mockAutocomplete, mockSetting,
+} from '../../../test-utils/nockWrapper';
+import createBasicCVs from './basicContentViews.fixtures';
 
 const cvIndexData = require('./contentViewList.fixtures.json');
 
 const cvIndexPath = api.getApiUrl('/content_views');
-const renderOptions = { namespace: CONTENT_VIEWS_KEY };
+const autocompleteUrl = '/content_views/auto_complete_search';
+const renderOptions = { apiNamespace: CONTENT_VIEWS_KEY };
 
 let firstCV;
+let searchDelayScope;
+let autoSearchScope;
 beforeEach(() => {
   const { results } = cvIndexData;
   [firstCV] = results;
+  searchDelayScope = mockSetting(nockInstance, 'autosearch_delay', 500);
+  autoSearchScope = mockSetting(nockInstance, 'autosearch_while_typing', true);
+});
+
+afterEach(() => {
+  nock.cleanAll();
+  assertNockRequest(searchDelayScope);
+  assertNockRequest(autoSearchScope);
 });
 
-test('Can call API for CVs and show on screen on page load', async () => {
+test('Can call API for CVs and show on screen on page load', async (done) => {
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+
   // Mocking API call with nock so it returns the fixture data
   const scope = nockInstance
     .get(cvIndexPath)
@@ -27,19 +44,22 @@ test('Can call API for CVs and show on screen on page load', async () => {
 
   // Using a custom rendering function that sets up both redux and react-router.
   // This allows us to use the component as it is normally used
-  const { queryByText } = renderWithApiRedux(<ContentViewsPage />, renderOptions);
+  const { queryByText } = renderWithRedux(<ContentViewsPage />, renderOptions);
 
   // query* functions will return the element or null if it cannot be found
   // get* functions will return the element or throw an error if it cannot be found
   // Assert that the CV is not showing yet by searching by name and the query returning null
   expect(queryByText(firstCV.name)).toBeNull();
   // Assert that the CV name is now showing on the screen, but wait for it to appear.
-  await waitFor(() => expect(queryByText(firstCV.name)).toBeTruthy());
+  await patientlyWaitFor(() => expect(queryByText(firstCV.name)).toBeTruthy());
   // Assert request was made and completed, see helper function
-  assertNockRequest(scope);
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done); // Pass jest callback to confirm test is done
 });
 
-test('Can handle no Content Views being present', async () => {
+test('Can handle no Content Views being present', async (done) => {
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+
   const noResults = {
     total: 0,
     subtotal: 0,
@@ -51,49 +71,179 @@ test('Can handle no Content Views being present', async () => {
     .get(cvIndexPath)
     .query(true)
     .reply(200, noResults);
-  const { queryByText } = renderWithApiRedux(<ContentViewsPage />, renderOptions);
+  const { queryByText } = renderWithRedux(<ContentViewsPage />, renderOptions);
 
   expect(queryByText(firstCV.name)).toBeNull();
-  await waitFor(() => expect(queryByText(/don't have any Content Views/)).toBeTruthy());
-  assertNockRequest(scope);
+  await patientlyWaitFor(() => expect(queryByText(/don't have any Content Views/i)).toBeTruthy());
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done);
 });
 
-test('Can handle errored response', async () => {
+test('Can handle errored response', async (done) => {
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
   const scope = nockInstance
     .get(cvIndexPath)
     .query(true)
     .reply(500);
-  const { queryByText } = renderWithApiRedux(<ContentViewsPage />, renderOptions);
+
+  const { queryByText } = renderWithRedux(<ContentViewsPage />, renderOptions);
 
   expect(queryByText(firstCV.name)).toBeNull();
-  await waitFor(() => expect(queryByText(/unable to retrieve information/i)).toBeTruthy());
-  assertNockRequest(scope);
+  await patientlyWaitFor(() => expect(queryByText(/unable to connect/i)).toBeTruthy());
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done);
 });
 
-test('Can handle loading state while request is being made', () => {
+test('Can handle loading state while request is being made', async (done) => {
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
   const scope = nockInstance
     .get(cvIndexPath)
     .delay(2000) // Delay the response so we can check loading state properly
     .query(true)
     .reply(200);
 
-  const { queryByText } = renderWithApiRedux(<ContentViewsPage />, renderOptions);
+  const { queryByText } = renderWithRedux(<ContentViewsPage />, renderOptions);
 
   expect(queryByText('Loading')).toBeTruthy();
-  scope.isDone(); // ensure request is cleaned up
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done);
 });
 
-test('Can handle unpublished Content Views', async () => {
+test('Can handle unpublished Content Views', async (done) => {
   const { results } = cvIndexData;
   const unpublishedCVs = results.map(cv => ({ ...cv, last_published: null }));
   const unpublishedCVData = { ...cvIndexData, results: unpublishedCVs };
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
   const scope = nockInstance
     .get(cvIndexPath)
     .query(true)
     .reply(200, unpublishedCVData);
 
-  const { getAllByText } = renderWithApiRedux(<ContentViewsPage />, renderOptions);
+  const { getAllByText } = renderWithRedux(<ContentViewsPage />, renderOptions);
+
+  await patientlyWaitFor(() => expect(getAllByText(/not yet published/i).length).toBeGreaterThan(0));
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(scope, done);
+});
+
+test('Can handle pagination', async (done) => {
+  const cvIndexLarge = createBasicCVs(100);
+  const { results } = cvIndexLarge;
+  const cvIndexFirstPage = { ...cvIndexLarge, ...{ results: results.slice(0, 20) } };
+  const cvIndexSecondPage = { ...cvIndexLarge, page: 2, results: results.slice(20, 40) };
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+
+  // Match first page API request
+  const firstPageScope = nockInstance
+    .get(cvIndexPath)
+    .query(createContentViewsParams())
+    .reply(200, cvIndexFirstPage);
+
+  // Match second page API request
+  const secondPageScope = nockInstance
+    .get(cvIndexPath)
+    // Using a custom query params matcher because parameters can be strings
+    .query(actualQueryObject => parseInt(actualQueryObject.page, 10) === 2)
+    .reply(200, cvIndexSecondPage);
+
+  const { queryByText, getByLabelText } = renderWithRedux(<ContentViewsPage />, renderOptions);
+
+  // Wait for first paginated page to load and assert only the first page of results are present
+  await patientlyWaitFor(() => {
+    expect(queryByText(results[0].name)).toBeInTheDocument();
+    expect(queryByText(results[19].name)).toBeInTheDocument();
+    expect(queryByText(results[21].name)).not.toBeInTheDocument();
+  });
+
+  // Label comes from patternfly, if this test fails, check if patternfly updated the label.
+  expect(getByLabelText('Go to next page')).toBeTruthy();
+  getByLabelText('Go to next page').click();
+
+  // Wait for second paginated page to load and assert only the second page of results are present
+  await patientlyWaitFor(() => {
+    expect(queryByText(results[20].name)).toBeInTheDocument();
+    expect(queryByText(results[39].name)).toBeInTheDocument();
+    expect(queryByText(results[41].name)).not.toBeInTheDocument();
+  });
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(firstPageScope);
+  assertNockRequest(secondPageScope, done); // Only pass jest callback to the last API request
+});
+
+test('Can search for specific Content View', async (done) => {
+  const cvname = 'composite one';
+  const { results } = cvIndexData;
+  const matchQuery = actualParams => actualParams?.search?.includes(cvname);
+  const searchResults = {
+    ...cvIndexData,
+    ...{ total: 1, subtotal: 1, results: results.slice(-1) },
+  };
+
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+  const withSearchScope = mockAutocomplete(nockInstance, autocompleteUrl, matchQuery);
+  const initialScope = nockInstance
+    .get(cvIndexPath)
+    .query(true)
+    .reply(200, cvIndexData);
+  const searchResultScope = nockInstance
+    .get(cvIndexPath)
+    .query(matchQuery)
+    .reply(200, searchResults);
+
+  const {
+    getByLabelText,
+    getByText,
+    queryByText,
+  } = renderWithRedux(<ContentViewsPage />, renderOptions);
+
+  await patientlyWaitFor(() => expect(getByText(firstCV.name)).toBeInTheDocument());
+
+  const searchInput = getByLabelText(/text input for search/i);
+  expect(searchInput).toBeInTheDocument();
+  fireEvent.change(searchInput, { target: { value: `name = \"${cvname}\"` } });
+
+  await patientlyWaitFor(() => {
+    expect(getByText(cvname)).toBeInTheDocument();
+    expect(queryByText(firstCV.name)).not.toBeInTheDocument();
+  });
+
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(initialScope);
+  assertNockRequest(withSearchScope);
+  assertNockRequest(searchResultScope, done);
+});
+
+test('No results message is shown for empty search', async (done) => {
+  const cvname = 'notanactualname';
+  const query = `name = \"${cvname}\"`;
+  const matchQuery = actualParams => actualParams?.search?.includes(cvname);
+  const emptyResults = {
+    total: 1, subtotal: 1, page: 1, per_page: 20, search: query, results: [],
+  };
+
+  const autocompleteScope = mockAutocomplete(nockInstance, autocompleteUrl);
+  const withSearchScope = mockAutocomplete(nockInstance, autocompleteUrl, matchQuery);
+  const initialScope = nockInstance
+    .get(cvIndexPath)
+    .query(true)
+    .reply(200, cvIndexData);
+  const searchResultScope = nockInstance
+    .get(cvIndexPath)
+    .query(matchQuery)
+    .reply(200, emptyResults);
+
+  const { getByLabelText, getByText } = renderWithRedux(<ContentViewsPage />, renderOptions);
+
+  await patientlyWaitFor(() => expect(getByText(firstCV.name)).toBeInTheDocument());
+
+  fireEvent.change(getByLabelText(/text input for search/i), { target: { value: query } });
+
+  await patientlyWaitFor(() => expect(getByText(/No matching Content Views found/i)).toBeInTheDocument());
 
-  await waitFor(() => expect(getAllByText(/not yet published/i).length).toBeGreaterThan(0));
-  assertNockRequest(scope);
+  assertNockRequest(autocompleteScope);
+  assertNockRequest(initialScope);
+  assertNockRequest(withSearchScope);
+  assertNockRequest(searchResultScope, done);
 });
+/* eslint-enable no-useless-escape */

data/webpack/scenes/ContentViews/components/ContentViewIcon.js

@@ -0,0 +1,26 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { CubesIcon, CubeIcon } from '@patternfly/react-icons';
+import './contentViewIcon.scss';
+
+const ContentViewIcon = ({ composite }) => {
+  const props = {
+    title: composite ? 'composite' : 'single',
+    className: 'svg-icon-centered',
+  };
+  return (
+    <div className="svg-centered-container">
+      {composite ? <CubesIcon {...props} /> : <CubeIcon {...props} />}
+    </div>
+  );
+};
+
+ContentViewIcon.propTypes = {
+  composite: PropTypes.bool,
+};
+
+ContentViewIcon.defaultProps = {
+  composite: false,
+};
+
+export default ContentViewIcon;

data/webpack/scenes/ModuleStreams/Details/ModuleStreamDetailsActions.js

@@ -4,7 +4,7 @@ import {
   MODULE_STREAM_DETAILS_SUCCESS,
   MODULE_STREAM_DETAILS_FAILURE,
 } from './ModuleStreamDetailsConstants';
-import { apiError } from '../../../move_to_foreman/common/helpers.js';
+import { apiError } from '../../../utils/helpers.js';
 
 export const loadModuleStreamDetails = moduleStreamId => async (dispatch) => {
   dispatch({ type: MODULE_STREAM_DETAILS_REQUEST });

data/webpack/scenes/ModuleStreams/Details/Profiles/TableSchema.js

@@ -3,7 +3,7 @@ import { translate as __ } from 'foremanReact/common/I18n';
 import {
   headerFormatter,
   cellFormatter,
-} from '../../../../move_to_foreman/components/common/table';
+} from '../../../../components/pf3Table';
 import ProfileRpmsCellFormatter from './ProfileRpmsCellFormatter';
 
 const TableSchema = [

data/webpack/scenes/ModuleStreams/Details/__tests__/ModuleStreamDetailsActions.test.js

@@ -1,11 +1,11 @@
 import { testActionSnapshotWithFixtures } from 'react-redux-test-utils';
 import api from '../../../../services/api';
-import { apiError } from '../../../../move_to_foreman/common/helpers';
+import { apiError } from '../../../../utils/helpers';
 import { loadModuleStreamDetails } from '../ModuleStreamDetailsActions';
 import { details } from './moduleStreamDetails.fixtures';
 
 jest.mock('../../../../services/api');
-jest.mock('../../../../move_to_foreman/common/helpers');
+jest.mock('../../../../utils/helpers');
 
 const fixtures = {
   'should load module stream details on success': () => async (dispatch) => {

data/webpack/scenes/ModuleStreams/ModuleStreamsActions.js

@@ -6,7 +6,7 @@ import {
   MODULE_STREAMS_SUCCESS,
   MODULE_STREAMS_FAILURE,
 } from './ModuleStreamsConstants';
-import { apiError } from '../../move_to_foreman/common/helpers.js';
+import { apiError } from '../../utils/helpers.js';
 
 export const getModuleStreams = (extendedParams = {}) => async (dispatch) => {
   dispatch({ type: MODULE_STREAMS_REQUEST });

data/webpack/scenes/ModuleStreams/ModuleStreamsTableSchema.js

@@ -5,7 +5,7 @@ import { translate as __ } from 'foremanReact/common/I18n';
 import {
   headerFormatter,
   cellFormatter,
-} from '../../move_to_foreman/components/common/table';
+} from '../../components/pf3Table';
 
 
 const TableSchema = [

data/webpack/scenes/ModuleStreams/__tests__/ModuleStreamsTable.test.js

@@ -3,7 +3,7 @@ import { shallow } from 'enzyme';
 import toJson from 'enzyme-to-json';
 import ContentTable from '../../../components/Content/ContentTable';
 import TableSchema from '../../ModuleStreams/ModuleStreamsTableSchema';
-import { Table } from '../../../move_to_foreman/components/common/table';
+import { Table } from '../../../components/pf3Table';
 
 jest.mock('foremanReact/components/Pagination/PaginationWrapper', () => (<div>Pagination Mock</div>));
 

data/webpack/scenes/Organizations/OrganizationSelectors.js

@@ -1,4 +1,18 @@
 export const selectOrganizationState = state => state.katello.organization;
 
+export const selectManifestName = state =>
+  selectOrganizationState(state).owner_details?.upstreamConsumer?.name;
+
+// for use in ManageManifestModal to replace getManifestName()
+export const selectManifestHref = state =>
+  selectManifestName(state) && [
+    'https://',
+    selectOrganizationState(state).owner_details.upstreamConsumer.webUrl,
+    selectOrganizationState(state).owner_details.upstreamConsumer.uuid,
+  ].join('/');
+
+export const selectIsManifestImported = state =>
+  !!selectOrganizationState(state).owner_details?.upstreamConsumer?.webUrl;
+
 export const selectSimpleContentAccessEnabled = state =>
   selectOrganizationState(state).simple_content_access;

data/webpack/scenes/Products/ProductActions.js

@@ -5,7 +5,7 @@ import {
   PRODUCTS_SUCCESS,
   PRODUCTS_FAILURE,
 } from './ProductConstants';
-import { apiError } from '../../move_to_foreman/common/helpers.js';
+import { apiError } from '../../utils/helpers.js';
 
 export const loadProducts = (params = {}) => async (dispatch) => {
   dispatch({ type: PRODUCTS_REQUEST });

data/webpack/scenes/RedHatRepositories/RedHatRepositoriesPage.js

@@ -9,7 +9,7 @@ import { Grid, Row, Col } from 'react-bootstrap';
 import { Button } from 'patternfly-react';
 import { translate as __ } from 'foremanReact/common/I18n';
 import PermissionDenied from 'foremanReact/components/PermissionDenied';
-import { LoadingState } from '../../move_to_pf/LoadingState';
+import { LoadingState } from '../../components/LoadingState';
 import { createEnabledRepoParams } from '../../redux/actions/RedHatRepositories/enabled';
 import SearchBar from './components/SearchBar';
 import RecommendedRepositorySetsToggler from './components/RecommendedRepositorySetsToggler';

data/webpack/scenes/Settings/SettingsConstants.js

@@ -0,0 +1,3 @@
+export const AUTOSEARCH_DELAY = 'autosearch_delay';
+export const AUTOSEARCH_WHILE_TYPING = 'autosearch_while_typing';
+export const CONTENT_DISCONNECTED = 'content_disconnected';

data/webpack/scenes/Settings/SettingsReducer.js

@@ -0,0 +1,33 @@
+import Immutable from 'seamless-immutable';
+import { GET_SETTING_SUCCESS } from 'foremanReact/components/Settings/SettingsConstants';
+import {
+  AUTOSEARCH_DELAY,
+  AUTOSEARCH_WHILE_TYPING,
+  CONTENT_DISCONNECTED,
+} from './SettingsConstants';
+
+export const initialSettingsState = Immutable({
+  autoSearchEnabled: true,
+  autoSearchDelay: 500,
+});
+
+export default (state = initialSettingsState, action) => {
+  switch (action.type) {
+    case GET_SETTING_SUCCESS: {
+      const { name, value } = action.response;
+      switch (name) {
+        case AUTOSEARCH_DELAY:
+          return state.set('autoSearchDelay', value);
+        case AUTOSEARCH_WHILE_TYPING:
+          return state.set('autoSearchEnabled', value);
+        case CONTENT_DISCONNECTED:
+          return state.set('disconnected', value);
+        default:
+          return state;
+      }
+    }
+
+    default:
+      return state;
+  }
+};

data/webpack/scenes/Settings/SettingsSelectors.js

@@ -0,0 +1,4 @@
+export const selectSettings = state => state.katello.settings.settings;
+
+export const selectTableSettings = (state, tableName) =>
+  state.katello.settings.tables[tableName] || undefined;