katello 4.5.0 → 4.6.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 687476385ef6943c54b1bbe07e424155cde7b21fc79230d3013a730cdd5d2261
-  data.tar.gz: 9619b38f2b5505ced4d59a6e46ce8042be4d0a95bcdabf467177554b33d48b04
+  metadata.gz: ed8eb04c88654bdacc69fa01282d4122141a68430d8259cc6f0ec46dcae06367
+  data.tar.gz: 96bc2cd4a26684dae6a71884a3fd745469b30118e723613f2640b8017a1c6b50
 SHA512:
-  metadata.gz: e03d2a7fcd995895fbc94435d5bed4fae374a5a3a081ffce1bbe12f249dafa8ebba964c62c8d018419c3744ca976bcd1badada46b8bf1843e1d50842eec1cc5f
-  data.tar.gz: 8b0cbe4d4ce376daeae8901ac5f7fed804de075f9b89baf109a1134933d7cb6a910cc64cf9cd123d77b5b05bc14f531b80b7762e34cff1334ede4d0c138a69f6
+  metadata.gz: 99b345b1016334d1f7277f2eecb3f6ad8f21a90d45582a30367b49441891216b359fb118c61e2c59ec93fa4071b49e6a9c131175b7ba365613c2fb5acece0a4b
+  data.tar.gz: c9523e61da53201364bef634d3960bab1ff7120e648133b168da057bdd5d32c603c44f38e7395097fd2e3960f2451407a7f9444eb4a1382a28ab139452dc0033

data/app/controllers/katello/api/rhsm/candlepin_dynflow_proxy_controller.rb

@@ -59,6 +59,16 @@ module Katello
       @host = facet.host
     end
 
+    rescue_from RestClient::Exception do |e|
+      Rails.logger.error(pp_exception(e, with_backtrace: false))
+      Rails.logger.error(e.backtrace.detect { |line| line.match("katello.*controller") })
+      if request_from_katello_cli?
+        render :json => { :errors => [e.http_body] }, :status => e.http_code
+      else
+        render :plain => e.http_body, :status => e.http_code
+      end
+    end
+
     def authorize_client_or_user
       client_authorized? || authorize
     end

data/app/controllers/katello/api/v2/activation_keys_controller.rb

@@ -11,6 +11,7 @@ module Katello
                                                                :content_override, :add_subscriptions, :remove_subscriptions,
                                                                :subscriptions]
     before_action :verify_simple_content_access_disabled, :only => [:add_subscriptions]
+    before_action :validate_release_version, :only => [:create, :update]
 
     wrap_parameters :include => (ActivationKey.attribute_names + %w(host_collection_ids service_level auto_attach purpose_role purpose_usage purpose_addons content_view_environment))
 
@@ -337,5 +338,11 @@ module Katello
         fail HttpErrors::BadRequest, _("The specified organization is in Simple Content Access mode. Attaching subscriptions is disabled")
       end
     end
+
+    def validate_release_version
+      if params[:release_version].present? && !@organization.library.available_releases.include?(params[:release_version])
+        fail HttpErrors::BadRequest, _("Invalid release version: [%s]") % params[:release_version]
+      end
+    end
   end
 end

data/app/controllers/katello/api/v2/alternate_content_sources_controller.rb

@@ -2,10 +2,12 @@ module Katello
   class Api::V2::AlternateContentSourcesController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    acs_wrap_params = AlternateContentSource.attribute_names + [:smart_proxy_ids, :smart_proxy_names]
+    acs_wrap_params = AlternateContentSource.attribute_names + [:smart_proxy_ids, :smart_proxy_names, :product_ids]
     wrap_parameters :alternate_content_source, include: acs_wrap_params
 
     before_action :find_authorized_katello_resource, only: [:show, :update, :destroy, :refresh]
+    before_action :find_smart_proxies, only: :create
+    before_action :find_products, only: :create
 
     def_param_group :acs do
       param :name, String, desc: N_("Name of the alternate content source")
