katello 4.4.0.2 → 4.5.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e2cbec78c4d297f09f1517b095e566c055bd14e2b3d4a534a5f904f8e9d43bc
-  data.tar.gz: 5f96a7ce828a6ac081883643f8f79d55088ded4a5a06d86c4bfc69fababc315e
+  metadata.gz: 5922047abc1b1bd8649e30bbaaf5eaf2e09f09bc9abb5e1b61920c0b84b1b57b
+  data.tar.gz: 8105c45f9d16ca034430e89224f9bb81fa95c02d38ca638268864e34a9d57e2b
 SHA512:
-  metadata.gz: c109e2ed4481c10d8bc475b706aa00498f3cfce65fb2f9ec6cf589be8da2a47344561b31d45a5721aaab9743ccdbf751ec665663b858c26eb433803db59bbc6c
-  data.tar.gz: 87d9b9ced044f3b34df8045a1ca1a02ca5ba695e4048999290fc0594f21186065c63036b93d4b1beef09162ddf9bb60c06dbd7cde7057df8a456a5701b8e9e3d
+  metadata.gz: '069335f24169763ce80081693498c668a115893acb4e9c7b2a1486d54d5394f53b9d21cb6442acd6cba990f07d58e6b75f7ec0d9e32515165226fb833874a311'
+  data.tar.gz: 22cda386e45a6d989daff56fe3897d07a75205282b2aa1e901bf7c333fd38d72869ab3dd808641a5535d8f72063c2961aa575c2420dfa51c2f98a3ab4152b28c

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

@@ -406,7 +406,11 @@ module Katello
           where("#{Organization.table_name}.id = ?", organization.id)
       environments = environments.where("#{Katello::ContentViewEnvironment.table_name}.label = ?", label) if label
 
-      environments.reject { |env| (env.content_view.default && !env.environment.readable?) || !env.content_view.readable? }
+      environments.reject do |env|
+        (env.content_view.default && !env.environment.readable?) ||
+            !env.content_view.readable? ||
+            env.content_view.generated_for_repository?
+      end
     end
 
     def rhsm_params

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

@@ -0,0 +1,121 @@
+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]
+    wrap_parameters :alternate_content_source, include: acs_wrap_params
+
+    before_action :find_authorized_katello_resource, only: [:show, :update, :destroy, :refresh]
+
+    def_param_group :acs do
+      param :name, String, desc: N_("Name of the alternate content source")
+      param :description, String, desc: N_("Description for the alternate content source"), required: false
+      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 :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
+      param :ssl_client_cert_id, :number, desc: N_("Identifier of the content credential containing the SSL Client Cert"), required: false
+      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
+    end
+
+    api :GET, "/alternate_content_sources", N_("List of alternate_content_sources")
+    param_group :search, Api::V2::ApiController
+    add_scoped_search_description_for(AlternateContentSource)
+    def index
+      respond_to do |format|
+        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'])
+        end
+        format.any do
+          alternate_content_sources = scoped_search(index_relation, :name, :asc)
+          respond(collection: alternate_content_sources)
+        end
+      end
+    end
+
+    def index_relation
+      AlternateContentSource.readable.distinct
+    end
+
+    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')
+    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.reload
+      respond_for_create(resource: @alternate_content_source)
+    end
+
+    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?
+        @smart_proxies = @alternate_content_source.smart_proxies
+      elsif params[:smart_proxy_ids].empty?
+        @smart_proxies = []
+      else
+        find_smart_proxies
+      end
+      sync_task(::Actions::Katello::AlternateContentSource::Update, @alternate_content_source, @smart_proxies, acs_params.except(:smart_proxy_ids))
+      respond_for_show(:resource => @alternate_content_source)
+    end
+
+    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')
+    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: []}, {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]
+      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])
+      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
+  end
+end

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

@@ -2,8 +2,10 @@ module Katello
   class Api::V2::ContentExportIncrementalsController < Api::V2::ApiController
     before_action :find_exportable_organization, :only => [:library]
     before_action :find_exportable_content_view_version, :only => [:version]
+    before_action :find_exportable_repository, :only => [:repository]
     before_action :find_library_export_view, :only => [:library]
