katello 4.12.1 → 4.13.0.rc1

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

@@ -1,42 +1,29 @@
 module Katello
   class Api::V2::SimpleContentAccessController < Api::V2::ApiController
-    before_action :find_organization
-
     resource_description do
       description "Red Hat subscriptions management platform."
       api_version 'v2'
     end
 
-    api :GET, "/organizations/:organization_id/simple_content_access/eligible",
-      N_("Check if the specified organization is eligible for Simple Content Access. %s") % sca_only_deprecation_text, deprecated: true
+    def render_sca_410_error
+      render_error 'custom_error', status: :gone,
+                                    locals: { message: N_('Simple Content Access is the only supported content access mode') }
+    end
+
     def eligible
-      ::Foreman::Deprecation.api_deprecation_warning(N_("This endpoint is deprecated and will be removed in Katello 4.12. All organizations are now eligible for Simple Content Access."))
-      eligible = @organization.simple_content_access_eligible?
-      render json: { simple_content_access_eligible: eligible }
+      render_sca_410_error
     end
 
-    api :GET, "/organizations/:organization_id/simple_content_access/status",
-      N_("Check if the specified organization has Simple Content Access enabled. %s") % sca_only_deprecation_text, deprecated: true
-    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def status
-      status = @organization.simple_content_access?
-      render json: { simple_content_access: status }
+      render_sca_410_error
     end
 
-    api :PUT, "/organizations/:organization_id/simple_content_access/enable",
-      N_("Enable simple content access for a manifest"), deprecated: true
-    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def enable
-      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id])
-      respond_for_async :resource => task
+      render_sca_410_error
     end
 
-    api :PUT, "/organizations/:organization_id/simple_content_access/disable",
-      N_("Disable simple content access for a manifest. %s") % sca_only_deprecation_text, deprecated: true
-    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def disable
-      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:organization_id])
-      respond_for_async :resource => task
+      render_sca_410_error
     end
   end
 end

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

@@ -49,7 +49,7 @@ module Katello
 
         # promote_or_remove_content_views_to_environments has a special relationship to promote_or_remove_content_views
         if path_to_authenticate["controller"] == "katello/api/v2/content_view_versions" &&
-            path_to_authenticate["action"].in?(["promote", "remove_from_environment", "remove", "republish_repositories"])
+            path_to_authenticate["action"].in?(["promote", "remove_from_environment", "remove", "republish_repositories", "verify_checksum"])
           missing_perms << ::Permission.find_by(name: "promote_or_remove_content_views_to_environments")
         end
         missing_perms

data/app/helpers/katello/subscription_mailer_helper.rb

@@ -13,7 +13,7 @@ module Katello
     end
 
     def start_report_task(days_from_now)
-      @report_template = ReportTemplate.find_by(name: "Subscription - Entitlement Report")
+      @report_template = ReportTemplate.find_by(name: "Subscription - General Report")
       template_input_id = @report_template.template_inputs.find_by_name("Days from Now").id.to_s
       params = { format: 'csv', template_id: @report_template.id, input_values: { template_input_id => { value: days_from_now} } }
       composer = ReportComposer.new(params)

data/app/jobs/create_manifest_expire_soon_warning_notifications.rb

@@ -0,0 +1,11 @@
+class CreateManifestExpireSoonWarningNotifications < ApplicationJob
+  def perform
+    Katello::UINotifications::Subscriptions::ManifestExpireSoonWarning.deliver!
+  ensure
+    self.class.set(:wait => 24.hours).perform_later
+  end
+
+  def humanized_name
+    _('Subscription Manifest expiration date check')
+  end
+end

data/app/lib/actions/candlepin/owner/regenerate_upstream_identity_cert.rb

@@ -0,0 +1,21 @@
+module Actions
+  module Candlepin
+    module Owner
+      class RegenerateUpstreamIdentityCert < Candlepin::Abstract
+        input_format do
+          param :organization_id
+          param :upstream
+        end
+
+        def run
+          organization = ::Organization.find(input[:organization_id])
+          output[:response] = organization.redhat_provider.owner_upstream_regenerate_identity_cert(input[:upstream])
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/capsule_content/sync.rb

