katello 3.5.2 → 3.6.0.rc1

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

@@ -1,6 +1,5 @@
 module Katello
   class Api::V2::HostAutocompleteController < ::Api::V2::BaseController
-    include ::Api::TaxonomyScope
     include ::Foreman::Controller::AutoCompleteSearch
 
     before_action :find_optional_nested_object

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

@@ -34,7 +34,7 @@ module Katello
     param :available_for, String, :required => false,
           :desc => N_("Interpret specified object to return only Host Collections that can be associated with specified object. The value 'host' is supported.")
     def index
-      respond(:collection => scoped_search(index_relation.uniq!, :name, :asc))
+      respond(:collection => scoped_search(index_relation.distinct, :name, :asc))
     end
 
     def index_relation

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

@@ -80,7 +80,7 @@ module Katello
     end
 
     def params_to_rhsm_params
-      rhsm_params = params.slice(:facts, :uuid, :name)
+      rhsm_params = params.slice(:facts, :uuid, :name).to_unsafe_h
       rhsm_params[:releaseVer] = params['release_version'] if params['release_version']
       rhsm_params[:serviceLevel] = params['service_level'] if params['service_level']
       rhsm_params[:guestIds] = params['hypervisor_guest_uuids'] if params[:hypervisor_guest_uuids]

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

@@ -6,9 +6,9 @@ module Katello
     before_action :find_host_collections, :only => [:bulk_add_host_collections, :bulk_remove_host_collections]
     before_action :find_environment, :only => [:environment_content_view]
     before_action :find_content_view, :only => [:environment_content_view]
-    before_action :find_editable_hosts, :except => [:destroy_hosts, :installable_errata]
+    before_action :find_editable_hosts, :except => [:destroy_hosts, :applicable_errata, :installable_errata]
     before_action :find_deletable_hosts, :only => [:destroy_hosts]
-    before_action :find_readable_hosts, :only => [:installable_errata, :available_incremental_updates]
+    before_action :find_readable_hosts, :only => [:applicable_errata, :installable_errata, :available_incremental_updates]
     before_action :find_errata, :only => [:available_incremental_updates]
 
     before_action :validate_content_action, :only => [:install_content, :update_content, :remove_content]
@@ -91,6 +91,14 @@ module Katello
                        :resource => { 'displayMessages' => display_messages }
     end
 
+    api :POST, "/hosts/bulk/applicable_errata",
+        N_("Fetch applicable errata for a host.")
+    param_group :bulk_params
+    def applicable_errata
+      respond_for_index(:collection => scoped_search(Katello::Erratum.applicable_to_hosts(@hosts), 'updated', 'desc',
+                                                     :resource_class => Erratum))
+    end
+
     api :POST, "/hosts/bulk/installable_errata",
         N_("Fetch installable errata for a host.")
     param_group :bulk_params
@@ -137,7 +145,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/subscriptions/remove_subscriptions", N_("Remove subscriptions from one or more hosts")
+    api :PUT, "/hosts/bulk/remove_subscriptions", N_("Remove subscriptions from one or more hosts")
     param_group :bulk_params
     param :subscriptions, Array, :desc => N_("Array of subscriptions to remove") do
       param :id, String, :desc => N_("Subscription Pool id"), :required => true
@@ -154,7 +162,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/subscriptions/add_subscriptions", N_("Add subscriptions to one or more hosts")
+    api :PUT, "/hosts/bulk/add_subscriptions", N_("Add subscriptions to one or more hosts")
     param_group :bulk_params
     param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => true do
       param :id, String, :desc => N_("Subscription Pool id"), :required => true
@@ -169,7 +177,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/subscriptions/auto_attach", N_("Trigger an auto-attach of subscriptions on one or more hosts")
+    api :PUT, "/hosts/bulk/auto_attach", N_("Trigger an auto-attach of subscriptions on one or more hosts")
     param_group :bulk_params
     def auto_attach
       task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::AutoAttachSubscriptions, @hosts)

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

@@ -63,7 +63,8 @@ module Katello
     param_group :resource, ::Api::V2::TaxonomiesController
     def update
       if params.key?(:redhat_repository_url)
-        sync_task(::Actions::Katello::Provider::Update, @organization.redhat_provider, params)
+        org_params = params.permit(:redhat_repository_url).to_h
+        sync_task(::Actions::Katello::Provider::Update, @organization.redhat_provider, org_params)
       end
       super
     end

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

