curation_concerns 1.0.0.beta1 → 1.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 82ff29ee951976ef550ed0a64a07495a4eacad37
-  data.tar.gz: c2537a3a7611199f193a9643a53e98dacccb2d96
+  metadata.gz: 96756d166c6631a6999f710b4d914c1633bf87b6
+  data.tar.gz: 3a0dee7f354c71afc0b72844e3eb6a37cbc48b3e
 SHA512:
-  metadata.gz: 6b97ceab4d2982f871070aa678f66e8d37dfb04f1184a22b66b0d34d07fc08269e3ac0817a2fbc0fce55767bddfa952eed57871141d2f3ceadacee084336bf34
-  data.tar.gz: e1b11872f569fe9a090a35a71984374812b85de8cdcbd022fe2a0f3f8a0ea22203b57a3e802ae51c7bbe3f55f72dd37880606d8e334703463855f8bd250ed34a
+  metadata.gz: 616e0cec3bf1225238270505c6966c83639857dd54b5fbcb500c9b677341d6e775ea6abec678dfe2a8e113644c51379fca9f9fc5df0bf61716c46a707df0b67a
+  data.tar.gz: 09ca08d9a68ef729446a05e92f4e604ce8b2b764e35a73dcb0b12c8876fc2c68b2cb2711a3c7580d6e2fdc6730f85c150bc49ad4b20a32a6f9438bb6f069a4cf

data/app/actors/curation_concerns/actors/abstract_actor.rb

@@ -0,0 +1,30 @@
+module CurationConcerns
+  module Actors
+    # The CurationConcern Abstract actor responds to two primary actions:
+    # * #create
+    # * #update
+    #
+    # and the following attributes
+    #
+    # * next_actor
+    # * curation_concern
+    # * user
+    #
+    # it must instantiate the next actor in the chain and instantiate it.
+    # it should respond to curation_concern, user and attributes.
+    # it ha to next_actor
+    class AbstractActor
+      attr_reader :next_actor
+
+      def initialize(_curation_concern, _user, next_actor)
+        @next_actor = next_actor
+      end
+
+      delegate :curation_concern, :user, to: :next_actor
+
+      delegate :create, to: :next_actor
+
+      delegate :update, to: :next_actor
+    end
+  end
+end

data/app/actors/curation_concerns/actors/actor_stack.rb

@@ -0,0 +1,29 @@
+module CurationConcerns
+  module Actors
+    class ActorStack
+      attr_reader :curation_concern, :user, :first_actor_class, :more_actors
+      def initialize(curation_concern, user, more_actors)
+        @curation_concern = curation_concern
+        @user = user
+        @more_actors = more_actors
+        @first_actor_class = @more_actors.shift || RootActor
+      end
+
+      def inner_stack
+        Actors::ActorStack.new(curation_concern, user, more_actors)
+      end
+
+      def actor
+        first_actor_class.new(curation_concern, user, inner_stack)
+      end
+
+      def create(attributes)
+        actor.create(attributes.with_indifferent_access)
+      end
+
+      def update(attributes)
+        actor.update(attributes.with_indifferent_access)
+      end
+    end
+  end
+end

data/app/actors/curation_concerns/actors/add_to_collection_actor.rb

@@ -0,0 +1,40 @@
+module CurationConcerns
+  module Actors
+    class AddToCollectionActor < AbstractActor
+      def create(attributes)
+        collection_ids = attributes.delete(:collection_ids)
+        next_actor.create(attributes) && add_to_collections(collection_ids)
+      end
+
+      def update(attributes)
+        collection_ids = attributes.delete(:collection_ids)
+        add_to_collections(collection_ids) && next_actor.update(attributes)
+      end
+
+      private
+
+        # The default behavior of active_fedora's aggregates association,
+        # when assigning the id accessor (e.g. collection_ids = ['foo:1']) is to add
+        # to new collections, but not remove from old collections.
+        # This method ensures it's removed from the old collections.
+        def add_to_collections(new_collection_ids)
+          return true unless new_collection_ids
+          # remove from old collections
+          # TODO: Implement in_collection_ids https://github.com/projecthydra-labs/hydra-pcdm/issues/157
+          (curation_concern.in_collections.map(&:id) - new_collection_ids).each do |old_id|
+            collection = ::Collection.find(old_id)
+            collection.members.delete(curation_concern)
+            collection.save
+          end
+
+          # add to new
+          new_collection_ids.each do |coll_id|
+            collection = ::Collection.find(coll_id)
+            collection.members << curation_concern
+            collection.save
+          end
+          true
+        end
+    end
+  end
+end