@@ -14,8 +16,6 @@ module Katello
       param :subpaths, Array, desc: N_('Path suffixes for finding alternate content'), required: false
       param :smart_proxy_ids, Array, desc: N_("Ids of smart proxies to associate"), required: false
       param :smart_proxy_names, Array, desc: N_("Names of smart proxies to associate"), required: false
-      param :content_type, RepositoryTypeManager.defined_repository_types.keys & AlternateContentSource::CONTENT_TYPES, desc: N_("The content type for the Alternate Content Source"), required: false
-      param :alternate_content_source_type, AlternateContentSource::ACS_TYPES, desc: N_("The Alternate Content Source type")
       param :upstream_username, String, desc: N_("Basic authentication username"), required: false
       param :upstream_password, String, desc: N_("Basic authentication password"), required: false
       param :ssl_ca_cert_id, :number, desc: N_("Identifier of the content credential containing the SSL CA Cert"), required: false
@@ -23,9 +23,10 @@ module Katello
       param :ssl_client_key_id, :number, desc: N_("Identifier of the content credential containing the SSL Client Key"), required: false
       param :http_proxy_id, :number, desc: N_("ID of a HTTP Proxy"), required: false
       param :verify_ssl, :bool, desc: N_("If SSL should be verified for the upstream URL"), required: false
+      param :product_ids, Array, desc: N_("IDs of products to copy repository information from into a Simplified Alternate Content Source. Products must include at least one repository of the chosen content type."), required: false
     end
 
-    api :GET, "/alternate_content_sources", N_("List of alternate_content_sources")
+    api :GET, "/alternate_content_sources", N_("List alternate content sources.")
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(AlternateContentSource)
     def index
@@ -33,9 +34,15 @@ module Katello
         format.csv do
           options[:csv] = true
           alternate_content_sources = scoped_search(index_relation, :name, :asc)
-          csv_response(alternate_content_sources,
-                       [:id, :name, :description, :label, :base_url, :subpaths, :content_type, :alternate_content_source_type],
-                       ['Id', 'Name', 'Description', 'label', 'Base URL', 'Subpaths', 'Content Type', 'Alternate Content Source Type'])
+          if @acs.custom?
+            csv_response(alternate_content_sources,
+                        [:id, :name, :description, :label, :base_url, :subpaths, :content_type, :alternate_content_source_type],
+                        ['Id', 'Name', 'Description', 'label', 'Base URL', 'Subpaths', 'Content Type', 'Alternate Content Source Type'])
+          elsif @acs.simplified?
+            csv_response(alternate_content_sources,
+                        [:id, :name, :description, :label, :content_type, :alternate_content_source_type, :products],
+                        ['Id', 'Name', 'Description', 'label', 'Content Type', 'Alternate Content Source Type', 'Products'])
+          end
         end
         format.any do
           alternate_content_sources = scoped_search(index_relation, :name, :asc)
@@ -48,46 +55,56 @@ module Katello
       AlternateContentSource.readable.distinct
     end
 
-    api :GET, '/alternate_content_sources/:id', N_('Show an alternate content source')
+    api :GET, '/alternate_content_sources/:id', N_('Show an alternate content source.')
     param :id, :number, :required => true, :desc => N_("Alternate content source ID")
     def show
       respond_for_show(:resource => @alternate_content_source)
     end
 
-    api :POST, '/alternate_content_sources', N_('Create an ACS')
+    api :POST, '/alternate_content_sources', N_('Create an alternate content source to download content from during repository syncing.  Note: alternate content sources are global and affect ALL sync actions on their smart proxies regardless of organization.')
+    param :content_type, RepositoryTypeManager.defined_repository_types.keys & AlternateContentSource::CONTENT_TYPES, desc: N_("The content type for the Alternate Content Source"), required: false
+    param :alternate_content_source_type, AlternateContentSource::ACS_TYPES, desc: N_("The Alternate Content Source type")
     param_group :acs
     def create