@@ -38,7 +38,8 @@ module Katello
       params[:user_visible] = ::Foreman::Cast.to_bool(params[:user_visible])
       params[:user_visible] ||= true
 
-      sync_task(::Actions::Katello::Repository::UploadPackageGroup, @repo, params)
+      create_params = params.slice(:name, :description, :user_visible, :mandatory_package_names, :optional_package_names, :conditional_package_names, :default_package_names).to_unsafe_h
+      sync_task(::Actions::Katello::Repository::UploadPackageGroup, @repo, create_params)
       render :json => {:status => "success"}
     end
 
@@ -54,7 +55,7 @@ module Katello
       render :json => {:status => "success"}
     end
 
-    def available_for_content_view_filter(filter, collection)
+    def available_for_content_view_filter(filter, _collection)
       collection_ids = []
       current_ids = filter.package_group_rules.map(&:uuid)
       filter.applicable_repos.each do |repo|

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

@@ -31,7 +31,7 @@ module Katello
       validate_contents = ::Foreman::Cast.to_bool(params[:validate_contents])
 
       syncable_products = @products.syncable
-      syncable_repositories = Repository.where(:product_id => syncable_products).has_url
+      syncable_repositories = Repository.where(:product_id => syncable_products).has_url.in_default_view
 
       syncable_repositories = syncable_repositories.where(:content_type => Repository::YUM_TYPE) if skip_metadata_check || validate_contents
       syncable_repositories = syncable_repositories.where.not(:download_policy => ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND) if validate_contents

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

@@ -36,7 +36,7 @@ module Katello
     param_group :search, Api::V2::ApiController
     def index
       options = {:includes => [:sync_plan, :provider]}
-      respond(:collection => scoped_search(index_relation.uniq, :name, :asc, options))
+      respond(:collection => scoped_search(index_relation.distinct, :name, :asc, options))
     end
 
     def index_relation
@@ -71,7 +71,7 @@ module Katello
     def create
       params[:product][:label] = labelize_params(product_params) if product_params
 
-      product = Product.new(product_params)
+      product = Product.new(product_params.to_h)
 
       sync_task(::Actions::Katello::Product::Create, product, @organization)
       respond(:resource => product)
@@ -89,7 +89,7 @@ module Katello
     param_group :product
     param :name, String, :desc => N_("Product name")
     def update
-      sync_task(::Actions::Katello::Product::Update, @product, product_params)
+      sync_task(::Actions::Katello::Product::Update, @product, product_params.to_h)
 
       respond(:resource => @product.reload)
     end

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

@@ -1,5 +1,5 @@
 module Katello
-  class Api::V2::RepositoriesController < Api::V2::ApiController
+  class Api::V2::RepositoriesController < Api::V2::ApiController # rubocop:disable Metrics/ClassLength
     include Katello::Concerns::FilteredAutoCompleteSearch
 
     before_action :find_optional_organization, :only => [:index, :auto_complete_search]
@@ -16,8 +16,6 @@ module Katello
     before_action :error_on_rh_repo, :only => [:destroy]
 
     skip_before_action :authorize, :only => [:sync_complete, :gpg_key_content]
-    skip_before_action :require_org, :only => [:sync_complete]
-    skip_before_action :require_user, :only => [:sync_complete]
     skip_before_action :check_content_type, :only => [:upload_content]
 
     def_param_group :repo do
@@ -27,7 +25,7 @@ module Katello
       param :url, String, :desc => N_("repository source url")
       param :gpg_key_id, :number, :desc => N_("id of the gpg key that will be assigned to the new repository")
       param :unprotected, :bool, :desc => N_("true if this repository can be published via HTTP")
-      param :content_type, RepositoryTypeManager.creatable_repository_types.keys, :required => true, :desc => N_("type of repo (either 'yum', 'puppet', 'docker', or 'ostree')")
+      param :content_type, RepositoryTypeManager.creatable_repository_types.keys, :required => true, :desc => N_("type of repo (either 'yum', 'deb', 'puppet', 'docker', or 'ostree')")
       param :checksum_type, String, :desc => N_("checksum of the repository, currently 'sha1' & 'sha256' are supported.")
       param :docker_upstream_name, String, :desc => N_("name of the upstream docker repository")
       param :download_policy, ["immediate", "on_demand", "background"], :desc => N_("download policy for yum repos (either 'immediate', 'on_demand', or 'background')")