data/app/actors/curation_concerns/actors/apply_order_actor.rb

@@ -0,0 +1,26 @@
+module CurationConcerns
+  module Actors
+    class ApplyOrderActor < AbstractActor
+      def update(attributes)
+        ordered_member_ids = attributes.delete(:ordered_member_ids)
+        apply_order(ordered_member_ids) && next_actor.update(attributes)
+      end
+
+      private
+
+        def apply_order(new_order)
+          return true unless new_order
+          curation_concern.ordered_member_proxies.each_with_index do |proxy, index|
+            unless new_order[index]
+              proxy.prev.next = curation_concern.ordered_member_proxies.last.next
+              break
+            end
+            proxy.proxy_for = ActiveFedora::Base.id_to_uri(new_order[index])
+            proxy.target = nil
+          end
+          curation_concern.list_source.order_will_change!
+          true
+        end
+    end
+  end
+end

data/app/actors/curation_concerns/actors/assign_identifier_actor.rb

@@ -0,0 +1,9 @@
+module CurationConcerns
+  module Actors
+    class AssignIdentifierActor < AbstractActor
+      def create(attributes)
+        curation_concern.assign_id && next_actor.create(attributes)
+      end
+    end
+  end
+end

data/app/actors/curation_concerns/actors/assign_representative_actor.rb

@@ -0,0 +1,20 @@
+module CurationConcerns
+  module Actors
+    class AssignRepresentativeActor < AbstractActor
+      def create(attributes)
+        next_actor.create(attributes) && assign_representative
+      end
+
+      private
+
+        def assign_representative
+          unless curation_concern.representative_id
+            # TODO: Possible optimization here. Does this cause a fetch of ordered_members if they're already loaded?
+            representative = nil # curation_concern.ordered_members.association.reader.first.target
+            curation_concern.representative = representative if representative
+          end
+          curation_concern.save
+        end
+    end
+  end
+end

data/app/actors/curation_concerns/actors/attach_files_actor.rb

@@ -0,0 +1,41 @@
+module CurationConcerns
+  module Actors
+    class AttachFilesActor < AbstractActor
+      def create(attributes)
+        files = [attributes.delete(:files)].flatten.compact
+        attach_files(files, visibility_attributes(attributes)) &&
+          next_actor.create(attributes)
+      end
+
+      def update(attributes)
+        files = [attributes.delete(:files)].flatten.compact
+        next_actor.update(attributes) &&
+          attach_files(files, visibility_attributes(attributes))
+      end
+
+      private
+
+        def attach_files(files, visibility_attr)
+          files.all? do |file|
+            attach_file(file, visibility_attr)
+          end
+        end
+
+        def attach_file(file, visibility_attr)
+          file_set = ::FileSet.new
+          file_set_actor = CurationConcerns::Actors::FileSetActor.new(file_set, user)
+          file_set_actor.create_metadata(curation_concern, visibility_attr)
+          file_set_actor.create_content(file)
+        end
+
+        # The attributes used for visibility - used to send as initial params to
+        # created FileSets.
+        def visibility_attributes(attributes)
+          attributes.slice(:visibility, :visibility_during_lease,
+                           :visibility_after_lease, :lease_expiration_date,
+                           :embargo_release_date, :visibility_during_embargo,
+                           :visibility_after_embargo)
+        end
+    end
+  end
+end

data/app/actors/curation_concerns/actors/base_actor.rb

