katello 4.5.1 → 4.8.0.rc2

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

@@ -7,7 +7,7 @@ module Katello
       generic_repo_wrap_params << option.name
     end
 
-    repo_wrap_params = RootRepository.attribute_names + [:mirror_on_sync] + generic_repo_wrap_params
+    repo_wrap_params = RootRepository.attribute_names + generic_repo_wrap_params
 
     wrap_parameters :repository, :include => repo_wrap_params
 
@@ -55,7 +55,6 @@ module Katello
       param :exclude_tags, Array, :desc => N_("Comma-separated list of tags to exclude when syncing a container image repository. Default: any tag ending in \"-source\"")
       param :download_policy, ["immediate", "on_demand"], :desc => N_("download policy for yum, deb, and docker repos (either 'immediate' or 'on_demand')")
       param :download_concurrency, :number, :desc => N_("Used to determine download concurrency of the repository in pulp3. Use value less than 20. Defaults to 10")
-      param :mirror_on_sync, :bool, :desc => N_("true if this repository when synced has to be mirrored from the source and stale rpms removed (Deprecated)")
       param :mirroring_policy, Katello::RootRepository::MIRRORING_POLICIES, :desc => N_("Policy to set for mirroring content.  Must be one of %s.") % RootRepository::MIRRORING_POLICIES
       param :verify_ssl_on_sync, :bool, :desc => N_("if true, Katello will verify the upstream url's SSL certifcates are signed by a trusted CA")
       param :upstream_username, String, :desc => N_("Username of the upstream repository user used for authentication")
@@ -81,7 +80,7 @@ module Katello
     def_param_group :repo_create do
       param :label, String, :required => false
       param :product_id, :number, :required => true, :desc => N_("Product the repository belongs to")
-      param :content_type, RepositoryTypeManager.creatable_repository_types(false).keys, :required => true, :desc => N_("type of repo")
+      param :content_type, String, :required => true, :desc => N_("Type of repository. Available types endpoint: /katello/api/repositories/repository_types")
     end
 
     api :GET, "/repositories", N_("List of enabled repositories")
@@ -102,18 +101,28 @@ module Katello
     param :ansible_collection_id, String, :desc => N_("Id of an ansible collection to find repositories that contain the ansible collection")
     param :library, :bool, :desc => N_("show repositories in Library and the default content view")
     param :archived, :bool, :desc => N_("show archived repositories")
-    param :content_type, RepositoryTypeManager.defined_repository_types.keys, :desc => N_("limit to only repositories of this type")
+    param :content_type, String, :desc => N_("Limit the repository type. Available types endpoint: /katello/api/repositories/repository_types")
     param :name, String, :desc => N_("name of the repository"), :required => false
     param :label, String, :desc => N_("label of the repository"), :required => false
     param :description, String, :desc => N_("description of the repository")
     param :available_for, String, :desc => N_("interpret specified object to return only Repositories that can be associated with specified object.  Only 'content_view' & 'content_view_version' are supported."),
           :required => false
-    param :with_content, RepositoryTypeManager.enabled_content_types(false), :desc => N_("only repositories having at least one of the specified content type ex: rpm , erratum")
+    param :with_content, String, :desc => N_("Filter repositories by content unit type (erratum, docker_tag, etc.). Check the \"Indexed?\" types here: /katello/api/repositories/repository_types")
     param :download_policy, ::Katello::RootRepository::DOWNLOAD_POLICIES, :desc => N_("limit to only repositories with this download policy")
     param :username, String, :desc => N_("only show the repositories readable by this user with this username")
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Repository)
     def index
+      unless params[:content_type].empty? || RepositoryTypeManager.find(params[:content_type])
+        msg = _("Invalid params provided - content_type must be one of %s") %
+          RepositoryTypeManager.enabled_repository_types.keys.sort.join(",")
+        fail HttpErrors::UnprocessableEntity, msg
+      end
+      unless params[:with_content].empty? || RepositoryTypeManager.find_content_type(params[:with_content], true)
+        msg = _("Invalid params provided - with_content must be one of %s") %
+          RepositoryTypeManager.indexable_content_types.map(&:label).sort.join(",")
+        fail HttpErrors::UnprocessableEntity, msg
+      end
       base_args = [index_relation.distinct, :name, :asc]
       options = {:includes => [:environment, {:root => [:gpg_key, :product]}]}
 
