curation_concerns 0.12.0.pre1 → 0.12.0.pre2

data/app/models/concerns/curation_concerns/naming.rb

@@ -0,0 +1,17 @@
+module CurationConcerns
+  module Naming
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Override of ActiveModel::Model name that allows us to use our custom name class
+      def model_name
+        @_model_name ||= begin
+          namespace = parents.detect do |n|
+            n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
+          end
+          CurationConcerns::Name.new(self, namespace)
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/curation_concerns/permissions/readable.rb

@@ -0,0 +1,18 @@
+module CurationConcerns
+  module Permissions
+    module Readable
+      extend ActiveSupport::Concern
+      def public?
+        read_groups.include?('public')
+      end
+
+      def registered?
+        read_groups.include?('registered')
+      end
+
+      def private?
+        !(public? || registered?)
+      end
+    end
+  end
+end

data/app/models/concerns/curation_concerns/permissions/writable.rb

@@ -0,0 +1,34 @@
+module CurationConcerns
+  module Permissions
+    module Writable
+      extend ActiveSupport::Concern
+
+      # we're overriding the permissions= method which is in Hydra::AccessControls::Permissions
+      include Hydra::AccessControls::Permissions
+      include Hydra::AccessControls::Visibility
+
+      included do
+        validate :paranoid_permissions
+      end
+
+      def paranoid_permissions
+        valid = true
+        paranoid_edit_permissions.each do |validation|
+          next unless validation[:condition].call(self)
+          errors[validation[:key]] ||= []
+          errors[validation[:key]] << validation[:message]
+          valid = false
+        end
+        valid
+      end
+
+      def paranoid_edit_permissions
+        [
+          { key: :edit_users, message: 'Depositor must have edit access', condition: ->(obj) { !obj.edit_users.include?(obj.depositor) } },
+          { key: :edit_groups, message: 'Public cannot have edit access', condition: ->(obj) { obj.edit_groups.include?('public') } },
+          { key: :edit_groups, message: 'Registered cannot have edit access', condition: ->(obj) { obj.edit_groups.include?('registered') } }
+        ]
+      end
+    end
+  end
+end

data/app/models/concerns/curation_concerns/permissions.rb

@@ -0,0 +1,7 @@
+module CurationConcerns
+  module Permissions
+    extend ActiveSupport::Concern
+    include CurationConcerns::Permissions::Writable
+    include CurationConcerns::Permissions::Readable
+  end
+end

data/app/models/concerns/curation_concerns/required_metadata.rb

@@ -0,0 +1,30 @@
+module CurationConcerns
+  module RequiredMetadata
+    extend ActiveSupport::Concern
+
+    included do
+      property :depositor, predicate: ::RDF::URI.new('http://id.loc.gov/vocabulary/relators/dpt'), multiple: false do |index|
+        index.as :symbol, :stored_searchable
+      end
+
+      property :title, predicate: ::RDF::Vocab::DC.title do |index|
+        index.as :stored_searchable, :facetable
+      end
+
+      # We reserve date_uploaded for the original creation date of the record.
+      # For example, when migrating data from a fedora3 repo to fedora4,
+      # fedora's system created date will reflect the date when the record
+      # was created in fedora4, but the date_uploaded will preserve the
+      # original creation date from the old repository.
+      property :date_uploaded, predicate: ::RDF::Vocab::DC.dateSubmitted, multiple: false do |index|
+        index.type :date
+        index.as :stored_sortable
+      end
+
+      property :date_modified, predicate: ::RDF::Vocab::DC.modified, multiple: false do |index|
+        index.type :date
+        index.as :stored_sortable
+      end
+    end
+  end
+end

data/app/models/concerns/curation_concerns/serializers.rb

@@ -0,0 +1,13 @@
+module CurationConcerns
+  module Serializers
+    def to_s
+      if title.present?
+        Array(title).join(' | ')
+      elsif label.present?
+        Array(label).join(' | ')
+      else
+        'No Title'
+      end
+    end
+  end
+end

data/app/models/concerns/curation_concerns/solr_document_behavior.rb

