foreman_scc_manager 1.8.20 → 2.1.0

data/test/controllers/scc_accounts_controller_test.rb

@@ -2,6 +2,12 @@ require 'test_plugin_helper'
 
 class SccAccountsControllerTest < ActionController::TestCase
   def setup
+    # rubocop: disable Lint/SuppressedException
+    begin
+      ::Katello::ContentCredential
+    rescue NameError
+    end
+    # rubocop: enable Lint/SuppressedException
     @scc_account = scc_accounts(:one)
   end
 
@@ -13,7 +19,7 @@ class SccAccountsControllerTest < ActionController::TestCase
           'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
           'Authorization' => auth,
           'Host' => host,
-          'User-Agent' => "rest-client/2.1.0 (linux-gnu x86_64) ruby/#{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
+          'User-Agent' => "rest-client/2.1.0 (linux x86_64) ruby/#{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
         }
       )
       .to_return(status: 200, body: '', headers: {})

data/test/fixtures/models/katello_root_repositories.yml

@@ -5,11 +5,7 @@ sles12_sp4_updates:
   product_id:           <%= ActiveRecord::FixtureSet.identify(:suse) %>
   url:                  www.not-valid.com
   download_policy:      immediate
-<% if ActiveRecord::Base.connection.column_exists? :katello_root_repositories, :mirroring_policy %>
   mirroring_policy:     "mirror_content_only"
-<% else %>
-  mirror_on_sync:       "true"
-<% end %>
   created_at:           <%= Time.now %>
   updated_at:           <%= Time.now %>
 
@@ -20,11 +16,7 @@ sles12_sp4_installer_updates:
   product_id:           <%= ActiveRecord::FixtureSet.identify(:suse) %>
   url:                  www.not-valid.com
   download_policy:      on_demand
-<% if ActiveRecord::Base.connection.column_exists? :katello_root_repositories, :mirroring_policy %>
   mirroring_policy:     "mirror_content_only"
-<% else %>
-  mirror_on_sync:       "true"
-<% end %>
   created_at:           <%= Time.now %>
   updated_at:           <%= Time.now %>
 
@@ -35,10 +27,6 @@ sles12_sp4_installer_updates_2:
   product_id:           <%= ActiveRecord::FixtureSet.identify(:suse) %>
   url:                  www.not-valid.com
   download_policy:      on_demand
-<% if ActiveRecord::Base.connection.column_exists? :katello_root_repositories, :mirroring_policy %>
   mirroring_policy:     "mirror_content_only"
-<% else %>
-  mirror_on_sync:       "true"
-<% end %>
   created_at:           <%= Time.now %>
   updated_at:           <%= Time.now %>

data/test/test_plugin_helper.rb

@@ -29,8 +29,6 @@ module FixtureTestCase
     fixtures(:all)
     FIXTURES = load_fixtures(ActiveRecord::Base)
 
-    Setting::Content.load_defaults
-
     User.current = ::User.unscoped.find(FIXTURES['users']['admin']['id'])
   end
 end
@@ -41,10 +39,6 @@ class ActiveSupport::TestCase
   include FixtureTestCase
   include ForemanTasks::TestHelpers::WithInThreadExecutor
 
-  before do
-    Setting::Content.load_defaults
-  end
-
   def get_organization(org = nil)
     saved_user = User.current
     User.current = User.unscoped.find(users(:admin).id)

data/webpack/components/SCCProductPage/EmptySccProducts.js

