hyrax 3.0.0.pre.rc1 → 3.0.0.pre.rc2

data/app/actors/hyrax/actors/file_set_actor.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
 module Hyrax
   module Actors
     # Actions are decoupled from controller logic so that they may be called from a controller or a background job.
-    class FileSetActor
+    class FileSetActor # rubocop:disable Metrics/ClassLength
       include Lockable
-      attr_reader :file_set, :user, :attributes
+      attr_reader :file_set, :user, :attributes, :use_valkyrie
 
-      def initialize(file_set, user)
+      def initialize(file_set, user, use_valkyrie: false)
+        @use_valkyrie = use_valkyrie
         @file_set = file_set
         @user = user
       end
@@ -21,7 +23,8 @@ module Hyrax
         # If the file set doesn't have a title or label assigned, set a default.
         file_set.label ||= label_for(file)
         file_set.title = [file_set.label] if file_set.title.blank?
-        return false unless file_set.save # Need to save to get an id
+        @file_set = perform_save(file_set) # Need to save to get an id # TODO: change this to `save(file_set)` when fully valkyrized
+        return false unless file_set
         if from_url
           # If ingesting from URL, don't spawn an IngestJob; instead
           # reach into the FileActor and run the ingest with the file instance in
@@ -71,26 +74,46 @@ module Hyrax
       def attach_to_work(work, file_set_params = {})
         acquire_lock_for(work.id) do
           # Ensure we have an up-to-date copy of the members association, so that we append to the end of the list.
-          work.reload unless work.new_record?
-          file_set.visibility = work.visibility unless assign_visibility?(file_set_params)
-          work.ordered_members << file_set
-          work.representative = file_set if work.representative_id.blank?
-          work.thumbnail = file_set if work.thumbnail_id.blank?
-          # Save the work so the association between the work and the file_set is persisted (head_id)
-          # NOTE: the work may not be valid, in which case this save doesn't do anything.
-          work.save
-          Hyrax.config.callback.run(:after_create_fileset, file_set, user)
+          if valkyrie_object?(work)
+            attach_to_valkyrie_work(work, file_set_params)
+          else
+            attach_to_af_work(work, file_set_params)
+          end
+          Hyrax.config.callback.run(:after_create_fileset, file_set, user, warn: false)
         end
       end
       alias attach_file_to_work attach_to_work
       deprecation_deprecate attach_file_to_work: "use attach_to_work instead"
 
+      def attach_to_valkyrie_work(work, file_set_params)
+        work = Hyrax.query_service.find_by(id: work.id) unless work.new_record
+        file_set.visibility = work.visibility unless assign_visibility?(file_set_params)
+        Hyrax.persister.save(resource: file_set)
+        work.member_ids << file_set.id
+        work.representative_id = file_set.id if work.representative_id.blank?
+        work.thumbnail_id = file_set.id if work.thumbnail_id.blank?
+        # Save the work so the association between the work and the file_set is persisted (head_id)
+        # NOTE: the work may not be valid, in which case this save doesn't do anything.
+        Hyrax.persister.save(resource: work)
+      end
+
+      def attach_to_af_work(work, file_set_params)
+        work.reload unless work.new_record?
+        file_set.visibility = work.visibility unless assign_visibility?(file_set_params)
+        work.ordered_members << file_set
+        work.representative = file_set if work.representative_id.blank?
+        work.thumbnail = file_set if work.thumbnail_id.blank?
+        # Save the work so the association between the work and the file_set is persisted (head_id)
+        # NOTE: the work may not be valid, in which case this save doesn't do anything.
+        work.save
+      end
+
       # @param [String] revision_id the revision to revert to
       # @param [Symbol, #to_sym] relation
       # @return [Boolean] true on success, false otherwise
       def revert_content(revision_id, relation = :original_file)
         return false unless build_file_actor(relation).revert_to(revision_id)
-        Hyrax.config.callback.run(:after_revert_content, file_set, user, revision_id)
+        Hyrax.config.callback.run(:after_revert_content, file_set, user, revision_id, warn: false)
         true
       end
 
@@ -102,7 +125,7 @@ module Hyrax
       def destroy
         unlink_from_work
         file_set.destroy