@@ -224,6 +233,51 @@ module Katello
       query
     end
 
+    api :GET, "/repositories/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(',')
+      end
+
+      archived_version_repos = Katello::Repository.where(:content_view_version_id => @versions&.pluck(:id))&.archived
+      repos = Katello::Repository.where(id: archived_version_repos&.pluck(:library_instance_id))
+      repos = repos.where(:root_id => @repo.root_id) if @repo
+      repositories = restrict_comparison(repos, @versions, params[:restrict_comparison])
+      collection = scoped_search(repositories.distinct, :name, :asc)
+      collection[:results] = collection[:results].map { |item| ContentViewVersionComparePresenter.new(item, @versions, @repo) }
+      respond_for_index(:collection => collection)
+    end
+
+    def restrict_comparison(collection, content_view_versions = nil, compare = 'all')
+      case compare
+      when 'same'
+        same_repo_ids = compare_same(collection, content_view_versions)
+        collection.where(id: same_repo_ids)
+      when 'different'
+        same_repo_ids = compare_same(collection, content_view_versions)
+        collection.where.not(id: same_repo_ids)
+      else
+        collection
+      end
+    end
+
+    def compare_same(collection, content_view_versions = nil)
+      same_repo_ids = []
+      collection.each do |repo|
+        if (content_view_versions&.pluck(:id)&.- repo.published_in_versions&.pluck(:id))&.empty?
+          same_repo_ids << repo.id
+        end
+      end
+      same_repo_ids
+    end
+
     api :POST, "/repositories", N_("Create a custom repository")
     param :name, String, :desc => N_("Name of the repository"), :required => true
     param :description, String, :desc => N_("Description of the repository"), :required => false
@@ -233,7 +287,7 @@ module Katello
       repo_params = repository_params
       unless RepositoryTypeManager.creatable_by_user?(repo_params[:content_type], false)
         msg = _("Invalid params provided - content_type must be one of %s") %
-          RepositoryTypeManager.creatable_repository_types(false).keys.join(",")
+          RepositoryTypeManager.creatable_repository_types.keys.sort.join(",")
         fail HttpErrors::UnprocessableEntity, msg
       end
 
@@ -291,7 +345,7 @@ module Katello
     param :id, :number, :required => true, :desc => N_("repository ID")
     param :source_url, String, :desc => N_("temporarily override feed URL for sync"), :required => false
     param :incremental, :bool, :desc => N_("perform an incremental import"), :required => false
