katello 3.1.0.1 → 3.2.0.rc1

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

@@ -2,8 +2,8 @@ module Katello
   class Api::V2::ContentViewFiltersController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_filter :find_content_view
-    before_filter :find_filter, :except => [:index, :create, :auto_complete_search]
+    before_action :find_content_view
+    before_action :find_filter, :except => [:index, :create, :auto_complete_search]
 
     wrap_parameters :include => (ContentViewFilter.attribute_names + %w(repository_ids))
 

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

@@ -2,7 +2,7 @@ module Katello
   class Api::V2::ContentViewHistoriesController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_filter :find_content_view
+    before_action :find_content_view
 
     api :GET, "/content_views/:id/history", N_("Show a content view's history")
     param :id, :number, :desc => N_("content view numeric identifier"), :required => true

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

@@ -2,8 +2,8 @@ module Katello
   class Api::V2::ContentViewPuppetModulesController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_filter :find_content_view, :except => [:autocomplete_search]
-    before_filter :find_content_view_puppet_module, :only => [:show, :update, :destroy]
+    before_action :find_content_view, :except => [:autocomplete_search]
+    before_action :find_content_view_puppet_module, :only => [:show, :update, :destroy]
 
     api :GET, "/content_views/:content_view_id/content_view_puppet_modules", N_("List content view puppet modules")
     param :content_view_id, :identifier, :desc => N_("content view identifier"), :required => true

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

@@ -3,13 +3,13 @@ module Katello
     include Concerns::Api::V2::BulkHostsExtensions
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_filter :find_content_view_version, :only => [:show, :promote, :destroy, :export]
-    before_filter :find_content_view, :except => [:incremental_update]
-    before_filter :find_environment, :only => [:promote, :index]
-    before_filter :authorize_promotable, :only => [:promote]
-    before_filter :authorize_destroy, :only => [:destroy]
-    before_filter :find_version_environments, :only => [:incremental_update]
-    before_filter :find_puppet_module, :only => [:index]
+    before_action :find_content_view_version, :only => [:show, :promote, :destroy, :export]
+    before_action :find_content_view, :except => [:incremental_update]
+    before_action :find_environment, :only => [:promote, :index]
+    before_action :authorize_promotable, :only => [:promote]
+    before_action :authorize_destroy, :only => [:destroy]
+    before_action :find_version_environments, :only => [:incremental_update]
+    before_action :find_puppet_module, :only => [:index]
 
     api :GET, "/content_view_versions", N_("List content view versions")
     api :GET, "/content_views/:content_view_id/content_view_versions", N_("List content view versions")
@@ -18,6 +18,7 @@ module Katello
     param :puppet_module_id, :identifier, :desc => N_("Filter versions by puppet module"), :required => false
     param :version, String, :desc => N_("Filter versions by version number"), :required => false
     param :composite_version_id, :identifier, :desc => N_("Filter versions that are components in the specified composite version"), :required => false