-        Hyrax.config.callback.run(:after_destroy, file_set.id, user)
+        Hyrax.config.callback.run(:after_destroy, file_set.id, user, warn: false)
       end
 
       class_attribute :file_actor_class
@@ -110,57 +133,93 @@ module Hyrax
 
       private
 
-        def ability
-          @ability ||= ::Ability.new(user)
-        end
+      def ability
+        @ability ||= ::Ability.new(user)
+      end
 
-        def build_file_actor(relation)
-          file_actor_class.new(file_set, relation, user)
-        end
+      def build_file_actor(relation)
+        file_actor_class.new(file_set, relation, user, use_valkyrie: use_valkyrie)
+      end
 
-        # uses create! because object must be persisted to serialize for jobs
-        def wrapper!(file:, relation:)
-          JobIoWrapper.create_with_varied_file_handling!(user: user, file: file, relation: relation, file_set: file_set)
-        end
+      # uses create! because object must be persisted to serialize for jobs
+      def wrapper!(file:, relation:)
+        JobIoWrapper.create_with_varied_file_handling!(user: user, file: file, relation: relation, file_set: file_set)
+      end
 
-        # For the label, use the original_filename or original_name if it's there.
-        # If the file was imported via URL, parse the original filename.
-        # If all else fails, use the basename of the file where it sits.
-        # @note This is only useful for labeling the file_set, because of the recourse to import_url
-        def label_for(file)
-          if file.is_a?(Hyrax::UploadedFile) # filename not present for uncached remote file!
-            file.uploader.filename.present? ? file.uploader.filename : File.basename(Addressable::URI.parse(file.file_url).path)
-          elsif file.respond_to?(:original_name) # e.g. Hydra::Derivatives::IoDecorator
-            file.original_name
-          elsif file_set.import_url.present?
-            # This path is taken when file is a Tempfile (e.g. from ImportUrlJob)
-            File.basename(Addressable::URI.parse(file_set.import_url).path)
-          else
-            File.basename(file)
-          end
+      # For the label, use the original_filename or original_name if it's there.
+      # If the file was imported via URL, parse the original filename.
+      # If all else fails, use the basename of the file where it sits.
+      # @note This is only useful for labeling the file_set, because of the recourse to import_url
+      def label_for(file)
+        if file.is_a?(Hyrax::UploadedFile) # filename not present for uncached remote file!
+          file.uploader.filename.presence || File.basename(Addressable::URI.unencode(file.file_url))
+        elsif file.respond_to?(:original_name) # e.g. Hydra::Derivatives::IoDecorator
+          file.original_name
+        elsif file_set.import_url.present?
+          # This path is taken when file is a Tempfile (e.g. from ImportUrlJob)
+          File.basename(Addressable::URI.unencode(file.file_url))
+        else
+          File.basename(file)
         end
+      end
 
-        def assign_visibility?(file_set_params = {})
-          !((file_set_params || {}).keys.map(&:to_s) & %w[visibility embargo_release_date lease_expiration_date]).empty?
-        end
+      def assign_visibility?(file_set_params = {})
+        !((file_set_params || {}).keys.map(&:to_s) & %w[visibility embargo_release_date lease_expiration_date]).empty?
+      end
 
-        # replaces file_set.apply_depositor_metadata(user)from hydra-access-controls so depositor doesn't automatically get edit access
-        def depositor_id(depositor)
-          depositor.respond_to?(:user_key) ? depositor.user_key : depositor
-        end
+      # replaces file_set.apply_depositor_metadata(user)from hydra-access-controls so depositor doesn't automatically get edit access
+      def depositor_id(depositor)
+        depositor.respond_to?(:user_key) ? depositor.user_key : depositor
+      end
+
+      # Must clear the fileset from the thumbnail_id, representative_id and rendering_ids fields on the work
+      #   and force it to be re-solrized.
+      # Although ActiveFedora clears the children nodes it leaves those fields in Solr populated.
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def unlink_from_work
+        work = file_set.parent
+        return unless work && (work.thumbnail_id == file_set.id || work.representative_id == file_set.id || work.rendering_ids.include?(file_set.id))
+        work.thumbnail = nil if work.thumbnail_id == file_set.id
+        work.representative = nil if work.representative_id == file_set.id
+        work.rendering_ids -= [file_set.id]
+        work.save!
+      end
 