-    param :skip_metadata_check, :bool, :desc => N_("Force sync even if no upstream changes are detected. Only used with yum repositories."), :required => false
+    param :skip_metadata_check, :bool, :desc => N_("Force sync even if no upstream changes are detected. Only used with yum or deb repositories."), :required => false
     param :validate_contents, :bool, :desc => N_("Force a sync and validate the checksums of all content. Only used with yum repositories."), :required => false
     def sync
       sync_options = {
@@ -374,9 +428,14 @@ module Katello
     desc "Remove content from a repository"
     param :id, :number, :required => true, :desc => "repository ID"
     param 'ids', Array, :required => true, :desc => "Array of content ids to remove"
-    param :content_type, RepositoryTypeManager.removable_content_types(false).map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree', 'rpm', 'srpm')")
+    param :content_type, String, :required => false, :desc => N_("The type of content to remove (srpm, docker_manifest, etc.). Check removable types here: /katello/api/repositories/repository_types")
     param 'sync_capsule', :bool, :desc => N_("Whether or not to sync an external capsule after upload. Default: true")
     def remove_content
+      unless params[:content_type].empty? || RepositoryTypeManager.removable_content_types.map(&:label).include?(params[:content_type])
+        msg = _("Invalid params provided - content_type must be one of %s") %
+          RepositoryTypeManager.removable_content_types.map(&:label).sort.join(",")
+        fail HttpErrors::UnprocessableEntity, msg
+      end
       sync_capsule = ::Foreman::Cast.to_bool(params.fetch(:sync_capsule, true))
       fail _("No content ids provided") if @content.blank?
       respond_for_async :resource => sync_task(::Actions::Katello::Repository::RemoveContent, @repository, @content, content_type: params[:content_type], sync_capsule: sync_capsule)
@@ -385,10 +444,15 @@ module Katello
     api :POST, "/repositories/:id/upload_content", N_("Upload content into the repository")
     param :id, :number, :required => true, :desc => N_("repository ID")
     param :content, File, :required => true, :desc => N_("Content files to upload. Can be a single file or array of files.")
-    param :content_type, RepositoryTypeManager.uploadable_content_types(false).map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree', 'rpm', 'srpm')")
+    param :content_type, String, :required => false, :desc => N_("The type of content to upload (srpm, file, etc.). Check uploadable types here: /katello/api/repositories/repository_types")
     def upload_content
       fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Container Image content.") if @repository.docker?
       fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Ansible collections.") if @repository.ansible_collection?
+      unless params[:content_type].empty? || RepositoryTypeManager.uploadable_content_types.map(&:label).include?(params[:content_type])
+        msg = _("Invalid params provided - content_type must be one of %s") %
+          RepositoryTypeManager.uploadable_content_types.map(&:label).sort.join(",")
+        fail HttpErrors::UnprocessableEntity, msg
+      end
 
       filepaths = Array.wrap(params[:content]).compact.collect do |content|
         {path: content.path, filename: content.original_filename}
@@ -421,7 +485,7 @@ module Katello
       param 'content_unit_id', String
       param 'size', String
       param 'checksum', String
-      param 'name', String, :desc => N_("Needs to only be set for file repositories or docker tags")
+      param 'name', String, :desc => N_("Needs to only be set for file repositories or docker tags"), :required => true
       param 'digest', String, :desc => N_("Needs to only be set for docker tags")
     end
     Katello::RepositoryTypeManager.generic_repository_types.each_pair do |_, repo_type|
@@ -442,6 +506,14 @@ module Katello
         upload.permit(:id, :content_unit_id, :size, :checksum, :name, :digest).to_h
       end
 
+      if @repository.content_type != 'docker' && uploads.first['checksum'].nil?
+        fail HttpErrors::BadRequest, _('Checksum is a required parameter.')
+      end
+
+      if uploads.first['name'].nil?
+        fail HttpErrors::BadRequest, _('Name is a required parameter.')
+      end
+
       begin
         upload_args = {
           content_type: params[:content_type],
@@ -507,7 +579,7 @@ module Katello
 
     # rubocop:disable Metrics/CyclomaticComplexity
     def repository_params
-      keys = [:download_policy, :mirror_on_sync, :mirroring_policy, :sync_policy, :arch, :verify_ssl_on_sync, :upstream_password,
+      keys = [:download_policy, :mirroring_policy, :sync_policy, :arch, :verify_ssl_on_sync, :upstream_password,
               :upstream_username, :download_concurrency, :upstream_authentication_token,
               {:os_versions => []}, :deb_releases, :deb_components, :deb_architectures, :description,
               :http_proxy_policy, :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
@@ -531,8 +603,7 @@ module Katello
         keys += [:url, :gpg_key_id, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id, :unprotected, :name,
                  :checksum_type]
       end
-      to_return = params.require(:repository).permit(*keys).to_h.with_indifferent_access
-      handle_mirror_on_sync(to_return)
+      params.require(:repository).permit(*keys).to_h.with_indifferent_access
     end
 
     def get_content_credential(repo_params, content_type)
@@ -591,19 +662,6 @@ module Katello
     end
     # rubocop:enable Metrics/CyclomaticComplexity,Metrics/MethodLength
 
-    def handle_mirror_on_sync(repo_params)
-      if !repo_params.key?(:mirroring_policy) && repo_params.key?(:mirror_on_sync)
-        ::Foreman::Deprecation.api_deprecation_warning("mirror_on_sync is deprecated in favor of mirroring_policy.  It will be removed in Katello 4.6.")
-        if ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync])
-          repo_params[:mirroring_policy] = Katello::RootRepository::MIRRORING_POLICY_CONTENT
-        else
-          repo_params[:mirroring_policy] = Katello::RootRepository::MIRRORING_POLICY_ADDITIVE
-        end
-      end
-      repo_params.delete(:mirror_on_sync)
-      repo_params
-    end
-
     def error_on_rh_product
       fail HttpErrors::BadRequest, _("Red Hat products cannot be manipulated.") if @product.redhat?
     end
@@ -659,12 +717,10 @@ module Katello
     end
 
     def generic_remote_options_hash(repo_params)
-      generic_remote_options = {}
       content_type = @repository&.content_type || repo_params[:content_type]
-      RepositoryTypeManager.generic_remote_options(content_type: content_type).each do |option|
-        generic_remote_options[option.name] = repo_params[option.name]
+      RepositoryTypeManager.generic_remote_options(content_type: content_type).to_h do |option|
+        [option.name, repo_params[option.name].nil? ? option&.default : repo_params[option.name]]
       end
-      generic_remote_options
     end
 
     def generic_content_type_import_upload_args

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

@@ -38,12 +38,11 @@ module Katello
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Katello::ProductContent)
     def index
-      collection = scoped_search(index_relation, :name, :asc, :resource_class => Katello::ProductContent)
+      collection = scoped_search(index_relation, :name, :asc, :resource_class => Katello::ProductContent, :custom_sort => ->(relation) { custom_sort_results(relation) })
       pcf = ProductContentFinder.wrap_with_overrides(
         product_contents: collection[:results],
-        overrides: @consumable&.content_overrides,
-        status: params[:status])
-      collection[:results] = custom_sort_results(pcf)
+        overrides: @consumable&.content_overrides)
+      collection[:results] = pcf
       respond(:collection => collection)
     end
 