@@ -52,7 +52,7 @@ module Actions
           notification = MailNotification[:proxy_sync_failure]
           proxy = SmartProxy.find(input.fetch(:smart_proxy, {})[:id])
           subjects = subjects(input[:options]).merge(smart_proxy: proxy)
-          notification.users.where(disabled: [nil, false], mail_enabled: true).each do |user|
+          notification.users.with_enabled_email.each do |user|
             notification.deliver(subjects.merge(user: user, task: task))
           end
         end

data/app/lib/actions/katello/capsule_content/verify_checksum.rb

@@ -0,0 +1,75 @@
+module Actions
+  module Katello
+    module CapsuleContent
+      class VerifyChecksum < ::Actions::EntryAction
+        def humanized_name
+          _("Verify checksum for content on smart proxy")
+        end
+
+        def plan(smart_proxy, options = {})
+          input[:options] = options
+          action_subject(smart_proxy)
+          fail _("Action not allowed for the default smart proxy.") if smart_proxy.pulp_primary?
+          subjects = subjects(options)
+          repair_options = options.merge(subjects)
+          environment = repair_options[:environment]
+          content_view = repair_options[:content_view]
+          check_cv_capsule_environments!(smart_proxy, content_view, environment)
+          repository = repair_options[:repository]
+          repos = repos_to_repair(smart_proxy, environment, content_view, repository)
+          repos.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
+            concurrence do
+              repo_batch.each do |repo|
+                if smart_proxy.pulp3_support?(repo)
+                  plan_action(Actions::Pulp3::CapsuleContent::VerifyChecksum,
+                              repo,
+                              smart_proxy)
+                end
+              end
+            end
+          end
+        end
+
+        def repos_to_repair(smart_proxy, environment, content_view, repository)
+          smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
+          smart_proxy_helper.lifecycle_environment_check(environment, repository)
+          if repository
+            [repository]
+          else
+            repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count
+            repositories
+          end
+        end
+
+        def check_cv_capsule_environments!(smart_proxy, content_view, environment)
+          cv_environments = content_view&.versions&.collect(&:environments)&.flatten
+          if cv_environments.present?
+            if environment.present? && !(cv_environments.pluck(:id).include? environment.id)
+              fail _("Content view '%{content_view}' is not attached to the environment.") % {content_view: content_view.name}
+            end
+            if (smart_proxy.lifecycle_environments.pluck(:id) & cv_environments.pluck(:id)).empty?
+              fail _("Content view '%{content_view}' is not attached to this capsule.") % {content_view: content_view.name}
+            end
+          end
+        end
+
+        def subjects(options = {})
+          environment_id = options.fetch(:environment_id, nil)
+          environment = ::Katello::KTEnvironment.find(environment_id) if environment_id
+
+          repository_id = options.fetch(:repository_id, nil)
+          repository = ::Katello::Repository.find(repository_id) if repository_id
+
+          content_view_id = options.fetch(:content_view_id, nil)
+          content_view = ::Katello::ContentView.find(content_view_id) if content_view_id
+
+          {content_view: content_view, environment: environment, repository: repository}
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/content_view/promote.rb

@@ -27,7 +27,7 @@ module Actions
         def notify_on_failure(_plan)
           notification = MailNotification[:content_view_promote_failure]
           view = ::Katello::ContentView.find(input.fetch(:content_view, {})[:id])
-          notification.users.where(disabled: [nil, false], mail_enabled: true).each do |user|
+          notification.users.with_enabled_email.each do |user|
             notification.deliver(user: user, content_view: view, task: task)
           end
         end

data/app/lib/actions/katello/content_view/publish.rb

@@ -136,7 +136,7 @@ module Actions
         def notify_on_failure(_plan)
           notification = MailNotification[:content_view_publish_failure]
           view = ::Katello::ContentView.find(input.fetch(:content_view, {})[:id])
-          notification.users.where(disabled: [nil, false], mail_enabled: true).each do |user|
+          notification.users.with_enabled_email.each do |user|
             notification.deliver(user: user, content_view: view, task: task)
           end
         end

data/app/lib/actions/katello/content_view_version/verify_checksum.rb