-        # Must clear the fileset from the thumbnail_id, representative_id and rendering_ids fields on the work
-        #   and force it to be re-solrized.
-        # Although ActiveFedora clears the children nodes it leaves those fields in Solr populated.
-        # rubocop:disable Metrics/CyclomaticComplexity
-        def unlink_from_work
-          work = file_set.parent
-          return unless work && (work.thumbnail_id == file_set.id || work.representative_id == file_set.id || work.rendering_ids.include?(file_set.id))
-          work.thumbnail = nil if work.thumbnail_id == file_set.id
-          work.representative = nil if work.representative_id == file_set.id
-          work.rendering_ids -= [file_set.id]
-          work.save!
+      # save a valkyrie resource returning false if FailedSaveError is raised
+      # TODO: Change calls to `#perform_save` to call `#save` instead when env passes resources instead of active fedora objects
+      def save(resource)
+        Hyrax.persister.save(resource: resource)
+      rescue FailedSaveError
+        false
+      end
+
+      # switches between using valkyrie to save or active fedora to save
+      # TODO: Remove this method when env passes resources instead of active fedora objects
+      def perform_save(object)
+        obj_to_save = object_to_act_on(object)
+        if valkyrie_object?(obj_to_save)
+          saved_resource = save(obj_to_save)
+          # return the same type of object that was passed in
+          saved_object_to_return = valkyrie_object?(object) ? saved_resource : Wings::ActiveFedoraConverter.new(resource: saved_resource).convert
+        else
+          obj_to_save.save
+          saved_object_to_return = obj_to_save
         end
+        saved_object_to_return
+      end
+
+      # if passed a resource or if use_valkyrie==true, object to act on is the valkyrie resource
+      # TODO: Remove this method when env passes resources instead of active fedora objects
+      def object_to_act_on(object)
+        return object if valkyrie_object?(object)
+        use_valkyrie ? object.valkyrie_resource : object
+      end
+
+      # determine if the object is a valkyrie resource
+      # TODO: Remove this method when env passes resources instead of active fedora objects
+      def valkyrie_object?(object)
+        object.is_a? Valkyrie::Resource
+      end
       # rubocop:enable Metrics/AbcSize
       # rubocop:enable Metrics/CyclomaticComplexity
     end

data/app/actors/hyrax/actors/initialize_workflow_actor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   module Actors
     # Responsible for generating the workflow for the given curation_concern.
@@ -17,10 +18,10 @@ module Hyrax
 
       private
 
-        # @return [TrueClass]
-        def create_workflow(env)
-          workflow_factory.create(env.curation_concern, env.attributes, env.user)
-        end
+      # @return [TrueClass]
+      def create_workflow(env)
+        workflow_factory.create(env.curation_concern, env.attributes, env.user)
+      end
     end
   end
 end

data/app/actors/hyrax/actors/interpret_visibility_actor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hyrax
   module Actors
     class InterpretVisibilityActor < AbstractActor
@@ -25,47 +26,47 @@ module Hyrax
 
         private
 