-      find_smart_proxies
-      @alternate_content_source = ::Katello::AlternateContentSource.new(acs_params.except(:smart_proxy_ids, :smart_proxy_names))
-      sync_task(::Actions::Katello::AlternateContentSource::Create, @alternate_content_source, @smart_proxies)
+      @alternate_content_source = ::Katello::AlternateContentSource.new(acs_params.except(:smart_proxy_ids, :smart_proxy_names, :product_ids))
+      @alternate_content_source.verify_ssl = nil if @alternate_content_source.simplified?
+      sync_task(::Actions::Katello::AlternateContentSource::Create, @alternate_content_source, @smart_proxies, @products)
       @alternate_content_source.reload
       respond_for_create(resource: @alternate_content_source)
     end
 
-    api :PUT, '/alternate_content_sources/:id', N_('Update an alternate content source')
+    api :PUT, '/alternate_content_sources/:id', N_('Update an alternate content source.')
     param_group :acs
     param :id, :number, :required => true, :desc => N_("Alternate content source ID")
     def update
-      # If a user doesn't include smart proxies in the update call, don't accidentally remove all of them.
-      if params[:smart_proxy_ids].nil?
+      # If a user doesn't include smart proxies or products in the update call, don't accidentally remove all of them.
+      if params[:smart_proxy_ids].nil? && params[:smart_proxy_names].nil?
         @smart_proxies = @alternate_content_source.smart_proxies
-      elsif params[:smart_proxy_ids].empty?
+      elsif params[:smart_proxy_ids] == [] || params[:smart_proxy_names] == []
         @smart_proxies = []
       else
         find_smart_proxies
       end
-      sync_task(::Actions::Katello::AlternateContentSource::Update, @alternate_content_source, @smart_proxies, acs_params.except(:smart_proxy_ids))
+
+      if params[:product_ids].nil?
+        @products = @alternate_content_source.products
+      elsif params[:product_ids] == []
+        @products = []
+      else
+        find_products
+      end
+      sync_task(::Actions::Katello::AlternateContentSource::Update, @alternate_content_source, @smart_proxies, @products, acs_params.except(:smart_proxy_ids, :smart_proxy_names, :product_ids))
       respond_for_show(:resource => @alternate_content_source)
     end
 
-    api :DELETE, '/alternate_content_sources/:id', N_('Destroy an alternate content source')
+    api :DELETE, '/alternate_content_sources/:id', N_('Destroy an alternate content source.')
     param :id, :number, :required => true, :desc => N_("Alternate content source ID")
     def destroy
       sync_task(::Actions::Katello::AlternateContentSource::Destroy, @alternate_content_source)
       respond_for_destroy
     end
 
-    api :POST, '/alternate_content_sources/:id/refresh', N_('Refresh an alternate content source')
+    api :POST, '/alternate_content_sources/:id/refresh', N_('Refresh an alternate content source. Refreshing, like repository syncing, is required before using an alternate content source.')
     param :id, :number, :required => true, :desc => N_("Alternate content source ID")
     def refresh
       task = async_task(::Actions::Katello::AlternateContentSource::Refresh, @alternate_content_source)
@@ -97,9 +114,9 @@ module Katello
     protected
 
     def acs_params
-      keys = [:name, :label, :base_url, {subpaths: []}, {smart_proxy_ids: []}, {smart_proxy_names: []}, :content_type, :alternate_content_source_type,
-              :upstream_username, :upstream_password, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id,
-              :http_proxy_id, :verify_ssl]
+      keys = [:name, :label, :description, {smart_proxy_ids: []}, {smart_proxy_names: []}, :content_type, :alternate_content_source_type]
+      keys += [:base_url, {subpaths: []}, :upstream_username, :upstream_password, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id, :http_proxy_id, :verify_ssl] if params[:action] == 'create' || @alternate_content_source&.custom?
+      keys += [{product_ids: []}] if params[:action] == 'create' || @alternate_content_source&.simplified?
       params.require(:alternate_content_source).permit(*keys).to_h.with_indifferent_access
     end
 
