katello 4.2.1 → 4.3.0.rc1

data/app/models/katello/concerns/content_facet_host_extensions.rb

@@ -30,6 +30,7 @@ module Katello
         has_one :content_source, :through => :content_facet
         has_many :content_facet_errata, :through => :content_facet, :class_name => 'Katello::ContentFacetErratum'
         has_many :applicable_errata, :through => :content_facet_errata, :source => :erratum
+        has_many :applicable_debs, :through => :content_facet
         has_many :applicable_rpms, :through => :content_facet
         has_many :applicable_module_streams, :through => :content_facet
 
@@ -40,6 +41,8 @@ module Katello
         scoped_search :relation => :applicable_errata, :on => :errata_id, :rename => :applicable_errata, :complete_value => true, :ext_method => :find_by_applicable_errata, :only_explicit => true
         scoped_search :relation => :applicable_errata, :on => :errata_id, :rename => :installable_errata, :complete_value => true, :ext_method => :find_by_installable_errata, :only_explicit => true
         scoped_search :relation => :applicable_errata, :on => :issued, :rename => :applicable_errata_issued, :complete_value => true, :only_explicit => true
+        scoped_search :relation => :applicable_debs, :on => :nav, :rename => :applicable_debs, :complete_value => true, :ext_method => :find_by_applicable_debs, :only_explicit => true, :operators => ['=']
+        scoped_search :relation => :applicable_debs, :on => :nav, :rename => :upgradable_debs, :complete_value => true, :ext_method => :find_by_installable_debs, :only_explicit => true, :operators => ['=']
         scoped_search :relation => :applicable_rpms, :on => :nvra, :rename => :applicable_rpms, :complete_value => true, :ext_method => :find_by_applicable_rpms, :only_explicit => true
         scoped_search :relation => :applicable_rpms, :on => :nvra, :rename => :upgradable_rpms, :complete_value => true, :ext_method => :find_by_installable_rpms, :only_explicit => true
         scoped_search :relation => :content_source, :on => :name, :complete_value => true, :rename => :content_source
@@ -88,6 +91,24 @@ module Katello
           end
         end
 
+        def find_by_applicable_debs(_key, operator, value)
+          hosts = find_by_debs(::Host::Managed.joins(:applicable_debs), operator, value)
+          if hosts.empty?
+            { :conditions => "1=0" }
+          else
+            { :conditions => "#{::Host::Managed.table_name}.id IN (#{hosts.pluck(:id).join(',')})" }
+          end
+        end
+
+        def find_by_installable_debs(_key, operator, value)
+          facets = find_by_debs(Katello::Host::ContentFacet.joins_installable_debs, operator, value)
+          if facets.empty?
+            { :conditions => "1=0" }
+          else
+            { :conditions => "#{::Host::Managed.table_name}.id IN (#{facets.pluck(:host_id).join(',')})" }
+          end
+        end
+
         def find_by_applicable_rpms(_key, operator, value)
           conditions = sanitize_sql_for_conditions(["#{Katello::Rpm.table_name}.nvra #{operator} ?", value_to_sql(operator, value)])
           hosts = ::Host::Managed.joins(:applicable_rpms).where(conditions)
@@ -118,6 +139,25 @@ module Katello
         def in_environment(lifecycle_environment)
           in_content_view_environment(:lifecycle_environment => lifecycle_environment)
         end
+
+        private
+
+        def find_by_debs(base, operator, value)
+          table = Katello::Deb.table_name
+
+          name, architecture, version = Katello::Deb.split_nav(value)
+          if name.nil?
+            return []
+          end
+
+          res = base.where(sanitize_sql_for_conditions(["#{table}.name #{operator} ?", value_to_sql(operator, name)]))
+
+          res = res.where(sanitize_sql_for_conditions(["#{table}.architecture #{operator} ?", value_to_sql(operator, architecture)])) unless architecture.nil?
+
+          res = res.where(sanitize_sql_for_conditions(["#{table}.version #{operator} ?", value_to_sql(operator, version)])) unless version.nil?
+
+          res
+        end
       end
     end
   end

