foreman_scc_manager 1.8.20 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39d299a2ed13146bd47fda51bfe3b47cccc78a2fe3984f5070b38acfa1d54bb0
-  data.tar.gz: eb22cc8040b485c69aa0dffd09b91a5ba926e89c9d124f4d9a32800a8db7546f
+  metadata.gz: 73d2510abbdbe51fef59bba613502fb02ef1fe14eeb441f0bee716b17e2eba8d
+  data.tar.gz: c61b9f852d58033c290204508d0d4653e5379c6c8b73e6d5b58d026ea485b0f0
 SHA512:
-  metadata.gz: bf8c718efe53da5e8f8b417e249bfb3826a080f328331bee932af7108b0fea3da7a0f6b2fc5f581dc0c9f1588e056ae19d1dad83a2e3f45e2ba776763f672a1a
-  data.tar.gz: 83665d655bb8fa02fa9140115b3d6a604c7e18bde4c1bb4cc5d0bda505c2e1df7cb8c34fc515c62894e0964edc78ca0c773ca5ec34ed1d821ffe87304ecdd0b3
+  metadata.gz: d3ce92fbe191d0aaa6f10d0015ed4a3e3320892d1f45a519a965cdbd63a93e49a0fe6918fcc1b7cfb4618b8a8fc016349bfbceba5825a93ca5400dce5dd18e03
+  data.tar.gz: a48593aa198df8fbc5b4c88a2654facb7dc1f77f80373d3cf7a03fa46e84bd5f02af338af0a0e1dd2968da7e7afa6e44548f992e51d1ece7a0a82fa05922f0d9

data/README.md

@@ -8,7 +8,13 @@ Foreman plugin to sync SUSE Customer Center products and repositories into Katel
 
 ## Installation
 