@@ -37,6 +35,10 @@ module Katello
       param :upstream_password, String, :desc => N_("Password of the upstream repository user used for authentication")
       param :ostree_upstream_sync_policy, ::Katello::Repository::OSTREE_UPSTREAM_SYNC_POLICIES, :desc => N_("policies for syncing upstream ostree repositories.")
       param :ostree_upstream_sync_depth, :number, :desc => N_("if a custom sync policy is chosen for ostree repositories then a 'depth' value must be provided.")
+      param :deb_releases, String, :desc => N_("comma separated list of releases to be synched from deb-archive")
+      param :deb_components, String, :desc => N_("comma separated list of repo components to be synched from deb-archive")
+      param :deb_architectures, String, :desc => N_("comma separated list of architectures to be synched from deb-archive")
+      param :ignore_global_proxy, :bool, :desc => N_("if true, will ignore the globally configured proxy when syncing.")
     end
 
     api :GET, "/repositories", N_("List of enabled repositories")
@@ -50,8 +52,9 @@ module Katello
     param :environment_id, :number, :desc => N_("ID of an environment to show repositories in")
     param :content_view_id, :number, :desc => N_("ID of a content view to show repositories in")
     param :content_view_version_id, :number, :desc => N_("ID of a content view version to show repositories in")
+    param :deb_id, String, :desc => N_("Id of a deb package to find repositories that contain the deb")
     param :erratum_id, String, :desc => N_("Id of an erratum to find repositories that contain the erratum")
-    param :rpm_id, String, :desc => N_("Id of a package to find repositories that contain the rpm")
+    param :rpm_id, String, :desc => N_("Id of a rpm package to find repositories that contain the rpm")
     param :ostree_branch_id, String, :desc => N_("Id of an ostree branch to find repositories that contain that branch")
     param :library, :bool, :desc => N_("show repositories in Library and the default content view")
     param :content_type, RepositoryTypeManager.repository_types.keys, :desc => N_("limit to only repositories of this type")
@@ -61,7 +64,7 @@ module Katello
     param_group :search, Api::V2::ApiController
     def index
       options = {:includes => [:gpg_key, :product, :environment]}
-      respond(:collection => scoped_search(index_relation.uniq, :name, :asc, options))
+      respond(:collection => scoped_search(index_relation.distinct, :name, :asc, options))
     end
 
     def index_relation
@@ -70,6 +73,10 @@ module Katello
       query = query.where(:content_type => params[:content_type]) if params[:content_type]
       query = query.where(:name => params[:name]) if params[:name]
 
+      if params[:deb_id]
+        query = query.joins(:debs).where("#{Deb.table_name}.id" => Deb.with_identifiers(params[:deb_id]))
+      end
+
       if params[:erratum_id]
         query = query.joins(:errata).where("#{Erratum.table_name}.id" => Erratum.with_identifiers(params[:erratum_id]))
       end
@@ -131,7 +138,7 @@ module Katello
 
     api :POST, "/repositories", N_("Create a custom repository")
     param_group :repo
-    def create
+    def create # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity
       repo_params = repository_params
       unless RepositoryTypeManager.creatable_by_user?(repo_params[:content_type])
         msg = _("Invalid params provided - content_type must be one of %s") % RepositoryTypeManager.creatable_repository_types.keys.join(",")
@@ -147,9 +154,10 @@ module Katello
       repo_params[:url] = nil if repo_params[:url].blank?
       repo_params[:unprotected] = repo_params.key?(:unprotected) ? repo_params[:unprotected] : true
       repo_params[:gpg_key] = gpg_key
-      repository = @product.add_repo(Hash[repo_params.slice(:label, :name, :url, :content_type, :arch, :unprotected, :gpg_key, :checksum_type, :download_policy).map { |k, v| [k.to_sym, v] }])
+      repository = @product.add_repo(Hash[repo_params.slice(:label, :name, :url, :content_type, :arch, :unprotected, :gpg_key, :checksum_type, :download_policy).to_h.map { |k, v| [k.to_sym, v] }])
       repository.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
       repository.mirror_on_sync = ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync]) if repo_params.key?(:mirror_on_sync)
+      repository.ignore_global_proxy = ::Foreman::Cast.to_bool(repo_params[:ignore_global_proxy]) if repo_params.key?(:ignore_global_proxy)
       repository.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
       repository.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
       repository.upstream_password = repo_params[:upstream_password] if repo_params.key?(:upstream_password)
@@ -157,6 +165,11 @@ module Katello
         repository.ostree_upstream_sync_policy = repo_params[:ostree_upstream_sync_policy]
         repository.ostree_upstream_sync_depth = repo_params[:ostree_upstream_sync_depth]
       end
