foreman_scc_manager 1.8.20 → 2.0.0

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;
+ }

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

@@ -0,0 +1,303 @@
+import React, { useState, useEffect } from 'react';
+import { useDispatch } from 'react-redux';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+import {
+  TreeView,
+  Button,
+  Tooltip,
+  Switch,
+  Flex,
+  FlexItem,
+  Card,
+  CardBody,
+} from '@patternfly/react-core';
+import { cloneDeep, merge, clone } from 'lodash';
+import SCCRepoPicker from './components/SCCRepoPicker';
+import { subscribeProductsWithReposAction } from '../../../../SCCProductPageActions';
+import SCCProductTreeExpander from '../../../common/SCCProductTreeExpander';
+
+const addCheckBoxToTree = (tree) => {
+  const checkProps = {};
+  checkProps.checked = tree.product_id !== null;
+  checkProps.disabled = tree.product_id !== null;
+  tree.checkProps = checkProps;
+
+  return tree;
+};
+
+const addParentToTree = (tree, par) => {
+  tree.parent = par;
+  return tree;
+};
+
+const addSCCRepoPickerToTree = (
+  tree,
+  disableRepos,
+  activateDebugFilter,
+  setSelectedReposFromChild
+) => {
+  tree.customBadgeContent[0] = (
+    <Tooltip content={__('Filter repositories')}>
+      <SCCRepoPicker
+        sccRepos={tree.scc_repositories}
+        disableRepos={tree.product_id === null && !tree.checkProps.checked}
+        activateDebugFilter={activateDebugFilter}
+        productAlreadySynced={tree.product_id !== null}
+        sccProductId={tree.id}
+        sccProductName={tree.name}
+        setSelectedReposFromChild={setSelectedReposFromChild}
+      />{' '}
+    </Tooltip>
+  );
+  return tree;
+};
+
+const setupTreeViewListItem = (
+  tree,
+  isRoot,
+  activateDebugFilter,
+  setSelectedReposFromChild
+) => {
+  tree.customBadgeContent = [];
+  addCheckBoxToTree(tree);
+  addSCCRepoPickerToTree(
+    tree,
+    tree.product_id === null,
+    activateDebugFilter,
+    setSelectedReposFromChild
+  );
+  if ('children' in tree) {
+    tree.children = tree.children.map((p) =>
+      setupTreeViewListItem(
+        p,
+        false,
+        activateDebugFilter,
+        setSelectedReposFromChild
+      )
+    );
+    tree.children.map((child) => addParentToTree(child, tree));
+  }
+  return tree;
+};
+
+const checkAllParents = (
+  tree,
+  activateDebugFilter,
+  setSelectedReposFromChild
+) => {
+  if (!tree.checkProps.checked) {
+    tree.checkProps.checked = true;
+    addSCCRepoPickerToTree(
+      tree,
+      false,
+      activateDebugFilter,
+      setSelectedReposFromChild
+    );
+  }
+  if (tree.parent)
+    checkAllParents(
+      tree.parent,
+      activateDebugFilter,
+      setSelectedReposFromChild
+    );
+
+  return tree;
+};
+
+const uncheckAllChildren = (
+  tree,
+  activateDebugFilter,
+  setSelectedReposFromChild
+) => {
+  if (tree.product_id === null) {
+    tree.checkProps.checked = false;
+    addSCCRepoPickerToTree(
+      tree,
+      true,
+      activateDebugFilter,
+      setSelectedReposFromChild
+    );
+  }
+  if ('children' in tree)
+    tree.children = tree.children.map((c) =>
+      uncheckAllChildren(c, activateDebugFilter, setSelectedReposFromChild)
+    );
+
+  return tree;
+};
+
+const getRootParent = (tree) => {
+  if (tree.parent) return getRootParent(tree.parent);
+
+  return tree;
+};
+
+const SCCTreePicker = ({
+  sccProducts,
+  sccAccountId,
+  resetFormFromParent,
+  handleSubscribeCallback,
+}) => {
+  const dispatch = useDispatch();
+  // this needs to be uninitialized such that the first call to setAllExpanded can actually
+  // change the value of allExpanded
+  const [expandAll, setExpandAll] = useState();
+  const [selectedRepos, setSelectedRepos] = useState({});
+  // the debug filter is actually a 'includeDebugRepos' setting which should not be active by default
+  const [activateDebugFilter, setActivateDebugFilter] = useState(false);
+
+  const setSelectedReposFromChild = (
+    productId,
+    productName,
+    repoIds,
+    repoNames
+  ) => {
+    if (repoIds.length !== 0) {
+      selectedRepos[productId] = {};
+      selectedRepos[productId].repoIds = repoIds;
+      selectedRepos[productId].productName = productName;
+      selectedRepos[productId].repoNames = repoNames;
+      const newSelectedRepos = clone(selectedRepos);
+      setSelectedRepos(newSelectedRepos);
+    } else if (selectedRepos !== {} && productId in selectedRepos) {
+      delete selectedRepos[productId];
+      const newSelectedRepos = clone(selectedRepos);
+      setSelectedRepos(newSelectedRepos);
+    }
+  };
+
+  const [sccProductTree, setSccProductTree] = useState(
+    cloneDeep(sccProducts).map((p) =>
+      setupTreeViewListItem(
+        p,
+        true,
+        activateDebugFilter,
+        setSelectedReposFromChild
+      )
+    )
+  );
+
+  useEffect(() => {
+    setSccProductTree(
+      cloneDeep(sccProducts).map((p) =>
+        setupTreeViewListItem(
+          p,
+          true,
+          activateDebugFilter,
+          setSelectedReposFromChild
+        )
+      )
+    );
+    // some thorough cleaning is required for hash maps
+    Object.keys(selectedRepos).forEach((k) => delete selectedRepos[k]);
+  }, [sccProducts]);
+
+  const setExpandAllFromChild = (expandAllFromChild) => {
+    setExpandAll(expandAllFromChild);
+  };
+
+  const debugFilterChange = (evt) => {
+    setActivateDebugFilter(!activateDebugFilter);
+  };
+
+  const onCheck = (evt, treeViewItem) => {
+    if (evt.target.checked) {
+      checkAllParents(
+        treeViewItem,
+        activateDebugFilter,
+        setSelectedReposFromChild
+      );
+    } else {
+      uncheckAllChildren(
+        treeViewItem,
+        activateDebugFilter,
+        setSelectedReposFromChild
+      );
+    }
+
+    setSccProductTree([...merge(sccProductTree, getRootParent(treeViewItem))]);
+  };
+
+  const submitForm = (evt) => {
+    const productsToSubscribe = [];
+    Object.keys(selectedRepos).forEach((k) => {
+      const repo = {
+        scc_product_id: parseInt(k, 10),
+        repository_list: selectedRepos[k].repoIds,
+      };
+      productsToSubscribe.push(repo);
+    });
+    dispatch(
+      subscribeProductsWithReposAction(
+        sccAccountId,
+        productsToSubscribe,
+        handleSubscribeCallback,
+        selectedRepos
+      )
+    );
+    // reset data structure and form
+    setSelectedRepos({});
+    resetFormFromParent();
+  };
+
+  return (
+    <Card>
+      <CardBody>
+        <Flex direction={{ default: 'column' }}>
+          <Flex>
+            <SCCProductTreeExpander
+              setExpandAllInParent={setExpandAllFromChild}
+            />
+            <FlexItem>
+              <Tooltip
+                content={__(
+                  'If this option is enabled, debug and source pool repositories are automatically selected if you select a product. This option is disabled by default. It applies for unselected products, only. Already selected products are not filtered.'
+                )}
+              >
+                <Switch
+                  id="filter-debug-switch"
+                  onChange={debugFilterChange}
+                  isChecked={activateDebugFilter}
+                  label={__('Include Debug and Source Pool repositories')}
+                />
+              </Tooltip>
+            </FlexItem>
+          </Flex>
+          <Flex>
+            <TreeView
+              data={sccProductTree}
+              allExpanded={expandAll}
+              onCheck={onCheck}
+              hasChecks
+              hasBadges
+              hasGuides
+            />
+          </Flex>
+          <Flex>
+            <Button
+              variant="primary"
+              onClick={submitForm}
+              isDisabled={Object.keys(selectedRepos).length === 0}
+            >
+              {__('Add product(s)')}
+            </Button>
+          </Flex>
+        </Flex>
+      </CardBody>
+    </Card>
+  );
+};
+
+SCCTreePicker.propTypes = {
+  sccProducts: PropTypes.array,
+  sccAccountId: PropTypes.number.isRequired,
+  resetFormFromParent: PropTypes.func.isRequired,
+  handleSubscribeCallback: PropTypes.func.isRequired,
+};
+
+SCCTreePicker.defaultProps = {
+  sccProducts: [],
+};
+
+export default SCCTreePicker;