curation_concerns 0.1.0 → 0.2.0

data/app/presenters/curation_concerns/collection_presenter.rb

@@ -1,40 +1,22 @@
 module CurationConcerns
   class CollectionPresenter
-    include Hydra::Presenter
-    include ActionView::Helpers::NumberHelper
+    include ModelProxy
+    include PresentsAttributes
+    attr_accessor :solr_document, :current_ability
 
-    self.model_class = ::Collection
-    # Terms is the list of fields displayed by app/views/collections/_show_descriptions.html.erb
-    self.terms = [:title, :total_items, :size, :resource_type, :description, :creator, :contributor,
-                  :tag, :rights, :publisher, :date_created, :subject, :language, :identifier,
-                  :based_near, :related_url]
-
-    # Depositor and permissions are not displayed in app/views/collections/_show_descriptions.html.erb
-    # so don't include them in `terms'.
-    # delegate :depositor, :permissions, to: :model
-
-    def terms_with_values
-      terms.select { |t| self[t].present? }
-    end
-
-    def [](key)
-      case key
-        when :size
-          size
-        when :total_items
-          total_items
-        else
-          super
-      end
+    # @param [SolrDocument] solr_document
+    # @param [Ability] current_ability
+    def initialize(solr_document, current_ability)
+      @solr_document = solr_document
+      @current_ability = current_ability
     end
 
-    def size
-      number_to_human_size(model.bytes)
-    end
-
-    def total_items
-      model.members.count
-    end
+    # CurationConcern methods
+    delegate :stringify_keys, :human_readable_type, :collection?, :representative_id,
+             to: :solr_document
 
+    # Metadata Methods
+    delegate :title, :description, :creator, :contributor, :subject, :publisher, :language,
+             :embargo_release_date, :lease_expiration_date, :rights, to: :solr_document
   end
 end

data/app/presenters/curation_concerns/embargo_presenter.rb

@@ -0,0 +1,26 @@
+module CurationConcerns
+  # Presents embargoed objects
+  class EmbargoPresenter
+    include ModelProxy
+    attr_accessor :solr_document
+
+    delegate :human_readable_type, :visibility, :to_s, to: :solr_document
+
+    # @param [SolrDocument] solr_document
+    def initialize(solr_document)
+      @solr_document = solr_document
+    end
+
+    def embargo_release_date
+      Date.parse(solr_document.embargo_release_date).to_formatted_s(:rfc822)
+    end
+
+    def visibility_after_embargo
+      solr_document.fetch('visibility_after_embargo_ssim', []).first
+    end
+
+    def embargo_history
+      solr_document['embargo_history_ssim']
+    end
+  end
+end

data/app/presenters/curation_concerns/file_set_presenter.rb

@@ -0,0 +1,34 @@
+module CurationConcerns
+  class FileSetPresenter
+    include ModelProxy
+    include PresentsAttributes
+    attr_accessor :solr_document, :current_ability
+
+    # @param [SolrDocument] solr_document
+    # @param [Ability] current_ability
+    def initialize(solr_document, current_ability)
+      @solr_document = solr_document
+      @current_ability = current_ability
+    end
+
+    # CurationConcern methods
+    delegate :stringify_keys, :human_readable_type, :collection?, :image?, :video?,
+             :audio?, :pdf?, :office_document?, :representative_id, :to_s, to: :solr_document
+
+    # Methods used by blacklight helpers
+    delegate :has?, :first, :fetch, to: :solr_document
+
+    # Metadata Methods
+    delegate :title, :description, :creator, :contributor, :subject, :publisher,
+             :language, :date_uploaded, :rights,
+             :embargo_release_date, :lease_expiration_date, to: :solr_document
+
+    def page_title
+      Array(solr_document['label_tesim']).first
+    end
+
+    def link_name
+      current_ability.can?(:read, id) ? Array(solr_document['label_tesim']).first : 'File'
+    end
+  end
+end

data/app/presenters/curation_concerns/lease_presenter.rb

