katello 2.4.0.rc2 → 2.4.0.rc3

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

@@ -7,7 +7,8 @@ module Katello
     before_filter :find_optional_organization, :only => [:index, :create, :show]
     before_filter :find_activation_key, :only => [:show, :update, :destroy, :available_releases, :copy, :product_content,
                                                   :available_host_collections, :add_host_collections, :remove_host_collections,
-                                                  :content_override, :add_subscriptions, :remove_subscriptions]
+                                                  :content_override, :add_subscriptions, :remove_subscriptions,
+                                                  :subscriptions]
     before_filter :authorize
 
     wrap_parameters :include => (ActivationKey.attribute_names + %w(host_collection_ids service_level auto_attach content_view_environment))
@@ -214,6 +215,18 @@ module Katello
       activation_keys
     end
 
+    api :GET, "/activation_keys/:id/subscriptions", N_("List an activation key's subscriptions")
+    param :activation_key_id, String, :desc => N_("Activation key ID"), :required => true
+    def subscriptions
+      subscriptions = @activation_key.get_key_pools.map { |sub| ActivationKeySubscriptionPresenter.new(sub) }
+      collection = subscriptions.map(&:subscription)
+      @collection = { :results => collection,
+                      :total => collection.count,
+                      :page => 1,
+                      :per_page => collection.count,
+                      :subtotal => collection.count }
+    end
+
     private
 
     def validate_content_overrides(content_params)

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

@@ -10,7 +10,6 @@ module Katello
     # support for session (thread-local) variables must be the last filter in this class
     include Foreman::ThreadSession::Cleaner
 
-    before_filter :load_search_service, :only => [:index]
     skip_before_filter :setup_has_many_params # TODO: get this working #8862
 
     resource_description do
@@ -39,40 +38,6 @@ module Katello
       @resource_class ||= "Katello::#{resource_name.classify}".constantize
     end
 
-    def item_search(item_class, param_hash, options)
-      fail "@search_service search not defined" if @search_service.nil?
-      if param_hash[:order]
-        (param_hash[:sort_by], param_hash[:sort_order]) = param_hash[:order].split(' ')
-      end
-      options[:sort_by] = param_hash[:sort_by] if param_hash[:sort_by]
-      options[:sort_order] = param_hash[:sort_order] if param_hash[:sort_order]
-      options[:full_result] = param_hash[:full_result] if param_hash[:full_result]
-
-      unless options[:full_result]
-        options[:per_page] = param_hash[:per_page] || ::Setting::General.entries_per_page
-        options[:page] = param_hash[:page] || 1
-        offset = (options[:page].to_i - 1) * options[:per_page].to_i
-      end
-
-      @search_service.model = item_class
-
-      if block_given?
-        options[:offset] = offset
-        @search_service.search_options = options
-        @search_service.query_string = param_hash[:search]
-        results, total_count = yield(@search_service)
-      else
-        results, total_count = @search_service.retrieve(param_hash[:search], offset, options)
-      end
-      {
-        :results  => results,
-        :subtotal => total_count,
-        :total    => @search_service.total_items,
-        :page     => options[:page],
-        :per_page => options[:per_page]
-      }
-    end
-
     def scoped_search(query, default_sort_by, default_sort_order, options = {})
       resource = options[:resource_class] || resource_class
       includes = options.fetch(:includes, [])
@@ -110,26 +75,6 @@ module Katello
       }
     end
 
-    def facet_search(item_class, term, options)
-      fail "@search_service search not defined" if @search_service.nil?
-      facet_name = 'facet_search'
-
-      @search_service.model =  item_class
-      options[:per_page] = 1
-      options[:facets] = {facet_name => term}
-      options[:facet_filters] =  {:and => options[:filters]}
-
-      @search_service.retrieve('', 0, options)
-
-      facets = @search_service.facets[facet_name]['terms']
-      results = facets.collect { |f| Katello::Glue::ElasticSearch::FacetItem.new(f) }
-      {
-        :results  => results.sort_by { |f| f.term },
-        :subtotal => results.length,
-        :total    => results.length
-      }
-    end
-
     protected
 
     def labelize_params(param_hash)

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

@@ -6,12 +6,14 @@ module Katello
     api :GET, "/content_view_filters/:content_view_filter_id/rules", N_("List filter rules")
     param :content_view_filter_id, :identifier, :desc => N_("filter identifier"), :required => true
     def index