data/app/models/katello/concerns/host_managed_extensions.rb

@@ -67,9 +67,10 @@ module Katello
         scoped_search :relation => :host_collections, :on => :name, :complete_value => true, :rename => :host_collection
         scoped_search :relation => :installed_packages, :on => :nvra, :complete_value => true, :rename => :installed_package, :only_explicit => true
         scoped_search :relation => :installed_packages, :on => :name, :complete_value => true, :rename => :installed_package_name, :only_explicit => true
+        scoped_search :relation => :installed_debs, :on => :name, :rename => :installed_deb, :only_explicit => true, :ext_method => :find_by_installed_debs, operators: ['=']
+        scoped_search :relation => :installed_debs, :on => :name, :complete_value => true, :rename => :installed_package_name, :only_explicit => true
         scoped_search :relation => :available_module_streams, :on => :name, :complete_value => true, :rename => :available_module_stream_name, :only_explicit => true
         scoped_search :relation => :available_module_streams, :on => :stream, :complete_value => true, :rename => :available_module_stream_stream, :only_explicit => true
-        scoped_search :relation => :installed_debs, :on => :name, :complete_value => true, :rename => :installed_package_name, :only_explicit => true
         scoped_search :relation => :host_traces, :on => :application, :complete_value => true, :rename => :trace_app, :only_explicit => true
         scoped_search :relation => :host_traces, :on => :app_type, :complete_value => true, :rename => :trace_app_type, :only_explicit => true
         scoped_search :relation => :host_traces, :on => :helper, :complete_value => true, :rename => :trace_helper, :only_explicit => true
@@ -141,6 +142,25 @@ module Katello
         !new_record? && build && self.changes.key?('build')
       end
 
+      module ClassMethods
+        def find_by_installed_debs(_key, _operator, value)
+          name, architecture, version = Katello::Deb.split_nav(value)
+          debs = Katello::InstalledDeb.where(:name => name)
+          debs = debs.where(:architecture => architecture) unless architecture.nil?
+          debs = debs.where(:version => version) unless version.nil?
+          hosts = debs.joins(:host_installed_debs).select("#{Katello::HostInstalledDeb.table_name}.host_id as host_id").pluck(:host_id)
+          if hosts.empty?
+            {
+              :conditions => "1=0"
+            }
+          else
+            {
+              :conditions => "#{::Host::Managed.table_name}.id IN (#{hosts.join(',')})"
+            }
+          end
+        end
+      end
+
       def correct_kickstart_repository
         return unless content_facet
 
@@ -363,6 +383,12 @@ module Katello
         @traces_status_label ||= get_status(::Katello::TraceStatus).to_label(options)
       end
 
+      def traces_helpers(ids = nil)
+        traces = host_traces
+        traces = host_traces.where(id: ids) if ids.present?
+        ::Katello::HostTracer.helpers_for(traces)
+      end
+
       def valid_content_override_label?(content_label)
         available_content = subscription_facet.candlepin_consumer.available_product_content
         available_content.map(&:content).any? { |content| content.label == content_label }
@@ -385,7 +411,7 @@ end
 class ::Host::Managed::Jail < Safemode::Jail
   allow :content_source, :subscription_manager_configuration_url, :rhsm_organization_label,
         :host_collections, :pools, :hypervisor_host, :lifecycle_environment, :content_view,
-        :installed_packages
+        :installed_packages, :traces_helpers
 end
 
 class ActiveRecord::Associations::CollectionProxy::Jail < Safemode::Jail

data/app/models/katello/concerns/hostgroup_extensions.rb

@@ -59,7 +59,7 @@ module Katello
       # instead of calling nested_attribute_for(:content_source_id) in Foreman, define the methods explictedly
       def content_source
         return super if ancestry.nil? || self.content_source_id.present?