@@ -0,0 +1,78 @@
+module CurationConcerns
+  module Actors
+    # The CurationConcern base actor responds to two primary actions:
+    # * #create
+    # * #update
+    # it must instantiate the next actor in the chain and instantiate it.
+    # it should respond to curation_concern, user and attributes.
+    class BaseActor < AbstractActor
+      attr_reader :cloud_resources
+
+      def create(attributes)
+        @cloud_resources = attributes.delete(:cloud_resources.to_s)
+        apply_creation_data_to_curation_concern
+        apply_save_data_to_curation_concern(attributes)
+        next_actor.create(attributes) && save && run_callbacks(:after_create_concern)
+      end
+
+      def update(attributes)
+        apply_update_data_to_curation_concern
+        apply_save_data_to_curation_concern(attributes)
+        next_actor.update(attributes) && save && run_callbacks(:after_update_metadata)
+      end
+
+      protected
+
+        def run_callbacks(hook)
+          CurationConcerns.config.callback.run(hook, curation_concern, user)
+          true
+        end
+
+        def apply_creation_data_to_curation_concern
+          apply_depositor_metadata
+          apply_deposit_date
+        end
+
+        def apply_update_data_to_curation_concern
+          true
+        end
+
+        def apply_depositor_metadata
+          curation_concern.apply_depositor_metadata(user.user_key)
+          curation_concern.edit_users += [user.user_key]
+        end
+
+        def apply_deposit_date
+          curation_concern.date_uploaded = CurationConcerns::TimeService.time_in_utc
+        end
+
+        def save
+          curation_concern.save
+        end
+
+        def apply_save_data_to_curation_concern(attributes)
+          attributes[:rights] = Array(attributes[:rights]) if attributes.key? :rights
+          remove_blank_attributes!(attributes)
+          curation_concern.attributes = attributes.symbolize_keys
+          curation_concern.date_modified = CurationConcerns::TimeService.time_in_utc
+        end
+
+        # If any attributes are blank remove them
+        # e.g.:
+        #   self.attributes = { 'title' => ['first', 'second', ''] }
+        #   remove_blank_attributes!
+        #   self.attributes
+        # => { 'title' => ['first', 'second'] }
+        def remove_blank_attributes!(attributes)
+          multivalued_form_attributes(attributes).each_with_object(attributes) do |(k, v), h|
+            h[k] = v.instance_of?(Array) ? v.select(&:present?) : v
+          end
+        end
+
+        # Return the hash of attributes that are multivalued and not uploaded files
+        def multivalued_form_attributes(attributes)
+          attributes.select { |_, v| v.respond_to?(:select) && !v.respond_to?(:read) }
+        end
+    end
+  end
+end

data/app/actors/curation_concerns/actors/embargo_actor.rb

@@ -0,0 +1,21 @@
+module CurationConcerns
+  module Actors
+    class EmbargoActor
+      attr_reader :work
+
+      # @param [Hydra::Works::Work] work
+      def initialize(work)
+        @work = work
+      end
+
+      # Update the visibility of the work to match the correct state of the embargo, then clear the embargo date, etc.
+      # Saves the embargo and the work
+      def destroy
+        work.embargo_visibility! # If the embargo has lapsed, update the current visibility.
+        work.deactivate_embargo!
+        work.embargo.save!
+        work.save!
+      end
+    end
+  end
+end

data/app/actors/curation_concerns/actors/file_actor.rb