-      options = sort_params
-      options[:load_records?] = true
-      options[:filters] = [{ :terms => { :id => ContentViewFilter.rule_ids_for(@filter) } }]
-
-      @search_service.model = ContentViewFilter.rule_class_for(@filter)
-      respond(:collection => item_search(ContentViewFilter.rule_class_for(@filter), params, options))
+      ids = ContentViewFilter.rule_ids_for(@filter)
+      results = ids.map { |id| ContentViewFilter.rule_class_for(@filter).find(id) }
+      collection = {
+        :results  => results.uniq,
+        :subtotal => results.count,
+        :total    => results.count
+      }
+      respond :collection => collection
     end
 
     api :POST, "/content_view_filters/:content_view_filter_id/rules",

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

@@ -0,0 +1,23 @@
+module Katello
+  class Api::V2::ContentViewHistoriesController < Api::V2::ApiController
+    include Katello::Concerns::FilteredAutoCompleteSearch
+
+    before_filter :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
+    def index
+      respond_for_index :collection => scoped_search(index_relation.uniq, :katello_content_view_version_id, :asc, :resource_class => ContentViewHistory)
+    end
+
+    def index_relation
+      ContentViewHistory.joins(:content_view_version).where("#{ContentViewVersion.table_name}.content_view_id" => @view.id)
+    end
+
+    private
+
+    def find_content_view
+      @view = ContentView.find(params[:content_view_id]) if params[:content_view_id]
+    end
+  end
+end

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

@@ -8,7 +8,6 @@ module Katello
     before_filter :find_environment, :only => [:promote, :index]
     before_filter :authorize_promotable, :only => [:promote]
     before_filter :authorize_destroy, :only => [:destroy]
-    before_filter :load_search_service, :only => [:incremental_update]
     before_filter :find_version_environments, :only => [:incremental_update]
     before_filter :find_puppet_module, :only => [:index]
 

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

@@ -6,8 +6,6 @@ module Katello
     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 :load_search_service, :only => [:history, :available_puppet_modules,
-                                                  :available_puppet_module_names]
     before_filter :find_environment, :only => [:index, :remove_from_environment]
 
     wrap_parameters :include => (ContentView.attribute_names + %w(repository_ids component_ids))
@@ -119,17 +117,6 @@ module Katello
                         :collection => scoped_search(modules, 'name', 'ASC', :resource_class => PuppetModule, :group => :name)
     end
 
-    api :GET, "/content_views/:id/history", N_("Show a content view's history")
-    param :id, :number, :desc => N_("content view numeric identifier"), :required => true
-    def history
-      options = sort_params
-      options[:load_records?] = true
-      options[:filters] = [{:term => {:content_view_id => @view.id}}]
-
-      respond_for_index :template => '../content_view_histories/index',
-                        :collection => item_search(ContentViewHistory, params, options)
-    end
-
     api :DELETE, "/content_views/:id/environments/:environment_id", N_("Remove a content view from an environment")
     param :id, :number, :desc => N_("content view numeric identifier"), :required => true
     param :environment_id, :number, :desc => N_("environment numeric identifier"), :required => true

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

@@ -39,7 +39,6 @@ module Katello
     before_filter :find_prior, :only => [:create]
     before_filter :find_environment, :only => [:show, :update, :destroy, :repositories]
     before_filter :find_content_view, :only => [:repositories]
-    before_filter :load_search_service, :only => [:index]
 
     wrap_parameters :include => (KTEnvironment.attribute_names + %w(prior prior_id new_name))
 

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

@@ -7,7 +7,6 @@ module Katello
     before_filter :find_system
     before_filter :find_optional_organization, :only => [:index]
     before_filter :find_organization, :only => [:create, :auto_complete_search]
-    before_filter :load_search_service, :only => [:index, :systems]
 
     wrap_parameters :include => (HostCollection.attribute_names + %w(system_ids))
 
@@ -72,17 +71,6 @@ module Katello
       respond
     end
 
-    # TODO: switch to systems controller index w/ @adprice pull-request
-    api :GET, "/host_collections/:id/systems", N_("List content hosts in the host collection"), :deprecated => true
-    param :id, :identifier, :desc => N_("Id of the host collection"), :required => true
-    def systems
-      options = {
-        :filters       => [{:term => {:host_collection_ids => @host_collection.id }}],
-        :load_records? => true
-      }
-      respond_for_index(:collection => item_search(System, params, options))
-    end
-
     api :PUT, "/host_collections/:id/add_systems", N_("Add content host to the host collection"), :deprecated => true
     param :id, :identifier, :desc => N_("Id of the host collection"), :required => true
     param :system_ids, Array, :desc => N_("Array of content host ids")