-        SmartProxy.find_by(:id => inherited_content_source_id)
+        SmartProxy.unscoped.find_by(:id => inherited_content_source_id)
       end
 
       def inherited_content_source_id

data/app/models/katello/concerns/organization_extensions.rb

@@ -31,6 +31,8 @@ module Katello
         has_many :subscriptions, :class_name => "Katello::Subscription", :dependent => :destroy, :inverse_of => :organization
         has_many :pools, :class_name => "Katello::Pool", :dependent => :destroy, :inverse_of => :organization
         has_many :product_contents, :through => :products
+        has_many :repositories, :through => :products
+        has_one :cdn_configuration, :class_name => "Katello::CdnConfiguration", :dependent => :destroy, :inverse_of => :organization
 
         #older association
         has_many :org_tasks, :dependent => :destroy, :class_name => "Katello::TaskStatus", :inverse_of => :organization
@@ -132,7 +134,7 @@ module Katello
         end
 
         def redhat_repository_url
-          redhat_provider.repository_url
+          cdn_configuration.url
         end
 
         def being_deleted?

data/app/models/katello/concerns/pulp_database_unit.rb

@@ -150,10 +150,9 @@ module Katello
             service = service_class.new(model.pulp_id)
             service.backend_data = unit
             if repository&.generic?
-              service.update_model(model, repository.repository_type, generic_content_type)
-            else
-              service.update_model(model)
+              service.update_model(model, generic_content_type)
             end
+            service.update_model(model)
             ids_to_associate << model.pulp_id
           end
         end
@@ -186,8 +185,9 @@ module Katello
               service = service_class.new(model.pulp_id)
               service.backend_data = unit
               model.repository_id = repository.id unless many_repository_associations
+
               if repository.generic?
-                service.update_model(model, repository.repository_type, generic_content_type)
+                service.update_model(model, generic_content_type)
               elsif self == ::Katello::Erratum
                 # Errata will change pulp_hrefs if the upstream repo updates them
                 erratum_updated_ids << service.update_model(model)
@@ -203,6 +203,7 @@ module Katello
 
       def sync_repository_associations(repository, options = {})
         additive = options.fetch(:additive, false)
+        generic_content_type = options.fetch(:generic_content_type, nil)
         pulp_id_href_map = options.dig(:pulp_id_href_map) || {}
         pulp_ids = options.dig(:pulp_ids) || pulp_id_href_map.try(:keys)
         ids_for_repository = with_pulp_id(pulp_ids).pluck(:id, :pulp_id)
@@ -213,7 +214,16 @@ module Katello
         erratum_updated_ids = options.fetch(:erratum_updated_ids, []).flatten.compact
 
         existing_ids = self.repository_association_class.uncached do
-          self.repository_association_class.where(:repository_id => repository).pluck(unit_id_field)
+          repo_assoc_units = self.repository_association_class.where(:repository_id => repository)
+
+          if generic_content_type
+            generic_unit_ids = Katello::GenericContentUnit
+              .where(id: repo_assoc_units.pluck(unit_id_field))
+              .where(content_type: generic_content_type).pluck(:id)
+            repo_assoc_units = repo_assoc_units.where(generic_content_unit_id: generic_unit_ids)
+          end
+
+          repo_assoc_units.pluck(unit_id_field)
         end
 
         new_ids = associated_ids - existing_ids

data/app/models/katello/concerns/remote_execution_provider_extensions.rb

@@ -0,0 +1,9 @@
+module Katello
+  module Concerns
+    module RemoteExecutionProviderExtensions
+      def alternative_names(host)
+        super.merge(:consumer_uuid => host.subscription_facet&.uuid)
+      end
+    end
+  end
+end

data/app/models/katello/concerns/setting_extensions.rb

@@ -4,7 +4,7 @@ module Katello
       extend ActiveSupport::Concern
 
       included do