@@ -0,0 +1,30 @@
+module CurationConcerns
+  # Presents leased objects
+  class LeasePresenter
+    include ModelProxy
+    attr_accessor :solr_document
+
+    delegate :human_readable_type, :visibility, :to_s, to: :solr_document
+
+    # @param [SolrDocument] solr_document
+    def initialize(solr_document)
+      @solr_document = solr_document
+    end
+
+    def lease_expiration_date
+      if solr_document.lease_expiration_date
+        Date.parse(solr_document.lease_expiration_date).to_formatted_s(:rfc822)
+      else
+        solr_document.keys
+      end
+    end
+
+    def visibility_after_lease
+      solr_document.fetch('visibility_after_lease_ssim', []).first
+    end
+
+    def lease_history
+      solr_document['lease_history_ssim']
+    end
+  end
+end

data/app/presenters/curation_concerns/model_proxy.rb

@@ -0,0 +1,27 @@
+module CurationConcerns
+  # Provide the ActiveModel methods so that this object routes the same as the
+  # object represented by the solr document.
+  module ModelProxy
+    delegate :to_param, :to_key, :id, to: :solr_document
+
+    delegate :model_name, to: :_delegated_to
+
+    def to_partial_path
+      _delegated_to._to_partial_path
+    end
+
+    def persisted?
+      true
+    end
+
+    def to_model
+      self
+    end
+
+    private
+
+      def _delegated_to
+        @_delegated_to ||= solr_document.fetch(Solrizer.solr_name('has_model', :symbol)).first.constantize
+      end
+  end
+end

data/app/presenters/curation_concerns/permission_badge.rb

@@ -0,0 +1,61 @@
+module CurationConcerns
+  class PermissionBadge
+    include ActionView::Helpers::TagHelper
+
+    def initialize(solr_document)
+      @solr_document = solr_document
+    end
+
+    # Draws a span tag with styles for a bootstrap label
+    def render
+      content_tag(:span, link_title, title: link_title, class: "label #{dom_label_class}")
+    end
+
+    private
+
+      def dom_label_class
+        if open_access_with_embargo?
+          'label-warning'
+        elsif open_access?
+          'label-success'
+        elsif registered?
+          'label-info'
+        else
+          'label-danger'
+        end
+      end
+
+      def link_title
+        if open_access_with_embargo?
+          'Open Access with Embargo'
+        elsif open_access?
+          'Open Access'
+        elsif registered?
+          I18n.translate('curation_concerns.institution_name')
+        else
+          'Private'
+        end
+      end
+
+      def open_access_with_embargo?
+        if @open_access_with_embargo.nil?
+          @open_access_with_embargo = open_access? && embargo?
+        end
+        @open_access_with_embargo
+      end
+
+      def open_access?
+        @open_access = @solr_document.visibility == Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC if @open_access.nil?
+        @open_access
+      end
+
+      def registered?
+        @registered = @solr_document.visibility == Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED if @registered.nil?
+        @registered
+      end
+
+      def embargo?
+        @solr_document.embargo_release_date.present?
+      end
+  end
+end

data/app/presenters/curation_concerns/presenter_factory.rb

@@ -0,0 +1,45 @@
+module CurationConcerns
+  class PresenterFactory
+    class << self
+      # @param [Array] ids the list of ids to load
+      # @param [Class] klass the class of presenter to make
+      # @return [Array] presenters for the generic files in order of the ids
+      def build_presenters(ids, klass, ability)
+        new(ids, klass, ability).build
+      end
+    end
+
+    attr_reader :ids, :klass, :ability
+
+    def initialize(ids, klass, ability)
+      @ids = ids
+      @klass = klass
+      @ability = ability
+    end
+
+    def build
+      return [] if ids.blank?
+      docs = load_docs
+      ids.map do |id|
+        solr_doc = docs.find { |doc| doc.id == id }
+        klass.new(solr_doc, ability) if solr_doc
+      end.compact
+    end
+
+    private
+
+      # @return [Array<SolrDocument>] a list of solr documents in no particular order
+      def load_docs
+        query("{!terms f=id}#{ids.join(',')}", rows: 1000)
+          .map { |res| SolrDocument.new(res) }
+      end
+
+      # Query solr using POST so that the query doesn't get too large for a URI
+      def query(query, args = {})
+        args.merge!(q: query, qt: 'standard')
+        conn = ActiveFedora::SolrService.instance.conn
+        result = conn.post('select', data: args)
+        result.fetch('response').fetch('docs')
+      end
+  end
+end