@@ -0,0 +1,81 @@
+module CurationConcerns
+  module Actors
+    # actions for a file identified by file_set and relation (maps to use predicate)
+    class FileActor
+      attr_reader :file_set, :relation, :user
+
+      # @param [FileSet] file_set the parent FileSet
+      # @param [String] relation the type/use for the file.
+      # @param [User] user the user to record as the Agent acting upon the file
+      def initialize(file_set, relation, user)
+        @file_set = file_set
+        @relation = relation
+        @user = user
+      end
+
+      # Puts the uploaded content into a staging directory. Then kicks off a
+      # job to characterize and create derivatives with this on disk variant.
+      # Simultaneously moving a preservation copy to the repostiory.
+      # TODO: create a job to monitor this directory and prune old files that
+      # have made it to the repo
+      # @param [File, ActionDigest::HTTP::UploadedFile, Tempfile] file the file to save in the repository
+      def ingest_file(file)
+        working_file = copy_file_to_working_directory(file, file_set.id)
+        mime_type = file.respond_to?(:content_type) ? file.content_type : nil
+        IngestFileJob.perform_later(file_set, working_file, mime_type, user, relation)
+        make_derivative(file_set, working_file)
+        true
+      end
+
+      def revert_to(revision_id)
+        repository_file = file_set.send(relation.to_sym)
+        repository_file.restore_version(revision_id)
+
+        return false unless file_set.save
+
+        CurationConcerns::VersioningService.create(repository_file, user)
+
+        # Retrieve a copy of the orginal file from the repository
+        working_file = copy_repository_resource_to_working_directory(repository_file)
+        make_derivative(file_set, working_file)
+        true
+      end
+
+      private
+
+        def make_derivative(file_set, working_file)
+          CharacterizeJob.perform_later(file_set, working_file)
+        end
+
+        # @param [File, ActionDispatch::Http::UploadedFile] file
+        # @param [String] id the identifer of the FileSet
+        # @return [String] path of the working file
+        def copy_file_to_working_directory(file, id)
+          file_name = file.respond_to?(:original_filename) ? file.original_filename : ::File.basename(file)
+          copy_stream_to_working_directory(id, file_name, file)
+        end
+
+        # @param [ActiveFedora::File] file the resource in the repo
+        # @return [String] path of the working file
+        def copy_repository_resource_to_working_directory(file)
+          copy_stream_to_working_directory(file_set.id, file.original_name, StringIO.new(file.content))
+        end
+
+        # @param [String] id the identifer
+        # @param [String] name the file name
+        # @param [#read] stream the stream to copy to the working directory
+        # @return [String] path of the working file
+        def copy_stream_to_working_directory(id, name, stream)
+          working_path = full_filename(id, name)
+          FileUtils.mkdir_p(File.dirname(working_path))
+          IO.copy_stream(stream, working_path)
+          working_path
+        end
+
+        def full_filename(id, original_name)
+          pair = id.scan(/..?/).first(4)
+          File.join(CurationConcerns.config.working_path, *pair, original_name)
+        end
+    end
+  end
+end

data/app/actors/curation_concerns/actors/file_set_actor.rb