-        validates :value, inclusion: { in: ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES },
+        validates :value, inclusion: { in: ::Katello::RootRepository::DOWNLOAD_POLICIES },
           if: ->(setting) { setting.name == 'default_download_policy' }
 
         after_save :recalculate_errata_status

data/app/models/katello/concerns/smart_proxy_extensions.rb

@@ -1,6 +1,7 @@
 require 'proxy_api'
 require 'proxy_api/pulp'
 require 'proxy_api/pulp_node'
+require 'proxy_api/container_gateway'
 
 module Katello
   module Concerns
@@ -21,7 +22,7 @@ module Katello
       CONTAINER_GATEWAY_FEATURE = "Container_Gateway".freeze
 
       DOWNLOAD_INHERIT = 'inherit'.freeze
-      DOWNLOAD_POLICIES = ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES + [DOWNLOAD_INHERIT]
+      DOWNLOAD_POLICIES = [::Katello::RootRepository::DOWNLOAD_ON_DEMAND, ::Katello::RootRepository::DOWNLOAD_IMMEDIATE, DOWNLOAD_INHERIT].freeze
 
       included do
         include ForemanTasks::Concerns::ActionSubject
@@ -128,7 +129,7 @@ module Katello
                            auth_required: !unauthenticated_container_repositories.include?(repo.id) }
           end
         end
-        ProxyAPI::ContainerGateway.new(url: self.url).repository_list({ repositories: repo_list })
+        ::ProxyAPI::ContainerGateway.new(url: self.url).repository_list({ repositories: repo_list })
       end
 
       def update_user_container_repo_mapping(users)
@@ -348,7 +349,7 @@ module Katello
       end
 
       def set_default_download_policy
-        self.download_policy ||= ::Setting[:default_proxy_download_policy] || ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+        self.download_policy ||= ::Setting[:default_proxy_download_policy] || ::Katello::RootRepository::DOWNLOAD_ON_DEMAND
       end
 
       def associate_lifecycle_environments

data/app/models/katello/content_credential.rb

@@ -13,6 +13,10 @@ module Katello
     has_many :repositories, :through => :root_repositories
 
     has_many :products, :class_name => "Katello::Product", :inverse_of => :gpg_key, :dependent => :nullify, :foreign_key => 'gpg_key_id'
+
+    has_many :ssl_ca_cdn_configurations, :class_name => "Katello::CdnConfiguration", :foreign_key => 'ssl_ca_credential_id',
+      :inverse_of => :ssl_ca_credential, :dependent => :nullify
+
     has_many :ssl_ca_products, :class_name => "Katello::Product", :foreign_key => "ssl_ca_cert_id",
                                :inverse_of => :ssl_ca_cert, :dependent => :nullify
     has_many :ssl_client_products, :class_name => "Katello::Product", :foreign_key => "ssl_client_cert_id",

data/app/models/katello/content_facet_applicable_deb.rb

@@ -0,0 +1,7 @@
+module Katello
+  class ContentFacetApplicableDeb < Katello::Model
+    # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
+    belongs_to :content_facet, :inverse_of => :content_facet_applicable_debs, :class_name => 'Katello::Host::ContentFacet'
+    belongs_to :deb, :inverse_of => :content_facet_applicable_debs, :class_name => 'Katello::Deb'
+  end
+end

data/app/models/katello/content_view.rb

@@ -108,7 +108,7 @@ module Katello
     end
 
     def self.in_organization(org)
-      where(organization_id: org.id)
+      where(organization_id: org.id) unless org.nil?
     end
 
     def to_s
@@ -641,6 +641,29 @@ module Katello
       repositories.on_demand
     end
 
+    def related_cv_count
+      if composite
+        content_view_components.length
+      else
+        component_composites.length
+      end
+    end
+
+    def related_composite_cvs
+      content_views = []
+      component_composites.each do |cv|
+        cv_id = cv.composite_content_view_id
+        cv_name = ContentView.find(cv_id).name
+        content_views.push(
+          {
+            id: cv_id,
+            name: cv_name
+          }
+        )
+      end
+      content_views
+    end
+
     protected
 
     def remove_repository(repository)