@@ -0,0 +1,147 @@
+module CurationConcerns
+  module SolrDocumentBehavior
+    extend ActiveSupport::Concern
+    include Hydra::Works::MimeTypes
+
+    def title_or_label
+      title || label
+    end
+
+    def to_param
+      id
+    end
+
+    def to_s
+      title_or_label
+    end
+
+    ##
+    # Offer the source (ActiveFedora-based) model to Rails for some of the
+    # Rails methods (e.g. link_to).
+    # @example
+    #   link_to '...', SolrDocument(:id => 'bXXXXXX5').new => <a href="/dams_object/bXXXXXX5">...</a>
+    def to_model
+      @model ||= begin
+        m = ActiveFedora::Base.load_instance_from_solr(id, self)
+        m.class == ActiveFedora::Base ? self : m
+      end
+    end
+
+    def collection?
+      hydra_model == 'Collection'
+    end
+
+    # Method to return the ActiveFedora model
+    def hydra_model
+      self[Solrizer.solr_name('active_fedora_model', Solrizer::Descriptor.new(:string, :stored, :indexed))]
+    end
+
+    def human_readable_type
+      Array(self[Solrizer.solr_name('human_readable_type', :stored_searchable)]).first
+    end
+
+    def representative_id
+      fetch(Solrizer.solr_name('hasRelatedMediaFragment', :symbol), []).first
+    end
+
+    # Date created is indexed as a string. This allows users to enter values like: 'Circa 1840-1844'
+    def date_created
+      fetch(Solrizer.solr_name("date_created"), []).first
+    end
+
+    def date_modified
+      date_field('date_modified')
+    end
+
+    def date_uploaded
+      date_field('date_uploaded')
+    end
+
+    def depositor(default = '')
+      val = Array(self[Solrizer.solr_name('depositor')]).first
+      val.present? ? val : default
+    end
+
+    def title
+      Array(self[Solrizer.solr_name('title')]).first
+    end
+
+    def description
+      Array(self[Solrizer.solr_name('description')]).first
+    end
+
+    def label
+      Array(self[Solrizer.solr_name('label')]).first
+    end
+
+    def file_format
+      Array(self[Solrizer.solr_name('file_format')]).first
+    end
+
+    def creator
+      fetch(Solrizer.solr_name('creator'), [])
+    end
+
+    def contributor
+      fetch(Solrizer.solr_name('contributor'), [])
+    end
+
+    def subject
+      fetch(Solrizer.solr_name('subject'), [])
+    end
+
+    def publisher
+      fetch(Solrizer.solr_name('publisher'), [])
+    end
+
+    def language
+      fetch(Solrizer.solr_name('language'), [])
+    end
+
+    def tags
+      fetch(Solrizer.solr_name('tag'), [])
+    end
+
+    def embargo_release_date
+      self[Hydra.config.permissions.embargo.release_date]
+    end
+
+    def lease_expiration_date
+      self[Hydra.config.permissions.lease.expiration_date]
+    end
+
+    def rights
+      self[Solrizer.solr_name('rights')]
+    end
+
+    def mime_type
+      self[Solrizer.solr_name('mime_type', :stored_sortable)]
+    end
+
+    def read_groups
+      fetch(Hydra.config.permissions.read.group, [])
+    end
+
+    def visibility
+      @visibility ||= if read_groups.include? Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_PUBLIC
+                        Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+                      elsif read_groups.include? Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_AUTHENTICATED
+                        Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
+                      else
+                        Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+                      end
+    end
+
+    private
+
+      def date_field(field_name)
+        field = self[Solrizer.solr_name(field_name, :stored_sortable, type: :date)]
+        return unless field.present?
+        begin
+          Date.parse(field).to_formatted_s(:standard)
+        rescue
+          Rails.logger.info "Unable to parse date: #{field.first.inspect} for #{self['id']}"
+        end
+      end
+  end
+end

data/app/models/concerns/curation_concerns/user.rb

@@ -0,0 +1,18 @@
+module CurationConcerns::User
+  extend ActiveSupport::Concern
+  included do
+    delegate :can?, :cannot?, to: :ability
+  end
+
+  # Redefine this for more intuitive keys in Redis
+  def to_param
+    # HACK: because rails doesn't like periods in urls.
+    user_key.gsub(/\./, '-dot-')
+  end
+
+  private
+
+    def ability
+      @ability ||= ::Ability.new(self)
+    end
+end

data/app/models/concerns/curation_concerns/with_file_sets.rb

@@ -0,0 +1,37 @@
+# Copied from Curate
+module CurationConcerns
+  module WithFileSets
+    extend ActiveSupport::Concern
+
+    included do
+      # The file_sets association and its accessor methods comes from Hydra::Works::AggregatesFileSets
+      before_destroy :cleanup_file_sets
+    end
+
+    # Stopgap unil ActiveFedora ContainerAssociation includes an *_ids accessor.
+    # At the moment, this is no more efficient than calling file_sets, but hopefully that will change in the future.
+    def file_set_ids
+      file_sets.map(&:id)
+    end
+
+    def cleanup_file_sets
+      # Destroy the list source first.  This prevents each file_set from attemping to
+      # remove itself individually from the work. If hundreds of files are attached,
+      # this would take too long.
+
+      # Get list of member file_sets from Solr
+      fs = file_sets
+      list_source.destroy
+      # Remove Work from Solr after it was removed from Fedora
+      ActiveFedora::SolrService.delete(id)
+      fs.each(&:destroy)
+    end
+
+    def copy_visibility_to_files
+      file_sets.each do |fs|
+        fs.visibility = visibility
+        fs.save!
+      end
+    end
+  end
+end