+      if repository.deb?
+        repository.deb_releases = repo_params[:deb_releases] if repo_params[:deb_releases]
+        repository.deb_components = repo_params[:deb_components] if repo_params[:deb_components]
+        repository.deb_architectures = repo_params[:deb_architectures] if repo_params[:deb_architectures]
+      end
       sync_task(::Actions::Katello::Repository::Create, repository, false, true)
       repository = Repository.find(repository.id)
       respond_for_show(:resource => repository)
@@ -197,7 +210,7 @@ module Katello
         :source_url => params[:source_url]
       }
 
-      if params[:source_url].present? && params[:source_url] !~ /\A#{URI.regexp}\z/
+      if params[:source_url].present? && params[:source_url] !~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
         fail HttpErrors::BadRequest, _("source URL is malformed")
       end
 
@@ -355,7 +368,9 @@ module Katello
         fail HttpErrors::BadRequest, _('No upload param specified. Either uploads or upload_ids (deprecated) is required.')
       end
 
-      uploads = params['uploads'] || []
+      uploads = (params[:uploads] || []).map do |upload|
+        upload.permit(:id, :size, :checksum, :name).to_h
+      end
 
       if params.key?(:upload_ids)
         ::Foreman::Deprecation.api_deprecation_warning("The parameter upload_ids will be removed in Katello 3.3. Please update to use the uploads parameter.")
@@ -418,13 +433,14 @@ module Katello
 
     def repository_params
       keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password, :upstream_username,
-              :ostree_upstream_sync_depth, :ostree_upstream_sync_policy
+              :ostree_upstream_sync_depth, :ostree_upstream_sync_policy, :ignore_global_proxy,
+              :deb_releases, :deb_components, :deb_architectures
              ]
       keys += [:label, :content_type] if params[:action] == "create"
       if params[:action] == 'create' || @repository.custom?
         keys += [:url, :gpg_key_id, :unprotected, :name, :checksum_type, :docker_upstream_name]
       end
-      params.require(:repository).permit(*keys)
+      params.require(:repository).permit(*keys).to_h
     end
 
     def error_on_rh_product

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

@@ -14,19 +14,11 @@ module Katello
     api :GET, "/products/:product_id/repository_sets", N_("List repository sets for a product.")
     param :product_id, :number, :required => true, :desc => N_("ID of a product to list repository sets from")
     param :name, String, :required => false, :desc => N_("Repository set name to search on")
+    param :enabled, :bool, :required => false, :desc => N_("If true, only return repository sets that have been enabled. Defaults to false")
     param_group :search, Api::V2::ApiController
     def index
-      collection = {}
-      if @product.nil?
-        collection[:results] = @organization.enabled_product_content
-      else
-        collection[:results] = @product.displayable_product_contents
-      end
-      # filter on name if it is provided
-      collection[:results] = collection[:results].select { |pc| pc.content.name == params[:name] } if params[:name]
-      collection[:subtotal] = collection[:results].size
-      collection[:total] = collection[:subtotal]
-      respond_for_index :collection => collection
+      respond(:collection => scoped_search(index_relation, nil, nil, :custom_sort => default_sort,
+                                           :resource_class => Katello::ProductContent))
     end
 
     api :GET, "/products/:product_id/repository_sets/:id", N_("Get info about a repository set")
@@ -40,7 +32,7 @@ module Katello
     param :id, :number, :required => true, :desc => N_("ID of the repository set")
     param :product_id, :number, :required => true, :desc => N_("ID of a product to list repository sets from")
     def available_repositories
-      scan_cdn = sync_task(::Actions::Katello::RepositorySet::ScanCdn, @product, @product_content.content.id)
+      scan_cdn = sync_task(::Actions::Katello::RepositorySet::ScanCdn, @product, @product_content.content.cp_content_id)
       repos = scan_cdn.output[:results]
 
       repos = repos.select do |repo|
@@ -83,6 +75,22 @@ module Katello
 
     private
 
+    def default_sort
+      lambda { |relation| relation.joins(:content).order("name asc") }
+    end
+
+    def index_relation
+      if @product.nil?
+        relation = @organization.enabled_product_content
+      else
+        relation = @product.displayable_product_contents
+      end
+
+      relation = relation.enabled(@organization) if ::Foreman::Cast.to_bool(params[:enabled])
+      relation = relation.joins(:content).where(:name => params[:name]) if params[:name].present?
+      relation
+    end
+
     def find_product_content
       @product_content = @product.product_content_by_id(params[:id])
       fail HttpErrors::NotFound, _("Couldn't find repository set with id '%s'.") % params[:id] if @product_content.nil?