data/app/models/katello/content_view_component.rb

@@ -31,6 +31,10 @@ module Katello
       end
     end
 
+    def component_content_view_versions
+      self.content_view&.versions
+    end
+
     private
 
     def ensure_valid_content_view

data/app/models/katello/content_view_erratum_filter.rb

@@ -27,6 +27,8 @@ module Katello
     end
 
     def content_unit_pulp_ids(repo)
+      return [] if erratum_rules.blank?
+
       if filter_by_id?
         errata_ids = erratum_rules.map(&:errata_id)
         errata_pulp_ids = errata_package_pulp_ids_from_errata_ids(repo, errata_ids)

data/app/models/katello/content_view_filter.rb

@@ -35,7 +35,7 @@ module Katello
                                       Erratum::CONTENT_TYPE.to_sym => "Katello::ContentViewErratumFilter",
                                       DOCKER.to_sym => "Katello::ContentViewDockerFilter",
                                       MODULE_STREAM.to_sym => "Katello::ContentViewModuleStreamFilter"}
-    scoped_search :on => :inclusion, :rename => :inclusion_type, :complete_value => {:include => true, :exclude => :false}
+    scoped_search :on => :inclusion, :rename => :inclusion_type, :complete_value => {include: "true", exclude: "false"}
 
     def self.yum(include_module_streams = true)
       types = [::Katello::ContentViewPackageGroupFilter.name,

data/app/models/katello/content_view_package_filter_rule.rb

@@ -20,7 +20,8 @@ module Katello
                                :version => self.version,
                                :content_view_filter_id => self.content_view_filter_id,
                                :min_version => self.min_version,
-                               :max_version => self.max_version)
+                               :max_version => self.max_version,
+                               :architecture => self.architecture)
       other = other.where.not(:id => self.id) if self.id
       if other.exists?
         errors.add(:base, "This package filter rule already exists.")

data/app/models/katello/content_view_version.rb

@@ -1,4 +1,5 @@
 module Katello
+  # rubocop:disable Metrics/ClassLength
   class ContentViewVersion < Katello::Model
     include Authorization::ContentViewVersion
     include ForemanTasks::Concerns::ActionSubject
@@ -61,6 +62,10 @@ module Katello
       where("#{Katello::ContentViewVersion.table_name}.id in (#{sql})")
     end
 
+    scope :with_repositories, ->(repositories) do
+      joins(:repositories).includes(:content_view).merge(repositories).distinct
+    end
+
     scoped_search :on => :content_view_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
     scoped_search :on => :major, :rename => :version, :complete_value => true, :ext_method => :find_by_version
     serialize :content_counts
@@ -102,6 +107,10 @@ module Katello
       name
     end
 
+    def ansible_collections
+      AnsibleCollection.in_repositories(archived_repos)
+    end
+
     delegate :organization, to: :content_view
 
     def active_history
@@ -121,13 +130,17 @@ module Katello
     end
 
     def description
-      history.publish.successful.first.try(:notes)
+      history.publish.first.try(:notes)
     end
 
     def default_content_view?
       default?
     end
 
+    def latest?
+      content_view.latest_version_id == self.id
+    end
+
     def in_composite?
       composite_content_views.any?
     end
@@ -263,6 +276,14 @@ module Katello
       Katello::Deb.in_repositories(self.repositories.archived)
     end
 
+    def library_debs
+      Katello::Deb.in_repositories(library_repos)
+    end
+
+    def available_debs
+      library_packages.where.not(:id => debs)
+    end
+
     def errata(errata_type = nil)
       errata = Erratum.in_repositories(archived_repos)
       errata = errata.of_type(errata_type) if errata_type
@@ -323,6 +344,14 @@ module Katello
       save!
     end
 
