katello 4.5.0.rc1 → 4.6.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2fd3647b864eba8c468c3eea9e6d6d867a43192dcb29c0758f0771085fb1621
-  data.tar.gz: 764696ceedc7d01432439f6ac00012be79383073c35f0d491cbf4a1da1af6a77
+  metadata.gz: ed8eb04c88654bdacc69fa01282d4122141a68430d8259cc6f0ec46dcae06367
+  data.tar.gz: 96bc2cd4a26684dae6a71884a3fd745469b30118e723613f2640b8017a1c6b50
 SHA512:
-  metadata.gz: d67f10a68cf3f81316e77099d82266960fc5887513004f5e35daa47c591ccc44f2a8ba78f54e8ef84c6ba8bc53d5a42c0621d842c70fa5b20c3dd61cae90e648
-  data.tar.gz: 5c798d57fbde2baf9c9d62c172e294ade51f32e2d822ed56c63983f48d8f690abd0d2f625e061c7318d4680e916d477fc64025974396ead7f17b919bf06a83c4
+  metadata.gz: 99b345b1016334d1f7277f2eecb3f6ad8f21a90d45582a30367b49441891216b359fb118c61e2c59ec93fa4071b49e6a9c131175b7ba365613c2fb5acece0a4b
+  data.tar.gz: c9523e61da53201364bef634d3960bab1ff7120e648133b168da057bdd5d32c603c44f38e7395097fd2e3960f2451407a7f9444eb4a1382a28ab139452dc0033

data/app/assets/javascripts/katello/hosts/activation_key_edit.js

@@ -75,8 +75,15 @@ function ktSetParam(name, value) {
     var paramContainer = ktFindParamContainer(name);
     if(value) {
         if(! paramContainer) { // we create the param for kt_activation_keys
-            $("div#parameters a[target~='#global_parameters_table']").click();
-            paramContainer = $("div#parameters .fields").last();
+            var addParameterButton = $('#parameters').find('.btn-primary');
+            addParameterButton.click();
+            var directionOfAddedItems = addParameterButton.attr('direction');
+            var paramContainer = $('#parameters').find('.fields');
+            if(directionOfAddedItems === 'append'){
+                paramContainer = paramContainer.last();
+            } else {
+                paramContainer = paramContainer.first();
+            }
             paramContainer.find("input[name*='name']").val(name);
         }
         paramContainer.find("textarea").val(value);

data/app/controllers/katello/api/registry/registry_proxies_controller.rb

@@ -177,6 +177,9 @@ module Katello
                        end
         end
         response.headers['Content-Type'] = media_type
+        length = manifest_response.try(:body).try(:size)
+        length ||= 0
+        response.header['Content-Length'] = "#{length}"
         render json: manifest_response
       end
     end

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_bulk_actions_controller.rb

@@ -0,0 +1,44 @@
+module Katello
+  class Api::V2::AlternateContentSourcesBulkActionsController < Api::V2::ApiController
+    before_action :find_alternate_content_sources
+
+    api :PUT, '/alternate_content_sources/bulk/destroy', N_('Destroy one or more alternate content sources')
+    param :ids, Array, desc: N_('List of alternate content source IDs'), required: true
+    def destroy_alternate_content_sources
+      deletable_alternate_content_sources = @alternate_content_sources.deletable
+
+      if deletable_alternate_content_sources.empty?
+        msg = _("Unable to delete any alternate content source. You either do not have the permission to"\
+          " delete, or none of the alternate content sources exist.")
+        fail HttpErrors::UnprocessableEntity, msg
+      end
+      task = async_task(::Actions::BulkAction,
+                        ::Actions::Katello::AlternateContentSource::Destroy,
+                        deletable_alternate_content_sources)
+      respond_for_async :resource => task
+    end
+
+    api :POST, '/alternate_content_sources/bulk/refresh', N_('Refresh alternate content sources')
+    param :ids, Array, desc: N_('List of alternate content source IDs'), required: true
+    def refresh_alternate_content_sources
+      refreshable_alternate_content_sources = @alternate_content_sources.editable
+      if refreshable_alternate_content_sources.empty?
+        msg = _("Unable to refresh any alternate content source. You either do not have the permission to"\
+                " refresh, or none of the alternate content sources exist.")
+        fail HttpErrors::UnprocessableEntity, msg
+      else
+        task = async_task(::Actions::BulkAction,
+                          ::Actions::Katello::AlternateContentSource::Refresh,
+                          refreshable_alternate_content_sources)
+        respond_for_async resource: task
+      end
+    end
+
+    private
+
+    def find_alternate_content_sources
+      params.require(:ids)
+      @alternate_content_sources = AlternateContentSource.readable.where(id: params[:ids])
+    end
+  end
+end

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

@@ -2,8 +2,12 @@ module Katello
   class Api::V2::AlternateContentSourcesController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_action :find_authorized_katello_resource, :only => [:show, :update, :destroy]
-    before_action :find_smart_proxies
+    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")
@@ -11,8 +15,7 @@ module Katello
       param :base_url, String, desc: N_('Base URL for finding alternate content'), required: false
       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 :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 :smart_proxy_names, Array, desc: N_("Names of smart proxies to associate"), required: false
       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
@@ -20,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
@@ -30,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)
@@ -45,53 +55,96 @@ 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
-      @alternate_content_source = ::Katello::AlternateContentSource.new(acs_params)
-      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] == [] || params[:smart_proxy_names] == []
+        @smart_proxies = []
+      else
+        find_smart_proxies
+      end
+
+      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, acs_params)
+      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. 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)
+      respond_for_async :resource => task
+    end
+
     protected
 
     def acs_params