-    before_action :find_history, :only => [:version, :library]
+    before_action :find_repository_export_view, :only => [:repository]
+    before_action :find_history, :only => [:version, :library, :repository]
 
     api :POST, "/content_export_incrementals/version", N_("Performs an incremental-export of a content view version.")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
@@ -44,6 +46,20 @@ module Katello
       respond_for_async :resource => tasks
     end
 
+    api :POST, "/content_export_incrementals/repository", N_("Performs a incremental-export of the repository in library.")
+    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 :from_history_id, :number, :desc => N_("Export history identifier used for incremental export. "\
+                                                 "If not provided the most recent export history will be used."), :required => false
+    def repository
+      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportRepository,
+                          @repository,
+                          chunk_size: params[:chunk_size_gb],
+                          from_history: @history)
+      respond_for_async :resource => tasks
+    end
+
     private
 
     def find_exportable_content_view_version
@@ -63,6 +79,16 @@ module Katello
       end
     end
 
+    def find_repository_export_view
+      @view = ::Katello::Pulp3::ContentViewVersion::Export.find_repository_export_view(
+                                                                repository: @repository,
+                                                                create_by_default: false)
+      if @view.blank?
+        msg = _("Unable to incrementally export. Do a Full Export on the repository content.")
+        fail HttpErrors::BadRequest, msg
+      end
+    end
+
     def find_history
       if params[:from_history_id].present?
         @history = ::Katello::ContentViewVersionExportHistory.find(params[:from_history_id])
@@ -72,8 +98,7 @@ module Katello
         end
       else
         @history = ::Katello::ContentViewVersionExportHistory.
-                      latest(@view,
-                                          destination_server: params[:destination_server])
+                      latest(@view, destination_server: params[:destination_server])
         if @history.blank?
           msg = _("No existing export history was found to perform an incremental export. A full export must be performed")
           fail HttpErrors::NotFound, msg
@@ -87,5 +112,16 @@ module Katello
         throw_resource_not_found(name: 'organization', id: params[:organization_id])
       end
     end
+
+    def find_exportable_repository
+      @repository = Repository.find_by_id(params[:id])
+      if @repository.blank?
+        throw_resource_not_found(name: 'repository', id: params[:id])
+      end
+
+      unless @repository.organization.can_export_content?
+        throw_resource_not_found(name: 'organization', id: @repository.organization.id)
+      end
+    end
   end
 end

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

@@ -2,6 +2,7 @@ module Katello
   class Api::V2::ContentExportsController < Api::V2::ApiController
     before_action :find_exportable_organization, :only => [:library]
     before_action :find_exportable_content_view_version, :only => [:version]
+    before_action :find_exportable_repository, :only => [:repository]
 
     api :GET, "/content_exports", N_("List export histories")
     param :content_view_version_id, :number, :desc => N_("Content view version identifier"), :required => false
@@ -58,8 +59,26 @@ module Katello
       respond_for_async :resource => tasks
     end
 
+    api :POST, "/content_exports/repository", N_("Performs a full-export of the repository in library.")
+    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
+    def repository
+      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportRepository,
+                          @repository,
+                          chunk_size: params[:chunk_size_gb])
+      respond_for_async :resource => tasks
+    end
+
     private
 
+    def find_exportable_repository
+      @repository = Repository.find_by_id(params[:id])
+      if @repository.blank? || !@repository.organization.can_export_content?
+        throw_resource_not_found(name: 'repository', id: params[:id])
+      end
+    end
+
     def find_exportable_content_view_version
       @version = ContentViewVersion.exportable.find_by_id(params[:id])
       throw_resource_not_found(name: 'content view version', id: params[:id]) if @version.blank?

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

@@ -1,10 +1,7 @@
 module Katello
   class Api::V2::ContentImportsController < Api::V2::ApiController
-    before_action :find_organization, :only => [:version]
-    before_action :check_authorized, :only => [:version]
-
-    before_action :find_importable_organization, :only => [:library]
-    before_action :find_default_content_view, :only => [:library]
+    before_action :find_organization, :only => [:version, :repository, :library]
+    before_action :check_authorized, :only => [:version, :repository, :library]
 
     api :GET, "/content_imports", N_("List import histories")
     param :content_view_version_id, :number, :desc => N_("Content view version identifier"), :required => false