-This plugin installation is not supported by foreman-installer and has to be installed manually:
+This plugin installation is supported since Foreman 3.4 / Katello 4.6 by the foreman-installer, but only with the scenario Katello:
+
+```sh
+foreman-install --scenario katello --enable-foreman-plugin-scc-manager
+```
+
+You can also install it manually:
 
 ```sh
 yum install tfm-rubygem-foreman_scc_manager
@@ -20,18 +26,16 @@ foreman-installer
 
 | Foreman Version | Katello Version | Plugin Version |
 | --------------- | --------------- | -------------- |
+| 3.5             | 4.5             | ~> 2.0.0       |
+| 3.1             | 4.3             | ~> 1.8.20\*    |
+| 3.0             | 4.2             | ~> 1.8.20      |
+| 2.5             | 4.1             | ~> 1.8.20      |
 | 2.3             | 3.18            | ~> 1.8.9       |
 | 2.1             | 3.16            | ~> 1.8.5       |
 | 2.0             | 3.16            | ~> 1.8.4       |
 | 1.24            | 3.14            | ~> 1.8.0       |
-| 1.22            | 3.12            | ~> 1.7.0       |
-| 1.21            | 3.10            | ~> 1.6.0       |
-| 1.20            | 3.9             | ~> 1.6.0       |
-| 1.19            | 3.8             | ~> 1.5.1       |
-| 1.18            | 3.7             | ~> 1.5.0       |
-| 1.17            | 3.6             | >= 1.3.1       |
-| 1.16            | 3.5             | <= 1.3.0       |
-| 1.15            | 3.4             | ~> 1.1.0       |
+
+\* If you are using foreman_scc_manager in version 1.8.20 and then upgrade to Katello 4.3, you need to manually run the following rake task on your Foreman instance: `foreman-rake foreman_scc_manager:setup_authentication_tokens`.
 
 ## Documentation
 
@@ -47,7 +51,7 @@ Fork and send a Pull Request. Thanks!
 
 ## Copyright
 
-Copyright (c) 2021 ATIX AG - https://atix.de
+Copyright (c) 2022 ATIX AG - https://atix.de
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

data/app/controllers/api/v2/scc_accounts_controller.rb

@@ -10,7 +10,7 @@ module Api
         api_base_url '/api/v2'
       end
 
-      before_action :find_resource, :only => [:show, :update, :destroy, :sync, :bulk_subscribe]
+      before_action :find_resource, :only => [:show, :update, :destroy, :sync, :bulk_subscribe, :bulk_subscribe_with_repos]
 
       api :GET, '/scc_accounts/', N_('List all scc_accounts')
       param :organization_id, :identifier, :required => true
@@ -105,12 +105,16 @@ module Api
       param :id, :identifier_dottable, :required => true
       param :scc_subscribe_product_ids, Array, :required => true
       def bulk_subscribe
-        scc_products_to_subscribe = @scc_account.scc_products.where(:id => params[:scc_subscribe_product_ids])
         respond_to do |format|
-          if scc_products_to_subscribe.count > 0
+          if params[:scc_subscribe_product_ids].count > 0
+            # we need to pass two parameters to the product subscribe task,
+            # the product itself and an array of repo ids
+            # if the id array is empty, all repositories will be subscribed to
+            scc_products = @scc_account.scc_products.where(:id => params[:scc_subscribe_product_ids])
             subscribe_task = ForemanTasks.async_task(::Actions::BulkAction,
                                                      ::Actions::SccManager::SubscribeProduct,
-                                                     scc_products_to_subscribe)
+                                                     scc_products,
+                                                     {})
             format.json { render json: subscribe_task.to_json, status: :ok }
           else
             format.json { render json: { error: 'No Product selected' }, status: :expectation_failed }
@@ -122,6 +126,43 @@ module Api
         render json: { error: ('Lock on SCC account already taken: %s' % e).to_s }, status: :unprocessable_entity
       end
 
+      def_param_group :scc_product_data do
+        param :scc_product_data, Array, :required => true, :desc => 'Array of Hash elements. One hash element contains an scc_product_id and a repository_list.' do
+          param :scc_product_id, Integer, :required => true, :desc => 'Product ID of SCC product'
+          param :repository_list, Array, of: Integer, :required => false,
+                                         :desc => 'List of SCC repositories belonging to the SCC product. If the list is empty, all repositories will be subscribed to.'
+        end
+      end
+
+      api :PUT, '/scc_accounts/:id/bulk_subscribe_with_repos/', N_('Bulk subscription of scc_products with individual repository selection for scc_account.')
+      param :id, :identifier_dottable, :required => true
+      param_group :scc_product_data
+      def bulk_subscribe_with_repos
+        respond_to do |format|
+          # if we want to subscribe to specific repos, we need to pass the product and the
+          # corresponding repository ids instead of scc products only
+          if params[:scc_product_data].count > 0
+            scc_products = @scc_account.scc_products.where(:id => params[:scc_product_data].pluck(:scc_product_id))
+            if scc_products.empty?
+              format.json { render json: { error: _('The selected products cannot be found for this SCC account.') }, status: :unprocessable_entity }
+            else
+              action_args = params[:scc_product_data].map { |p| { p['scc_product_id'] => p['repository_list'] } }.inject(:merge)
+              subscribe_task = ForemanTasks.async_task(::Actions::BulkAction,
+                                                       ::Actions::SccManager::SubscribeProduct,
+                                                       scc_products,
+                                                       action_args)
+              format.json { render json: subscribe_task.to_json, status: :ok }
+            end
+          else
+            format.json { render json: { error: 'No Product selected' }, status: :expectation_failed }
+          end
+        end
+      rescue ::Foreman::Exception => e
+        render json: { error: ('Failed to add task to queue: %s' % e).to_s }, status: :unprocessable_entity
+      rescue ForemanTasks::Lock::LockConflict => e
+        render json: { error: ('Lock on SCC account already taken: %s' % e).to_s }, status: :unprocessable_entity
+      end
+
       private
 
       def scc_account_params
@@ -152,6 +193,8 @@ module Api
           :sync
         when 'bulk_subscribe'
           :bulk_subscribe
+        when 'bulk_subscribe_with_repos'
+          :bulk_subscribe_with_repos
         else
           super
         end

data/app/controllers/api/v2/scc_products_controller.rb

@@ -41,7 +41,7 @@ module Api
       param :id, :identifier_dottable, :required => true
       param :scc_account_id, :identifier_dottable, :required => true
       def subscribe
-        subcribe_task = ForemanTasks.async_task(::Actions::SccManager::SubscribeProduct, @scc_product) if @scc_product
+        subcribe_task = ForemanTasks.async_task(::Actions::SccManager::SubscribeProduct, @scc_product, {}) if @scc_product
         respond_to do |format|
           if subcribe_task
             format.json { render json: subcribe_task.to_json, status: :ok }

data/app/controllers/scc_accounts_controller.rb

@@ -1,5 +1,6 @@
 class SccAccountsController < ApplicationController
   helper_method :scc_filtered_products
+  helper_method :create_nested_product_tree
   before_action :find_organization
   before_action :find_resource, only: %i[show edit update destroy sync bulk_subscribe]
   before_action :find_available_gpg_keys, only: %i[new edit update create]
@@ -97,6 +98,52 @@ class SccAccountsController < ApplicationController
     redirect_to scc_accounts_path
   end
 
+  def create_nested_product_tree(scc_products, subscribed_only:)
+    if subscribed_only
+      scc_products_base = scc_products.where(:product_type => 'base').where.not(:product_id => nil).includes([:scc_extensions])
+    else
+      scc_products_base = scc_products.where(:product_type => 'base').includes([:scc_extensions])
+    end
+    tree = []
+    scc_products_base.each do |p|
+      tree.push(get_product_tree_hash(p))
+    end
+
+    tree
+  end
+
+  def scc_product_hash(scc_product)
+    scc_product_json = scc_product.as_json(:only => [:scc_id, :id, :arch, :version, :product_id, :subscription_valid],
+                                           include: { :scc_repositories => { :only => [:id, :name, :subscription_valid] } })
+                                  .merge('name' => scc_product.pretty_name, 'product_category' => scc_product.product_category)
+    # find if and which Katello root repository is associated with this SCC product
+    repo_ids_katello = scc_product.product.blank? || scc_product.product.root_repository_ids.blank? ? nil : scc_product.product.root_repository_ids
+    scc_product_json['scc_repositories'].each do |repo|
+      # byebug
+      if repo_ids_katello.blank?
+        repo['katello_root_repository_id'] = nil
+      else
+        repo_ids_scc = scc_product.scc_repositories.find(repo['id']).katello_root_repository_ids
+        repo['katello_root_repository_id'] = repo_ids_scc.blank? ? nil : (repo_ids_scc & repo_ids_katello).first
+      end
+    end
+    scc_product_json
+  end
+
+  def get_product_tree_hash(scc_product_base)
+    if scc_product_base.scc_extensions.blank?
+      scc_product_hash(scc_product_base)
+    else
+      children = []
+      scc_product_base.scc_extensions.each do |ext|
+        children.push(get_product_tree_hash(ext))
+      end
+      scc_product_base_hash = scc_product_hash(scc_product_base)
+      scc_product_base_hash['children'] = children
+      scc_product_base_hash
+    end
+  end
+
   private
 
   def find_available_gpg_keys

data/app/lib/actions/scc_manager/subscribe_product.rb

@@ -1,22 +1,54 @@
 module Actions
   module SccManager
     class SubscribeProduct < Actions::EntryAction
-      def plan(scc_product)
-        raise _('Product already subscribed!') if scc_product.product
+      # scc_product is an ActiveRecord object of Class SccProduct
+      # scc_repos_to_subscribe is a hash with the product id as keys and an array of
+      # repos to subscribe as values
+      # rubocop:disable Metrics/MethodLength
+      def plan(scc_product, scc_repos_to_subscribe)
+        if scc_product.product
+          ::Foreman::Logging.logger('foreman_scc_manager')
+                            .info("SccProduct '#{scc_product.friendly_name}' is already subscribed to.")
+        else
+          ::Foreman::Logging.logger('foreman_scc_manager')
+                            .info("Initiating subscription for SccProduct '#{scc_product.friendly_name}'.")
+        end
 
-        ::Foreman::Logging.logger('foreman_scc_manager')
-                          .info("Initiating subscription for SccProduct '#{scc_product.friendly_name}'.")
         sequence do
-          product_create_action = plan_action(CreateProduct,
-                                              :product_name => scc_product.pretty_name,
-                                              :product_description => scc_product.pretty_description,
-                                              :organization_id => scc_product.organization.id,
-                                              :gpg_key => scc_product.scc_account.katello_gpg_key_id)
+          if scc_product.product_id.nil?
+            product_create_action = plan_action(CreateProduct,
+                                                :product_name => scc_product.pretty_name,
+                                                :product_description => scc_product.pretty_description,
+                                                :organization_id => scc_product.organization.id,
+                                                :gpg_key => scc_product.scc_account.katello_gpg_key_id)
+          end
           katello_repos = {}
-          scc_product.scc_repositories.each do |repo|
+          # we need to set the repositories to subscribe to
+          scc_repos = []
+          if scc_repos_to_subscribe.empty?
+            scc_repos = scc_product.scc_repositories
+          else
+            # at this point, we need to make sure that the repository list is valid
+            # we want to subscribe only to repos that we have not subscribed before
+            repo_ids_katello = scc_product.product.blank? || scc_product.product.root_repository_ids.blank? ? nil : scc_product.product.root_repository_ids
+            scc_repos = scc_product.scc_repositories.where(id: scc_repos_to_subscribe[scc_product.id])
+            unless repo_ids_katello.nil? || scc_repos.empty?
+              # remove repo if Katello repo is already associated
+              scc_repos.reject { |repo| (repo.katello_root_repositories & repo_ids_katello).present? }
+            end
+          end
+          if scc_repos.empty?
+            ::Foreman::Logging.logger('foreman_scc_manager')
+                              .info('The repositories you have selected are either already subscribed to or invalid.')
+          else
+            ::Foreman::Logging.logger('foreman_scc_manager')
+                              .info("Subscribing to SCC repositories '#{scc_repos.pluck(:id)}'.
+                                    If you requested more repositories, please check if those are already subscribed to or invalid.")
+          end
+          scc_repos.each do |repo|
             arch = scc_product.arch || 'noarch'
             repo_create_action = plan_action(CreateRepository,
-                                             :product_id => product_create_action.output[:product_id],
+                                             :product_id => scc_product.product_id || product_create_action.output[:product_id],
                                              :uniq_name => repo.uniq_name(scc_product),
                                              :pretty_repo_name => repo.pretty_name,
                                              :url => repo.url,
@@ -24,18 +56,22 @@ module Actions
                                              :arch => arch)
             katello_repos[repo.id] = repo_create_action.output[:katello_root_repository_id]
           end
+
           # connect action to resource (=> make parameters accessable in input)
-          action_subject(scc_product, product_id: product_create_action.output[:product_id])
+          action_subject(scc_product, product_id: product_create_action.output[:product_id]) if scc_product.product_id.nil?
           input.update(katello_repos: katello_repos)
           plan_self
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       def finalize
         # connect Scc products and Katello products
-        scc_product = SccProduct.find(input[:scc_product][:id])
-        product = ::Katello::Product.find(input[:product_id])
-        scc_product.update!(product: product)
+        # it may happen that we only append repos to an existing product
+        unless input[:scc_product].nil?
+          scc_product = SccProduct.find(input[:scc_product][:id])
+          scc_product.update!(product_id: input[:product_id])
+        end
         # extract Katello repo ids from input hash and store to database
         input[:katello_repos].each do |scc_repo_id, katello_root_repository_id|
           SccKatelloRepository.find_or_create_by(scc_repository_id: scc_repo_id, katello_root_repository_id: katello_root_repository_id)

data/app/models/scc_account.rb

@@ -219,8 +219,8 @@ class SccAccount < ApplicationRecord
       cached_product.product_type = up['product_type']
       cached_product.scc_repositories =
         scc_repositories.where(scc_id: up['repositories'].map { |repo| repo['id'] })
-      # name should be set after friendly_name because it depends on friendly_name
       cached_product.name = cached_product.pretty_name
+      cached_product.product_category = up['name']
       cached_product.description = cached_product.pretty_description
       cached_product.subscription_valid = true
       cached_product.save!

data/app/views/scc_accounts/show.html.erb

@@ -1,52 +1,8 @@
 <% title (_("Product Selection for Account %s") % @scc_account) %>
-
-<% javascript 'foreman_scc_manager/scc_accounts' %>
-<%= form_for([:bulk_subscribe, @scc_account], method: :put) do |f| %>
-  <% def render_list_node(f, scc_product, parent_id = "") %>
-    <li>
-      <span class="scc_product_checkbox" id="<%= "scc_product_span_#{parent_id + "_" + scc_product.id.to_s}" %>" <%= "data-parent=scc_product_span_#{parent_id}" if parent_id != "" %>>
-        <% if scc_product.product %>
-          <%= check_box_tag("scc_account[scc_unsubscribe_product_ids][]", scc_product.id, true, disabled: true) %>
-          <%= link_to(scc_product.pretty_name, "/products/#{scc_product.product_id}") %>
-        <% else %>
-          <%= check_box_tag("scc_account[scc_subscribe_product_ids][]", scc_product.id, false) %>
-          <%= scc_product.pretty_name %>
-        <% end %>
-        <% unless scc_product.subscription_valid? %>
-          <span style="color:red">
-            <%= _('(WARNING: Please check your SUSE subscription)') %>
-          </span>
-        <% end %>
-      </span>
-      <% if scc_product.scc_extensions.any? %>
-        <ul style='padding-left: 20px;'>
-          <% scc_filtered_products(scc_product.scc_extensions, 'extension').each do |scc_extension| %>
-            <% render_list_node(f, scc_extension, parent_id + "_" + scc_product.id.to_s) %>
-          <% end %>
-        </ul>
-      <% end %>
-    </li>
-  <% end %>
-
-  <%= f.hidden_field :prevent_missing, value: 1 %>
-  <ul class="nav nav-tabs" data-tabs="tabs">
-    <li class="active"><a href="#primary" data-toggle="tab"><%= _("SUSE Customer Center") %></a></li>
-  </ul>
-
-  <div class="tab-content">
-    <div class="tab-pane active" id="primary">
-      <ul>
-        <% if @scc_account.synced %>
-          <% scc_filtered_products(@scc_account.scc_products).each do |scc_product| %>
-            <% render_list_node(f, scc_product) %>
-          <% end %>
-        <% else %>
-          <%= _('Please sync your SUSE subscriptions first.') %>
-          <% submit_disabled = true %>
-        <% end %>
-      </ul>
-    </div>
-    <%= submit_or_cancel f, false, {disabled: submit_disabled || false} %>
-  </div>
-<% end %>
-
+<%= webpacked_plugins_js_for :foreman_scc_manager %>
+<%= webpacked_plugins_css_for :foreman_scc_manager %>
+<%= react_component('SCCProductPage', {
+  :canCreate => authorized_for(action: :sync),
+  :sccAccountId => @scc_account.id,
+  :sccProductsInit => create_nested_product_tree(@scc_account.scc_products, subscribed_only: false)
+}) %>

data/config/routes.rb

@@ -32,6 +32,7 @@ Rails.application.routes.draw do
           put 'test_connection'
           put 'sync'
           put 'bulk_subscribe'
+          put 'bulk_subscribe_with_repos'
         end
       end
       constraints(:scc_account_id => /[^\/]+/) do

data/db/migrate/20220429102717_populate_scc_katello_repositories.rb

@@ -3,6 +3,11 @@ class PopulateSccKatelloRepositories < ActiveRecord::Migration[6.0]
     belongs_to :product, class_name: 'Katello::Product'
     has_and_belongs_to_many :scc_repositories
   end
+  class SccRepository < ApplicationRecord
+    has_many :scc_katello_repositories
+    has_many :katello_root_repositories, through: :scc_katello_repositories
+    has_and_belongs_to_many :scc_products
+  end
 
   def up
     SccProduct.where.not(product_id: nil).each do |scc_p|

data/db/migrate/20220531120722_add_product_category_to_scc_products.rb

@@ -0,0 +1,5 @@
+class AddProductCategoryToSccProducts < ActiveRecord::Migration[6.0]
+  def change
+    add_column :scc_products, :product_category, :string, null: true
+  end
+end

data/lib/foreman_scc_manager/engine.rb

@@ -38,7 +38,7 @@ module ForemanSccManager
 
           permission :use_scc_accounts,
                      { :scc_accounts => [:bulk_subscribe],
-                       :'api/v2/scc_accounts' => [:bulk_subscribe] },
+                       :'api/v2/scc_accounts' => [:bulk_subscribe, :bulk_subscribe_with_repos] },
                      :resource_type => 'SccAccount'
 
           permission :new_scc_accounts,

data/lib/foreman_scc_manager/version.rb

@@ -1,3 +1,3 @@
 module ForemanSccManager
-  VERSION = '1.8.20'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/tasks/republish_repositories.rake

@@ -0,0 +1,13 @@
+namespace :foreman_scc_manager do
+  desc 'Republish all SCC-repositories.'
+  task :republish_scc_repositories => ['dynflow:client', 'katello:check_ping'] do
+    needing_publish = SccKatelloRepository.joins(:katello_root_repository)
+                                          .joins(:katello_root_repository => :repositories)
+                                          .pluck("#{Katello::Repository.table_name}.id")
+    if needing_publish.any?
+      ForemanTasks.async_task(::Actions::Katello::Repository::BulkMetadataGenerate, Katello::Repository.where(:id => needing_publish))
+    else
+      puts 'Skipped. No repository found which was created by the SCC plugin.'
+    end
+  end
+end

data/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "foreman_scc_manager",
+  "version": "1.8.16",
+  "description": "Foreman plugin to sync SUSE Customer Center products and repositories into Katello ",
+  "main": "index.js",
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "create-react-component": "yo react-domain"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/ATIX-AG/foreman_scc_manager.git"
+  },
+  "peerDependencies": {
+    "@theforeman/vendor": "^4.14.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.7.0",
+    "babel-eslint": "^10.0.0",
+    "babel-loader": "^8.0.0",
+    "@theforeman/builder": "^4.14.0",
+    "@theforeman/eslint-plugin-foreman": "^8.16.0",
+    "@theforeman/find-foreman": "^4.14.0",
+    "@theforeman/stories": "^4.14.0",
+    "@theforeman/test": "^4.14.0",
+    "@theforeman/vendor-dev": "^4.14.0",
+    "eslint": "^6.7.2",
+    "eslint-plugin-spellcheck": "0.0.17",
+    "eslint-plugin-react": "^7.27.1",
+    "eslint-plugin-react-hooks": "^4.3.0",
+    "prettier": "^2.5.1",
+    "react-redux-test-utils": "^0.2.0"
+  },
+  "keywords": [
+    "SUSE",
+    "Katello",
+    "products",
+    "repositories"
+  ],
+  "author": "ATIX AG",
+  "license": "GPL-3.0",
+  "bugs": {
+    "url": "https://github.com/ATIX-AG/foreman_scc_manager/issues"
+  },
+  "homepage": "https://github.com/ATIX-AG/foreman_scc_manager#readme",
+  "dependencies": {
+    "react-native-elements": "^3.4.2",
+    "react-native-vector-icons": "^9.0.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
 

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;