Fixes #7888 Move Package Groups from Elastic Search to Database

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

@@ -4,16 +4,14 @@ class Api::V2::ContentViewFiltersController < Api::V2::ApiController
 
     before_filter :find_content_view
     before_filter :find_filter, :except => [:index, :create, :auto_complete_search]
-    before_filter :load_search_service, :only => [:available_package_groups]
-    before_filter :deprecated, :only => [:available_package_groups]
 
     wrap_parameters :include => (ContentViewFilter.attribute_names + %w(repository_ids))
 
-    api :GET, "/content_views/:content_view_id/filters", N_("List filters")
-    api :GET, "/content_view_filters", N_("List filters")
+    api :get, "/content_views/:content_view_id/filters", N_("list filters")
+    api :get, "/content_view_filters", N_("list filters")
     param_group :search, Api::V2::ApiController
     param :content_view_id, :identifier, :desc => N_("content view identifier"), :required => true
-    param :name, String, :desc => N_("Filter content view filters by name")
+    param :name, String, :desc => N_("filter content view filters by name")
     def index
       respond(:collection => scoped_search(index_relation.uniq, :name, :asc))
     end
@@ -24,13 +22,13 @@ def index_relation
       query
     end
 
-    api :POST, "/content_views/:content_view_id/filters", N_("Create a filter for a content view")
-    api :POST, "/content_view_filters", N_("Create a filter for a content view")
+    api :post, "/content_views/:content_view_id/filters", N_("create a filter for a content view")
+    api :post, "/content_view_filters", N_("create a filter for a content view")
     param :content_view_id, :identifier, :desc => N_("content view identifier"), :required => true
     param :name, String, :desc => N_("name of the filter"), :required => true
     param :type, String, :desc => N_("type of filter (e.g. rpm, package_group, erratum)"), :required => true
-    param :original_packages, :bool, :desc => N_("Add all packages without Errata to the included/excluded list. " \
-                                                       "(Package Filter only)")
+    param :original_packages, :bool, :desc => N_("add all packages without errata to the included/excluded list. " \
+                                                       "(package filter only)")
     param :inclusion, :bool, :desc => N_("specifies if content should be included or excluded, default: inclusion=false")
     param :repository_ids, Array, :desc => N_("list of repository ids")
     param :description, String, :desc => N_("description of the filter")
@@ -39,56 +37,37 @@ def create
       respond :resource => filter
     end
 
-    api :GET, "/content_views/:content_view_id/filters/:id", N_("Show filter info")
-    api :GET, "/content_view_filters/:id", N_("Show filter info")
+    api :get, "/content_views/:content_view_id/filters/:id", N_("show filter info")
+    api :get, "/content_view_filters/:id", N_("show filter info")
     param :content_view_id, :identifier, :desc => N_("content view identifier")
     param :id, :identifier, :desc => N_("filter identifier"), :required => true
     def show
       respond :resource => @filter
     end
 
-    api :PUT, "/content_views/:content_view_id/filters/:id", N_("Update a filter")
-    api :PUT, "/content_view_filters/:id", N_("Update a filter")
+    api :put, "/content_views/:content_view_id/filters/:id", N_("update a filter")
+    api :put, "/content_view_filters/:id", N_("update a filter")
     param :content_view_id, :identifier, :desc => N_("content view identifier")
     param :id, :identifier, :desc => N_("filter identifier"), :required => true
     param :name, String, :desc => N_("new name for the filter")
-    param :original_packages, :bool, :desc => N_("Add all packages without Errata to the included/excluded list. " \
-                                                       "(Package Filter only)")
+    param :original_packages, :bool, :desc => N_("add all packages without errata to the included/excluded list. " \
+                                                       "(package filter only)")
     param :inclusion, :bool, :desc => N_("specifies if content should be included or excluded, default: inclusion=false")
     param :repository_ids, Array, :desc => N_("list of repository ids")
     def update
       @filter.update_attributes!(filter_params)
       respond :resource => @filter
     end
 
-    api :DELETE, "/content_views/:content_view_id/filters/:id", N_("Delete a filter")
-    api :DELETE, "/content_view_filters/:id", N_("Delete a filter")
+    api :delete, "/content_views/:content_view_id/filters/:id", N_("delete a filter")
+    api :delete, "/content_view_filters/:id", N_("delete a filter")
     param :content_view_id, :identifier, :desc => N_("content view identifier")
     param :id, :identifier, :desc => N_("filter identifier"), :required => true
     def destroy
       @filter.destroy
       respond_for_show :resource => @filter
     end
 