@@ -0,0 +1,46 @@
+import React from 'react';
+import { useDispatch } from 'react-redux';
+import PropTypes from 'prop-types';
+import { Button } from '@patternfly/react-core';
+import { translate as __ } from 'foremanReact/common/I18n';
+import EmptyState from 'foremanReact/components/common/EmptyState';
+import { syncSccAccountAction } from './SCCProductPageActions';
+
+export const EmptySccProducts = ({ canCreate, sccAccountId }) => {
+  const dispatch = useDispatch();
+  const onSyncStart = (evt) => {
+    dispatch(syncSccAccountAction(sccAccountId));
+  };
+
+  const content = __(
+    `Please synchronize your SUSE account before you can subscribe to SUSE products.`
+  );
+  return (
+    <>
+      <EmptyState
+        icon="th"
+        iconType="fa"
+        header={__('SUSE Customer Center')}
+        description={<div dangerouslySetInnerHTML={{ __html: content }} />}
+        documentation={{
+          url: 'https://docs.orcharhino.com/or/docs/sources/usage_guides/managing_sles_systems_guide.html#mssg_adding_scc_accounts',
+        }}
+      />
+      <Button onClick={onSyncStart} className="btn btn-primary">
+        {__('Synchronize SUSE Account')}
+      </Button>
+    </>
+  );
+};
+
+EmptySccProducts.propTypes = {
+  canCreate: PropTypes.bool,
+  sccAccountId: PropTypes.number,
+};
+
+EmptySccProducts.defaultProps = {
+  canCreate: false,
+  sccAccountId: undefined,
+};
+
+export default EmptySccProducts;

data/webpack/components/SCCProductPage/SCCProductPage.js

@@ -0,0 +1,96 @@
+import PropTypes from 'prop-types';
+import React, { useState } from 'react';
+import { Stack, StackItem } from '@patternfly/react-core';
+import { useDispatch } from 'react-redux';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { useForemanModal } from 'foremanReact/components/ForemanModal/ForemanModalHooks';
+import SCCProductView from './components/SCCProductView';
+import EmptySccProducts from './EmptySccProducts';
+import SCCProductPicker from './components/SCCProductPicker';
+import SCCProductPickerModal from './components/SCCProductPickerModal';
+import { SCCPRODUCTPAGE_SUMMARY_MODAL_ID } from './SCCProductPageConstants';
+import './sccProductPage.scss';
+
+const SCCProductPage = ({
+  canCreate,
+  sccAccountId,
+  sccProductsInit,
+  ...props
+}) => {
+  const dispatch = useDispatch();
+  const [productToEdit, setProductToEdit] = useState(0);
+  const [reposToSubscribe, setReposToSubscribe] = useState([]);
+  const [subscriptionTaskId, setSubscriptionTaskId] = useState();
+
+  const editProductTree = (productId) => {
+    setProductToEdit(productId);
+  };
+
+  const { setModalOpen, setModalClosed } = useForemanModal({
+    id: SCCPRODUCTPAGE_SUMMARY_MODAL_ID,
+  });
+
+  const handleSubscribeCallback = (
+    subscriptionTaskIdFromAction,
+    reposToSubscribeFromAction
+  ) => {
+    setSubscriptionTaskId(subscriptionTaskIdFromAction);
+    const newReposToSubscribe = [];
+    Object.keys(reposToSubscribeFromAction).forEach((k) => {
+      const repo = {
+        productName: reposToSubscribeFromAction[k].productName,
+        repoNames: reposToSubscribeFromAction[k].repoNames,
+      };
+      newReposToSubscribe.push(repo);
+    });
+    setReposToSubscribe(newReposToSubscribe);
+    dispatch(setModalOpen({ id: SCCPRODUCTPAGE_SUMMARY_MODAL_ID }));
+  };
+
+  return sccProductsInit.length > 0 ? (
+    <Stack>
+      <StackItem>
+        <SCCProductPickerModal
+          id={SCCPRODUCTPAGE_SUMMARY_MODAL_ID}
+          title={__('The subscription task has been started successfully')}
+          taskId={subscriptionTaskId}
+          reposToSubscribe={reposToSubscribe}
+        />
+      </StackItem>
+      <StackItem>
+        <SCCProductView
+          sccProducts={sccProductsInit.filter(
+            (prod) => prod.product_id !== null
+          )}
+          subscriptionTaskId={subscriptionTaskId}
+          editProductTreeGlobal={editProductTree}
+        />
+      </StackItem>
+      <br />
+      <StackItem />
+      <StackItem>
+        <SCCProductPicker
+          sccProducts={sccProductsInit}
+          sccAccountId={sccAccountId}
+          editProductId={productToEdit}
+          handleSubscribeCallback={handleSubscribeCallback}
+        />
+      </StackItem>
+    </Stack>
+  ) : (
+    <EmptySccProducts sccAccountId={sccAccountId} canCreate={canCreate} />
+  );
+};
+
+SCCProductPage.propTypes = {
+  canCreate: PropTypes.bool,
+  sccAccountId: PropTypes.number.isRequired,
+  sccProductsInit: PropTypes.array,
+};
+
+SCCProductPage.defaultProps = {
+  canCreate: false,
+  sccProductsInit: [],
+};
+
+export default SCCProductPage;