data/app/models/concerns/curation_concerns/work_behavior.rb

@@ -0,0 +1,45 @@
+module CurationConcerns::WorkBehavior
+  extend ActiveSupport::Concern
+
+  include Hydra::Works::WorkBehavior
+  include CurationConcerns::HumanReadableType
+  include CurationConcerns::Noid
+  include CurationConcerns::Permissions
+  include CurationConcerns::Serializers
+  include Hydra::WithDepositor
+  include Solrizer::Common
+  include CurationConcerns::HasRepresentative
+  include CurationConcerns::WithFileSets
+  include CurationConcerns::Naming
+  include CurationConcerns::RequiredMetadata
+  include Hydra::AccessControls::Embargoable
+  include GlobalID::Identification
+
+  included do
+    property :owner, predicate: RDF::URI.new('http://opaquenamespace.org/ns/hydra/owner'), multiple: false
+    class_attribute :human_readable_short_description
+  end
+
+  module ClassMethods
+    def indexer
+      CurationConcerns::WorkIndexer
+    end
+
+    # This governs which partial to draw when you render this type of object
+    def _to_partial_path #:nodoc:
+      @_to_partial_path ||= begin
+        element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(name))
+        collection = ActiveSupport::Inflector.tableize(name)
+        "curation_concerns/#{collection}/#{element}".freeze
+      end
+    end
+  end
+
+  def to_s
+    if title.present?
+      Array(title).join(' | ')
+    else
+      'No Title'
+    end
+  end
+end

data/app/models/curation_concerns/classify_concern.rb

@@ -0,0 +1,49 @@
+require 'active_attr'
+module CurationConcerns
+  class ClassifyConcern
+    include ActiveAttr::Model
+    attribute :curation_concern_type
+
+    validates(
+      :curation_concern_type,
+      presence: true,
+      inclusion: { in: ->(record) { record.registered_curation_concern_types } }
+    )
+
+    def all_curation_concern_classes
+      registered_curation_concern_types.sort.map { |c| self.class.to_class(c) }
+    end
+
+    def registered_curation_concern_types
+      CurationConcerns.config.registered_curation_concern_types
+    end
+
+    def possible_curation_concern_types
+      registered_curation_concern_types.collect do |concern|
+        [self.class.to_class(concern).human_readable_type, concern]
+      end
+    end
+
+    def curation_concern_class
+      if possible_curation_concern_types.detect do |_name, class_name|
+        class_name == curation_concern_type
+      end
+        self.class.to_class(curation_concern_type)
+      else
+        fail 'Invalid :curation_concern_type'
+      end
+    end
+
+    # @option [String] type name of the model
+    # @return [Class] the model class
+    def self.to_class(type)
+      # TODO: we may want to allow a different (or nil) namespace
+      type.camelize.constantize
+      # begin
+      #   "::#{type.camelize}".constantize
+      # rescue NameError
+      #   "CurationConcerns::#{type}".constantize
+      # end
+    end
+  end
+end

data/app/models/curation_concerns/quick_classification_query.rb

@@ -0,0 +1,38 @@
+module CurationConcerns
+  class QuickClassificationQuery
+    attr_reader :user
+
+    # @param [User] user the current user
+    # @param [Hash] options
+    # @option options [#call] :concern_name_normalizer (ClassifyConcern.to_class) a proc that translates names to classes
+    # @option options [Array<String>] :models the options to display, defaults to everything.
+    def initialize(user, options = {})
+      @user = user
+      @concern_name_normalizer = options.fetch(:concern_name_normalizer, ClassifyConcern.method(:to_class))
+      @models = options.fetch(:models, CurationConcerns.config.registered_curation_concern_types)
+    end
+
+    def each(&block)
+      authorized_models.each(&block)
+    end
+
+    # @return true if the requested concerns is same as all avaliable concerns
+    def all?
+      models == CurationConcerns.config.registered_curation_concern_types
+    end
+
+    # @return [Array] a list of all the requested concerns that the user can create
+    def authorized_models
+      normalized_model_names.select { |klass| user.can?(:create, klass) }
+    end
+
+    private
+
+      attr_reader :concern_name_normalizer, :models
+
+      # Transform the list of requested model names into a list of class names
+      def normalized_model_names
+        models.map { |name| concern_name_normalizer.call(name) }
+      end
+  end
+end

data/app/models/single_use_link.rb

