curation_concerns 0.1.0

data/app/controllers/leases_controller.rb

@@ -0,0 +1,5 @@
+class LeasesController < ApplicationController
+  include CurationConcerns::ManagesEmbargoes
+  include CurationConcerns::LeasesControllerBehavior
+  include Hydra::Collections::AcceptsBatches
+end

data/app/controllers/registrations_controller.rb

@@ -0,0 +1,20 @@
+class RegistrationsController < Devise::RegistrationsController
+  include CurationConcerns::ThemedLayoutController
+  with_themed_layout '1_column'
+
+  protected
+
+  # def after_update_path_for(resource)
+  #   resource.update_column(:user_does_not_require_profile_update, true)
+  #   super
+  # end
+
+  # def resource_class
+  #   Account
+  # end
+
+  # def sign_up(resource_name, resource)
+  #   sign_in(resource_name, resource.user)
+  # end
+
+end

data/app/controllers/sessions_controller.rb

@@ -0,0 +1,4 @@
+class SessionsController < Devise::SessionsController
+  include CurationConcerns::ThemedLayoutController
+  with_themed_layout '1_column'
+end

data/app/datastreams/curation_concerns/generic_work_rdf_properties.rb

@@ -0,0 +1,57 @@
+module CurationConcerns::GenericWorkRdfProperties
+  extend ActiveSupport::Concern
+  included do
+    property :part_of, predicate: RDF::DC.isPartOf
+    property :resource_type, predicate: RDF::DC.type do |index|
+      index.as :stored_searchable, :facetable
+    end
+    property :title, predicate: RDF::DC.title do |index|
+      index.as :stored_searchable, :facetable
+    end
+    property :creator, predicate: RDF::DC.creator do |index|
+      index.as :stored_searchable, :facetable
+    end
+    property :contributor, predicate: RDF::DC.contributor do |index|
+      index.as :stored_searchable, :facetable
+    end
+    property :description, predicate: RDF::DC.description do |index|
+      index.type :text
+      index.as :stored_searchable
+    end
+    property :relation, predicate: RDF::DC.relation
+    property :rights, predicate: RDF::DC.rights do |index|
+      index.as :stored_searchable
+    end
+    property :publisher, predicate: RDF::DC.publisher do |index|
+      index.as :stored_searchable, :facetable
+    end
+    property :created, predicate: RDF::DC.created
+
+    property :date, predicate: RDF::DC.date do |index|
+      index.type :date
+      index.as :stored_sortable
+    end
+    property :date_uploaded, predicate: RDF::DC.dateSubmitted do |index|
+      index.type :date
+      index.as :stored_sortable
+    end
+    property :date_modified, predicate: RDF::DC.modified do |index|
+      index.type :date
+      index.as :stored_sortable
+    end
+    property :subject, predicate: RDF::DC.subject do |index|
+      index.as :stored_searchable, :facetable
+    end
+    property :language, predicate: RDF::DC.language do |index|
+      index.as :stored_searchable, :facetable
+    end
+    property :identifier, predicate: RDF::DC.identifier do |index|
+      index.as :stored_searchable
+    end
+    property :bibliographic_citation, predicate: RDF::DC.bibliographicCitation
+    property :source, predicate: RDF::DC.source
+    property :coverage, predicate: RDF::DC.coverage
+    property :type, predicate: RDF::DC.type
+    property :content_format, predicate: RDF::DC.format
+  end
+end

data/app/datastreams/generic_work_metadata.rb

@@ -0,0 +1,3 @@
+class GenericWorkMetadata < ActiveFedora::NtriplesRDFDatastream
+  include CurationConcerns::GenericWorkRdfProperties
+end

data/app/forms/curation_concerns/forms/collection_edit_form.rb

@@ -0,0 +1,17 @@
+module CurationConcerns
+  module Forms
+    class CollectionEditForm
+      include HydraEditor::Form
+      self.model_class = ::Collection
+      self.terms = [:resource_type, :title, :creator, :contributor, :description, :tag, :rights,
+                  :publisher, :date_created, :subject, :language, :identifier, :based_near, :related_url]
+
+      # Test to see if the given field is required
+      # @param [Symbol] key a field
+      # @return [Boolean] is it required or not
+      def required?(key)
+        model_class.validators_on(key).any?{|v| v.kind_of? ActiveModel::Validations::PresenceValidator}
+      end
+    end
+  end
+end

data/app/forms/curation_concerns/forms/generic_file_edit_form.rb