data/webpack/components/SCCProductPage/SCCProductPageActions.js

@@ -0,0 +1,27 @@
+import { API_OPERATIONS, put } from 'foremanReact/redux/API';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+export const subscribeProductsWithReposAction = (
+  sccAccountId,
+  sccProductData,
+  handleSubscription,
+  sccSubscriptionData
+) =>
+  put({
+    type: API_OPERATIONS.PUT,
+    key: `subscribe_key_${sccAccountId}_${sccProductData[0].scc_product_id}_${sccProductData[0].repository_list}`,
+    url: `/api/scc_accounts/${sccAccountId}/bulk_subscribe_with_repos`,
+    params: { scc_product_data: sccProductData },
+    errorToast: (error) => __('Starting the subscription task failed.'),
+    handleSuccess: (response) =>
+      handleSubscription(response.data.id, sccSubscriptionData),
+  });
+
+export const syncSccAccountAction = (sccAccountId) =>
+  put({
+    type: API_OPERATIONS.PUT,
+    key: `syncSccAccountKey_${sccAccountId}`,
+    url: `/api/scc_accounts/${sccAccountId}/sync`,
+    successToast: () => __('Sync task started.'),
+    errorToast: (error) => __('Failed to add task to queue.'),
+  });

data/webpack/components/SCCProductPage/SCCProductPageConstants.js

@@ -0,0 +1,5 @@
+export const SCCPRODUCTPAGE_SUMMARY_MODAL_ID = 'SCCTreePickerForemanModal';
+export const SCCPRODUCTPAGE_SUBSCRIBE = 'SCCPRODUCTPAGE_SUBSCRIBE';
+export const SCCPRODUCTPAGE_SCCPRODUCTS = {
+  key: 'SCCPRODUCTPAGE_GET_PRODUCTS',
+};

data/webpack/components/SCCProductPage/SCCProductPageReducer.js

@@ -0,0 +1,34 @@
+import Immutable from 'seamless-immutable';
+import { actionTypeGenerator } from 'foremanReact/redux/API';
+
+export const initialState = Immutable({
+  sccProducts: [],
+  sccAccountId: undefined,
+});
+
+export default (state = initialState, action) => {
+  const { payload } = action;
+
+  const listTypes = actionTypeGenerator('SCC_PRODUCT_LIST');
+
+  switch (action.type) {
+    case 'FETCH_PRODUCT_SUCCESS':
+      return state.merge({
+        sccProducts: payload,
+      });
+    case listTypes.REQUEST:
+      return state.merge({
+        sccProducts: [],
+      });
+    case listTypes.SUCCESS:
+      return state.merge({
+        sccProducts: payload.data,
+      });
+    case listTypes.FAILURE:
+      return state.merge({
+        sccProducts: [payload.error],
+      });
+    default:
+      return state;
+  }
+};

data/webpack/components/SCCProductPage/SCCProductPageSelectors.js

@@ -0,0 +1,7 @@
+const SCCProductPageSelector = (state) => state.foremanSccManager;
+
+export const selectSCCProducts = (state) =>
+  SCCProductPageSelector(state).sccProducts;
+
+export const selectSCCAccountId = (state) =>
+  SCCProductPageSelector(state).sccAccountId;

data/webpack/components/SCCProductPage/components/SCCProductPicker/components/SCCGenericPicker/index.js