@@ -0,0 +1,34 @@
+class SingleUseLink < ActiveRecord::Base
+  validate :expiration_date_cannot_be_in_the_past
+  validate :cannot_be_destroyed
+
+  after_initialize :set_defaults
+
+  def create_for_path(path)
+    self.class.create(itemId: itemId, path: path)
+  end
+
+  def expired?
+    DateTime.now > expires
+  end
+
+  def to_param
+    downloadKey
+  end
+
+  protected
+
+    def expiration_date_cannot_be_in_the_past
+      errors.add(:expires, "can't be in the past") if expired?
+    end
+
+    def cannot_be_destroyed
+      errors[:base] << "Single Use Link has already been used" if destroyed?
+    end
+
+    def set_defaults
+      return unless new_record?
+      self.expires ||= DateTime.now.advance(hours: 24)
+      self.downloadKey ||= (Digest::SHA2.new << rand(1_000_000_000).to_s).to_s
+    end
+end

data/app/models/version_committer.rb

@@ -0,0 +1,2 @@
+class VersionCommitter < ActiveRecord::Base
+end

data/app/search_builders/curation_concerns/collection_member_search_builder.rb

@@ -1,5 +1,5 @@
 module CurationConcerns
-  class CollectionMemberSearchBuilder < Hydra::Collections::MemberSearchBuilder
+  class CollectionMemberSearchBuilder < CurationConcerns::MemberSearchBuilder
     include CurationConcerns::FilterByType
   end
 end

data/app/search_builders/curation_concerns/collection_search_builder.rb

@@ -0,0 +1,33 @@
+module CurationConcerns
+  class CollectionSearchBuilder < ::SearchBuilder
+    # Defines which search_params_logic should be used when searching for Collections
+    self.default_processor_chain = [:default_solr_parameters, :add_query_to_solr,
+                                    :add_access_controls_to_solr_params, :add_collection_filter, :some_rows, :sort_by_title]
+
+    def some_rows(solr_parameters)
+      solr_parameters[:rows] = '100'
+    end
+
+    def add_collection_filter(solr_parameters)
+      solr_parameters[:fq] ||= []
+      solr_parameters[:fq] << ActiveFedora::SolrQueryBuilder.construct_query_for_rel(has_model: ::Collection.to_class_uri)
+    end
+
+    # Sort results by title if no query was supplied.
+    # This overrides the default 'relevance' sort.
+    def sort_by_title(solr_parameters)
+      return if solr_parameters[:q]
+      solr_parameters[:sort] ||= "#{sort_field} asc"
+    end
+
+    attr_writer :discovery_perms
+
+    def discovery_permissions
+      @discovery_perms || super
+    end
+
+    def sort_field
+      Solrizer.solr_name('title', :sortable)
+    end
+  end
+end

data/app/search_builders/curation_concerns/member_search_builder.rb

@@ -0,0 +1,17 @@
+module CurationConcerns
+  class MemberSearchBuilder < ::SearchBuilder
+    class_attribute :from_field
+    self.from_field = 'member_ids_ssim'
+
+    # Defines which search_params_logic should be used when searching for Collection members
+    self.default_processor_chain += [:include_collection_ids]
+
+    delegate :collection, to: :scope
+
+    # include filters into the query to only include the collection memebers
+    def include_collection_ids(solr_parameters)
+      solr_parameters[:fq] ||= []
+      solr_parameters[:fq] << "{!join from=#{from_field} to=id}id:#{collection.id}"
+    end
+  end
+end

data/app/services/curation_concerns/derivative_path.rb

@@ -0,0 +1,49 @@
+module CurationConcerns
+  class DerivativePath
+    class << self
+      # Path on file system where derivative file is stored
+      def derivative_path_for_reference(object, destination_name)
+        destination_name = destination_name.gsub(/^original_file_/, '')
+        derivative_path(object, extension_for(destination_name), destination_name)
+      end
+
+      # @return [Array<String>] Array of paths to derivatives for this object.
+      def derivatives_for_reference(object)
+        Dir.glob(root_path(object).join("*")).select do |path|
+          path.start_with?(path_prefix(object).to_s)
+        end
+      end
+
+      private
+
+        # @param [#id] object Object whose ID is used to generate root path
+        # @return [String] Returns the root path where derivatives will be generated into.
+        def root_path(object)
+          Pathname.new(derivative_path(object, "", "")).dirname
+        end
+
+        # @return <Pathname> Full prefix of the path for object.
+        def path_prefix(object)
+          Pathname.new(CurationConcerns.config.derivatives_path).join(pair_path(object.id))
+        end
+
+        def derivative_path(object, extension, destination_name)
+          file_name = destination_name + extension
+          "#{path_prefix(object)}-#{file_name}"
+        end
+
+        def pair_path(id)
+          id.split('').each_slice(2).map(&:join).join('/')
+        end
+
+        def extension_for(destination_name)
+          case destination_name
+          when 'thumbnail'
+            ".#{MIME::Types.type_for('jpg').first.extensions.first}"
+          else
+            ".#{destination_name}"
+          end
+        end
+    end
+  end
+end