+    def repository_type_counts_map
+      counts = {}
+      Katello::RepositoryTypeManager.enabled_repository_types.keys.each do |repo_type|
+        counts["#{repo_type}_repository_count"] = archived_repos.with_type(repo_type).count
+      end
+      counts
+    end
+
     def content_counts_map
       # if its empty, calculate it on demand
       update_content_counts! if content_counts.blank?

data/app/models/katello/deb.rb

@@ -3,6 +3,13 @@ module Katello
     include Concerns::PulpDatabaseUnit
 
     CONTENT_TYPE = Pulp::Deb::CONTENT_TYPE
+
+    has_many :repository_debs, :class_name => "Katello::RepositoryDeb", :dependent => :destroy, :inverse_of => :deb
+    has_many :repositories, :through => :repository_debs, :class_name => "Katello::Repository"
+    has_many :content_facet_applicable_debs, :class_name => "Katello::ContentFacetApplicableDeb",
+             :dependent => :destroy, :inverse_of => :deb
+    has_many :content_facets, :through => :content_facet_applicable_debs, :class_name => "Katello::Host::ContentFacet"
+
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :version, :complete_value => true
     scoped_search :on => :architecture, :complete_value => true
@@ -15,6 +22,14 @@ module Katello
       order(:name).order(:version).order(:architecture)
     end
 
+    def self.repository_association_class
+      RepositoryDeb
+    end
+
+    def self.content_facet_association_class
+      ContentFacetApplicableDeb
+    end
+
     def self.search_version_range(min = nil, max = nil)
       query = self.all
       query = Katello::Util::PackageFilter.new(query, min, Katello::Util::PackageFilter::GREATER_THAN).results if min
@@ -29,5 +44,61 @@ module Katello
     def self.total_for_repositories(repos)
       self.in_repositories(repos).count
     end
+
+    # the format apt needs to identify the packet with version and architecture
+    def nav
+      "#{self.name}:#{self.architecture}=#{self.version}"
+    end
+
+    # the more natural format ;-)
+    def nva
+      "#{self.name}_#{self.version}_#{self.architecture}"
+    end
+
+    def self.split_nav(value)
+      v = /^(?<name>[^:\s]+)(:(?<architecture>[^=\s]*))?(=(?<version>.*))?$/.match(value)&.named_captures
+      if v
+        [ v['name'], v['architecture'], v['version'] ]
+      end
+    end
+
+    def hosts_applicable(org_id = nil)
+      if org_id.present?
+        self.content_facets.joins(:host).where("#{::Host.table_name}.organization_id" => org_id)
+      else
+        self.content_facets.joins(:host)
+      end
+    end
+
+    def hosts_available(org_id = nil)
+      self.hosts_applicable(org_id).joins("INNER JOIN #{Katello::RepositoryDeb.table_name} on \
+        #{Katello::RepositoryDeb.table_name}.deb_id = #{self.id}").joins(:content_facet_repositories).
+        where("#{Katello::ContentFacetRepository.table_name}.repository_id = #{Katello::RepositoryDeb.table_name}.repository_id").uniq
+    end
+
+    def self.installable_for_hosts(hosts = nil)
+      debs = Katello::Deb.joins(:repositories,
+                                "INNER JOIN #{Katello::InstalledDeb.table_name} ON #{Katello::InstalledDeb.table_name}.name = #{self.table_name}.name",
+                                "INNER JOIN #{Katello::HostInstalledDeb.table_name} ON #{Katello::HostInstalledDeb.table_name}.installed_deb_id = #{Katello::InstalledDeb.table_name}.id")
+                               .where("deb_version_cmp(#{self.table_name}.version, #{Katello::InstalledDeb.table_name}.version) > 0")
+      unless hosts.nil?
+        facet_repos = Katello::ContentFacetRepository.joins(:content_facet => :host).select(:repository_id)
+        hosts = ::Host.where(id: hosts) if hosts.is_a?(Array)
+        facet_repos = facet_repos.merge(hosts).reorder(nil)
+
+        debs = debs.where("#{Katello::HostInstalledDeb.table_name}.host_id": hosts.pluck(:id))
+                   .where("#{Katello::RepositoryDeb.table_name}.repository_id" => facet_repos)
+      end
+      debs.distinct
+    end
+
+    def self.applicable_to_hosts(hosts)
+      self.joins(:content_facets).
+        where("#{Katello::Host::ContentFacet.table_name}.host_id" => hosts).distinct
+    end
+
+    def self.latest(_relation)
+      fail 'NotImplemented'
+    end
   end
 end