@@ -0,0 +1,80 @@
+import React, { useState, useEffect } from 'react';
+import PropTypes from 'prop-types';
+import { ContextSelector, ContextSelectorItem } from '@patternfly/react-core';
+
+const GenericSelector = ({
+  selectionItems,
+  setGlobalSelected,
+  screenReaderLabel,
+  initialLabel,
+}) => {
+  const [isOpen, setIsOpen] = useState(false);
+  const [selected, setSelected] = useState(initialLabel);
+  const [searchValue, setSearchValue] = useState('');
+  const [filteredItems, setFilteredItems] = useState(selectionItems);
+
+  useEffect(() => {
+    setFilteredItems(selectionItems);
+    setSelected(initialLabel);
+  }, [selectionItems, initialLabel]);
+
+  const onToggle = (selectorOpen) => {
+    setIsOpen(selectorOpen);
+  };
+
+  const onSelect = (event, value) => {
+    setSelected(value);
+    setIsOpen(!isOpen);
+    setGlobalSelected(value);
+  };
+
+  const onSearchInputChange = (value) => {
+    setSearchValue(value);
+  };
+
+  const onSearchButtonClick = (event) => {
+    const filtered =
+      searchValue === ''
+        ? selectionItems
+        : selectionItems.filter((item) => {
+            const str = item.text ? item.text : item;
+            return str.toLowerCase().indexOf(searchValue.toLowerCase()) !== -1;
+          });
+
+    setFilteredItems(filtered || []);
+  };
+
+  return (
+    <ContextSelector
+      toggleText={selected}
+      onSearchInputChange={onSearchInputChange}
+      isOpen={isOpen}
+      searchInputValue={searchValue}
+      onToggle={onToggle}
+      onSelect={onSelect}
+      onSearchButtonClick={onSearchButtonClick}
+      screenReaderLabel={screenReaderLabel}
+    >
+      {filteredItems.map((item, index) => (
+        <ContextSelectorItem key={index}>
+          {item || 'no arch'}
+        </ContextSelectorItem>
+      ))}
+    </ContextSelector>
+  );
+};
+
+GenericSelector.propTypes = {
+  selectionItems: PropTypes.array,
+  setGlobalSelected: PropTypes.func.isRequired,
+  screenReaderLabel: PropTypes.string,
+  initialLabel: PropTypes.string,
+};
+
+GenericSelector.defaultProps = {
+  selectionItems: [],
+  screenReaderLabel: '',
+  initialLabel: '',
+};
+
+export default GenericSelector;

data/webpack/components/SCCProductPage/components/SCCProductPicker/components/SCCTreePicker/components/SCCRepoPicker/index.js