@@ -0,0 +1,29 @@
+module Actions
+  module Katello
+    module ContentViewVersion
+      class VerifyChecksum < Actions::EntryAction
+        def plan(content_view_version)
+          action_subject(content_view_version.content_view)
+          plan_self(:version_id => content_view_version.id)
+          plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::VerifyChecksum, content_view_version.repositories) if content_view_version.repositories.any?
+        end
+
+        def run
+          #dummy run phase to save input and support humanized_name
+        end
+
+        def humanized_name
+          if input && input[:version_id]
+            version = ::Katello::ContentViewVersion.find_by(:id => input[:version_id])
+          end
+
+          if version
+            _("Verify checksum of repositories in %{name} %{version}") % {:name => version.content_view.name, :version => version.version}
+          else
+            _("Verify checksum of version repositories")
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/host/hypervisors_update.rb

@@ -169,6 +169,7 @@ module Actions
           if @candlepin_attributes.key?(uuid)
             host.subscription_facet.candlepin_consumer.consumer_attributes = @candlepin_attributes[uuid]
             host.subscription_facet.import_database_attributes
+            host.subscription_facet.last_checkin = Time.now
             host.subscription_facet.save!
           end
         end

data/app/lib/actions/katello/host/update_content_view.rb

@@ -17,9 +17,9 @@ module Actions
 
         def humanized_name
           if input.try(:[], :hostname).nil?
-            _("Update for host")
+            _("Update content view environments for host")
           else
-            _("Update for host %s") % input[:hostname]
+            _("Update content view environments for host %s") % input[:hostname]
           end
         end
       end

data/app/lib/actions/katello/organization/manifest_import.rb

@@ -27,6 +27,11 @@ module Actions
           end
         end
 