-    api :GET, "/content_views/:content_view_id/filters/:id/available_package_groups",
-        N_("Get package groups that are available to be added to the filter"), :deprecated => true
-    api :GET, "/content_view_filters/:id/available_package_groups",
-        N_("Get package groups that are available to be added to the filter"), :deprecated => true
-    param :content_view_id, :identifier, :desc => N_("content view identifier")
-    param :id, :identifier, :desc => N_("filter identifier"), :required => true
-    def available_package_groups
-      current_ids = @filter.package_group_rules.map(&:uuid)
-      repo_ids = @filter.applicable_repos.readable.pluck("#{Repository.table_name}.pulp_id")
-      search_filters = [{ :terms => { :repo_id => repo_ids } }]
-      search_filters << { :not => { :terms => { :id => current_ids } } } unless current_ids.blank?
-
-      options = sort_params
-      options[:filters] = search_filters
-
-      respond_for_index :template => '../package_groups/index',
-                        :collection => item_search(PackageGroup, params, options)
-    end
-
     private
 
     def deprecated

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

@@ -2,11 +2,32 @@ module Katello
   class Api::V2::PackageGroupsController < Api::V2::ApiController
     apipie_concern_subst(:a_resource => N_("a package group"), :resource => "package_groups")
     include Katello::Concerns::Api::V2::RepositoryContentController
+    include Katello::Concerns::Api::V2::RepositoryDbContentController
+
+    api :GET, "package_groups/:id", N_("show package groups by id")
+    def index
+      super
+    end
+
+    def available_for_content_view_filter(filter, collection)
+      collection_ids = []
+      current_ids = filter.package_group_rules.map(&:uuid)
+      filter.applicable_repos.each do |repo|
+        collection_ids.concat(repo.package_groups.map(&:uuid))
+      end
+      collection = PackageGroup.where(:uuid => collection_ids)
+      collection = collection.where("uuid not in (?)", current_ids) unless current_ids.empty?
+      collection
+    end
+
+    def default_sort
+      %w(name asc)
+    end
 
     private
 
     def repo_association
-      :repo_id
+      :repository_id
     end
   end
 end

app/controllers/katello/concerns/api/v2/repository_db_content_controller.rb

@@ -5,7 +5,11 @@ module Api::V2::RepositoryDbContentController
 
       included do
         include Katello::Concerns::FilteredAutoCompleteSearch
-        before_filter :find_optional_organization, :only => [:index]
+        before_filter :find_optional_organization, :only => [:index, :auto_complete_search]
+        before_filter :find_environment, :only => [:index, :auto_complete_search]
+        before_filter :find_content_view_version, :only => [:index, :auto_complete_search]
+        before_filter :find_filter, :only => [:index, :auto_complete_search]
+        before_filter :find_content_resource, :only => [:show]
       end
 
       extend ::Apipie::DSL::Concern
@@ -35,7 +39,7 @@ def compare
         respond_for_index(:collection => collection)
       end
 
-      param :available_for, :string, :desc => N_("Show errata that can be added to content view filter")
+      param :available_for, :string, :desc => N_("Show available to be added to content view filter")
       param :filterId, :integer, :desc => N_("Content View Filter id")
       def index_relation
         collection = resource_class.scoped
@@ -79,13 +83,18 @@ def filter_by_environment(environment, collection)
       end
 
       def find_content_resource
-        @resource = resource_class.with_uuid(params[:id]).first
-        if resource_class == Katello::Erratum
-          # also try to look up erratum by errata_id
-          @resource ||= Erratum.find_by_errata_id(params[:id])
+        begin
+          id = Integer(params[:id])
+          @resource = resource_class.where(:id => id).first
+        rescue ArgumentError
+          @resource = resource_class.where(:uuid => params[:id]).first
         end
 
-        if @resource.nil?
+        if resource_class == Katello::Erratum && @resource.blank?
+          @resource = Erratum.find_by_errata_id(params[:id])
+        end
+
+        if @resource.blank?
           fail HttpErrors::NotFound, _("Failed to find %{content} with id '%{id}'.") %
             {content: resource_name, id: params[:id]}
         end

app/lib/actions/katello/repository/clone_yum_content.rb

@@ -41,6 +41,7 @@ def plan(source_repo, target_repo, filters, purge_empty_units, options = {})
             if purge_empty_units
               plan_action(Katello::Repository::IndexErrata, target_repo)
               plan_action(Pulp::Repository::PurgeEmptyErrata, :pulp_id => target_repo.pulp_id)