@@ -154,7 +153,13 @@ module Katello
           :match_subscription => !content_access_mode_all,
           :match_environment => content_access_mode_env,
           :consumable => @consumable)
-      relation.merge(content_finder.product_content)
+      unfiltered = relation.merge(content_finder.product_content)
+      return unfiltered unless params[:status]
+      filtered_ids = ProductContentFinder.wrap_with_overrides(
+        product_contents: unfiltered,
+        overrides: @consumable&.content_overrides,
+        status: params[:status]).map(&:id).uniq
+      unfiltered.where(id: filtered_ids)
     end
 
     def find_product_content
@@ -236,18 +241,24 @@ module Katello
               else
                 0
               end
-      Rails.logger.debug [pc.product_name, pc.enabled_content_override, "Id: #{pc.id}", "Score: #{score}"]
       score
     end
 
-    def custom_sort_results(product_content_finder)
-      if params[:sort_by] == 'enabled_by_default' && params[:sort_order] == 'desc'
-        product_content_finder.sort { |pca, pcb| sort_score(pca) <=> sort_score(pcb) }.reverse!
-      elsif params[:sort_by] == 'enabled_by_default'
-        product_content_finder.sort { |pca, pcb| sort_score(pca) <=> sort_score(pcb) }
-      else
-        product_content_finder
-      end
+    def custom_sort_results(unsorted_relation)
+      return unsorted_relation unless params[:sort_by] == 'enabled_by_default'
+      product_content_finder = ProductContentFinder.wrap_with_overrides(
+        product_contents: unsorted_relation,
+        overrides: @consumable&.content_overrides,
+        status: params[:status])
+      sorted_pcps = if params[:sort_by] == 'enabled_by_default' && params[:sort_order] == 'desc'
+                      product_content_finder.sort { |pca, pcb| sort_score(pca) <=> sort_score(pcb) }.reverse!
+                    elsif params[:sort_by] == 'enabled_by_default'
+                      product_content_finder.sort { |pca, pcb| sort_score(pca) <=> sort_score(pcb) }
+                    else
+                      product_content_finder
+                    end
+      sort_order = sorted_pcps.map(&:id)
+      unsorted_relation.reorder(Arel.sql("array_position('{#{sort_order.join(',')}}'::int[], #{Katello::ProductContent.table_name}.id)"))
     end
   end
 end

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

@@ -1,7 +1,6 @@
 module Katello
   class Api::V2::SimpleContentAccessController < Api::V2::ApiController
     before_action :find_organization
-    before_action :check_upstream_connection
 
     resource_description do
       description "Red Hat subscriptions management platform."
@@ -11,10 +10,19 @@ module Katello
     api :GET, "/organizations/:organization_id/simple_content_access/eligible",
       N_("Check if the specified organization is eligible for Simple Content Access")
     def eligible