-      keys = [:name, :label, :base_url, {subpaths: []}, {smart_proxy_ids: []}, :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
 
     def find_smart_proxies
       if params[:smart_proxy_ids]
         @smart_proxies = ::SmartProxy.where(id: params[:smart_proxy_ids])
-        fail HttpErrors::NotFound, _("Couldn't find smart proxies with id '%s'") % params[:smart_proxy_ids].to_sentence if @smart_proxies.empty?
+      elsif params[:smart_proxy_names]
+        @smart_proxies = ::SmartProxy.where(name: params[:smart_proxy_names])
+      end
+      if params[:smart_proxy_ids] && @smart_proxies.length < params[:smart_proxy_ids].length
+        missing_smart_proxies = params[:smart_proxy_ids] - @smart_proxies.pluck(:id)
+        fail HttpErrors::NotFound, _("Couldn't find smart proxies with id '%s'") % missing_smart_proxies.to_sentence
+      elsif params[:smart_proxy_names] && @smart_proxies.length < params[:smart_proxy_names].length
+        missing_smart_proxies = params[:smart_proxy_names] - @smart_proxies.pluck(:name)
+        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

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_components_controller.rb

@@ -57,7 +57,7 @@ module Katello
               else
                 query
               end
-      custom_sort = ->(sort_query) { sort_query.joins(join_query).order(order_query) }
+      custom_sort = ->(sort_query) { sort_query.joins(join_query).order(Arel.sql(order_query)) }
       options = { resource_class: Katello::ContentView, custom_sort: custom_sort }
       collection = scoped_search(query, nil, nil, options)
       collection[:results] = ComponentViewPresenter.component_presenter(@view, params[:status], views: collection[:results])

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/content_view_repositories_controller.rb

@@ -28,7 +28,7 @@ module Katello
       query = query.with_type(params[:content_type]) if params[:content_type]
       # Use custom sort to perform the join and order since we need to order by specific content_view
       # and the ORDER BY query needs access to the katello_content_view_repositories table
-      custom_sort = ->(sort_query) { sort_query.joins(:root).joins(join_query).order(order_query) }
+      custom_sort = ->(sort_query) { sort_query.joins(:root).joins(join_query).order(Arel.sql(order_query)) }
       options = { resource_class: Katello::Repository, custom_sort: custom_sort }
       repos = scoped_search(query, nil, nil, options)
 

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/repositories_controller.rb

@@ -420,8 +420,8 @@ module Katello
       param 'id', String, :required => true
       param 'content_unit_id', String
       param 'size', String
-      param 'checksum', String, :required => true
-      param 'name', String, :required => true, :desc => N_("Needs to only be set for file repositories or docker tags")
+      param 'checksum', String
+      param 'name', String, :desc => N_("Needs to only be set for file repositories or docker tags")
       param 'digest', String, :desc => N_("Needs to only be set for docker tags")
     end
     Katello::RepositoryTypeManager.generic_repository_types.each_pair do |_, repo_type|
@@ -439,12 +439,6 @@ module Katello
       end
 
       uploads = (params[:uploads] || []).map do |upload|
-        if upload[:checksum].nil?
-          fail HttpErrors::BadRequest, _('Checksum is a required parameter.')
-        end
-        if upload[:name].nil?
-          fail HttpErrors::BadRequest, _('Name is a required parameter.')
-        end
         upload.permit(:id, :content_unit_id, :size, :checksum, :name, :digest).to_h
       end
 

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