@@ -117,5 +134,18 @@ module Katello
         fail HttpErrors::NotFound, _("Couldn't find smart proxies with name '%s'") % missing_smart_proxies.to_sentence
       end
     end
+
+    def find_products
+      if params[:product_ids]
+        @products = ::Katello::Product.where(id: params[:product_ids])
+      else
+        @products = nil
+      end
+
+      if params[:product_ids] && @products.length < params[:product_ids].length
+        missing_products = params[:product_ids] - @products.pluck(:id)
+        fail HttpErrors::NotFound, _("Couldn't find products with id '%s'") % missing_products.to_sentence
+      end
+    end
   end
 end

data/app/controllers/katello/api/v2/content_exports_controller.rb

@@ -34,12 +34,18 @@ module Katello
                                                "no greater than the specified size in gigabytes."), :required => false
     param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this version"\
                                                          " are unexportable. False by default."), :required => false
+    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
+                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
+                               "Choose importable if content is to be imported via hammer content-import.
+                                Defaults to importable."),
+                   :required => false
     def version
       tasks = async_task(::Actions::Katello::ContentViewVersion::Export,
                           content_view_version: @version,
                           destination_server: params[:destination_server],
                           chunk_size: params[:chunk_size_gb],
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
+                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]),
+                          format: find_export_format)
       respond_for_async :resource => tasks
     end
 
@@ -50,12 +56,18 @@ module Katello
                                                "no greater than the specified size in gigabytes."), :required => false
     param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this organization"\
                                                          " are unexportable. False by default."), :required => false
+    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
+                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
+                               "Choose importable if content is to be imported via hammer content-import.
+                                Defaults to importable."),
+                   :required => false
     def library
       tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportLibrary,
                           @organization,
                           destination_server: params[:destination_server],
                           chunk_size: params[:chunk_size_gb],
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
+                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]),
+                          format: find_export_format)
       respond_for_async :resource => tasks
     end
 
@@ -63,10 +75,16 @@ module Katello
     param :id, :number, :desc => N_("Repository identifier"), :required => true
     param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
                                                "no greater than the specified size in gigabytes."), :required => false
+    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
+                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
+                               "Choose importable if content is to be imported via hammer content-import.
+                                Defaults to importable."),
+                   :required => false
     def repository
       tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportRepository,
                           @repository,
-                          chunk_size: params[:chunk_size_gb])
+                          chunk_size: params[:chunk_size_gb],
+                          format: find_export_format)
       respond_for_async :resource => tasks
     end
 
@@ -90,5 +108,17 @@ module Katello
         throw_resource_not_found(name: 'organization', id: params[:organization_id])
       end
     end
+
+    def find_export_format
+      if params[:format]
+        unless ::Katello::Pulp3::ContentViewVersion::Export::FORMATS.include?(params[:format])
+          fail HttpErrors::UnprocessableEntity, _('Invalid export format provided. Format must be one of  %s ') %
+                                            ::Katello::Pulp3::ContentViewVersion::Export::FORMATS.join(',')
+        end
+        params[:format]
+      else
+        ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
+      end
+    end
   end
 end

data/app/controllers/katello/api/v2/content_uploads_controller.rb

@@ -2,6 +2,8 @@ module Katello
   class Api::V2::ContentUploadsController < Api::V2::ApiController
     before_action :find_repository
     skip_before_action :check_media_type, :only => [:update]
+    # https://github.com/rails/rails/issues/42278#issuecomment-918079123
+    skip_parameter_encoding :update
 
     include ::Foreman::Controller::FilterParameters
     filter_parameters :content

data/app/controllers/katello/api/v2/content_view_filter_rules_controller.rb