data/app/presenters/curation_concerns/presents_attributes.rb

@@ -0,0 +1,25 @@
+module CurationConcerns
+  module PresentsAttributes
+    ##
+    # Present the attribute as an HTML table row.
+    #
+    # @param [Hash] options
+    # @option options [true, false] :catalog_search_link return a link to a catalog search for that text if true
+    # @option options [String] :search_field If the method_name of the attribute is different than
+    #   how the attribute name should appear on the search URL,
+    #   you can explicitly set the URL's search field name
+    # @option options [String] :label The default label for the field if no translation is found
+    def attribute_to_html(field, options = {})
+      return unless respond_to?(field)
+      AttributeRenderer.new(field, send(field), options).render
+    end
+
+    def permission_badge
+      permission_badge_class.new(solr_document).render
+    end
+
+    def permission_badge_class
+      PermissionBadge
+    end
+  end
+end

data/app/presenters/curation_concerns/version_list_presenter.rb

@@ -0,0 +1,18 @@
+module CurationConcerns
+  class VersionListPresenter
+    def initialize(version_list)
+      @raw_list = version_list
+    end
+
+    delegate :each, to: :wrapped_list
+
+    private
+
+      def wrapped_list
+        @wrapped_list ||=
+            @raw_list.map { |v| CurationConcerns::VersionPresenter.new(v) } # wrap each item in a presenter
+            .sort { |a, b| b.version.created <=> a.version.created } # sort list of versions based on creation date
+            .tap { |l| l.first.try(:current!) } # set the first version to the current version
+      end
+  end
+end

data/app/presenters/curation_concerns/version_presenter.rb

@@ -0,0 +1,27 @@
+module CurationConcerns
+  class VersionPresenter
+    attr_reader :version, :current
+
+    def initialize(version)
+      @version = version
+      @current = false
+    end
+
+    delegate :label, :uri, to: :version
+    alias_method :current?, :current
+
+    def current!
+      @current = true
+    end
+
+    def created
+      @created ||= version.created.to_time.to_formatted_s(:long_ordinal)
+      @created
+    end
+
+    def committer
+      vc = VersionCommitter.where(version_id: @version.uri)
+      vc.empty? ? nil : vc.first.committer_login
+    end
+  end
+end

data/app/presenters/curation_concerns/work_show_presenter.rb

@@ -0,0 +1,33 @@
+module CurationConcerns
+  class WorkShowPresenter
+    include ModelProxy
+    include PresentsAttributes
+    attr_accessor :solr_document, :current_ability
+
+    # @param [SolrDocument] solr_document
+    # @param [Ability] current_ability
+    def initialize(solr_document, current_ability)
+      @solr_document = solr_document
+      @current_ability = current_ability
+    end
+
+    def page_title
+      solr_document.title
+    end
+
+    # CurationConcern methods
+    delegate :stringify_keys, :human_readable_type, :collection?, :representative_id, :to_s,
+             to: :solr_document
+
+    # Metadata Methods
+    delegate :title, :description, :creator, :contributor, :subject, :publisher, :language,
+             :embargo_release_date, :lease_expiration_date, :rights, to: :solr_document
+
+    def file_presenters
+      @file_sets ||= begin
+        ids = solr_document.fetch('file_set_ids_ssim', [])
+        PresenterFactory.build_presenters(ids, FileSetPresenter, current_ability)
+      end
+    end
+  end
+end

data/app/renderers/curation_concerns/attribute_renderer.rb