data/app/models/katello/erratum.rb

@@ -5,8 +5,15 @@ module Katello
     SECURITY = ["security"].freeze
     BUGZILLA = ["bugfix", "recommended"].freeze
     ENHANCEMENT = ["enhancement", "optional"].freeze
-
     TYPES = [SECURITY, BUGZILLA, ENHANCEMENT].flatten.freeze
+
+    NONE = "None".freeze
+    LOW = "Low".freeze
+    MODERATE = "Moderate".freeze
+    IMPORTANT = "Important".freeze
+    CRITICAL = "Critical".freeze
+    SEVERITIES = [NONE, LOW, MODERATE, IMPORTANT, CRITICAL].freeze
+
     CONTENT_TYPE = "erratum".freeze
     BACKEND_IDENTIFIER_FIELD = "erratum_pulp3_href".freeze
 
@@ -20,6 +27,7 @@ module Katello
     scoped_search :on => :errata_id, :only_explicit => true
     scoped_search :on => :errata_id, :rename => :id, :complete_value => true, :only_explicit => true
     scoped_search :on => :title
+    scoped_search :on => :title, :rename => :synopsis, :complete_value => true, :only_explicit => true
     scoped_search :on => :severity, :complete_value => true
     scoped_search :on => :errata_type, :only_explicit => true
     scoped_search :on => :errata_type, :rename => :type, :complete_value => true
@@ -170,6 +178,10 @@ module Katello
       { :conditions => conditions }
     end
 
+    def content_view_filters
+      Katello::ContentViewErratumFilterRule.where(errata_id: self.errata_id).eager_load(:filter).map(&:filter)
+    end
+
     apipie :class, desc: "A class representing #{model_name.human} object" do
       name 'Erratum'
       refs 'Erratum'

data/app/models/katello/generic_content_unit.rb

@@ -5,8 +5,10 @@ module Katello
 
     CONTENT_TYPE = 'generic'.freeze
 
-    scoped_search :on => :name, :complete_value => true
     scoped_search :on => :id, :complete_value => true
+    scoped_search :on => :name, :complete_value => true
+    scoped_search :on => :version, :complete_value => true
+    scoped_search :on => :filename, :complete_value => true
 
     def self.default_sort
       order(:name)

data/app/models/katello/glue/pulp/repos.rb

@@ -42,7 +42,7 @@ module Katello
       def sync_status
         all_repos = repos(self.library, nil, false)
         task = last_repo_sync_task
-        last_synced_repo = task ? all_repos.find { |repo| task.locks.where(:resource_type => ::Katello::Repository.name).pluck(:resource_id).map(&:to_s).include?(repo.id.to_s) } : nil
+        last_synced_repo = task ? all_repos.find { |repo| task.links.where(:resource_type => ::Katello::Repository.name).pluck(:resource_id).map(&:to_s).include?(repo.id.to_s) } : nil
         ::Katello::SyncStatusPresenter.new(last_synced_repo, task).sync_progress
       end
 
@@ -124,7 +124,7 @@ module Katello
           content_url.dup
         else
           path = content_url.sub(%r{^/}, '')
-          repo_url = self.provider.repository_url&.sub(%r{/$}, '')
+          repo_url = cdn_configuration.url.sub(%r{/$}, '')
           "#{repo_url}/#{path}"
         end
       end