@@ -0,0 +1,15 @@
+module CurationConcerns
+  module Forms
+    class GenericFileEditForm < GenericFilePresenter
+      include HydraEditor::Form
+      include HydraEditor::Form::Permissions
+      self.required_fields = [:title, :creator, :tag, :rights]
+
+      # def self.build_permitted_params
+      #   super.merge {
+      # :visibility, :visibility_during_embargo, :embargo_release_date, :visibility_after_embargo, :visibility_during_lease, :lease_expiration_date, :visibility_after_lease }
+      # end
+    end
+  end
+end
+

data/app/forms/curation_concerns/forms/generic_work_edit_form.rb

@@ -0,0 +1,9 @@
+module CurationConcerns
+  module Forms
+    class GenericWorkEditForm < GenericWorkPresenter
+      include HydraEditor::Form
+      include HydraEditor::Form::Permissions
+      self.required_fields = [:title, :creator, :tag, :rights]
+    end
+  end
+end

data/app/helpers/curation_concerns/ability_helper.rb

@@ -0,0 +1,46 @@
+module CurationConcerns
+  module AbilityHelper
+    # Returns true if can create at least one type of work
+    def can_ever_create_works?
+      can = false
+      CurationConcerns.configuration.curation_concerns.each do |curation_concern_type|
+        break if can
+        can = can?(:create,curation_concern_type)
+      end
+      return can
+    end
+
+    def visibility_options(variant)
+      options = [
+          ['Open Access',Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC],
+          [t('curation_concerns.institution_name'),Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED],
+          ['Private',Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE]
+      ]
+      case variant
+        when :restrict
+          options.delete_at(0)
+          options.reverse!
+        when :loosen
+          options.delete_at(2)
+      end
+      return options
+    end
+
+    def visibility_badge(value)
+      case value
+        when Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+          content_tag :span, "Open Access", class:"label label-success"
+        when Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
+          content_tag :span, t('sufia.institution_name'), class:"label label-info"
+        when Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+          content_tag :span, "Private", class:"label label-danger"
+        when Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO
+          content_tag :span, "Embargo", class:"label label-warning"
+        when Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE
+          content_tag :span, "Lease", class:"label label-warning"
+        else
+          content_tag :span, value, class:"label label-info"
+      end
+    end
+  end
+end

data/app/helpers/curation_concerns/attribute_helper.rb