@@ -106,7 +114,7 @@ module Katello
     end
 
     def substitutions
-      params.slice(:basearch, :releasever)
+      params.permit(:basearch, :releasever).to_h
     end
   end
 end

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

@@ -1,7 +1,6 @@
 module Katello
   class Api::V2::RootController < Api::V2::ApiController
     skip_before_action :authorize # ok - only shows URLs available
-    skip_before_action :require_user
 
     resource_description do
       api_version 'v2'

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

@@ -30,7 +30,7 @@ module Katello
     param :no_overlap, :bool, :desc => N_("Return subscriptions which do not overlap with a currently-attached subscription")
     def index
       collection = scoped_search(
-        index_relation.uniq, :cp_id, :asc, resource_class: Pool, includes: [:subscription])
+        index_relation.distinct, :cp_id, :asc, resource_class: Pool, includes: [:subscription])
       if params[:activation_key_id]
         key_pools = @activation_key.get_key_pools
         collection[:results] = collection[:results].map do |pool|
@@ -82,14 +82,6 @@ module Katello
       respond_for_index(:collection => subscriptions, :template => 'index')
     end
 
-    api :DELETE, "/activation_keys/:activation_key_id/subscriptions/:id", N_("Unattach a subscription"), :deprecated => true
-    param :id, String, :desc => N_("Subscription ID"), :required => false
-    param :activation_key_id, String, :desc => N_("activation key ID")
-    def destroy
-      @activation_key.unsubscribe(params[:id])
-      respond_for_index(:collection => scoped_search(import_subscriptions.uniq, :cp_id, :asc, :resource_class => Pool), :template => "index")
-    end
-
     api :POST, "/organizations/:organization_id/subscriptions/upload", N_("Upload a subscription manifest")
     param :organization_id, :number, :desc => N_("Organization id"), :required => true
     param :content, File, :desc => N_("Subscription manifest file"), :required => true
@@ -171,16 +163,6 @@ module Katello
       %w(id desc)
     end
 
-    def import_subscriptions
-      subscriptions = if @activation_key
-                        index_activation_key
-                      else
-                        index_organization
-                      end
-      cp_ids = subscriptions.collect { |x| x["id"] }
-      index_relation.where("cp_id not in (?)", cp_ids)
-    end
-
     def index_activation_key
       @activation_key.subscriptions
     end

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

@@ -23,7 +23,7 @@ module Katello
     param :interval, SyncPlan::TYPES, :desc => N_("filter by interval")
     param_group :search, Api::V2::ApiController
     def index
-      respond_for_index(:collection => scoped_search(index_relation.uniq, :name, :asc))
+      respond_for_index(:collection => scoped_search(index_relation.distinct, :name, :asc))
     end
 
     def index_relation

data/app/controllers/katello/application_controller.rb

@@ -86,24 +86,6 @@ module Katello
       end
     end
 
-    def require_user
-      if current_user
-        #don't redirect if the user is trying to set an org
-        if params[:action] != 'set_org' && params[:controller] != 'user_sessions'
-          #redirect to originally requested page
-          unless session[:original_uri].nil?
-            redirect_to session[:original_uri]
-            session[:original_uri] = nil
-          end
-        end
-
-        return true
-      else
-        #save original uri and redirect to login page
-        session[:original_uri] = request.fullpath
-      end
-    end
-
     # render bad params to user
     # @overload render_bad_parameters()
     #   render bad_parameters with `default_message` and status `400`

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

@@ -4,9 +4,19 @@ module Katello
       extend ActiveSupport::Concern
       include ForemanTasks::Triggers
 
-      included do
-        alias_method_chain :action_permission, :katello
+      module Overrides
+        def action_permission
+          case params[:action]
+          when 'host_collections'
+            'edit'
+          else
+            super
+          end
+        end
+      end
 
+      included do
+        prepend Overrides
         def destroy
           sync_task(::Actions::Katello::Host::Destroy, @host)
           process_response(:object => @host)
@@ -21,17 +31,6 @@ module Katello
           render(:locals => { :resource => @host }, :template => 'katello/api/v2/hosts/show', :status => 200)
         end
       end
-
-      private
-
-      def action_permission_with_katello
-        case params[:action]
-        when 'host_collections'
-          'edit'
-        else
-          action_permission_without_katello
-        end
-      end
     end
   end
 end