@@ -46,22 +43,21 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :POST, "/content_imports/repository", N_("Import a repository")
+    param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
+    param :path, String, :desc => N_("Directory containing the exported Content View Version"), :required => true
+    param :metadata, Hash, :desc => N_("Metadata taken from the upstream export history for this Content View Version"), :required => true
+    def repository
+      task = async_task(::Actions::Katello::ContentViewVersion::ImportRepository, @organization, path: params[:path], metadata: metadata_params.to_h)
+      respond_for_async :resource => task
+    end
+
     private
 
     def check_authorized
       fail HttpErrors::Forbidden, _("Action unauthorized to be performed in this organization.") unless @organization.can_import_content?
     end
 
-    def find_default_content_view
-      @view = @organization&.default_content_view
-      throw_resource_not_found(name: 'organization', id: params[:organization_id]) if @view.blank?
-    end
-
-    def find_importable_organization
-      find_organization
-      throw_resource_not_found(name: 'organization', id: params[:organization_id]) unless @organization.can_import_content?
-    end
-
     def metadata_params
       params.require(:metadata).permit(
         :organization,
@@ -69,8 +65,9 @@ module Katello
         :products,
         :toc,
         :incremental,
+        :destination_server,
         gpg_keys: {},
-        content_view: [:name, :label, :description],
+        content_view: [:name, :label, :description, :generated_for],
         content_view_version: [:major, :minor, :description],
         from_content_view_version: [:major, :minor]
       ).tap do |nested|

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_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/content_view_versions_controller.rb

@@ -274,17 +274,5 @@ module Katello
       return deny_access unless @content_view_version.content_view.deletable?
       true
     end
-
-    def metadata_params
-      params.require(:metadata).permit(
-        :organization,
-        :content_view,
-        :repository_mapping,
-        :toc,
-        content_view_version: [:major, :minor]
-      ).tap do |nested|
-        nested[:repository_mapping] = params[:metadata].require(:repository_mapping).permit!
-      end
-    end
   end
 end

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

@@ -5,6 +5,7 @@ module Katello
     include Katello::Concerns::Api::V2::BulkExtensions
 
     before_action :find_authorized_katello_resource, :except => [:index, :create, :copy, :auto_complete_search]
+    before_action :ensure_non_generated, only: [:publish]
     before_action :ensure_non_default, :except => [:index, :create, :copy, :auto_complete_search]
     before_action :find_organization, :only => [:create]
     before_action :find_optional_organization, :only => [:index, :auto_complete_search]
@@ -54,6 +55,7 @@ module Katello
     param :without, Array, :desc => N_("Do not include this array of content views")
     param :name, String, :desc => N_("Name of the content view"), :required => false
     param :label, String, :desc => N_("Label of the content view"), :required => false
+    param :include_generated, :bool, :desc => N_("Include content views generated by imports/exports. Defaults to false")
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(ContentView)
     def index
@@ -64,6 +66,7 @@ module Katello
 
     def index_relation
       content_views = ContentView.readable
+      content_views = content_views.not_generated_for_repository unless Foreman::Cast.to_bool(params[:include_generated])
       content_views = content_views.where(:organization_id => @organization.id) if @organization
       content_views = content_views.in_environment(@environment) if @environment
       content_views = ::Foreman::Cast.to_bool(params[:nondefault]) ? content_views.non_default : content_views.default if params[:nondefault]
@@ -257,6 +260,16 @@ module Katello
       end
     end
 
+    def  ensure_non_generated
+      if @content_view.import_only?
+        fail HttpErrors::BadRequest, _("Import only Content Views cannot be directly publsihed. Content can only be updated by importing into the view.")
+      end
+
+      if @content_view.generated?
+        fail HttpErrors::BadRequest, _("Generated content views cannot be directly published. They can updated only via export.")
+      end
+    end
+
     def view_params
       attrs = [:name, :description, :auto_publish, :solve_dependencies, :import_only,
                :default, :created_at, :updated_at, :next_version, {:component_ids => []}]

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