@@ -0,0 +1,75 @@
+module CurationConcerns
+  class AttributeRenderer
+    include ActionView::Helpers::UrlHelper
+    include ActionView::Helpers::TranslationHelper
+    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'>)
+      Array(values).each do |value|
+        markup << %(<li class="attribute #{field}">#{attribute_value_to_html(value)}</li>\n)
+      end
+      markup << %(</ul></td></tr>)
+      markup.html_safe
+    end
+
+    private
+
+      def label
+        translate(
+          :"blacklight.search.fields.show.#{field}",
+          default: [:"blacklight.search.fields.#{field}", options.fetch(:label, field.to_s.humanize)])
+      end
+
+      def attribute_value_to_html(value)
+        if field == :rights
+          rights_attribute_to_html(value)
+        else
+          li_value(value)
+        end
+      end
+
+      def search_field
+        options.fetch(:search_field, field)
+      end
+
+      def li_value(value)
+        link_to_if(options[:catalog_search_link], ERB::Util.h(value),
+                   search_path(value))
+      end
+
+      def search_path(value)
+        Rails.application.routes.url_helpers.catalog_index_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/search_builders/curation_concerns/deactivated_embargo_search_builder.rb

@@ -0,0 +1,10 @@
+module CurationConcerns
+  class DeactivatedEmbargoSearchBuilder < EmbargoSearchBuilder
+    self.default_processor_chain += [:with_deactivated_embargos]
+
+    def with_deactivated_embargos(solr_params)
+      solr_params[:fq] ||= []
+      solr_params[:fq] = 'embargo_history_ssim:*'
+    end
+  end
+end

data/app/search_builders/curation_concerns/deactivated_lease_search_builder.rb

@@ -0,0 +1,10 @@
+module CurationConcerns
+  class DeactivatedLeaseSearchBuilder < LeaseSearchBuilder
+    self.default_processor_chain += [:with_deactivated_leases]
+
+    def with_deactivated_leases(solr_params)
+      solr_params[:fq] ||= []
+      solr_params[:fq] = 'lease_history_ssim:*'
+    end
+  end
+end

data/app/search_builders/curation_concerns/embargo_search_builder.rb

@@ -0,0 +1,23 @@
+module CurationConcerns
+  # Finds embargoed objects
+  class EmbargoSearchBuilder < Blacklight::SearchBuilder
+    self.default_processor_chain = [:with_pagination, :with_sorting, :only_active_embargoes]
+    def initialize(scope)
+      super(true, scope)
+    end
+
+    # TODO: add more complex pagination
+    def with_pagination(solr_params)
+      solr_params[:rows] = 1000
+    end
+
+    def with_sorting(solr_params)
+      solr_params[:sort] = 'embargo_release_date_dtsi desc'
+    end
+
+    def only_active_embargoes(solr_params)
+      solr_params[:fq] ||= []
+      solr_params[:fq] = 'embargo_release_date_dtsi:*'
+    end
+  end
+end

data/app/search_builders/curation_concerns/expired_embargo_search_builder.rb

@@ -0,0 +1,11 @@
+module CurationConcerns
+  # Finds embargoed objects with release dates in the past
+  class ExpiredEmbargoSearchBuilder < EmbargoSearchBuilder
+    self.default_processor_chain += [:only_expired_embargoes]
+
+    def only_expired_embargoes(solr_params)
+      solr_params[:fq] ||= []
+      solr_params[:fq] = 'embargo_release_date_dtsi:[* TO NOW]'
+    end
+  end
+end

data/app/search_builders/curation_concerns/expired_lease_search_builder.rb

@@ -0,0 +1,11 @@
+module CurationConcerns
+  # Finds embargoed objects with release dates in the past
+  class ExpiredLeaseSearchBuilder < LeaseSearchBuilder
+    self.default_processor_chain += [:only_expired_leases]
+
+    def only_expired_leases(solr_params)
+      solr_params[:fq] ||= []
+      solr_params[:fq] = 'lease_expiration_date_dtsi:[* TO NOW]'
+    end
+  end
+end

data/app/search_builders/curation_concerns/lease_search_builder.rb

@@ -0,0 +1,23 @@
+module CurationConcerns
+  # Finds objects under lease
+  class LeaseSearchBuilder < Blacklight::SearchBuilder
+    self.default_processor_chain = [:with_pagination, :with_sorting, :only_active_leases]
+    def initialize(scope)
+      super(true, scope)
+    end
+
+    # TODO: add more complex pagination
+    def with_pagination(solr_params)
+      solr_params[:rows] = 1000
+    end
+
+    def with_sorting(solr_params)
+      solr_params[:sort] = 'lease_expiration_date_dtsi desc'
+    end
+
+    def only_active_leases(solr_params)
+      solr_params[:fq] ||= []
+      solr_params[:fq] = 'lease_expiration_date_dtsi:*'
+    end
+  end
+end

data/app/search_builders/curation_concerns/search_builder.rb

@@ -1,18 +1,13 @@
 class CurationConcerns::SearchBuilder < Hydra::SearchBuilder
-  include BlacklightAdvancedSearch::AdvancedSearchBuilder 
+  include BlacklightAdvancedSearch::AdvancedSearchBuilder
   include Hydra::Collections::SearchBehaviors
 
-  def only_generic_files_and_curation_concerns(solr_parameters)
-    solr_parameters[:fq] ||= []
-    types_to_include = CurationConcerns.configuration.registered_curation_concern_types.dup
-    types_to_include << "Collection"
-    formatted_type_names = types_to_include.map{|class_name| "\"#{class_name}\""}.join(" ")
-
-    solr_parameters[:fq] << "#{Solrizer.solr_name("has_model", :symbol)}:(#{formatted_type_names})"
+  def only_file_sets(solr_parameters)
+    solr_parameters[:fq] << ActiveFedora::SolrQueryBuilder.construct_query_for_rel(has_model: FileSet.to_class_uri)
+  end
 
-    # CurationConcerns.configuration.registered_curation_concern_types.each do |curation_concern_class_name|
-    #   solr_parameters[:fq] << "#{Solrizer.solr_name("has_model", :symbol)}:(\"GenericFile\" \"Collection\")"
-    # end
+  def find_one(solr_parameters)
+    solr_parameters[:fq] << "_query_:\"{!raw f=id}#{blacklight_params.fetch(:id)}\""
   end
 
   # Override Hydra::AccessControlsEnforcement (or Hydra::PolicyAwareAccessControlsEnforcement)
@@ -24,11 +19,10 @@ class CurationConcerns::SearchBuilder < Hydra::SearchBuilder
 
   # show only files with edit permissions in lib/hydra/access_controls_enforcement.rb apply_gated_discovery
   def discovery_permissions
-    return ["edit"] if blacklight_params[:works] == 'mine'
+    return ['edit'] if blacklight_params[:works] == 'mine'
     super
   end
 
-
   # This is included as part of blacklight search solr params logic
   def filter_models(solr_parameters)
     solr_parameters[:fq] ||= []
@@ -36,14 +30,14 @@ class CurationConcerns::SearchBuilder < Hydra::SearchBuilder
   end
 
   def work_clauses
-    return [] if blacklight_params.has_key?(:f) && Array(blacklight_params[:f][:generic_type_sim]).include?('Collection')
-    CurationConcerns.configuration.registered_curation_concern_types.map(&:constantize).map do |klass|
+    return [] if blacklight_params.key?(:f) && Array(blacklight_params[:f][:generic_type_sim]).include?('Collection')
+    CurationConcerns.config.registered_curation_concern_types.map(&:constantize).map do |klass|
       ActiveFedora::SolrQueryBuilder.construct_query_for_rel(has_model: klass.to_class_uri)
     end
   end
 
   def collection_clauses
-    return [] if blacklight_params.has_key?(:f) && Array(blacklight_params[:f][:generic_type_sim]).include?('Work')
+    return [] if blacklight_params.key?(:f) && Array(blacklight_params[:f][:generic_type_sim]).include?('Work')
     [ActiveFedora::SolrQueryBuilder.construct_query_for_rel(has_model: ::Collection.to_class_uri)]
   end
 end

data/app/services/curation_concerns/curation_concern.rb

@@ -1,14 +1,9 @@
 module CurationConcerns
   module CurationConcern
-
     def self.actor(curation_concern, *args)
       actor_identifier = curation_concern.class.to_s.split('::').last
       klass = "CurationConcerns::#{actor_identifier}Actor".constantize
       klass.new(curation_concern, *args)
     end
-
-    def self.attach_file_to_generic_file(generic_file, user, file_to_attach)
-      CurationConcerns::GenericFileActor.new(generic_file, user).create_content(file_to_attach)
-    end
   end
 end