@@ -0,0 +1,67 @@
+module CurationConcerns
+  module AttributeHelper
+
+    # If options[:catalog_search_link] is false,
+    # it will return the attribute value as text.
+    # If options[:catalog_search_link] is true,
+    # it will return a link to a catalog search for that text.
+    #
+    # 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 using
+    # options[:search_field].
+    def curation_concern_attribute_to_html(curation_concern, method_name, label = nil, options = {})
+      if curation_concern.respond_to?(method_name)
+        markup = ""
+        label ||= derived_label_for(curation_concern, method_name)
+        subject = curation_concern.send(method_name)
+        return markup if !subject.present? && !options[:include_empty]
+        markup << %(<tr><th>#{label}</th>\n<td><ul class='tabular'>)
+        [subject].flatten.compact.each do |value|
+          if method_name == :rights
+            # 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.
+            parsedUri = URI.parse(value) rescue nil
+            if parsedUri.nil?
+              markup << %(<li class="attribute #{method_name}">#{h(value)}</li>\n)
+            else
+              markup << %(<li class="attribute #{method_name}"><a href=#{h(value)} target="_blank"> #{h(CurationConcerns.config.cc_licenses_reverse[value])}</a></li>\n)
+            end
+          else
+            search_field = options[:search_field] || method_name
+            li_value = link_to_if(options[:catalog_search_link], h(value), main_app.catalog_index_path(search_field: search_field, q: h(value)))
+            markup << %(<li class="attribute #{method_name}"> #{li_value} </li>\n)
+          end
+        end
+        markup << %(</ul></td></tr>)
+        markup.html_safe
+      end
+    end
+
+    def permission_badge_for(curation_concern, solr_document = nil)
+      solr_document ||= curation_concern.to_solr
+      dom_label_class, link_title = extract_dom_label_class_and_link_title(solr_document)
+      %(<span class="label #{dom_label_class}" title="#{link_title}">#{link_title}</span>).html_safe
+    end
+
+    private
+      def extract_dom_label_class_and_link_title(document)
+        hash = document.stringify_keys
+        dom_label_class, link_title = "label-danger", "Private"
+        if hash[Hydra.config.permissions.read.group].present?
+          if hash[Hydra.config.permissions.read.group].include?('public')
+            if hash[Hydra.config.permissions.embargo.release_date].present?
+              dom_label_class, link_title = 'label-warning', 'Open Access with Embargo'
+            else
+              dom_label_class, link_title = 'label-success', 'Open Access'
+            end
+          elsif hash[Hydra.config.permissions.read.group].include?('registered')
+            dom_label_class, link_title = "label-info", t('sufia.institution_name')
+          end
+        end
+        return dom_label_class, link_title
+      end
+
+
+  end
+end

data/app/helpers/curation_concerns/catalog_helper.rb

@@ -0,0 +1,38 @@
+module CurationConcerns::CatalogHelper
+  def type_tab(label, key=label)
+    if params[:f] && params[:f][type_field] == [key]
+      content_tag(:li, link_to(label, "#"), class: "active")
+    else
+      facet_solr_field = facet_configuration_for_field(type_field)
+      path = search_action_path(add_facet_params_and_redirect(type_field, key))
+      # local_params = params.dup
+      # local_facet_params = local_params[:f] || {}.with_indifferent_access
+      # local_params[:f] = local_facet_params.select{|k,_| k != type_field }
+      # puts "local #{local_params}"
+      # path = add_facet_params(type_field, key, local_params)
+      content_tag(:li, link_to(label, path))
+    end
+  end
+
+  def all_type_tab(label = t('curation_concerns.catalog.index.type_tabs.all'))
+    if params[:f] && params[:f][type_field]
+      facet_solr_field = facet_configuration_for_field(type_field)
+      new_params = remove_facet_params(type_field, params[:f][type_field].first)
+
+      # Delete any request params from facet-specific action, needed
+      # to redir to index action properly.
+      new_params.except! *Blacklight::Solr::FacetPaginator.request_keys.values
+      path = search_action_path(new_params)
+      content_tag(:li, link_to(label, path))
+    else
+      content_tag(:li, link_to(label, '#'), class: "active")
+    end
+  end
+
+  private
+
+    def type_field
+      Solrizer.solr_name("generic_type", :facetable)
+    end
+
+end

data/app/helpers/curation_concerns/collections_helper.rb

@@ -0,0 +1,63 @@
+module CurationConcerns::CollectionsHelper
+  def has_collection_search_parameters?
+    params[:cq].present?
+  end
+
+  def collection_modal_id(collectible)
+    "#{collectible.to_param.gsub(/:/, '-')}-modal"
+  end
+
+  def link_to_select_collection(collectible, opts={})
+    html_class = opts[:class]
+    link_to '#', data: { toggle: "modal", target: '#' + collection_modal_id(collectible) },
+      class: "add-to-collection #{html_class}", title: "Add #{collectible.human_readable_type} to Collection" do
+      icon('plus-sign') + ' Add to a Collection'
+    end
+  end
+
+  # override hydra-collections
+  def link_to_remove_from_collection(document, label = 'Remove From Collection')
+    link_to collections.collection_path(@collection.id, collection: { members: 'remove'},
+                batch_document_ids: [ document.id ]), method: :put do
+      icon('minus-sign') + ' ' + label
+    end
+  end
+
+  def icon(type)
+    content_tag :span, '', class: "glyphicon glyphicon-#{type}"
+  end
+
+  def collection_options_for_select(exclude_item = nil)
+    options_for_select(available_collections(exclude_item))
+  end
+
+  private
+    # return a list of collections for the current user with the exception of the passed in collection
+    def available_collections(exclude_item)
+      if exclude_item
+        collection_options.reject {|n| n.last == exclude_item.id}
+      else
+        collection_options
+      end
+    end
+
+
+    def collection_options
+      @collection_options ||= current_users_collections
+    end
+
+    # Defaults to returning a list of all collections.
+    # If you have implement User.collections, the results of that will be used.
+    def current_users_collections
+      if current_user.respond_to?(:collections)
+        current_user.collections.map { |c| [c.title.join(', '), c.id] }
+      else
+        query = ActiveFedora::SolrQueryBuilder.construct_query_for_rel(has_model: Collection.to_class_uri)
+        ActiveFedora::SolrService.query(query, fl: 'title_tesim id',
+                                        rows: 1000).map do |r|
+          [r['title_tesim'].join(', '), r['id']]
+        end.sort { |a, b| a.first <=> b.first }
+      end
+    end
+
+end

data/app/helpers/curation_concerns/embargo_helper.rb

@@ -0,0 +1,17 @@
+module CurationConcerns
+  module EmbargoHelper
+
+    def assets_with_expired_embargoes
+      @assets_with_expired_embargoes ||= EmbargoService.assets_with_expired_embargoes
+    end
+
+    def assets_under_embargo
+      @assets_under_embargo ||= EmbargoService.assets_under_embargo
+    end
+
+    def assets_with_deactivated_embargoes
+      @assets_with_deactivated_embargoes ||= EmbargoService.assets_with_deactivated_embargoes
+    end
+
+  end
+end

data/app/helpers/curation_concerns/generic_file_helper.rb

@@ -0,0 +1,19 @@
+module CurationConcerns::GenericFileHelper
+
+  def generic_file_title(gf)
+    can?(:read, gf) ? gf.to_s : "File"
+  end
+
+  def generic_file_link_name(gf)
+    can?(:read, gf) ? gf.filename : "File"
+  end
+
+  def parent_path(parent)
+    if parent.is_a?(Collection)
+      main_app.collection_path(parent)
+    else
+      polymorphic_path([main_app, :curation_concerns, parent])
+    end
+  end
+    
+end

data/app/helpers/curation_concerns/lease_helper.rb

@@ -0,0 +1,18 @@
+module CurationConcerns
+  module LeaseHelper
+
+    def assets_with_expired_leases
+      @assets_with_expired_leases ||= LeaseService.assets_with_expired_leases
+    end
+
+    def assets_under_lease
+      @assets_under_lease ||= LeaseService.assets_under_lease
+    end
+
+    def assets_with_deactivated_leases
+      @assets_with_deactivated_leases ||= LeaseService.assets_with_deactivated_leases
+    end
+
+  end
+end
+

data/app/helpers/curation_concerns/main_app_helpers.rb

@@ -0,0 +1,13 @@
+module CurationConcerns::MainAppHelpers
+  include CurationConcerns::TitleHelper
+  include CurationConcerns::AttributeHelper
+  include CurationConcerns::GenericFileHelper
+  include CurationConcerns::SearchPathsHelper
+  include CurationConcerns::RenderConstraintsHelper
+  include CurationConcerns::AbilityHelper
+  include CurationConcerns::ThumbnailHelper
+  include CurationConcerns::UrlHelper
+  include CurationConcerns::EmbargoHelper
+  include CurationConcerns::LeaseHelper
+  include CurationConcerns::CollectionsHelper
+end

data/app/helpers/curation_concerns/render_constraints_helper.rb

@@ -0,0 +1,42 @@
+module CurationConcerns
+  module RenderConstraintsHelper
+    # Overridden to remove the 'search_field' tag from the localized params when the query is cleared.
+    # This is because unlike Blacklight, there is no way to change the search_field in the curation_concerns UI
+    ##
+    # Render the query constraints
+    # 
+    # @param [Hash] query parameters
+    # @return [String]
+    def render_constraints_query(localized_params = params)
+      # So simple don't need a view template, we can just do it here.
+      return "".html_safe if localized_params[:q].blank?
+
+      render_constraint_element(constraint_query_label(localized_params),
+            localized_params[:q],
+            classes: ["query"],
+            remove: url_for(localized_params.except(:search_field).merge(q: nil, action: 'index')))
+    end
+
+    ##
+    # We can remove this method once we use Blacklight > 5.4.0
+    ##
+    # Return a label for the currently selected search field.
+    # If no "search_field" or the default (e.g. "all_fields") is selected, then return nil
+    # Otherwise grab the label of the selected search field.
+    # @param [Hash] query parameters
+    # @return [String]
+    def constraint_query_label(localized_params = params)
+      label_for_search_field(localized_params[:search_field]) unless default_search_field?(localized_params[:search_field])
+    end
+
+    ##
+    # We can remove this method once we use Blacklight > 5.4.0
+    ##
+    # Is the search form using the default search field ("all_fields" by default)?
+    # @param [String] the currently selected search_field
+    # @return [Boolean]
+    def default_search_field?(selected_search_field)
+      selected_search_field.blank? || (default_search_field && selected_search_field == default_search_field[:key])
+    end
+  end
+end

data/app/helpers/curation_concerns/search_paths_helper.rb

@@ -0,0 +1,13 @@
+module CurationConcerns::SearchPathsHelper
+
+  def search_path_for_my_works(opts={})
+    params_for_my_works = {:'f[generic_type_sim][]'=>'Work', works: 'mine'}
+    main_app.catalog_index_path(params_for_my_works.merge(opts))
+  end
+
+  def search_path_for_my_collections(opts={})
+    params_for_my_collections = {:'f[generic_type_sim][]'=>'Collection', works: 'mine'}
+    main_app.catalog_index_path(params_for_my_collections.merge(opts))
+  end
+
+end

data/app/helpers/curation_concerns/thumbnail_helper.rb

@@ -0,0 +1,11 @@
+module CurationConcerns
+  module ThumbnailHelper
+    def thumbnail_tag(document, image_options)
+      if document.representative.present?
+        image_tag main_app.download_path(document.representative, datastream_id: 'thumbnail'), alt: 'Thumbnail', class: "canonical-image"
+      else
+        content_tag :span, '', class: 'canonical-image'
+      end
+    end
+  end
+end

data/app/helpers/curation_concerns/title_helper.rb

@@ -0,0 +1,23 @@
+module CurationConcerns::TitleHelper
+
+  def construct_page_title(*elements)
+    (elements.flatten.compact + [application_name]).join(" // ")
+  end
+
+  def curation_concern_page_title(curation_concern)
+    if curation_concern.persisted?
+      construct_page_title(curation_concern.title, "#{curation_concern.human_readable_type} [#{curation_concern.to_param}]")
+    else
+      construct_page_title("New #{curation_concern.human_readable_type}")
+    end
+  end
+
+  def default_page_title
+    text = controller_name.singularize.titleize
+    if action_name
+      text = "#{action_name.titleize} " + text
+    end
+    construct_page_title(text)
+  end
+
+end

data/app/helpers/curation_concerns/url_helper.rb

@@ -0,0 +1,29 @@
+module CurationConcerns
+  module UrlHelper
+
+    # override Blacklight so we can use our 'curation_concern' namespace
+    # We may also pass in a ActiveFedora document instead of a SolrDocument
+    def url_for_document doc, options = {}
+      if doc.collection?
+        doc
+      else
+        polymorphic_path([main_app, :curation_concerns, doc])
+      end
+    end
+
+    def track_collection_path(*args)
+      main_app.track_solr_document_path(*args)
+    end
+
+    def track_generic_file_path(*args)
+      main_app.track_solr_document_path(*args)
+    end
+
+    # generated new GenericWork models get registered as curation concerns and need a
+    # track_model_path to render Blacklight-related views
+    CurationConcerns.configuration.registered_curation_concern_types.each do |concern|
+      define_method("track_#{concern.underscore}_path")  {|*args| main_app.track_solr_document_path(*args)}
+    end
+
+  end
+end

data/app/presenters/curation_concerns/collection_presenter.rb

@@ -0,0 +1,40 @@
+module CurationConcerns
+  class CollectionPresenter
+    include Hydra::Presenter
+    include ActionView::Helpers::NumberHelper
+
+    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
+    end
+
+    def size
+      number_to_human_size(model.bytes)
+    end
+
+    def total_items
+      model.members.count
+    end
+
+  end
+end

data/app/presenters/curation_concerns/generic_file_presenter.rb

@@ -0,0 +1,14 @@
+module CurationConcerns
+  class GenericFilePresenter
+    include Hydra::Presenter
+    self.model_class = ::GenericFile
+    # Terms is the list of fields displayed by app/views/generic_files/_show_descriptions.html.erb
+    self.terms = [:resource_type, :title, :creator, :contributor, :description, :tag, :rights,
+       :publisher, :date_created, :subject, :language, :identifier, :based_near, :related_url]
+
+    # Depositor and permissions are not displayed in app/views/generic_files/_show_descriptions.html.erb
+    # so don't include them in `terms'.
+    delegate :depositor, :permissions, to: :model
+  end
+end
+

data/app/presenters/curation_concerns/generic_work_presenter.rb

@@ -0,0 +1,13 @@
+module CurationConcerns
+  class GenericWorkPresenter
+    include Hydra::Presenter
+    self.model_class = GenericWork
+    # Terms is the list of fields displayed
+    self.terms = [:resource_type, :title, :creator, :contributor, :description, :tag, :rights,
+       :publisher, :date_created, :subject, :language, :identifier, :based_near, :related_url]
+
+    # Depositor and permissions are not displayed
+    # so don't include them in `terms'.
+    delegate :depositor, :permissions, to: :model
+  end
+end