-      eligible = @organization.upstream_consumer.simple_content_access_eligible?
+      ::Foreman::Deprecation.api_deprecation_warning("This endpoint is deprecated and will be removed in a future release. All organizations are now eligible for Simple Content Access.")
+      eligible = @organization.simple_content_access_eligible?
       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/api/v2/upstream_subscriptions_controller.rb

@@ -48,7 +48,7 @@ module Katello
     end
 
     api :DELETE, "/organizations/:organization_id/upstream_subscriptions",
-      N_("Remove one or more subscriptions from an upstream subscription allocation")
+      N_("Remove one or more subscriptions from an upstream manifest")
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     param :pool_ids, Array, desc: N_("Array of local pool IDs. Only pools originating upstream are accepted."), required: true
     def destroy

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

@@ -14,7 +14,7 @@ module Katello
         bulk_params[:included] ||= {}
         bulk_params[:excluded] ||= {}
 
-        if bulk_params[:included][:ids].blank? && bulk_params[:included][:search].nil?
+        if !params[:install_all] && bulk_params[:included][:ids].blank? && bulk_params[:included][:search].nil?
           fail HttpErrors::BadRequest, _("No hosts have been specified.")
         end
 
@@ -25,9 +25,8 @@ module Katello
           @hosts = @hosts.where(id: bulk_params[:included][:ids])
         end
 
-        if bulk_params[:included][:search]
-          search_hosts = bulk_hosts_relation(permission, @organization).search_for(bulk_params[:included][:search])
-          @hosts = @hosts.merge(search_hosts)
+        if bulk_params[:included][:search].present?
+          @hosts = @hosts.search_for(bulk_params[:included][:search])
         end
 
         @hosts = restrict_to.call(@hosts) if restrict_to
@@ -35,8 +34,7 @@ module Katello
         if bulk_params[:excluded][:ids].present?
           @hosts = @hosts.where.not(id: bulk_params[:excluded][:ids])
         end
-
-        fail HttpErrors::Forbidden, _("Action unauthorized to be performed on selected hosts.") if @hosts.empty?
+        fail HttpErrors::Forbidden, _("No hosts matched search, or action unauthorized for selected hosts.") if @hosts.empty?
 
         @hosts
       end

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

@@ -19,8 +19,7 @@ module Katello
 
       def host_setup_extension
         if params['host']['lifecycle_environment_id']
-          new_lce = KTEnvironment.readable.find(params['host']['lifecycle_environment_id'])
-          @host.content_facet.lifecycle_environment = new_lce
+          @host.content_facet.assign_single_environment(content_view_id: @host&.content_views&.first&.id, lifecycle_environment_id: params['host']['lifecycle_environment_id'])
           @host.update_candlepin_associations
         end
 
@@ -35,7 +34,7 @@ module Katello
 
       def smart_proxy
         @smart_proxy ||= begin
-          proxy = params[:url] ? SmartProxy.unscoped.find_by(url: params[:url]) : SmartProxy.pulp_primary
+          proxy = params[:url] ? find_smart_proxy : SmartProxy.pulp_primary
 
           fail Foreman::Exception, _('Smart proxy content source not found!') unless proxy
           fail Foreman::Exception, _('Pulp 3 is not enabled on Smart proxy!') unless proxy.pulp3_enabled?
@@ -43,6 +42,11 @@ module Katello
           proxy
         end
       end
+
+      def find_smart_proxy
+        auth_smart_proxy
+        @detected_proxy
+      end
     end
   end
 end

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
 

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

@@ -8,6 +8,7 @@ module Katello
           param :smart_proxy, Hash do
             param :download_policy, String, :required => false, :desc => N_('Download Policy of the capsule, must be one of %s') %
                 SmartProxy::DOWNLOAD_POLICIES.join(', ')
+            param :http_proxy_id, Integer, :required => false, :desc => N_('Id of the HTTP proxy to use with alternate content sources')
           end
         end
       end

data/app/controllers/katello/concerns/authorization/api/v2/content_views_controller.rb

@@ -118,7 +118,10 @@ module Katello
       # and also ensure that the environments have the remove permission
       return deny_access unless KTEnvironment.promotable.where(:id => env_ids).count == env_ids.size && view.promotable_or_removable?
 