-          ##
-          # This method provides compatibility between form attributes passed in
-          # by the Actor, and the interface of `VisibilityIntention`. This
-          # behavior might benefit from being extracted elsewhere (the Actor?
-          # the form object?). Or it might be better to just expect clients to
-          # only pass in one set of end_date/during/after values.
-          #
-          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          def instance_vars_from_attributes
-            self.visibility   = @attributes[:visibility]
-            self.release_date = (wants_embargo? && @attributes[:embargo_release_date].presence) ||
-                                (wants_lease?   && @attributes[:lease_expiration_date].presence)
-            self.after        = (wants_embargo? && @attributes[:visibility_after_embargo].presence) ||
-                                (wants_lease?   && @attributes[:visibility_after_lease].presence)
-            self.during       = (wants_embargo? && @attributes[:visibility_during_embargo].presence) ||
-                                (wants_lease?   && @attributes[:visibility_during_lease].presence)
-          end
-          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-          def sanitize_unrestricted_params
-            @attributes.except(:lease_expiration_date,
-                               :visibility_during_lease,
-                               :visibility_after_lease,
-                               :embargo_release_date,
-                               :visibility_during_embargo,
-                               :visibility_after_embargo)
-          end
+        ##
+        # This method provides compatibility between form attributes passed in
+        # by the Actor, and the interface of `VisibilityIntention`. This
+        # behavior might benefit from being extracted elsewhere (the Actor?
+        # the form object?). Or it might be better to just expect clients to
+        # only pass in one set of end_date/during/after values.
+        #
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def instance_vars_from_attributes
+          self.visibility   = @attributes[:visibility]
+          self.release_date = (wants_embargo? && @attributes[:embargo_release_date].presence) ||
+                              (wants_lease?   && @attributes[:lease_expiration_date].presence)
+          self.after        = (wants_embargo? && @attributes[:visibility_after_embargo].presence) ||
+                              (wants_lease?   && @attributes[:visibility_after_lease].presence)
+          self.during       = (wants_embargo? && @attributes[:visibility_during_embargo].presence) ||
+                              (wants_lease?   && @attributes[:visibility_during_lease].presence)
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def sanitize_unrestricted_params
+          @attributes.except(:lease_expiration_date,
+                             :visibility_during_lease,
+                             :visibility_after_lease,
+                             :embargo_release_date,
+                             :visibility_during_embargo,
+                             :visibility_after_embargo)
+        end
 
-          def sanitize_embargo_params
-            @attributes.except(:visibility,
-                               :lease_expiration_date,
-                               :visibility_during_lease,
-                               :visibility_after_lease)
-          end
+        def sanitize_embargo_params
+          @attributes.except(:visibility,
+                             :lease_expiration_date,
+                             :visibility_during_lease,
+                             :visibility_after_lease)
+        end
 
-          def sanitize_lease_params
-            @attributes.except(:visibility,
-                               :embargo_release_date,
-                               :visibility_during_embargo,
-                               :visibility_after_embargo)
-          end
+        def sanitize_lease_params
+          @attributes.except(:visibility,
+                             :embargo_release_date,
+                             :visibility_during_embargo,
+                             :visibility_after_embargo)
+        end
       end
 
       # @param [Hyrax::Actors::Environment] env
@@ -88,128 +89,136 @@ module Hyrax
 
       private
 
-        # Validate against selected AdminSet's PermissionTemplate (if any)
-        def validate(env, intention, attributes)
-          # If AdminSet was selected, look for its PermissionTemplate
-          template = PermissionTemplate.find_by!(source_id: attributes[:admin_set_id]) if attributes[:admin_set_id].present?
-
-          validate_lease(env, intention, template) &&
-            validate_release_type(env, intention, template) &&
-            validate_visibility(env, attributes, template) &&
-            validate_embargo(env, intention, attributes, template)
-        end
+      # Validate against selected AdminSet's PermissionTemplate (if any)
+      def validate(env, intention, attributes)
+        # If AdminSet was selected, look for its PermissionTemplate
+        template = PermissionTemplate.find_by!(source_id: attributes[:admin_set_id]) if attributes[:admin_set_id].present?
 
-        def apply_visibility(env, intention)
-          result = apply_lease(env, intention) && apply_embargo(env, intention)
-          env.curation_concern.visibility = env.attributes[:visibility] if env.attributes[:visibility]
-          result
-        end
+        validate_lease(env, intention, template) &&
+          validate_release_type(env, intention, template) &&
+          validate_visibility(env, attributes, template) &&
+          validate_embargo(env, intention, attributes, template)
+      end
 
-        # Validate that a lease is allowed by AdminSet's PermissionTemplate
-        def validate_lease(env, intention, template)
-          return true unless intention.wants_lease?
+      def apply_visibility(env, intention)
+        result = apply_lease(env, intention) && apply_embargo(env, intention)
+        env.curation_concern.visibility = env.attributes[:visibility] if env.attributes[:visibility]
+        result
+      end
 
-          # Leases are only allowable if a template doesn't require a release period or have any specific visibility requirement
-          # (Note: permission template release/visibility options do not support leases)
-          unless template.present? && (template.release_period.present? || template.visibility.present?)
-            return true if intention.valid_lease?
-            env.curation_concern.errors.add(:visibility, 'When setting visibility to "lease" you must also specify lease expiration date.')
-            return false
-          end
+      # Validate that a lease is allowed by AdminSet's PermissionTemplate
+      def validate_lease(env, intention, template)
+        return true unless intention.wants_lease?
 