+    param :organization_id, :identifier, :desc => N_("Organization identifier")
     param_group :search, Api::V2::ApiController
     def index
       options = {
@@ -30,6 +31,7 @@ module Katello
     def index_relation
       version_number = params.permit(:version)[:version]
       versions = ContentViewVersion.readable
+      versions = versions.with_organization_id(params[:organization_id]) if params[:organization_id]
       versions = versions.where(:content_view_id => @view.id) if @view
       versions = versions.for_version(version_number) if version_number
       versions = versions.in_environment(@environment) if @environment
@@ -214,7 +216,7 @@ module Katello
 
         version_environments_for_systems_map.values
       else
-        @version_environments.select { |ve| !ve[:environment_ids].blank? }
+        @version_environments.select { |ve| !ve[:environments].blank? }
       end
     end
 

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

@@ -3,10 +3,10 @@ module Katello
     include Concerns::Authorization::Api::V2::ContentViewsController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_filter :find_content_view, :except => [:index, :create, :auto_complete_search]
-    before_filter :find_organization, :only => [:create]
-    before_filter :find_optional_organization, :only => [:index, :auto_complete_search]
-    before_filter :find_environment, :only => [:index, :remove_from_environment]
+    before_action :find_content_view, :except => [:index, :create, :auto_complete_search]
+    before_action :find_organization, :only => [:create]
+    before_action :find_optional_organization, :only => [:index, :auto_complete_search]
+    before_action :find_environment, :only => [:index, :remove_from_environment]
 
     wrap_parameters :include => (ContentView.attribute_names + %w(repository_ids component_ids))
 
@@ -22,7 +22,7 @@ module Katello
 
     api :GET, "/organizations/:organization_id/content_views", N_("List content views")
     api :GET, "/content_views", N_("List content views")
-    param :organization_id, :number, :desc => N_("organization identifier"), :required => true
+    param :organization_id, :number, :desc => N_("organization identifier")
     param :environment_id, :identifier, :desc => N_("environment identifier")
     param :nondefault, :bool, :desc => N_("Filter out default content views")
     param :noncomposite, :bool, :desc => N_("Filter out composite content views")

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

@@ -6,8 +6,8 @@ module Katello
       description <<-DESC
         # Description
 
-        An environment is a basic organization structure that groups systems,
-        products, repositories, etc.  Every system belongs to one environment
+        An environment is a basic organization structure that groups hosts,
+        products, repositories, etc.  Every host belongs to one environment
         and it's isolated inside so that it can see only content that is in its
         environment.
 
@@ -34,17 +34,17 @@ module Katello
     end
 
     respond_to :json
-    before_filter :find_organization, :only => [:index, :create, :paths, :auto_complete_search]
-    before_filter :find_optional_organization, :only => [:show, :update, :destroy]
-    before_filter :find_prior, :only => [:create]
-    before_filter :find_environment, :only => [:show, :update, :destroy, :repositories]
-    before_filter :find_content_view, :only => [:repositories]
+    before_action :find_organization, :only => [:create, :paths, :auto_complete_search]
+    before_action :find_optional_organization, :only => [:index, :show, :update, :destroy]
+    before_action :find_prior, :only => [:create]
+    before_action :find_environment, :only => [:show, :update, :destroy, :repositories]
+    before_action :find_content_view, :only => [:repositories]
 
     wrap_parameters :include => (KTEnvironment.attribute_names + %w(prior prior_id new_name))
 
     api :GET, "/environments", N_("List environments in an organization")
     api :GET, "/organizations/:organization_id/environments", N_("List environments in an organization")
-    param :organization_id, :number, :desc => N_("organization identifier"), :required => true
+    param :organization_id, :number, :desc => N_("organization identifier")
     param :library, [true, false], :desc => N_("set true if you want to see only library environments")
     param :name, String, :desc => N_("filter only environments containing this name")
     def index
@@ -52,7 +52,8 @@ module Katello
     end
 
     def index_relation
-      query = KTEnvironment.readable.where(:organization_id => @organization.id)
+      query = KTEnvironment.readable
+      query = query.where(organization: @organization) if @organization
       query = query.where(:name => params[:name]) if params[:name]
       query = query.where(:library => params[:library]) if params[:library]
       query

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

@@ -0,0 +1,16 @@
+module Katello
+  class Api::V2::FileUnitsController < Api::V2::ApiController
+    apipie_concern_subst(:a_resource => N_("a file"), :resource => "files")
+    include Katello::Concerns::Api::V2::RepositoryContentController
+
+    def default_sort
+      %w(name asc)
+    end
+
+    private
+
+    def repo_association
+      :repository_id
+    end
+  end
+end

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

@@ -1,10 +1,10 @@
 module Katello
   class Api::V2::GpgKeysController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
-    before_filter :authorize
-    before_filter :find_organization, :only => [:create, :index, :auto_complete_search]
-    before_filter :find_gpg_key, :only => [:show, :update, :destroy, :content]
-    skip_before_filter :check_content_type, :only => [:create, :content]
+    before_action :authorize
+    before_action :find_organization, :only => [:create, :index, :auto_complete_search]
+    before_action :find_gpg_key, :only => [:show, :update, :destroy, :content]
+    skip_before_action :check_content_type, :only => [:create, :content]
 
     def_param_group :gpg_key do
       param :name, :identifier, :action_aware => true, :required => true, :desc => N_("identifier of the gpg key")

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

@@ -1,9 +1,9 @@
 module Katello
   class Api::V2::HostAutocompleteController < ::Api::V2::BaseController
     include ::Api::TaxonomyScope
-    include Foreman::Controller::AutoCompleteSearch
+    include ::Foreman::Controller::AutoCompleteSearch
 
-    before_filter :find_optional_nested_object
+    before_action :find_optional_nested_object
 
     resource_description do
       api_version 'v2'

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

@@ -1,12 +1,12 @@
 module Katello
   class Api::V2::HostCollectionsController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
-    before_filter :find_host_collection, :only => [:copy, :show, :update, :destroy, :destroy_hosts,
+    before_action :find_host_collection, :only => [:copy, :show, :update, :destroy, :destroy_hosts,
                                                    :add_hosts, :remove_hosts, :hosts]
-    before_filter :find_activation_key
-    before_filter :find_host
-    before_filter :find_optional_organization, :only => [:index]
-    before_filter :find_organization, :only => [:create, :auto_complete_search]
+    before_action :find_activation_key
+    before_action :find_host
+    before_action :find_optional_organization, :only => [:index]
+    before_action :find_organization, :only => [:create, :auto_complete_search]
 
     wrap_parameters :include => (HostCollection.attribute_names + %w(host_ids))
 
@@ -85,18 +85,32 @@ module Katello
     param :id, :identifier, :desc => N_("Id of the host collection"), :required => true
     param :host_ids, Array, :desc => N_("Array of host ids")
     def add_hosts
-      @hosts = ::Host::Managed.authorized(:edit_host).where(:id => params[:host_ids])
+      host_ids = params[:host_ids].map(&:to_i)
+
+      @hosts = ::Host::Managed.where(id: host_ids)
       @editable_hosts = @hosts.authorized(:edit_host)
-      @host_collection.host_ids = (@host_collection.host_ids + @editable_hosts.collect { |s| s.id }).uniq
+
+      already_added_host_ids = @host_collection.host_ids & host_ids
+      unfound_host_ids = host_ids - @hosts.pluck(:id)
+
+      @host_collection.host_ids += @editable_hosts.pluck(:id)
       @host_collection.save!
 
       messages = format_bulk_action_messages(
           :success    => _("Successfully added %s Host(s)."),
           :error      => _("You were not allowed to add %s"),
-          :models     => @hosts,
-          :authorized => @editable_hosts
+          :models     => @hosts.pluck(:id) - already_added_host_ids,
+          :authorized => @editable_hosts.pluck(:id) - already_added_host_ids
       )
 
+      already_added_host_ids.each do |host_id|
+        messages[:error] << _("Host with ID %s already exists in the host collection.") % host_id
+      end
+
+      unfound_host_ids.each do |host_id|
+        messages[:error] << _("Host with ID %s not found.") % host_id
+      end
+
       respond_for_show :template => 'bulk_action', :resource_name => 'common',
                        :resource => { 'displayMessages' => messages }
     end
@@ -105,18 +119,32 @@ module Katello
     param :id, :identifier, :desc => N_("Id of the host collection"), :required => true
     param :host_ids, Array, :desc => N_("Array of host ids")
     def remove_hosts
-      @hosts = ::Host::Managed.authorized(:edit_host).where(:id => params[:host_ids])
+      host_ids = params[:host_ids].map(&:to_i)
+
+      @hosts = ::Host::Managed.where(id: host_ids)
       @editable_hosts = @hosts.authorized(:edit_host)
-      @host_collection.host_ids = (@host_collection.host_ids - @editable_hosts.collect { |s| s.id }).uniq
+
+      already_removed_host_ids = @hosts.pluck(:id) - @host_collection.host_ids
+      unfound_host_ids = host_ids - @hosts.pluck(:id)
+
+      @host_collection.host_ids -= @editable_hosts.pluck(:id)
       @host_collection.save!
 
       messages = format_bulk_action_messages(
           :success    => _("Successfully removed %s Host(s)."),
           :error      => _("You were not allowed to sync %s"),
-          :models     => @hosts,
-          :authorized => @editable_hosts
+          :models     => @hosts.pluck(:id) - already_removed_host_ids,
+          :authorized => @editable_hosts.pluck(:id) - already_removed_host_ids
       )
 
+      already_removed_host_ids.each do |host_id|
+        messages[:error] << _("Host with ID %s does not exist in the host collection.") % host_id
+      end
+
+      unfound_host_ids.each do |host_id|
+        messages[:error] << _("Host with ID %s not found.") % host_id
+      end
+
       respond_for_show :template => 'bulk_action', :resource_name => 'common',
                        :resource => { 'displayMessages' => messages }
     end

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

@@ -2,11 +2,11 @@ module Katello
   class Api::V2::HostErrataController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_filter :find_host, :only => :index
-    before_filter :find_host_editable, :except => :index
-    before_filter :find_errata_ids, :only => :apply
-    before_filter :find_environment, :only => :index
-    before_filter :find_content_view, :only => :index
+    before_action :find_host, :only => :index
+    before_action :find_host_editable, :except => :index
+    before_action :find_errata_ids, :only => :apply
+    before_action :find_environment, :only => :index
+    before_action :find_content_view, :only => :index
 
     resource_description do
       api_version 'v2'
@@ -54,6 +54,13 @@ module Katello
       respond_for_show :resource => errata
     end
 
+    api :PUT, "/hosts/:host_id/errata/applicability", N_("Force regenerate applicability.")
+    param :host_id, :identifier, :desc => N_("Host ID"), :required => true
+    def applicability
+      task = async_task(::Actions::Katello::Host::GenerateApplicability, [@host], false)
+      respond_for_async :resource => task
+    end
+
     protected
 
     def index_relation

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

@@ -2,10 +2,10 @@ module Katello
   class Api::V2::HostPackagesController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_filter :require_packages_or_groups, :only => [:install, :remove]
-    before_filter :require_packages_only, :only => [:upgrade]
-    before_filter :find_editable_host_with_facet, :except => :index
-    before_filter :find_host, :only => :index
+    before_action :require_packages_or_groups, :only => [:install, :remove]
+    before_action :require_packages_only, :only => [:upgrade]
+    before_action :find_editable_host_with_facet, :except => :index
+    before_action :find_host, :only => :index
 
     resource_description do
       api_version 'v2'

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

@@ -1,8 +1,8 @@
 module Katello
   class Api::V2::HostSubscriptionsController < Katello::Api::V2::ApiController
-    before_filter :find_host, :except => :create
-    before_filter :check_subscriptions, :only => [:add_subscriptions, :remove_subscriptions]
-    before_filter :find_content_view_environment, :only => :create
+    before_action :find_host, :except => :create
+    before_action :check_subscriptions, :only => [:add_subscriptions, :remove_subscriptions]
+    before_action :find_content_view_environment, :only => :create
 
     def_param_group :subscription_facet_attributes do
       param :release_version, String, :desc => N_("Release version for this Host to use (7Server, 7.1, etc)")
@@ -72,7 +72,7 @@ module Katello
       name = rhsm_params[:facts]['network.hostname']
 
       host = Katello::Host::SubscriptionFacet.find_or_create_host(name, @content_view_environment.environment.organization, rhsm_params)
-      sync_task(::Actions::Katello::Host::Register, host, System.new, rhsm_params, @content_view_environment)
+      sync_task(::Actions::Katello::Host::Register, host, rhsm_params, @content_view_environment)
       host.reload
       ::Katello::Host::SubscriptionFacet.update_facts(host, rhsm_params[:facts]) unless rhsm_params[:facts].blank?
 
@@ -107,13 +107,13 @@ module Katello
     end
     def remove_subscriptions
       #combine the quantities for duplicate pools into PoolWithQuantities objects
-      pool_id_quantities = params[:subscriptions].inject({}) do |new_hash, subscription|
-        new_hash[subscription['id']] ||= PoolWithQuantities.new(Pool.find(subscription['id']))
+      pool_id_quantities = params.require(:subscriptions).inject({}) do |new_hash, subscription|
+        new_hash[subscription['id']] ||= PoolWithQuantities.new(Pool.with_identifier(subscription['id']))
         new_hash[subscription['id']].quantities << subscription['quantity']
         new_hash
       end
 
-      @host.subscription_facet.remove_subscriptions(pool_id_quantities.values)
+      sync_task(::Actions::Katello::Host::RemoveSubscriptions, @host, pool_id_quantities.values)
       respond_for_index(:collection => index_response, :template => "index")
     end
 
@@ -124,8 +124,8 @@ module Katello
       param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
     end
     def add_subscriptions
-      pools_with_quantities = params[:subscriptions].map do |sub_params|
-        PoolWithQuantities.new(Pool.find(sub_params['id']), sub_params['quantity'])
+      pools_with_quantities = params.require(:subscriptions).map do |sub_params|
+        PoolWithQuantities.new(Pool.with_identifier(sub_params['id']), sub_params['quantity'])
       end
 
       sync_task(::Actions::Katello::Host::AttachSubscriptions, @host, pools_with_quantities)

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

@@ -2,15 +2,15 @@ module Katello
   class Api::V2::HostsBulkActionsController < Api::V2::ApiController
     include Concerns::Api::V2::BulkHostsExtensions
 
-    before_filter :find_host_collections, :only => [:bulk_add_host_collections, :bulk_remove_host_collections]
-    before_filter :find_environment, :only => [:environment_content_view]
-    before_filter :find_content_view, :only => [:environment_content_view]
-    before_filter :find_editable_hosts, :except => [:destroy_hosts, :applicable_errata]
-    before_filter :find_deletable_hosts, :only => [:destroy_hosts]
-    before_filter :find_readable_hosts, :only => [:applicable_errata, :available_incremental_updates]
-    before_filter :find_errata, :only => [:available_incremental_updates]
+    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, :applicable_errata]
+    before_action :find_deletable_hosts, :only => [:destroy_hosts]
+    before_action :find_readable_hosts, :only => [:applicable_errata, :available_incremental_updates]
+    before_action :find_errata, :only => [:available_incremental_updates]
 
-    before_filter :validate_content_action, :only => [:install_content, :update_content, :remove_content]
+    before_action :validate_content_action, :only => [:install_content, :update_content, :remove_content]
 
     PARAM_ACTIONS = {
       :install_content => {
@@ -31,11 +31,11 @@ module Katello
     def_param_group :bulk_params do
       param :organization_id, :identifier, :required => true, :desc => N_("ID of the organization")
       param :included, Hash, :required => true, :action_aware => true do
-        param :search, String, :required => false, :desc => N_("Search string for systems to perform an action on")
-        param :ids, Array, :required => false, :desc => N_("List of system ids to perform an action on")
+        param :search, String, :required => false, :desc => N_("Search string for hosts to perform an action on")
+        param :ids, Array, :required => false, :desc => N_("List of host ids to perform an action on")
       end
       param :excluded, Hash, :required => true, :action_aware => true do
-        param :ids, Array, :required => false, :desc => N_("List of system ids to exclude and not run an action on")
+        param :ids, Array, :required => false, :desc => N_("List of host ids to exclude and not run an action on")
       end
     end
 
@@ -86,7 +86,7 @@ module Katello
     end
 
     api :POST, "/hosts/bulk/applicable_errata",
-        N_("Fetch applicable errata for a system.")
+        N_("Fetch applicable errata for a host.")
     param_group :bulk_params
     def installable_errata
       respond_for_index(:collection => scoped_search(Katello::Erratum.installable_for_hosts(@hosts), 'updated', 'desc',
@@ -131,7 +131,46 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/environment_content_view", N_("Assign the environment and content view to one or more systems")
+    api :PUT, "/hosts/bulk/subscriptions/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
+      param :quantity, Integer, :desc => N_("Quantity of specified subscription to remove"), :required => false
+    end
+    def remove_subscriptions
+      #combine the quantities for duplicate pools into PoolWithQuantities objects
+      pool_id_quantities = params.require(:subscriptions).inject({}) do |new_hash, subscription|
+        new_hash[subscription['id']] ||= PoolWithQuantities.new(Pool.find(subscription['id']))
+        new_hash[subscription['id']].quantities << subscription['quantity']
+        new_hash
+      end
+      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::RemoveSubscriptions, @hosts, pool_id_quantities.values)
+      respond_for_async :resource => task
+    end
+
+    api :PUT, "/hosts/bulk/subscriptions/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
+      param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
+    end
+    def add_subscriptions
+      pools_with_quantities = params.require(:subscriptions).map do |sub_params|
+        PoolWithQuantities.new(Pool.find(sub_params['id']), sub_params['quantity'])
+      end
+
+      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::AttachSubscriptions, @hosts, pools_with_quantities)
+      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")
+    param_group :bulk_params
+    def auto_attach
+      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::AutoAttachSubscriptions, @hosts)
+      respond_for_async :resource => task
+    end
+
+    api :PUT, "/hosts/bulk/environment_content_view", N_("Assign the environment and content view to one or more hosts")
     param_group :bulk_params
     param :environment_id, Integer
     param :content_view_id, Integer