@@ -0,0 +1,174 @@
+import React, { useState, useEffect } from 'react';
+import PropTypes from 'prop-types';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
+import { Select, SelectOption, SelectVariant } from '@patternfly/react-core';
+
+import './styles.scss';
+
+const createRepoSelectOption = (repo, disableRepos) => (
+  <SelectOption
+    key={repo.id}
+    isDisabled={repo.katello_root_repository_id !== null || disableRepos}
+    value={repo.name}
+  />
+);
+
+const setRepoSelection = (
+  sccRepos,
+  disableRepos,
+  activateDebugFilter,
+  productAlreadySynced
+) => {
+  let res = [];
+  // this is necessary because the logic of this option was inverted
+  // Instead of filtering the debug repositories with the corresponding option,
+  // this option now includes the repositories, instead - means, it does exactly the opposite.
+  activateDebugFilter = !activateDebugFilter;
+  if (!disableRepos && !productAlreadySynced) {
+    if (activateDebugFilter) {
+      res = sccRepos.filter(
+        (repo) =>
+          (!repo.name.includes('Debug') &&
+            !repo.name.includes('Source-Pool') &&
+            repo.katello_root_repository_id === null) ||
+          repo.katello_root_repository_id !== null
+      );
+    } else {
+      res = sccRepos;
+    }
+  } else {
+    res = sccRepos.filter((repo) => repo.katello_root_repository_id !== null);
+  }
+  return res.map((repo) => repo.name);
+};
+
+// disableRepos makes sure that repos can only be selected if the corresponding product
+// is also selected
+const SCCRepoPicker = ({
+  sccRepos,
+  disableRepos,
+  activateDebugFilter,
+  productAlreadySynced,
+  sccProductId,
+  sccProductName,
+  setSelectedReposFromChild,
+}) => {
+  const [isOpen, setIsOpen] = useState(false);
+  // set initial selected values to the already checked repos
+  const [selected, setSelected] = useState(
+    setRepoSelection(
+      sccRepos,
+      disableRepos,
+      activateDebugFilter,
+      productAlreadySynced
+    )
+  );
+  const onToggle = (toggle) => {
+    setIsOpen(toggle);
+  };
+
+  useEffect(() => {
+    const selectedRepos = setRepoSelection(
+      sccRepos,
+      disableRepos,
+      activateDebugFilter,
+      productAlreadySynced
+    );
+    setSelected(selectedRepos);
+    setSelectedReposFromChild(
+      sccProductId,
+      sccProductName,
+      sccRepos
+        // make sure that we do not request already subscribed repositories
+        .filter(
+          (repo) =>
+            selectedRepos.includes(repo.name) &&
+            repo.katello_root_repository_id === null
+        )
+        .map((repo) => repo.id),
+      sccRepos
+        // make sure that we do not request already subscribed repositories
+        .filter(
+          (repo) =>
+            selectedRepos.includes(repo.name) &&
+            repo.katello_root_repository_id === null
+        )
+        .map((repo) => repo.name)
+    );
+  }, [
+    sccRepos,
+    disableRepos,
+    activateDebugFilter,
+    productAlreadySynced,
+    sccProductId,
+    setSelectedReposFromChild,
+  ]);
+
+  const onSelect = (event, selection) => {
+    let selectedRepos = [];
+    if (event.target.checked) {
+      selectedRepos = [...new Set(selected.concat([selection]))];
+    } else {
+      selectedRepos = selected.filter((item) => item !== selection);
+    }
+    setSelected(selectedRepos);
+    setSelectedReposFromChild(
+      sccProductId,
+      sccProductName,
+      sccRepos
+        // make sure that we do not request already subscribed repositories
+        .filter(
+          (repo) =>
+            selectedRepos.includes(repo.name) &&
+            repo.katello_root_repository_id === null
+        )
+        .map((repo) => repo.id),
+      sccRepos
+        // make sure that we do not request already subscribed repositories
+        .filter(
+          (repo) =>
+            selectedRepos.includes(repo.name) &&
+            repo.katello_root_repository_id === null
+        )
+        .map((repo) => repo.name)
+    );
+  };
+
+  const selectOptions = sccRepos.map((repo) =>
+    createRepoSelectOption(repo, disableRepos)
+  );
+
+  return (
+    <Select
+      variant={SelectVariant.checkbox}
+      isCheckboxSelectionBadgeHidden
+      onToggle={onToggle}
+      onSelect={onSelect}
+      selections={selected}
+      isOpen={isOpen}
+      isDisabled={disableRepos}
+      placeholderText={sprintf(__('%s/%s'), selected.length, sccRepos.length)}
+    >
+      {selectOptions}
+    </Select>
+  );
+};
+
+SCCRepoPicker.propTypes = {
+  sccRepos: PropTypes.array,
+  disableRepos: PropTypes.bool,
+  activateDebugFilter: PropTypes.bool,
+  productAlreadySynced: PropTypes.bool,
+  sccProductId: PropTypes.number.isRequired,
+  sccProductName: PropTypes.string.isRequired,
+  setSelectedReposFromChild: PropTypes.func.isRequired,
+};
+
+SCCRepoPicker.defaultProps = {
+  sccRepos: [],
+  disableRepos: false,
+  activateDebugFilter: false,
+  productAlreadySynced: false,
+};
+
+export default SCCRepoPicker;

data/webpack/components/SCCProductPage/components/SCCProductPicker/components/SCCTreePicker/components/SCCRepoPicker/styles.scss

@@ -0,0 +1,3 @@
+.pf-c-tree-view__node .pf-c-tree-view__node-count .pf-c-badge.pf-m-read {
+    --pf-c-badge--m-read--BackgroundColor: transparent;
+ }