curation_concerns 1.0.0.beta1 → 1.0.0.beta2

data/app/actors/curation_concerns/base_actor.rb

@@ -1,76 +0,0 @@
-module CurationConcerns
-  # 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.wrap(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

data/app/actors/curation_concerns/embargo_actor.rb

@@ -1,19 +0,0 @@
-module CurationConcerns
-  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

data/app/actors/curation_concerns/file_actor.rb

@@ -1,79 +0,0 @@
-module CurationConcerns
-  # 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

data/app/actors/curation_concerns/file_set_actor.rb

@@ -1,157 +0,0 @@
-module CurationConcerns
-  # 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]
-
-      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 = 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::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::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

data/app/actors/curation_concerns/interpret_visibility_actor.rb

@@ -1,123 +0,0 @@
-module CurationConcerns
-  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

data/app/actors/curation_concerns/lease_actor.rb

@@ -1,19 +0,0 @@
-module CurationConcerns
-  class LeaseActor
-    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 lease, then clear the lease date, etc.
-    # Saves the lease and the work
-    def destroy
-      work.lease_visibility! # If the lease has lapsed, update the current visibility.
-      work.deactivate_lease!
-      work.lease.save!
-      work.save!
-    end
-  end
-end

data/app/actors/curation_concerns/root_actor.rb

@@ -1,17 +0,0 @@
-module CurationConcerns
-  class RootActor
-    attr_reader :curation_concern, :user, :cloud_resources
-    def initialize(curation_concern, user, _more_actors)
-      @curation_concern = curation_concern
-      @user = user
-    end
-
-    def create(_)
-      true
-    end
-
-    def update(_)
-      true
-    end
-  end
-end

data/app/actors/curation_concerns/work_actor_behavior.rb

@@ -1,8 +0,0 @@
-module CurationConcerns::WorkActorBehavior
-  extend ActiveSupport::Concern
-  extend Deprecation
-
-  included do
-    Deprecation.warn(CurationConcerns::WorkActorBehavior, "CurationConcerns::WorkActorBehavior is deprecated and will be removed in CurationConcerns 1.0")
-  end
-end

data/app/renderers/curation_concerns/attribute_renderer.rb

@@ -1,98 +0,0 @@
-require "rails_autolink/helpers"
-
-module CurationConcerns
-  class AttributeRenderer
-    include ActionView::Helpers::UrlHelper
-    include ActionView::Helpers::TranslationHelper
-    include ActionView::Helpers::TextHelper
-    include ConfiguredMicrodata
-
-    attr_reader :field, :values, :options
-
-    # @param [Symbol] field
-    # @param [Array] values
-    # @param [Hash] options
-    def initialize(field, values, options = {})
-      @field = field
-      @values = values
-      @options = options
-    end
-
-    # Draw the table row for the attribute
-    def render
-      markup = ''
-
-      return markup if !values.present? && !options[:include_empty]
-      markup << %(<tr><th>#{label}</th>\n<td><ul class='tabular'>)
-      attributes = microdata_object_attributes(field).merge(class: "attribute #{field}")
-      Array.wrap(values).each do |value|
-        markup << "<li#{html_attributes(attributes)}>#{attribute_value_to_html(value.to_s)}</li>"
-      end
-      markup << %(</ul></td></tr>)
-      markup.html_safe
-    end
-
-    # @return The human-readable label for this field.
-    # @note This is a central location for determining the label of a field
-    #   name. Can be overridden if more complicated logic is needed.
-    def label
-      translate(
-        :"blacklight.search.fields.show.#{field}",
-        default: [:"blacklight.search.fields.#{field}", options.fetch(:label, field.to_s.humanize)])
-    end
-
-    private
-
-      def attribute_value_to_html(value)
-        if field == :rights
-          rights_attribute_to_html(value)
-        elsif microdata_value_attributes(field).present?
-          "<span#{html_attributes(microdata_value_attributes(field))}>#{li_value(value)}</span>"
-        else
-          li_value(value)
-        end
-      end
-
-      def html_attributes(attributes)
-        buffer = ""
-        attributes.each do |k, v|
-          buffer << " #{k}"
-          buffer << %(="#{v}") unless v.blank?
-        end
-        buffer
-      end
-
-      def search_field
-        options.fetch(:search_field, field)
-      end
-
-      def li_value(value)
-        if options[:catalog_search_link]
-          link_to(ERB::Util.h(value), search_path(value))
-        else
-          auto_link(ERB::Util.h(value))
-        end
-      end
-
-      def search_path(value)
-        Rails.application.routes.url_helpers.search_catalog_path(
-          search_field: search_field, q: ERB::Util.h(value))
-      end
-
-      ##
-      # Special treatment for license/rights.  A URL from the Sufia gem's config/sufia.rb is stored in the descMetadata of the
-      # curation_concern.  If that URL is valid in form, then it is used as a link.  If it is not valid, it is used as plain text.
-      def rights_attribute_to_html(value)
-        begin
-          parsed_uri = URI.parse(value)
-        rescue
-          nil
-        end
-        if parsed_uri.nil?
-          ERB::Util.h(value)
-        else
-          %(<a href=#{ERB::Util.h(value)} target="_blank">#{RightsService.label(value)}</a>)
-        end
-      end
-  end
-end

data/app/renderers/curation_concerns/configured_microdata.rb

@@ -1,40 +0,0 @@
-module CurationConcerns
-  module ConfiguredMicrodata
-    def microdata?(field)
-      return false unless CurationConcerns.config.display_microdata
-      key = "curation_concerns.schema_org.#{field}.property"
-      t(key, default: false)
-    end
-
-    def microdata_object?(field)
-      return false unless CurationConcerns.config.display_microdata
-      key = "curation_concerns.schema_org.#{field}.type"
-      t(key, default: false)
-    end
-
-    def microdata_object_attributes(field)
-      if microdata_object?(field)
-        { itemprop: microdata_property(field), itemscope: '', itemtype: microdata_type(field) }
-      else
-        {}
-      end
-    end
-
-    def microdata_property(field)
-      t("curation_concerns.schema_org.#{field}.property")
-    end
-
-    def microdata_type(field)
-      t("curation_concerns.schema_org.#{field}.type")
-    end
-
-    def microdata_value_attributes(field)
-      if microdata?(field)
-        key = microdata_object?(field) ? :value : :property
-        { itemprop: t("curation_concerns.schema_org.#{field}.#{key}") }
-      else
-        {}
-      end
-    end
-  end
-end

data/app/services/curation_concerns/actor_factory.rb

@@ -1,24 +0,0 @@
-module CurationConcerns
-  class ActorFactory
-    def self.build(curation_concern, current_user)
-      ActorStack.new(curation_concern,
-                     current_user,
-                     stack_actors(curation_concern))
-    end
-
-    def self.stack_actors(curation_concern)
-      [AddToCollectionActor,
-       AssignRepresentativeActor,
-       AttachFilesActor,
-       ApplyOrderActor,
-       InterpretVisibilityActor,
-       model_actor(curation_concern),
-       AssignIdentifierActor]
-    end
-
-    def self.model_actor(curation_concern)
-      actor_identifier = curation_concern.class.to_s.split('::').last
-      "CurationConcerns::#{actor_identifier}Actor".constantize
-    end
-  end
-end