-          env.curation_concern.errors.add(:visibility, 'Lease option is not allowed by permission template for selected AdminSet.')
-          false
+        # Leases are only allowable if a template doesn't require a release period or have any specific visibility requirement
+        # (Note: permission template release/visibility options do not support leases)
+        unless template.present? && (template.release_period.present? || template.visibility.present?)
+          return true if intention.valid_lease?
+          env.curation_concern.errors.add(:visibility, 'When setting visibility to "lease" you must also specify lease expiration date.')
+          return false
         end
 
-        # Validate the selected release settings against template, checking for when embargoes/leases are not allowed
-        def validate_release_type(env, intention, template)
-          # It's valid as long as embargo is not specified when a template requires no release delays
-          return true unless intention.wants_embargo? && template.present? && template.release_no_delay?
+        env.curation_concern.errors.add(:visibility, 'Lease option is not allowed by permission template for selected AdminSet.')
+        false
+      end
 
-          env.curation_concern.errors.add(:visibility, 'Visibility specified does not match permission template "no release delay" requirement for selected AdminSet.')
-          false
-        end
+      # Validate the selected release settings against template, checking for when embargoes/leases are not allowed
+      def validate_release_type(env, intention, template)
+        # It's valid as long as embargo is not specified when a template requires no release delays
+        return true unless intention.wants_embargo? && template.present? && template.release_no_delay?
 
-        # Validate visibility complies with AdminSet template requirements
-        def validate_visibility(env, attributes, template)
-          # NOTE: For embargo/lease, attributes[:visibility] will be nil (see sanitize_params), so visibility will be validated as part of embargo/lease
-          return true if attributes[:visibility].blank?
+        env.curation_concern.errors.add(:visibility, 'Visibility specified does not match permission template "no release delay" requirement for selected AdminSet.')
+        false
+      end
 
-          # Validate against template's visibility requirements
-          return true if validate_template_visibility(attributes[:visibility], template)
+      # Validate visibility complies with AdminSet template requirements
+      def validate_visibility(env, attributes, template)
+        # NOTE: For embargo/lease, attributes[:visibility] will be nil (see sanitize_params), so visibility will be validated as part of embargo/lease
+        return true if attributes[:visibility].blank?
 
-          env.curation_concern.errors.add(:visibility, 'Visibility specified does not match permission template visibility requirement for selected AdminSet.')
-          false
-        end
+        # Validate against template's visibility requirements
+        return true if validate_template_visibility(attributes[:visibility], template)
 
-        # When specified, validate embargo is a future date that complies with AdminSet template requirements (if any)
-        def validate_embargo(env, intention, attributes, template)
-          return true unless intention.wants_embargo?
+        env.curation_concern.errors.add(:visibility, 'Visibility specified does not match permission template visibility requirement for selected AdminSet.')
+        false
+      end
 
-          embargo_release_date = parse_date(attributes[:embargo_release_date])
+      # When specified, validate embargo is a future date that complies with AdminSet template requirements (if any)
+      def validate_embargo(env, intention, attributes, template)
+        return true unless intention.wants_embargo?
 
-          # When embargo required, date must be in future AND matches any template requirements
-          return true if valid_future_date?(env, embargo_release_date) &&
-                         valid_template_embargo_date?(env, embargo_release_date, template) &&
-                         valid_template_visibility_after_embargo?(env, attributes, template)
+        embargo_release_date = parse_date(attributes[:embargo_release_date])
 
-          env.curation_concern.errors.add(:visibility, 'When setting visibility to "embargo" you must also specify embargo release date.') if embargo_release_date.blank?
-          false
-        end
+        # When embargo required, date must be in future AND matches any template requirements
+        return true if valid_future_date?(env, embargo_release_date) &&
+                       valid_template_embargo_date?(env, embargo_release_date, template) &&
+                       valid_template_visibility_after_embargo?(env, attributes, template)
 
-        # Validate an date attribute is in the future
-        def valid_future_date?(env, date, attribute_name: :embargo_release_date)
-          return true if date.present? && date.future?
+        env.curation_concern.errors.add(:visibility, 'When setting visibility to "embargo" you must also specify embargo release date.') if embargo_release_date.blank?
+        false
+      end
 