@@ -92,7 +80,6 @@ module Katello
       @editable_systems = @systems.editable
       @host_collection.system_ids = (@host_collection.system_ids + @editable_systems.collect { |s| s.id }).uniq
       @host_collection.save!
-      System.index.refresh
 
       messages = format_bulk_action_messages(
           :success    => _("Successfully added %s Content Host(s)."),
@@ -114,7 +101,6 @@ module Katello
       @editable_systems = @systems.editable
       @host_collection.system_ids = (@host_collection.system_ids - @editable_systems.collect { |s| s.id }).uniq
       @host_collection.save!
-      System.index.refresh
 
       messages = format_bulk_action_messages(
           :success    => _("Successfully removed %s Content Host(s)."),

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

@@ -17,8 +17,6 @@ module Katello
     end
 
     api :GET, "/organizations/:organization_id/subscriptions", N_("List organization subscriptions")
-    api :GET, "/systems/:system_id/subscriptions", N_("List a content host's subscriptions"), :deprecated => true
-    api :GET, "/activation_keys/:activation_key_id/subscriptions", N_("List an activation key's subscriptions")
     api :GET, "/subscriptions"
     param_group :search, Api::V2::ApiController
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
@@ -36,12 +34,8 @@ module Katello
       return available_for_system if params[:available_for] == "content_host"
       return available_for_activation_key if params[:available_for] == "activation_key"
       collection = Pool.readable
-      collection = collection.where(:id => ActivationKey.find(params[:activation_key_id]).pools) if params[:activation_key_id]
+      collection = collection.where(:unmapped_guest => false)
       collection = collection.get_for_organization(Organization.find(params[:organization_id])) if params[:organization_id]
-      if params[:system_id]
-        pool_ids = System.find_by_uuid(params[:system_id]).pools.map { |x| x['id'] }
-        collection = collection.where(:cp_id => pool_ids)
-      end
       collection
     end
 
@@ -66,7 +60,6 @@ module Katello
       respond_for_index(:collection => scoped_search(subscriptions.uniq, :cp_id, :asc, :resource_class => Pool), :template => "index")
     end
 
-    api :POST, "/subscriptions/:id", N_("Add a subscription to a resource")
     api :POST, "/systems/:system_id/subscriptions", N_("Add a subscription to a content host"), :deprecated => true
     api :POST, "/activation_keys/:activation_key_id/subscriptions", N_("Add a subscription to an activation key")
     param :id, String, :desc => N_("Subscription Pool uuid"), :required => false
@@ -78,7 +71,7 @@ module Katello
       param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
     end
     def create
-      object = @system || @activation_key || @distributor
+      object = @system || @activation_key
 
       if params[:subscriptions]
         params[:subscriptions].each do |sub|
@@ -94,14 +87,11 @@ module Katello
                         index_system
                       elsif @activation_key
                         index_activation_key
-                      else
-                        index_organization
                       end
 
       respond_for_index(:collection => subscriptions, :template => 'index')
     end
 
-    api :DELETE, "/subscriptions/:id", N_("Unattach a subscription")
     api :DELETE, "/systems/:system_id/subscriptions/:id", N_("Unattach a subscription"), :deprecated => true
     api :DELETE, "/activation_keys/:activation_key_id/subscriptions/:id", N_("Unattach a subscription")
     param :id, String, :desc => N_("Subscription ID"), :required => false
@@ -111,7 +101,7 @@ module Katello
       param :id, String, :desc => N_("Subscription Pool uuid")
     end
     def destroy
-      object = @system || @activation_key || @distributor
+      object = @system || @activation_key
 
       if @system
         params[:subscriptions].each do |subscription|
@@ -124,15 +114,7 @@ module Katello
         @system.unsubscribe_all
       end
 
-      subscriptions = if @system
-                        index_system
-                      elsif @activation_key
-                        index_activation_key
-                      else
-                        index_organization
-                      end
-
-      respond_for_index(:collection => subscriptions, :template => 'index')
+      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")
@@ -232,48 +214,29 @@ module Katello
       %w(id desc)
     end
 
+    def import_subscriptions
+      subscriptions = if @system
+                        index_system
+                      elsif @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_system
-      subs = @system.entitlements
-      # TODO: pluck id and call elasticsearch?
-      subscriptions = {
-        :results => subs,
-        :subtotal => subs.count,
-        :total => subs.count,
-        :page => 1,
-        :per_page => subs.count
-      }
-
-      return subscriptions
+      Katello::Pool.import_all
+      @system.entitlements
     end
 
     def index_activation_key
-      @organization = @activation_key.organization
-      subs = @activation_key.subscriptions
-      # TODO: pluck id and call elasticsearch?
-      subscriptions = {
-        :results => subs,
-        :subtotal => subs.count,
-        :total => subs.count,
-        :page => 1,
-        :per_page => subs.count
-      }
-
-      return subscriptions
+      @activation_key.subscriptions
     end
 
     def index_organization
-      filters = []
-      filters << {:term => {:org => [@organization.label]}}
-
-      options = {
-        :filters => filters,
-        :load_records? => false,
-        :default_field => :name
-      }
-
-      subscriptions = item_search(Pool, params, options)
-
-      return subscriptions
+      @organization.subscriptions
     end
 
     def available_for_activation_key

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

@@ -5,7 +5,6 @@ module Katello
     include Katello::Concerns::FilteredAutoCompleteSearch
     before_filter :find_organization, :only => [:create, :index, :auto_complete_search]
     before_filter :find_plan, :only => [:update, :show, :destroy, :add_products, :remove_products]
-    before_filter :load_search_service, :only => [:index]
 
     def_param_group :sync_plan do
       param :name, String, :desc => N_("sync plan name"), :required => true, :action_aware => true

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

@@ -5,7 +5,6 @@ module Katello
     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 :load_search_service
     before_filter :find_editable_systems, :except => [:destroy_systems, :applicable_errata]
     before_filter :find_deletable_systems, :only => [:destroy_systems]
     before_filter :find_readable_systems, :only => [:applicable_errata, :available_incremental_updates]

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

@@ -1,6 +1,7 @@
 # rubocop:disable SymbolName
 module Katello
   class Api::V2::SystemsController < Api::V2::ApiController
+    include Katello::Concerns::FilteredAutoCompleteSearch
     respond_to :json
 
     wrap_parameters :include => (System.attribute_names + %w(type autoheal facts guest_ids host_collection_ids installed_products content_view environment))
@@ -12,7 +13,8 @@ module Katello
                                           :pools, :enabled_repos, :releases,
                                           :available_host_collections,
                                           :refresh_subscriptions, :tasks, :content_override,
-                                          :product_content, :events]
+                                          :product_content, :events, :subscriptions,
+                                          :add_subscriptions]
     before_filter :find_environment, :only => [:index, :report]
     before_filter :find_optional_organization, :only => [:create, :index, :report]
     before_filter :find_host_collection, :only => [:index]