@@ -0,0 +1,159 @@
+module CurationConcerns
+  module Actors
+    # Actions are decoupled from controller logic so that they may be called from a controller or a background job.
+    class FileSetActor
+      include CurationConcerns::Lockable
+
+      attr_reader :file_set, :user, :attributes
+
+      def initialize(file_set, user)
+        @file_set = file_set
+        @user = user
+      end
+
+      # Adds the appropriate metadata, visibility and relationships to file_set
+      #
+      # *Note*: In past versions of Sufia this method did not perform a save because it is mainly used in conjunction with
+      # create_content, which also performs a save.  However, due to the relationship between Hydra::PCDM objects,
+      # we have to save both the parent work and the file_set in order to record the "metadata" relationship
+      # between them.
+      # @param [ActiveFedora::Base] work the parent work that will contain the file_set.
+      # @param [Hash] file_set specifying the visibility, lease and/or embargo of the file set.  If you don't provide at least one of visibility, embargo_release_date or lease_expiration_date, visibility will be copied from the parent.
+
+      def create_metadata(work, file_set_params = {})
+        file_set.apply_depositor_metadata(user)
+        now = CurationConcerns::TimeService.time_in_utc
+        file_set.date_uploaded = now
+        file_set.date_modified = now
+        file_set.creator = [user.user_key]
+
+        Actors::ActorStack.new(file_set, user, [InterpretVisibilityActor]).create(file_set_params) if assign_visibility?(file_set_params)
+        attach_file_to_work(work, file_set, file_set_params) if work
+        yield(file_set) if block_given?
+      end
+
+      # @param [File, ActionDigest::HTTP::UploadedFile, Tempfile] file the file uploaded by the user.
+      # @param [String] relation ('original_file')
+      def create_content(file, relation = 'original_file')
+        # If the file set doesn't have a title or label assigned, set a default.
+        file_set.label ||= file.respond_to?(:original_filename) ? file.original_filename : ::File.basename(file)
+        file_set.title = [file_set.label] if file_set.title.blank?
+
+        # Need to save the file_set in order to get an id
+        return false unless file_set.save
+
+        file_actor_class.new(file_set, relation, user).ingest_file(file)
+        true
+      end
+
+      # @param [String] revision_id the revision to revert to
+      # @param [String] relation ('original_file')
+      def revert_content(revision_id, relation = 'original_file')
+        file_actor = file_actor_class.new(file_set, relation, user)
+        if file_actor.revert_to(revision_id)
+          CurationConcerns.config.callback.run(:after_revert_content, file_set, user, revision_id)
+          true
+        else
+          false
+        end
+      end
+
+      # @param [File, ActionDigest::HTTP::UploadedFile, Tempfile] file the file uploaded by the user.
+      # @param [String] relation ('original_file')
+      def update_content(file, relation = 'original_file')
+        file_actor_class.new(file_set, relation, user).ingest_file(file)
+        CurationConcerns.config.callback.run(:after_update_content, file_set, user)
+        true
+      end
+
+      def update_metadata(attributes)
+        stack = Actors::ActorStack.new(file_set,
+                                       user,
+                                       [InterpretVisibilityActor, BaseActor])
+        stack.update(attributes)
+      end
+
+      def destroy
+        unlink_from_work
+        file_set.destroy
+        CurationConcerns.config.callback.run(:after_destroy, file_set.id, user)
+      end
+
+      def file_actor_class
+        CurationConcerns::Actors::FileActor
+      end
+
+      private
+
+        # Takes an optional block and executes the block if the save was successful.
+        # returns false if the save was unsuccessful
+        def save
+          save_tries = 0
+          begin
+            return false unless file_set.save
+          rescue RSolr::Error::Http => error
+            ActiveFedora::Base.logger.warn "CurationConcerns::Actors::FileSetActor#save Caught RSOLR error #{error.inspect}"
+            save_tries += 1
+            # fail for good if the tries is greater than 3
+            raise error if save_tries >= 3
+            sleep 0.01
+            retry
+          end
+          yield if block_given?
+          true
+        end
+
+        # Adds a FileSet to the work using ore:Aggregations.
+        # Locks to ensure that only one process is operating on
+        # the list at a time.
+        def attach_file_to_work(work, file_set, 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?
+            unless assign_visibility?(file_set_params)
+              copy_visibility(work, file_set)
+            end
+            work.ordered_members << file_set
+            set_representative(work, file_set)
+            set_thumbnail(work, file_set)
+
+            # Save the work so the association between the work and the file_set is persisted (head_id)
+            work.save
+          end
+          CurationConcerns.config.callback.run(:after_create_fileset, file_set, user)
+        end
+
+        def assign_visibility?(file_set_params = {})
+          !((file_set_params || {}).keys & %w(visibility embargo_release_date lease_expiration_date)).empty?
+        end
+
+        # copy visibility from source_concern to destination_concern
+        def copy_visibility(source_concern, destination_concern)
+          destination_concern.visibility =  source_concern.visibility
+        end
+
+        def set_representative(work, file_set)
+          return unless work.representative_id.blank?
+          work.representative = file_set
+        end
+
+        def set_thumbnail(work, file_set)
+          return unless work.thumbnail_id.blank?
+          work.thumbnail = file_set
+        end
+
+        def unlink_from_work
+          work = file_set.parent
+          return unless work && (work.thumbnail_id == file_set.id || work.representative_id == file_set.id)
+          # This is required to clear the thumbnail_id and representative_id
+          # fields on the work and force it to be re-solrized. Although
+          # ActiveFedora clears the children nodes it leaves the work's
+          # thumbnail_id and representative_id fields in Solr populated.
+          work.thumbnail = nil if work.thumbnail_id == file_set.id
+          work.representative = nil if work.representative_id == file_set.id
+          work.save!
+        end
+    end
+  end
+end

data/app/actors/curation_concerns/actors/interpret_visibility_actor.rb

@@ -0,0 +1,125 @@
+module CurationConcerns
+  module Actors
+    class InterpretVisibilityActor < AbstractActor
+      class Intention
+        def initialize(attributes)
+          @attributes = attributes
+        end
+
+        # returns a copy of attributes with the necessary params removed
+        # If the lease or embargo is valid, or if they selected something besides lease
+        # or embargo, remove all the params.
+        def sanitize_params
+          if valid_lease?
+            @attributes.except(:visibility,
+                               :embargo_release_date,
+                               :visibility_during_embargo,
+                               :visibility_after_embargo)
+          elsif valid_embargo?
+            @attributes.except(:visibility,
+                               :lease_expiration_date,
+                               :visibility_during_lease,
+                               :visibility_after_lease)
+          elsif !wants_lease? && !wants_embargo?
+            @attributes.except(:lease_expiration_date,
+                               :visibility_during_lease,
+                               :visibility_after_lease,
+                               :embargo_release_date,
+                               :visibility_during_embargo,
+                               :visibility_after_embargo)
+          else
+            @attributes
+          end
+        end
+
+        def wants_lease?
+          visibility == Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE
+        end
+
+        def wants_embargo?
+          visibility == Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO
+        end
+
+        def valid_lease?
+          wants_lease? && @attributes[:lease_expiration_date].present?
+        end
+
+        def valid_embargo?
+          wants_embargo? && @attributes[:embargo_release_date].present?
+        end
+
+        def lease_params
+          [:lease_expiration_date,
+           :visibility_during_lease,
+           :visibility_after_lease].map { |key| @attributes[key] }
+        end
+
+        def embargo_params
+          [:embargo_release_date,
+           :visibility_during_embargo,
+           :visibility_after_embargo].map { |key| @attributes[key] }
+        end
+
+        private
+
+          def visibility
+            @attributes[:visibility]
+          end
+      end
+
+      def create(attributes)
+        @intention = Intention.new(attributes)
+        attributes = @intention.sanitize_params
+        validate && apply_visibility(attributes) && next_actor.create(attributes)
+      end
+
+      def update(attributes)
+        @intention = Intention.new(attributes)
+        attributes = @intention.sanitize_params
+        validate && apply_visibility(attributes) && next_actor.update(attributes)
+      end
+
+      private
+
+        def validate
+          validate_lease && validate_embargo
+        end
+
+        def apply_visibility(attributes)
+          result = apply_lease && apply_embargo
+          if attributes[:visibility]
+            curation_concern.visibility = attributes[:visibility]
+          end
+          result
+        end
+
+        def validate_lease
+          return true unless @intention.wants_lease? && !@intention.valid_lease?
+          curation_concern.errors.add(:visibility, 'When setting visibility to "lease" you must also specify lease expiration date.')
+          false
+        end
+
+        def validate_embargo
+          return true unless @intention.wants_embargo? && !@intention.valid_embargo?
+          curation_concern.errors.add(:visibility, 'When setting visibility to "embargo" you must also specify embargo release date.')
+          false
+        end
+
+        # If they want a lease, we can assume it's valid
+        def apply_lease
+          return true unless @intention.wants_lease?
+          curation_concern.apply_lease(*@intention.lease_params)
+          return unless curation_concern.lease
+          curation_concern.lease.save # see https://github.com/projecthydra/hydra-head/issues/226
+        end
+
+        # If they want an embargo, we can assume it's valid
+        def apply_embargo
+          return true unless @intention.wants_embargo?
+          curation_concern.apply_embargo(*@intention.embargo_params)
+          return unless curation_concern.embargo
+          curation_concern.embargo.save # see https://github.com/projecthydra/hydra-head/issues/226
+        end
+    end
+  end
+end