-      total_count = Katello::Host::ContentFacet.where(:content_view_id => view, :lifecycle_environment_id => env_ids).count
+      total_count = Katello::Host::ContentFacet.in_content_views_and_environments(
+        :content_views => [view],
+        :lifecycle_environments => ::Katello::KTEnvironment.where(id: env_ids)
+      ).count
       if total_count > 0
         unless options[:system_content_view_id] && options[:system_environment_id]
           fail _("Unable to reassign content hosts. Please provide system_content_view_id and system_environment_id.")

data/app/controllers/katello/concerns/content_facet_hosts_controller_extensions.rb

@@ -0,0 +1,24 @@
+module Katello
+  module Concerns
+    module ContentFacetHostsControllerExtensions
+      extend ActiveSupport::Concern
+      included do
+        before_action :set_up_content_view_environment, only: [:update]
+
+        def set_up_content_view_environment
+          return unless params[:host] && params[:host][:content_facet_attributes]
+          cv_id = params[:host][:content_facet_attributes].delete(:content_view_id)
+          env_id = params[:host][:content_facet_attributes].delete(:lifecycle_environment_id)
+          Rails.logger.info "set_up_content_view_environment: cv_id=#{cv_id}, env_id=#{env_id}"
+          if (cv_id.present? && env_id.present?)
+            @host.content_facet.assign_single_environment(
+              lifecycle_environment_id: env_id,
+              content_view_id: cv_id
+            )
+            Rails.logger.info "set_up_content_view_environment: done"
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/katello/concerns/hosts_controller_extensions.rb

@@ -57,45 +57,47 @@ module Katello
             format.csv do
               @hosts = resource_base_with_search.where(organization_id: params[:organization_id])
                          .preload(:subscription_facet, :host_statuses, :operatingsystem,
-                                  :applicable_rpms, :lifecycle_environment, :content_view)
+                                  :applicable_rpms, :content_view_environments)
               csv_response(@hosts,
                 [:name, :subscription_status_label, 'content_facet.installable_security_errata_count',
                  'content_facet.installable_bugfix_errata_count', 'content_facet.installable_enhancement_errata_count',
-                 'content_facet.upgradable_rpm_count', :operatingsystem, :lifecycle_environment, :content_view,
+                 'content_facet.upgradable_rpm_count', :operatingsystem, :content_view_environment_names,
                  'subscription_facet.registered_at', 'subscription_facet.last_checkin'],
                 ['Name', 'Subscription Status', 'Installable Updates - Security',
                  'Installable Updates - Bug Fixes', 'Installable Updates - Enhancements',
-                 'Installable Updates - Package Count', 'OS', 'Environment', 'Content View',
+                 'Installable Updates - Package Count', 'OS', 'Content View Environments',
                  'Registered', 'Last Checkin'])
             end
           end
         end
 
         def change_content_source_data
-          hosts = ::Host.where(id: params[:host_ids])
-          content_hosts_ids = []
+          hosts = params[:search].presence ? ::Host.search_for(params[:search]) : ::Host.where(id: params[:host_ids])
+          content_hosts = []
           hosts_without_content = []
 
           hosts.each do |host|
             if host.content_facet
-              content_hosts_ids << host.id
+              content_hosts << { id: host.id, name: host.name }
             else
-              hosts_without_content << host.name
+              hosts_without_content << { id: host.id, name: host.name }
             end
           end
 
-          environments = KTEnvironment.readable.where(organization: Organization.current).includes([:organization, :env_priors, :priors]).order(:name)
-          content_sources = SmartProxy.authorized(:view_smart_proxies).with_content.includes([:smart_proxy_features])
+          content_sources = SmartProxy.authorized(:view_smart_proxies)
+                                      .with_content
+                                      .includes([:smart_proxy_features])
+                                      .joins(:lifecycle_environments)
+                                      .distinct
 
           if Katello.with_remote_execution?
             template_id = JobTemplate.find_by(name: 'Change content source')&.id
-            job_invocation_path = new_job_invocation_path(template_id: template_id, host_ids: content_hosts_ids) if template_id
+            job_invocation_path = new_job_invocation_path(template_id: template_id, host_ids: content_hosts.map { |h| h[:id] }) if template_id
           end
 
           render json: {
-            content_hosts_ids: content_hosts_ids,
+            content_hosts: content_hosts,
             hosts_without_content: hosts_without_content,
-            environments: environments,
             content_sources: content_sources,
             job_invocation_path: job_invocation_path
           }