@@ -107,7 +107,7 @@ module Katello
       fail HttpErrors::BadRequest, _("Can't update the '%s' environment") % "Library" if @environment.library? && update_params.empty?
       update_params[:name] = params[:environment][:new_name] if params[:environment][:new_name]
       @environment.update!(update_params)
-      if update_params[:registry_name_pattern]
+      if update_params[:registry_name_pattern] || update_params[:registry_unauthenticated_pull]
         task = send(async ? :async_task : :sync_task, ::Actions::Katello::Environment::PublishRepositories,
                     @environment, content_type: Katello::Repository::DOCKER_TYPE)
       end

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

@@ -35,7 +35,9 @@ module Katello
     end
 
     def all_for_content_view_filter(filter, _collection)
-      Erratum.joins(:repositories).merge(filter.applicable_repos)
+      available_ids = Erratum.joins(:repositories).merge(filter.applicable_repos)&.pluck(:errata_id) || []
+      added_ids = filter&.erratum_rules&.pluck(:errata_id) || []
+      Erratum.where(errata_id: available_ids + added_ids)
     end
 
     def custom_index_relation(collection)

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

@@ -12,6 +12,7 @@ module Katello
     api :GET, "/hosts/:host_id/module_streams", N_("List module streams available to the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
     param :status, ::Katello::HostAvailableModuleStream::API_STATES.keys, :desc => N_("Streams based on the host based on their status")
+    param :install_status, String, :desc => N_("Streams based on the host based on the installation status"), :required => false
     param_group :search, Api::V2::ApiController
     def index
       collection = scoped_search(index_relation, :name, :asc, :resource_class => ::Katello::HostAvailableModuleStream)
@@ -22,8 +23,13 @@ module Katello
       return HostAvailableModuleStream.upgradable([@host]) if params[:status] == HostAvailableModuleStream::UPGRADABLE
 
       rel = @host.host_available_module_streams
-      return rel if params[:status].blank?
-      rel.send(::Katello::HostAvailableModuleStream::API_STATES[params[:status]])
+      if params[:sort_by] == 'installed_profiles'
+        rel = rel.order([:installed_profiles, :status])
+      end
+      return rel if (params[:status].blank? && params[:install_status].blank?)
+      rel = rel.send(::Katello::HostAvailableModuleStream::API_STATES[params[:status]]) unless params[:status].blank?
+      rel = rel.installed_status(params[:install_status], @host) unless params[:install_status].blank?
+      rel
     end
 
     def resource_class

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

@@ -5,6 +5,7 @@ module Katello
     before_action :check_subscriptions, :only => [:add_subscriptions, :remove_subscriptions]
     before_action :find_content_view_environment, :only => :create
     before_action :check_registration_services, :only => [:destroy, :create]
+    before_action :find_content_overrides, :only => [:content_override]
 
     def_param_group :installed_products do
       param :product_id, String, :desc => N_("Product id as listed from a host's installed products, \
@@ -165,12 +166,16 @@ module Katello
       param :name, String, :desc => N_("Override key or name. Note if name is not provided the default name will be 'enabled'"), :required => false
       param :remove, :bool, :desc => N_("Set true to remove an override and reset it to 'default'"), :required => false
     end
+    param :content_overrides_search, Hash, :desc => N_("Content override search parameters") do
+      param_group :search, Api::V2::ApiController
+      param :enabled, :bool, :desc => N_("Set true to override to enabled; Set false to override to disabled.'"), :required => false
+      param :remove, :bool, :desc => N_("Set true to remove an override and reset it to 'default'"), :required => false
+    end
     def content_override
-      content_overrides = params[:content_overrides] || []
-
-      content_override_values = content_overrides.map do |override_params|
+      content_override_values = @content_overrides.map do |override_params|
         validate_content_overrides_enabled(override_params)
       end
+
       sync_task(::Actions::Katello::Host::UpdateContentOverrides, @host, content_override_values, false)
       fetch_product_content
     end
@@ -217,5 +222,22 @@ module Katello
         fail ::Foreman::Exception.new(N_("unknown permission for %s"), "#{params[:controller]}##{params[:action]}")
       end
     end
+
+    def find_content_overrides
+      if params[:content_overrides_search]
+        content_labels = ::Katello::Content.joins(:product_contents)
+                            .where("#{Katello::ProductContent.table_name}.product_id": @host.organization.products.subscribable.enabled)
+                            .search_for(params[:content_overrides_search][:search])
+                            .pluck(:label)
+        @content_overrides = content_labels.map do |label|
+          { content_label: label,
+            value: Foreman::Cast.to_bool(params[:content_overrides_search][:enabled]),
+            remove: Foreman::Cast.to_bool(params[:content_overrides_search][:remove])
+          }
+        end
+      else
+        @content_overrides = params[:content_overrides] || []
+      end
+    end
   end
 end

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

@@ -36,7 +36,9 @@ module Katello
     end
 
     def all_for_content_view_filter(filter, _collection)
-      ModuleStream.joins(:repositories).merge(filter.applicable_repos)
+      available_ids = ModuleStream.joins(:repositories).merge(filter.applicable_repos)&.pluck(:id) || []
+      added_ids = filter&.module_stream_rules&.pluck(:module_stream_id) || []
+      ModuleStream.where(id: available_ids + added_ids)
     end
 
     def available_for_content_view_filter(filter, _collection)

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

@@ -29,7 +29,6 @@ module Katello
         param :hostgroup_ids, Array, N_("Host group IDs"), :required => false
         param :environment_ids, Array, N_("Environment IDs"), :required => false
         param :subnet_ids, Array, N_("Subnet IDs"), :required => false
-        param :label, String, :required => false
         param :location_ids, Array, N_("Associated location IDs"), :required => false
       end
     end
@@ -66,6 +65,9 @@ module Katello
 
     api :POST, '/organizations', N_('Create organization')
     param_group :resource
+    param :organization, Hash do
+      param :label, String, :required => false
+    end
     def create
       @organization = Organization.new(resource_params)
       creator = ::Katello::OrganizationCreator.new(@organization)
@@ -134,7 +136,7 @@ module Katello
 
     api :PUT, "/organizations/:id/cdn_configuration", N_("Update the CDN configuration")
     param :id, String, :desc => N_("ID of the Organization"), :required => true
-    param :type, String, :desc => N_("CDN configuration type. One of %s.") % CdnConfiguration::TYPES, :required => true
+    param :type, String, :desc => N_("CDN configuration type. One of %s.") % CdnConfiguration::TYPES.join(", "), :required => true
     param :url, String, :desc => N_("Upstream foreman server to sync CDN content from. Relevant only for 'upstream_server' type.")
     param :username, String, :desc => N_("Username for authentication. Relevant only for 'upstream_server' type.")
     param :password, String, :desc => N_("Password for authentication. Relevant only for 'upstream_server' type.")

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

@@ -67,7 +67,9 @@ module Katello
     end
 
     def all_for_content_view_filter(filter, _collection)
-      PackageGroup.joins(:repositories).merge(filter.applicable_repos)
+      available_ids = PackageGroup.joins(:repositories).merge(filter.applicable_repos)&.pluck(:pulp_id) || []
+      added_ids = filter&.package_group_rules&.pluck(:uuid) || []
+      PackageGroup.where(pulp_id: available_ids + added_ids)
     end
 
     def default_sort

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

@@ -6,7 +6,7 @@ module Katello
     param :ids, Array, :desc => N_("List of repository ids"), :required => true
     def destroy_repositories
       deletion_authorized_repositories = @repositories.deletable
-      unpromoted_repos = deletion_authorized_repositories.reject { |repo| repo.promoted? }
+      unpromoted_repos = deletion_authorized_repositories.reject { |repo| repo.promoted? && repo.content_views.generated_for_none.exists? }
 
       messages1 = format_bulk_action_messages(
           :success    => "",

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.concat([:ignore_global_proxy, :mirror_on_sync]) + generic_repo_wrap_params
+    repo_wrap_params = RootRepository.attribute_names + [:mirror_on_sync] + generic_repo_wrap_params
 
     wrap_parameters :repository, :include => repo_wrap_params