@@ -27,7 +27,7 @@ module Katello
     api :POST, "/content_view_filters/:content_view_filter_id/rules",
         N_("Create a filter rule. The parameters included should be based upon the filter type.")
     param :content_view_filter_id, :number, :desc => N_("filter identifier"), :required => true
-    param :name, Array, of: [String], :desc => N_("package, package group, or docker tag names")
+    param :name, Array, of: [String], :desc => N_("deb, package, package group, or docker tag names")
     param :uuid, String, :desc => N_("package group: uuid")
     param :version, String, :desc => N_("package: version")
     param :architecture, String, :desc => N_("package: architecture")

data/app/controllers/katello/api/v2/content_view_filters_controller.rb

@@ -34,7 +34,7 @@ module Katello
     api :post, "/content_view_filters", N_("create a filter for a content view")
     param :content_view_id, :number, :desc => N_("content view identifier"), :required => true
     param :name, String, :desc => N_("name of the filter"), :required => true
-    param :type, String, :desc => N_("type of filter (e.g. rpm, package_group, erratum, erratum_id, erratum_date, docker, modulemd)"), :required => true
+    param :type, String, :desc => N_("type of filter (e.g. deb, rpm, package_group, erratum, erratum_id, erratum_date, docker, modulemd)"), :required => true
     param :original_packages, :bool, :desc => N_("add all packages without errata to the included/excluded list. " \
                                                        "(package filter only)")
     param :original_module_streams, :bool, :desc => N_("add all module streams without errata to the included/excluded list. " \

data/app/controllers/katello/api/v2/debs_controller.rb

@@ -7,23 +7,28 @@ module Katello
     apipie_concern_subst(:a_resource => N_("a deb package"), :resource => "deb packages")
     include Katello::Concerns::Api::V2::RepositoryContentController
 
-    before_action :find_repositories, :only => [:auto_complete_name, :auto_complete_arch]
     before_action :find_hosts, :only => :index
+    before_action :find_repositories, :only => [:auto_complete_name, :auto_complete_arch]
 
-    def auto_complete_name
+    def auto_complete(search)
       page_size = Katello::Concerns::FilteredAutoCompleteSearch::PAGE_SIZE
       debs = Deb.in_repositories(@repositories)
-      col = "#{Deb.table_name}.name"
-      debs = debs.where("#{Deb.table_name}.name ILIKE ?", "#{params[:term]}%").select(col).group(col).order(col).limit(page_size)
+      col = ''
+      if search == 'name'
+        col = "#{Deb.table_name}.name"
+      elsif search == 'arch'
+        col = "#{Deb.table_name}.architecture"
+      end
+      debs = debs.where("#{col} ILIKE ?", "#{params[:term]}%").select(col).group(col).order(col).limit(page_size)
       render :json => debs.pluck(col)
     end
 
+    def auto_complete_name
+      auto_complete('name')
+    end
+
     def auto_complete_arch
-      page_size = Katello::Concerns::FilteredAutoCompleteSearch::PAGE_SIZE
-      debs = Deb.in_repositories(@repositories)
-      col = "#{Deb.table_name}.architecture"
-      debs = debs.where("#{col} ILIKE ?", "%#{params[:term]}%").select(col).group(col).order(col).limit(page_size)
-      render :json => debs.pluck(col)
+      auto_complete('architecture')
     end
 
     api :GET, "/debs", N_("List deb packages")
@@ -39,14 +44,41 @@ module Katello
     param :host_id, :number, :desc => N_("Host id to list applicable deb packages for")
     param :packages_restrict_applicable, :boolean, :desc => N_("Return deb packages that are applicable to one or more hosts (defaults to true if host_id is specified)")
     param :packages_restrict_upgradable, :boolean, :desc => N_("Return deb packages that are upgradable on one or more hosts")
+    param :packages_restrict_latest, :boolean, :desc => N_("Return only the latest version of each package")
     param :available_for, String, :desc => N_("Return deb packages that can be added to the specified object.  Only the value 'content_view_version' is supported.")
     param_group :search, ::Katello::Api::V2::ApiController
     def index
       super
     end
 
+    def final_custom_index_relation(collection)
+      # :packages_restrict_latest is intended to filter the result set after all
+      # other constraints have been applied, including the scoped_search
+      # constraints.  If any constraints are applied after this, then a package
+      # will not be returned if its latest version does not match those
+      # constraints, even if an older version does match those constraints.
+      collection = Katello::Deb.latest(collection) if ::Foreman::Cast.to_bool(params[:packages_restrict_latest])
+      collection
+    end
+
+    def filter_by_content_view_filter(filter, collection)
+      filtered_debs = []
+      filter.deb_rules.each do |rule|
+        filtered_debs += filter.query_debs_from_collection(collection, rule).pluck(:id)
+      end
+
+      collection.where(id: filter.applicable_debs.pluck(:id) & filtered_debs)
+    end
+
+    def filter_by_content_view_filter_rule(rule, collection)
+      filter = rule.filter
+      filtered_debs = filter.query_debs_from_collection(collection, rule).pluck(:id)
+      collection.where(id: filter.applicable_debs.pluck(:id) & filtered_debs)
+    end
+
     def default_sort
-      %w(name asc)
+      lambda { |query| query.default_sort }
+      # %w(name asc)
     end
 
     def available_for_content_view_version(version)

data/app/controllers/katello/api/v2/host_collections_controller.rb

@@ -194,7 +194,11 @@ module Katello
 
     def host_collection_params_with_host_ids
       result = host_collection_params
-      result[:max_hosts] = nil if params[:unlimited_hosts]
+      if params[:unlimited_hosts]
+        result[:max_hosts] = nil
+      elsif params[:max_hosts]
+        result[:unlimited_hosts] = false
+      end
       result
     end
 

data/app/controllers/katello/api/v2/host_errata_controller.rb

@@ -104,6 +104,7 @@ module Katello
         relation = relation.where(:errata_type => TYPES_FROM_PARAMS[params[:type].to_sym])
       end
       if params[:severity].present?
+        params[:severity] = ['None', ''] if params[:severity] == 'None'
         relation = relation.where(:severity => params[:severity])
       end
       relation

data/app/controllers/katello/api/v2/host_module_streams_controller.rb

@@ -22,7 +22,7 @@ module Katello
     def index_relation
       return HostAvailableModuleStream.upgradable([@host]) if params[:status] == HostAvailableModuleStream::UPGRADABLE
 
-      rel = @host.host_available_module_streams
+      rel = @host.host_available_module_streams.where(available_module_stream_id: find_available_module_stream_ids)
       if params[:sort_by] == 'installed_profiles'
         rel = rel.order([:installed_profiles, :status])
       end
@@ -38,6 +38,14 @@ module Katello
 
     private
 
+    def find_available_module_stream_ids
+      items = @host.host_available_module_streams.includes(:available_module_stream).map(&:available_module_stream)
+      grouped = items.group_by { |item| [item.name, item.stream] }
+      grouped.values.map do |item|
+        item.first.id
+      end
+    end
+
     def find_host
       @host = resource_finder(::Host::Managed.authorized(:view_hosts, ::Host::Managed), params[:host_id])
     end

data/app/controllers/katello/api/v2/host_subscriptions_controller.rb

@@ -187,6 +187,13 @@ module Katello
       respond_for_index :collection => full_result_response(releases)
     end
 
+    api :GET, "/hosts/:host_id/subscriptions/enabled_repositories", N_("Show repositories enabled on the host that are known to Katello")
+    param :host_id, String, :desc => N_("id of host"), :required => true
+    def enabled_repositories
+      repositories = @host.content_facet.try(:bound_repositories) || []
+      respond_with_template_collection "index", 'repositories', :collection => full_result_response(repositories)
+    end
+
     private
 
     def fetch_product_content
@@ -216,7 +223,7 @@ module Katello
     def action_permission
       if ['add_subscriptions', 'destroy', 'remove_subscriptions', 'auto_attach', 'content_override'].include?(params[:action])
         :edit
-      elsif ['index', 'events', 'product_content', 'available_release_versions'].include?(params[:action])
+      elsif ['index', 'events', 'product_content', 'available_release_versions', 'enabled_repositories'].include?(params[:action])
         :view
       else
         fail ::Foreman::Exception.new(N_("unknown permission for %s"), "#{params[:controller]}##{params[:action]}")

data/app/controllers/katello/api/v2/organizations_controller.rb

@@ -68,9 +68,11 @@ module Katello
     param :organization, Hash do
       param :label, String, :required => false
     end
+    param :simple_content_access, :bool, :desc => N_('Whether to turn on Simple Content Access for the organization.'), :required => false, :default => true
     def create
       @organization = Organization.new(resource_params)
-      creator = ::Katello::OrganizationCreator.new(@organization)
+      sca = params.key?(:simple_content_access) ? ::Foreman::Cast.to_bool(params[:simple_content_access]) : true
+      creator = ::Katello::OrganizationCreator.new(@organization, sca: sca)
       creator.create!
       @organization.reload
       # @taxonomy instance variable is necessary for foreman side

data/app/controllers/katello/api/v2/simple_content_access_controller.rb

@@ -15,6 +15,14 @@ module Katello
       render json: { simple_content_access_eligible: eligible }
     end
 
+    api :GET, "/organizations/:organization_id/simple_content_access/status",
+      N_("Check if the specified organization has Simple Content Access enabled")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    def status
+      status = @organization.simple_content_access?
+      render json: { simple_content_access: status }
+    end
+
     api :PUT, "/organizations/:organization_id/simple_content_access/enable",
       N_("Enable simple content access for a manifest")
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true

data/app/controllers/katello/concerns/api/v2/repository_content_controller.rb

@@ -30,6 +30,7 @@ module Katello
       param :ids, Array, :desc => N_("ids to filter content by")
       param :include_filter_ids, :bool, desc: N_("Includes associated content view filter ids in response")
       param_group :search, ::Katello::Api::V2::ApiController
+
       def index
         sort_by, sort_order, options = sort_options
         respond(:collection => scoped_search(index_relation, sort_by, sort_order, options))
@@ -40,6 +41,7 @@ module Katello
       param :repository_id, :number, :desc => N_("repository identifier")
       param :organization_id, :number, :desc => N_("organization identifier")
       param :id, String, :desc => N_(":a_resource identifier"), :required => true
+
       def show
         respond :resource => @resource
       end
@@ -47,10 +49,11 @@ module Katello
       api :GET, "/:resource_id/compare/", N_("List :resource")
       param :content_view_version_ids, Array, :desc => N_("content view versions to compare")
       param :repository_id, :number, :desc => N_("Library repository id to restrict comparisons to")
+      param :restrict_comparison, String, :desc => N_("Return same, different or all results")
+
       def compare
         fail _("No content_view_version_ids provided") if params[:content_view_version_ids].empty?
         @versions = ContentViewVersion.readable.where(:id => params[:content_view_version_ids])
-
         if @versions.count != params[:content_view_version_ids].uniq.length
           missing = params[:content_view_version_ids] - @versions.pluck(:id)
           fail HttpErrors::NotFound, _("Couldn't find content view versions '%s'") % missing.join(',')
@@ -63,9 +66,8 @@ module Katello
         else
           repos = Katello::Repository.where(:content_view_version_id => @versions.pluck(:id))
           repos = repos.where(:root_id => @repo.root_id) if @repo
-          collection = filter_by_repos(repos, resource_class.all)
+          collection = filter_by_repos(repos, resource_class.all, @versions, params[:restrict_comparison])
         end
-
         collection = scoped_search(collection.distinct, sort_by, sort_order, options)
         collection[:results] = collection[:results].map { |item| ContentViewVersionComparePresenter.new(item, @versions, @repo) }
         respond_for_index(:collection => collection)
@@ -75,6 +77,7 @@ module Katello
       param :show_all_for, :bool,
             :desc => N_("Returns content that can be both added and is currently added to the object. The value 'content_view_filter' is supported")
       param :filterId, :integer, :desc => N_("Content View Filter id"), deprecated: true
+
       def index_relation
         if @version && params[:available_for] == "content_view_version" && self.respond_to?(:available_for_content_view_version)
           collection = self.available_for_content_view_version(@version)
@@ -125,8 +128,28 @@ module Katello
         repos
       end
 
-      def filter_by_repos(repos, collection)
-        collection.in_repositories(repos)
+      def filter_by_repos(repos, collection, content_view_versions = nil, compare = 'all')
+        collection = collection.in_repositories(repos)
+        case compare
+        when 'same'
+          compare_same(collection, content_view_versions)
+        when 'different'
+          collection_all_ids = collection&.pluck(:id)
+          collection_same_ids = compare_same(collection, content_view_versions)&.pluck(:id)
+          collection.where(id: collection_all_ids - collection_same_ids)
+        else
+          collection
+        end
+      end
+
+      def compare_same(collection, content_view_versions = nil)
+        cv_version_first = content_view_versions[0]
+        collection_ids = collection.in_repositories(Katello::Repository.where(:content_view_version_id => cv_version_first&.id))&.pluck(:id)
+        content_view_versions[1..-1].each do |version|
+          collection_version_ids = collection.in_repositories(Katello::Repository.where(:content_view_version_id => version&.id))&.pluck(:id)
+          collection_ids = collection_ids.intersection collection_version_ids
+        end
+        return collection.where(id: collection_ids)
       end
 
       def filter_by_content_view_version(version, collection)
@@ -145,12 +168,12 @@ module Katello
 
         if @resource.blank?
           fail HttpErrors::NotFound, _("Failed to find %{content} with id '%{id}'.") %
-            {content: resource_name, id: params[:id]}
+            { content: resource_name, id: params[:id] }
         end
 
         if params[:repository_id] && !@resource.repositories.include?(@repo)
           fail HttpErrors::NotFound, _("Could not find %{content} with id '%{id}' in repository.") %
-            {content: resource_name, id: params[:id]}
+            { content: resource_name, id: params[:id] }
         end
 
         if params[:organization_id] && !@resource.repositories.any? { |repo| repo.organization_id == params[:organization_id].to_i }
@@ -174,7 +197,7 @@ module Katello
           @environment = KTEnvironment.readable.find_by(:id => params[:environment_id])
           if @environment.nil?
             fail HttpErrors::NotFound, _("Could not find Lifecycle Environment with id '%{id}'.") %
-              {id: params[:environment_id]}
+              { id: params[:environment_id] }
           end
         end
       end
@@ -196,7 +219,7 @@ module Katello
 
           unless @filter
             fail HttpErrors::NotFound, _("Couldn't find %{type} Filter with id %{id}") %
-              {:type => resource_name, :id => params[:filter_id]}
+              { :type => resource_name, :id => params[:filter_id] }
           end
         end
       end
@@ -209,7 +232,7 @@ module Katello
 
           unless @filter_rule
             fail HttpErrors::NotFound, _("Couldn't find %{type} Filter with id %{id}") %
-              {:type => resource_name, :id => filter_rule_id}
+              { :type => resource_name, :id => filter_rule_id }
           end
         end
       end
@@ -272,7 +295,7 @@ module Katello
       def check_repo_for_content_resource
         if params[:repository_id] && !@resource.send(repo_association).include?(@repo.pulp_id)
           fail HttpErrors::NotFound, _("Could not find %{content} with id '%{id}' in repository.") %
-            {content: resource_name, id: params[:id]}
+            { content: resource_name, id: params[:id] }
         end
       end