+              plan_action(Katello::Repository::IndexPackageGroups, target_repo)
               plan_action(Pulp::Repository::PurgeEmptyPackageGroups, :pulp_id => target_repo.pulp_id)
             end
 

app/lib/actions/katello/repository/index_package_groups.rb

@@ -0,0 +1,18 @@
+module Actions
+  module Katello
+    module Repository
+      class IndexPackageGroups < Actions::EntryAction
+        middleware.use Actions::Middleware::KeepCurrentUser
+
+        def plan(repository)
+          plan_self(:user_id => ::User.current.id, :id => repository.id)
+        end
+
+        def run
+          repo = ::Katello::Repository.find(input[:id])
+          repo.index_db_package_groups
+        end
+      end
+    end
+  end
+end

app/lib/actions/pulp/repository/purge_empty_package_groups.rb

@@ -14,12 +14,11 @@ def invoke_external_task
 
           # Remove all  package groups with no packages
           package_groups_to_delete = repo.package_groups.collect do |group|
-            group.package_group_id if rpm_names.intersection(group.package_names).empty?
+            group.uuid if rpm_names.intersection(group.package_names).empty?
           end
-          package_groups_to_delete.compact!
+          criteria = {:association=>{"unit_id"=>{"$in"=>package_groups_to_delete.compact!}}}
 
-          repo.unassociate_by_filter(::Katello::ContentViewPackageGroupFilter::CONTENT_TYPE,
-                                   "id" => { "$in" => package_groups_to_delete })
+          ::Katello.pulp_server.extensions.repository.unassociate_units(repo.pulp_id, :filters => criteria)
         end
       end
     end

app/lib/katello/util/package_clause_generator.rb

@@ -60,7 +60,7 @@ def package_clauses_for_errata(errata_clauses = [])
       # output -> {"names" => {"$in" => {"foo", "..."}}}  <- packages belonging to those packages
       def package_clauses_for_group(group_clauses = [])
         group_clauses = {"$or" => group_clauses}
-        pkg_names = Katello::PackageGroup.list_by_filter_clauses(group_clauses).collect(&:package_names).flatten
+        pkg_names = Katello::PackageGroup.list_by_filter_clauses(group_clauses)
         {'name' => {"$in" => pkg_names}} unless pkg_names.empty?
       end
     end

app/lib/katello/util/search.rb

@@ -55,8 +55,7 @@ def self.backend_search_classes
       def self.pulp_backend_search_classes
         [Katello::Package,
          Katello::PuppetModule,
-         Katello::Distribution,
-         Katello::PackageGroup]
+         Katello::Distribution]
       end
 
       def self.get_subclasses(obj_class)

app/models/katello/content_view_package_group_filter.rb

@@ -6,11 +6,9 @@ class ContentViewPackageGroupFilter < ContentViewFilter
                                    :class_name => "Katello::ContentViewPackageGroupFilterRule"
     validates_lengths_from_database
 
-    def generate_clauses(repo)
-      package_group_ids = package_group_rules.reject { |rule| rule.uuid.blank? }.flat_map do |rule|
-        PackageGroup.legacy_search(rule.uuid, 0, 0, [repo.pulp_id], [:name_sort, "asc"], 'id').map(&:package_group_id).compact
-      end
-      { "id" => { "$in" => package_group_ids } } unless package_group_ids.empty?
+    def generate_clauses(_repo)
+      package_group_ids = package_group_rules.reject { |rule| rule.uuid.blank? }.flat_map.map(&:uuid)
+      { "_id" => { "$in" => package_group_ids } } unless package_group_ids.empty?
     end
   end
 end

app/models/katello/content_view_version.rb

@@ -231,6 +231,10 @@ def docker_images
       DockerImage.in_repositories(archived_repos).uniq
     end
 
+    def package_groups
+      PackageGroup.in_repositories(archived_repos).uniq
+    end
+
     def check_ready_to_promote!
       fail _("Default content view versions cannot be promoted") if default?
     end

app/models/katello/erratum.rb

@@ -95,6 +95,10 @@ def self.list_filenames_by_clauses(clauses)
       Katello::ErratumPackage.joins(:erratum).where("#{Erratum.table_name}.uuid" => errata.map { |e| e['_id'] }).pluck(:filename)
     end
 
+    def self.unit_handler
+      Katello.pulp_server.extensions.errata
+    end
+
     private
 
     def run_until(needed_function, action_function)