-          env.curation_concern.errors.add(attribute_name, "Must be a future date.")
-          false
-        end
+      # Validate an date attribute is in the future
+      def valid_future_date?(env, date, attribute_name: :embargo_release_date)
+        return true if date.present? && date.future?
 
-        # Validate an embargo date against permission template restrictions
-        def valid_template_embargo_date?(env, date, template)
-          return true if template.blank?
+        env.curation_concern.errors.add(attribute_name, "Must be a future date.")
+        false
+      end
 
-          # Validate against template's release_date requirements
-          return true if template.valid_release_date?(date)
+      # Validate an embargo date against permission template restrictions
+      def valid_template_embargo_date?(env, date, template)
+        return true if template.blank?
 
-          env.curation_concern.errors.add(:embargo_release_date, "Release date specified does not match permission template release requirements for selected AdminSet.")
-          false
-        end
+        # Validate against template's release_date requirements
+        return true if template.valid_release_date?(date)
+
+        env.curation_concern.errors.add(:embargo_release_date, "Release date specified does not match permission template release requirements for selected AdminSet.")
+        false
+      end
 
-        # Validate the post-embargo visibility against permission template requirements (if any)
-        def valid_template_visibility_after_embargo?(env, attributes, template)
-          # Validate against template's visibility requirements
-          return true if validate_template_visibility(attributes[:visibility_after_embargo], template)
+      # Validate the post-embargo visibility against permission template requirements (if any)
+      def valid_template_visibility_after_embargo?(env, attributes, template)
+        # Validate against template's visibility requirements
+        return true if validate_template_visibility(attributes[:visibility_after_embargo], template)
 
-          env.curation_concern.errors.add(:visibility_after_embargo, "Visibility after embargo does not match permission template visibility requirements for selected AdminSet.")
-          false
-        end
+        env.curation_concern.errors.add(:visibility_after_embargo, "Visibility after embargo does not match permission template visibility requirements for selected AdminSet.")
+        false
+      end
 
-        # Validate that a given visibility value satisfies template requirements
-        def validate_template_visibility(visibility, template)
-          return true if template.blank?
+      # Validate that a given visibility value satisfies template requirements
+      def validate_template_visibility(visibility, template)
+        return true if template.blank?
 
-          template.valid_visibility?(visibility)
-        end
+        template.valid_visibility?(visibility)
+      end
 
-        # Parse date from string. Returns nil if date_string is not a valid date
-        def parse_date(date_string)
-          datetime = Time.zone.parse(date_string) if date_string.present?
-          return datetime.to_date unless datetime.nil?
-          nil
-        end
+      # Parse date from string. Returns nil if date_string is not a valid date
+      def parse_date(date_string)
+        datetime = Time.zone.parse(date_string) if date_string.present?
+        return datetime.to_date unless datetime.nil?
+        nil
+      end
 
-        # If they want a lease, we can assume it's valid
-        def apply_lease(env, intention)
-          return true unless intention.wants_lease?
-          env.curation_concern.apply_lease(*intention.lease_params)
-        end
+      # If they want a lease, we can assume it's valid
+      def apply_lease(env, intention)
+        return true unless intention.wants_lease?
+        env.curation_concern.apply_lease(*intention.lease_params)
+        # apply_lease returns true if there has been a change in the lease period,
+        # otherwise it returns nil.  Since we want to continue processing, even when the date
+        # does not change, we return true from this method.
+        true
+      end
 
-        # If they want an embargo, we can assume it's valid
-        def apply_embargo(env, intention)
-          return true unless intention.wants_embargo?
-          env.curation_concern.apply_embargo(*intention.embargo_params)
-        end
+      # If they want an embargo, we can assume it's valid
+      def apply_embargo(env, intention)
+        return true unless intention.wants_embargo?
+        env.curation_concern.apply_embargo(*intention.embargo_params)
+        # apply_embargo returns true if there has been a change in the embargo period,
+        # otherwise it returns nil.  Since we want to continue processing, even when the date
+        # does not change, we return true from this method.
+        true
+      end
     end
   end
 end