@@ -20,7 +22,6 @@ module Katello
 
     before_filter :find_environment_and_content_view, :only => [:create]
     before_filter :find_content_view, :only => [:create, :update]
-    before_filter :load_search_service, :only => [:index, :available_host_collections, :tasks]
     before_filter :authorize_environment, :only => [:create]
 
     def organization_id_keys
@@ -58,39 +59,27 @@ module Katello
     param :erratum_restrict_non_installable, String, :desc => N_("Return only systems where the Erratum specified by erratum_id or errata_ids is unavailable to systems (default False)")
     param_group :search, Api::V2::ApiController
     def index
+      respond(:collection => scoped_search(index_relation.uniq, :name, :asc))
+    end
+
+    def index_relation
       if params[:erratum_id] || params[:errata_ids]
         errata_ids = params.fetch(:errata_ids, [])
-        errata_ids << params[:erratum_id] if params[:erratum_id]
-        systems = systems_by_errata(errata_ids, params[:erratum_restrict_installable],
+        collection = systems_by_errata(errata_ids, params[:erratum_restrict_installable],
             params[:erratum_restrict_non_installable])
       else
-        systems = System.readable
-      end
-
-      systems = systems.where(:content_view_id => params[:content_view_id]) if params[:content_view_id]
-      filters = [{:terms => {:uuid => systems.pluck("#{Katello::System.table_name}.uuid").compact}}]
-      environment_ids = params[:organization_id] ? Organization.find(params[:organization_id]).kt_environments.pluck(:id) : []
-      environment_ids = environment_ids.empty? ? params[:environment_id] : environment_ids & [params[:environment_id].to_i] if params[:environment_id]
-      unless environment_ids.empty?
-        filters << {:terms => {:environment_id =>  environment_ids}}
-      end
-      if params[:host_collection_id]
-        filters << {:terms => {:host_collection_ids => [params[:host_collection_id]] }}
+        collection = System.readable
       end
-      if params[:activation_key_id]
-        filters << {:terms => {:activation_key_ids => [params[:activation_key_id]] }}
-      end
-
-      filters << {:terms => {:uuid => System.all_by_pool_uuid(params['pool_id']) }} if params['pool_id']
-      filters << {:terms => {:uuid => [params['uuid']] }} if params['uuid']
-      filters << {:term => {:name => params['name'] }} if params['name']
 
-      options = {
-        :filters       => filters,
-        :load_records? => true,
-        :includes => [:content_view, :activation_keys, :environment]
-      }
-      respond_for_index(:collection => item_search(System, params, options))
+      collection = collection.where(:content_view_id => params[:content_view_id]) if params[:content_view_id]
+      collection = collection.where(:id => Organization.find(params[:organization_id]).systems.map(&:id)) if params[:organization_id]
+      collection = collection.where(:environment_id => params[:environment_id]) if params[:environment_id]
+      collection = collection.where(:id => HostCollection.find(params[:host_collection_id]).systems) if params[:host_collection_id]
+      collection = collection.where(:id => Katello::ActivationKey.find(params[:activation_key_id]).systems) if params[:activation_key_id]
+      collection = collection.where(:id => Pool.find(params['pool_id']).systems.map(&:id)) if params['pool_id']
+      collection = collection.where(:uuid => params['uuid']) if params['uuid']
+      collection = collection.where(:name => params['name']) if params['name']
+      collection
     end
 
     api :POST, "/systems", N_("Register a content host"), :deprecated => true
@@ -155,17 +144,10 @@ module Katello
     param :name, String, :desc => N_("host collection name to filter by")
     def available_host_collections
       system_org_id = @system.environment.organization_id
-      pluck_val = "#{Katello::HostCollection.table_name}.id"
-      filters = [:terms => {:id => HostCollection.readable.where(:organization_id => system_org_id).pluck(pluck_val) - @system.host_collection_ids}]
-      filters << {:term => {:name => params[:name]}} if params[:name]
 
-      options = {
-        :filters       => filters,
-        :load_records? => true
-      }
+      collection = HostCollection.readable.where(:organization_id => system_org_id).where("id not in (?)", @system.host_collection_ids)
 
-      host_collections = item_search(HostCollection, params, options)
-      respond_for_index(:collection => host_collections)
+      respond_for_index(:collection => scoped_search(collection, :name, :desc, :resource_class => HostCollection))
     end
 
     api :DELETE, "/systems/:id", N_("Unregister a content host"), :deprecated => true
@@ -243,6 +225,37 @@ module Katello
       respond_for_index :collection => response
     end
 
+    api :GET, "/systems/:id/subscriptions", N_("List a content host's subscriptions"), :deprecated => true
+    param :id, String, :desc => N_("UUID of the content host"), :required => true
+    def subscriptions
+      subscriptions =  @system.entitlements.map { |entitlement| SystemSubscriptionPresenter.new(entitlement) }
+      collection = subscriptions.map(&:subscription)
+      @collection = { :results => collection,
+                      :total => collection.count,
+                      :page => 1,
+                      :per_page => collection.count,
+                      :subtotal => collection.count }
+    end
+
+    api :POST, "/systems/:id/subscriptions", N_("Add a subscription to a content host"), :deprecated => true
+    param :subscription_id, String, :desc => N_("Subscription Pool uuid"), :required => false
+    param :id, String, :desc => N_("UUID of a content host"), :required => false
+    param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => false
+    param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => false do
+      param :id, String, :desc => N_("Subscription Pool uuid"), :required => true
+      param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
+    end
+    def add_subscriptions
+      if params[:subscriptions]
+        params[:subscriptions].each do |sub_params|
+          attach_subscription(@system, sub_params[:id], sub_params[:quantity])
+        end
+      elsif params[:subscription_id] && params.key?(:quantity)
+        attach_subscription(@system, params[:subscription_id], params[:quantity])
+      end
+      respond_for_show(:resource => @system)
+    end
+
     api :GET, "/systems/:id/releases", N_("Show releases available for the content host"), :deprecated => true
     param :id, String, :desc => N_("UUID of the content host"), :required => true
     desc <<-DESC
@@ -293,6 +306,11 @@ module Katello
       respond_for_index :collection => @events
     end
 
+    def attach_subscription(system, pool_id, quantity)
+      subscription = Pool.find(pool_id)
+      async_task(::Actions::Katello::Subscription::Subscribe, system.id, subscription.cp_id, quantity)
+    end
+
     private
 
     def validate_content_overrides(content_params)