+        def run
+          organization = ::Organization.find_by(name: input[:organization_name])
+          organization&.manifest_expiration_date(cached: false) # update the date
+        end
+
         def failure_notification(plan)
           ::Katello::UINotifications::Subscriptions::ManifestImportError.deliver!(
             :subject => subject_organization,

data/app/lib/actions/katello/organization/manifest_refresh.rb

@@ -21,6 +21,9 @@ module Actions
             upstream_update = plan_action(Candlepin::Owner::UpstreamUpdate,
                         { :organization_id => organization.id,
                           :upstream => upstream })
+            plan_action(Candlepin::Owner::RegenerateUpstreamIdentityCert,
+                        { :organization_id => organization.id,
+                          :upstream => upstream })
             export_action = plan_action(Candlepin::Owner::StartUpstreamExport,
                         { :organization_id => organization.id,
                           :upstream => upstream,

data/app/lib/actions/katello/repository/metadata_generate.rb

@@ -1,8 +1,10 @@
 module Actions
   module Katello
     module Repository
-      class MetadataGenerate < Actions::Base
+      class MetadataGenerate < Actions::EntryAction
         def plan(repository, options = {})
+          action_subject(repository)
+          repository.check_ready_to_act!
           source_repository = options.fetch(:source_repository, nil)
           source_repository ||= repository.target_repository if repository.link?
           smart_proxy = options.fetch(:smart_proxy, SmartProxy.pulp_primary)
@@ -15,6 +17,10 @@ module Actions
                         :source_repository => source_repository,
                         :matching_content => matching_content)
         end
+
+        def resource_locks
+          :link
+        end
       end
     end
   end

data/app/lib/actions/katello/repository/remove_content.rb

@@ -5,6 +5,7 @@ module Actions
         include Dynflow::Action::WithSubPlans
 
         def plan(repository, content_units, options = {})
+          repository.check_ready_to_act!
           sync_capsule = options.fetch(:sync_capsule, true)
           if repository.redhat?
             fail _("Cannot remove content from a non-custom repository")

data/app/lib/actions/katello/repository/sync.rb

@@ -20,6 +20,7 @@ module Actions
         #   of Katello and we just need to finish the rest of the orchestration
         def plan(repo, options = {})
           action_subject(repo)
+          repo.check_ready_to_act!
 
           validate_contents = options.fetch(:validate_contents, false)
           skip_metadata_check = options.fetch(:skip_metadata_check, false) || (validate_contents && (repo.yum? || repo.deb?))
@@ -100,7 +101,7 @@ module Actions
         def notify_on_failure(_plan)
           notification = MailNotification[:repository_sync_failure]
           repo = ::Katello::Repository.find(input.fetch(:repository, {})[:id])
-          notification.users.where(disabled: [nil, false], mail_enabled: true).each do |user|
+          notification.users.with_enabled_email.each do |user|
             notification.deliver(user: user, repo: repo, task: task)
           end
         end

data/app/lib/actions/katello/repository/upload_files.rb

@@ -8,6 +8,7 @@ module Actions
       class UploadFiles < Actions::EntryAction
         def plan(repository, files, content_type = nil, options = {})
           action_subject(repository)
+          repository.check_ready_to_act!
           repository.clear_smart_proxy_sync_histories
           tmp_files = prepare_tmp_files(files)
 

data/app/lib/actions/pulp3/capsule_content/verify_checksum.rb

@@ -0,0 +1,27 @@
+module Actions
+  module Pulp3
+    module CapsuleContent
+      class VerifyChecksum < Pulp3::AbstractAsyncTask
+        def plan(repository, smart_proxy)
+          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def invoke_external_task
+          repo = ::Katello::Repository.find(input[:repository_id])
+          output[:pulp_tasks] = repo.backend_service(smart_proxy).with_mirror_adapter.repair
+        end
+
+        def repos_to_repair(smart_proxy, environment, content_view, repository)
+          smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
+          smart_proxy_helper.lifecycle_environment_check(environment, repository)
+          if repository
+            [repository]
+          else
+            repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count
+            repositories
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/content_view_version/export_repository.rb

@@ -3,26 +3,24 @@ module Actions
     module Orchestration
       module ContentViewVersion
         class ExportRepository < Actions::EntryAction
-          def plan(repository,
-                    chunk_size: nil,
-                    from_history: nil,
-                    format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
+          def plan(repository, opts = {})
+            opts[:format] ||= ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
             action_subject(repository)
             validate_repositories_immediate!(repository)
-            validate_export_types!(repository, format)
+            validate_export_types!(repository, opts[:format])
             content_view = ::Katello::Pulp3::ContentViewVersion::Export.find_repository_export_view(
                                                                            repository: repository,
                                                                            create_by_default: true,
-                                                                           format: format)
+                                                                           format: opts[:format])
             content_view.update!(repository_ids: [repository.library_instance_or_self.id])
 
             sequence do
               publish_action = plan_action(::Actions::Katello::ContentView::Publish, content_view, '')
               export_action = plan_action(Actions::Katello::ContentViewVersion::Export,
                                           content_view_version: publish_action.version,
-                                          chunk_size: chunk_size,
-                                          from_history: from_history,
-                                          format: format)
+                                          chunk_size: opts[:chunk_size],
+                                          from_history: opts[:from_history],
+                                          format: opts[:format])
               plan_self(export_action_output: export_action.output)
             end
           end

data/app/lib/actions/pulp3/orchestration/content_view_version/syncable_export.rb

@@ -16,10 +16,11 @@ module Actions
             param :export_history_id, Integer
           end
 
-          def plan(content_view_version:,
-                   smart_proxy:,
-                   destination_server:,
-                   from_content_view_version:)
+          def plan(opts = {})
+            content_view_version = opts[:content_view_version]
+            smart_proxy = opts[:smart_proxy]
+            destination_server = opts[:destination_server]
+            from_content_view_version = opts[:from_content_view_version]
             format = ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
             sequence do
               export_service = ::Katello::Pulp3::ContentViewVersion::Export.create(

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -216,9 +216,14 @@ module Katello
         keyword :includes, Array, of: [String, Symbol], desc: 'An array of associations represented by strings or symbols, to be included in the SQL query. The list can be extended
           from plugins and can not be fully documented here. Most used associations are :subscription, :products, :organization', default: nil
         returns array_of: 'Pool', desc: 'The collection that can be iterated over using each_record'
+        keyword :expiring_in_days, String, desc: "Return subscriptions expiring in the given number of days. Leave blank to return all subscriptions.", default: nil
       end
-      def load_pools(search: '', includes: nil)
-        load_resource(klass: Pool.readable, search: search, permission: nil, includes: includes)
+      def load_pools(search: '', includes: nil, expiring_in_days: nil)
+        pools = Pool.readable
+        if expiring_in_days
+          pools = pools.expiring_in_days(expiring_in_days)
+        end
+        load_resource(klass: pools, search: search, permission: nil, includes: includes)
       end
 
       apipie :method, 'Returns the last time the host checked in via RHSM' do

data/app/lib/katello/http_resource.rb

@@ -38,6 +38,7 @@ module Katello
       get: Net::HTTP::Get,
       post: Net::HTTP::Post,
       put: Net::HTTP::Put,
+      patch: Net::HTTP::Patch,
       delete: Net::HTTP::Delete
     }.freeze
 
@@ -84,7 +85,11 @@ module Katello
       def issue_request(method:, path:, headers: {}, payload: nil)
         logger.debug("Resource #{method.upcase} request: #{path}")
         logger.debug "Headers: #{headers.to_json}"
-        logger.debug "Body: #{filter_sensitive_data(payload.to_json)}"
+        begin
+          logger.debug "Body: #{filter_sensitive_data(payload.to_json)}"
+        rescue JSON::GeneratorError, Encoding::UndefinedConversionError
+          logger.debug "Body: Error: could not render payload as json"
+        end
 
         client = rest_client(REQUEST_MAP[method], method, path)
         args = [method, payload, headers].compact

data/app/lib/katello/resources/candlepin/consumer.rb

@@ -7,7 +7,7 @@ module Katello
         class << self
           def all_uuids
             cp_consumers = Organization.all.map do |org|
-              ::Katello::Resources::Candlepin::Consumer.get('owner' => org.label, :include_only => [:uuid])
+              ::Katello::Resources::Candlepin::Consumer.get('owner' => org.label, :include_only => [:uuid], :sort_by => "uuid")
             end
             cp_consumers.flatten!
             cp_consumers.map { |consumer| consumer["uuid"] }

data/app/lib/katello/resources/candlepin/upstream_consumer.rb

@@ -40,19 +40,31 @@ module Katello
             raise ::Katello::Errors::UpstreamEntitlementGone
           end
 
-          def get_export(url, client_cert, client_key, ca_file)
+          def start_upstream_export(url, client_cert, client_key, ca_file)
             logger.debug "Sending GET request to upstream Candlepin: #{url}"
-            return resource(url: url, client_cert: client_cert, client_key: client_key, ca_file: ca_file).get
+            resource(url: url, client_cert: client_cert, client_key: client_key, ca_file: ca_file).get
           rescue RestClient::Exception => e
             raise e
           end
 
+          alias_method :retrieve_upstream_export, :start_upstream_export
+
           def update(url, client_cert, client_key, ca_file, attributes)
             logger.debug "Sending PUT request to upstream Candlepin: #{url} #{attributes.to_json}"
-            return resource(url: url, client_cert: client_cert, client_key: client_key, ca_file: ca_file).put(attributes.to_json,
-                                                                       'accept' => 'application/json',
-                                                                       'accept-language' => I18n.locale,
-                                                                       'content-type' => 'application/json')
+            resource(
+              url: url,
+              client_cert: client_cert,
+              client_key: client_key,
+              ca_file: ca_file).put(
+                attributes.to_json,
+                'accept' => 'application/json',
+                'accept-language' => I18n.locale,
+                'content-type' => 'application/json')
+          end
+
+          def regenerate_upstream_identity(url, client_cert, client_key, ca_file)
+            logger.debug "Sending POST request to upstream Candlepin: #{url}"
+            resource(url: url, client_cert: client_cert, client_key: client_key, ca_file: ca_file).post(nil)
           end
 
           def bind_entitlement(**pool)

data/app/lib/katello/resources/candlepin/upstream_job.rb

@@ -12,7 +12,7 @@ module Katello
 
           def get(id, upstream)
             url = API_URL
-            response = Resources::Candlepin::UpstreamConsumer.get_export("#{url}#{path(id)}", upstream['idCert']['cert'],
+            response = Resources::Candlepin::UpstreamConsumer.start_upstream_export("#{url}#{path(id)}", upstream['idCert']['cert'],
               upstream['idCert']['key'], nil)
             job = JSON.parse(response)
             job.with_indifferent_access

data/app/lib/katello/resources/registry.rb

@@ -18,10 +18,35 @@ module Katello
           client.options.merge!(options)
           client.get(headers)
         end
+
+        def self.put(path, body, headers)
+          logger.debug "Sending PUT request to Registry: #{path}"
+          resource = RegistryResource.load_class
+          joined_path = resource.prefix.chomp("/") + path
+          resource.issue_request(method: :put, path: joined_path, headers: headers, payload: body)
+        end
+
+        def self.patch(path, body, headers)
+          logger.debug "Sending PATCH request to Registry: #{path}"
+          resource = RegistryResource.load_class
+          joined_path = resource.prefix.chomp("/") + path
+          resource.issue_request(method: :patch, path: joined_path, headers: headers, payload: body)
+        end
+
+        def self.post(path, body, headers)
+          logger.debug "Sending PUT request to Registry: #{path}"
+          resource = RegistryResource.load_class
+          joined_path = resource.prefix.chomp("/") + path
+          resource.issue_request(method: :post, path: joined_path, headers: headers, payload: body)
+        end
       end
 
       class RegistryResource < HttpResource
         class << self
+          def logger
+            ::Foreman::Logging.logger('katello/registry_proxy')
+          end
+
           def load_class
             pulp_primary = ::SmartProxy.pulp_primary
             content_app_url = pulp_primary.setting(SmartProxy::PULP3_FEATURE, 'content_app_url')

data/app/mailers/katello/subscription_mailer.rb

@@ -10,14 +10,11 @@ module Katello
 
       ::User.as(user.login) do
         @pools = Katello::Pool.readable.expiring_in_days(days_from_now)
-        @affected_hosts = ::Host::Managed.with_pools_expiring_in_days(days_from_now)
       end
 
-      if @affected_hosts.any?
-        start_report_task(days_from_now)
-        @report_url = report_url
-        @report_link = report_link
-      end
+      start_report_task(days_from_now)
+      @report_url = report_url
+      @report_link = report_link
 
       set_locale_for(user) do
         mail(:to => user.mail, :subject => _("You have subscriptions expiring within %s days") % days_from_now)

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

@@ -100,16 +100,55 @@ module Katello
           end
         end
 
-        def manifest_expired?
-          manifest_expiry = owner_details.dig(:upstreamConsumer, :idCert, :serial, :expiration)
+        def manifest_expiration_date(cached: true)
+          Rails.cache.fetch("#{self.label}_manifest_expiration_date", expires_in: 1.minute, force: !cached) do
+            unless manifest_imported?(cached: cached)
+              Rails.logger.error "Manifest not imported for organization #{self.label}"
+              return nil
+            end
+            manifest_expiry = owner_details.dig(:upstreamConsumer, :idCert, :serial, :expiration)
+
+            if manifest_expiry.present?
+              DateTime.parse(manifest_expiry)
+            else
+              Rails.logger.error "Unable to parse manifest expiration date from owner details"
+              nil
+            end
+          end
+        end
+
+        def manifest_expired?(cached: true)
+          manifest_expiry = manifest_expiration_date(cached: cached)
 
           if manifest_expiry
-            DateTime.parse(manifest_expiry) < DateTime.now
+            manifest_expiry < DateTime.now
           else
             false
           end
         end
 
+        def manifest_expiring_soon?(days = Setting[:expire_soon_days])
+          return false if !manifest_imported? || manifest_expired?
+          manifest_expiry = manifest_expiration_date
+
+          if manifest_expiry
+            manifest_expiry < DateTime.now + days.days
+          else
+            false
+          end
+        end
+
+        def manifest_expire_days_remaining
+          manifest_expiry = manifest_expiration_date
+          return 0 if manifest_expired?
+
+          if manifest_expiry
+            (manifest_expiry - DateTime.now).to_i
+          else
+            0
+          end
+        end
+
         def manifest_history
           imports.map { |i| OpenStruct.new(i) }
         end