sufia 7.2.0 → 7.3.0.rc1

data/app/controllers/sufia/admin_controller.rb

@@ -1,11 +1,13 @@
 module Sufia
   class AdminController < ApplicationController
+    include Blacklight::Base
     layout 'admin'
     def show
       authorize! :read, :admin_dashboard
       add_breadcrumb t(:'sufia.controls.home'), root_path
       add_breadcrumb t(:'sufia.toolbar.admin.menu'), sufia.admin_path
       @presenter = AdminDashboardPresenter.new
+      @admin_set_rows = Sufia::AdminSetService.new(self).search_results_with_work_count(:read)
     end
   end
 end

data/app/controllers/sufia/trophies_controller.rb

@@ -6,10 +6,8 @@ module Sufia
       t = current_user.trophies.where(work_id: work_id).first
       if t
         t.destroy
-        return false if t.persisted?
       else
         t = current_user.trophies.create(work_id: work_id)
-        return false unless t.persisted?
       end
       render json: t
     end

data/app/forms/sufia/forms/admin_set_form.rb

@@ -4,12 +4,31 @@ module Sufia
       self.model_class = AdminSet
       self.terms = [:title, :description, :thumbnail_id]
 
+      # @param model [AdminSet]
+      # @param permission_template [PermissionTemplate]
+      def initialize(model, permission_template)
+        super(model)
+        @permission_template = permission_template
+      end
+
       # Cast any array values on the model to scalars.
       def [](key)
         return super if key == :thumbnail_id
         super.first
       end
 
+      def permission_template
+        PermissionTemplateForm.new(@permission_template)
+      end
+
+      def workflow_name
+        @permission_template.workflow_name
+      end
+
+      def workflows
+        Sipity::Workflow.all.map { |workflow| [workflow.label, workflow.name] }
+      end
+
       class << self
         # This determines whether the allowed parameters are single or multiple.
         # By default it delegates to the model.

data/app/forms/sufia/forms/batch_edit_form.rb

@@ -1,6 +1,7 @@
 module Sufia
   module Forms
     class BatchEditForm < Sufia::Forms::WorkForm
+      # Used for drawing the fields that appear on the page
       self.terms = [:creator, :contributor, :description,
                     :keyword, :resource_type, :rights, :publisher, :date_created,
                     :subject, :language, :identifier, :based_near,
@@ -12,22 +13,31 @@ module Sufia
 
       # @param [ActiveFedora::Base] model the model backing the form
       # @param [Ability] current_ability the user authorization model
-      # @param [Array<String>] batch a list of document ids in the batch
-      def initialize(model, current_ability, batch)
+      # @param [Array<String>] batch_document_ids a list of document ids in the batch
+      def initialize(model, current_ability, batch_document_ids)
         super(model, current_ability)
         @names = []
-        initialize_combined_fields(batch)
+        @batch_document_ids = batch_document_ids
+        initialize_combined_fields
+      end
+
+      attr_reader :batch_document_ids
+
+      # Which parameters can we accept from the form
+      def self.build_permitted_params
+        super + [:visibility_during_embargo, :embargo_release_date,
+                 :visibility_after_embargo, :visibility_during_lease,
+                 :lease_expiration_date, :visibility_after_lease, :visibility]
       end
 
       private
 
         # override this method if you need to initialize more complex RDF assertions (b-nodes)
-        # @param [Array<String>] batch a list of document ids in the batch
-        def initialize_combined_fields(batch)
+        def initialize_combined_fields
           combined_attributes = {}
           permissions = []
           # For each of the files in the batch, set the attributes to be the concatenation of all the attributes
-          batch.each do |doc_id|
+          batch_document_ids.each do |doc_id|
             work = model_class.find(doc_id)
             terms.each do |key|
               combined_attributes[key] ||= []

data/app/forms/sufia/forms/batch_upload_form.rb

@@ -6,6 +6,8 @@ module Sufia
 
       self.terms -= [:title, :resource_type]
 
+      attr_accessor :payload_concern # a Class name: what is form creating a batch of?
+
       # The WorkForm delegates `#depositor` to `:model`, but `:model` in the
       # BatchUpload context is a blank work with a `nil` depositor
       # value. This causes the "Sharing With" widget to display the Depositor as
@@ -25,8 +27,7 @@ module Sufia
       #   super - [:title]
       # end
 
-      # Override of ActiveModel::Model name that allows us to use our
-      # custom name class
+      # Override of ActiveModel::Model name that allows us to use our custom name class
       def self.model_name
         @_model_name ||= begin
           namespace = parents.detect do |n|

data/app/forms/sufia/forms/permission_template_form.rb

@@ -0,0 +1,115 @@
+module Sufia
+  module Forms
+    class PermissionTemplateForm
+      include HydraEditor::Form
+      self.model_class = PermissionTemplate
+      self.terms = []
+      delegate :access_grants, :access_grants_attributes=, :release_date, :release_period, :visibility, to: :model
+
+      # Stores which radio button under release "Varies" option is selected
+      attr_accessor :release_varies
+      # Selected release embargo timeframe (if any) under release "Varies" option
+      attr_accessor :release_embargo
+
+      # Visibility options for permission templates
+      def visibility_options
+        i18n_prefix = "sufia.admin.admin_sets.form_visibility.visibility"
+        # Note: Visibility 'varies' = '' implies no constraints
+        [[Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC, I18n.t('.everyone', scope: i18n_prefix)],
+         ['', I18n.t('.varies', scope: i18n_prefix)],
+         [Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED, I18n.t('.institution', scope: i18n_prefix)],
+         [Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE, I18n.t('.restricted', scope: i18n_prefix)]]
+      end
+
+      # Embargo / release period options
+      def embargo_options
+        i18n_prefix = "sufia.admin.admin_sets.form_visibility.release.varies.embargo"
+        [[Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_6_MONTHS, I18n.t('.6mos', scope: i18n_prefix)],
+         [Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR, I18n.t('.1yr', scope: i18n_prefix)],
+         [Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_2_YEARS, I18n.t('.2yrs', scope: i18n_prefix)],
+         [Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_3_YEARS, I18n.t('.3yrs', scope: i18n_prefix)]]
+      end
+
+      def initialize(model)
+        # This is a temporary way to make sure all new PermissionTemplates have
+        # a workflow assigned to them. Ultimately we want to expose workflows in
+        # the UI and have users choose a workflow for their PermissionTemplate.
+        model.workflow_name = 'one_step_mediated_deposit'
+        super(model)
+        # Ensure proper form options selected, based on model
+        select_release_varies_option(model)
+      end
+
+      def update(attributes)
+        manage_grants = grants_as_collection(attributes).select { |x| x[:access] == 'manage' }
+        grant_admin_set_access(manage_grants) if manage_grants.present?
+        update_release_attributes(attributes)
+        model.update(attributes)
+      end
+
+      private
+
+        # This allows the attributes
+        def grants_as_collection(attributes)
+          return [] unless attributes[:access_grants_attributes]
+          attributes_collection = attributes[:access_grants_attributes]
+
+          if attributes_collection.respond_to?(:permitted?)
+            attributes_collection = attributes_collection.to_h
+          end
+          if attributes_collection.is_a? Hash
+            attributes_collection = attributes_collection
+                                    .sort_by { |i, _| i.to_i }
+                                    .map { |_, attrs| attrs }
+          end
+          attributes_collection
+        end
+
+        def grant_admin_set_access(manage_grants)
+          admin_set = AdminSet.find(model.admin_set_id)
+          admin_set.edit_users = manage_grants.select { |x| x[:agent_type] == 'user' }.map { |x| x[:agent_id] }
+          admin_set.edit_groups = manage_grants.select { |x| x[:agent_type] == 'group' }.map { |x| x[:agent_id] }
+          admin_set.save!
+        end
+
+        # In form, select appropriate radio button under Release "Varies" option based on saved permission_template
+        def select_release_varies_option(permission_template)
+          # Ignore 'no_delay' or 'fixed' values, as they are separate options
+          return if permission_template.release_no_delay? || permission_template.release_fixed_date?
+
+          # If embargo specified, then 'embargo' option under "varies" was selected and embargo period selected
+          if permission_template.release_max_embargo?
+            # If release_period is some other value, it is specifying an embargo period (e.g. 6mos, 1yr, etc)
+            @release_varies = Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_EMBARGO
+            @release_embargo = permission_template.release_period
+          # Else If release_period BEFORE a specified date, then 'before' option under "varies" was selected
+          elsif permission_template.release_before_date?
+            @release_varies = Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE
+          end
+        end
+
+        # Update attributes based on release options selected (if any).
+        def update_release_attributes(attributes)
+          # If 'varies' before date option selected, then set release_period='before' and save release_date as-is
+          if attributes[:release_varies] == Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE
+            attributes[:release_period] = Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE
+          # Else if 'varies' + embargo selected, save embargo as the release_period
+          elsif attributes[:release_varies] == Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_EMBARGO && attributes[:release_embargo]
+            attributes[:release_period] = attributes[:release_embargo]
+            # In an embargo, the release_date should be unspecified as it is based on deposit date
+            attributes[:release_date] = nil
+          end
+
+          # If release is "no delay", a release_date should never be allowed/specified
+          if attributes[:release_period] == Sufia::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY
+            attributes[:release_date] = nil
+          end
+
+          # Remove release_varies and release_embargo from attributes
+          # These form fields are only used (above) to update release_period
+          attributes.delete(:release_varies)
+          attributes.delete(:release_embargo)
+        end
+    end
+  end
+end

data/app/forms/sufia/forms/work_form.rb

@@ -49,6 +49,12 @@ module Sufia::Forms
       model.ordered_members.to_a.select { |m| m.model_name.singular.to_sym != :file_set }
     end
 
+    # The in_work items
+    # @return [Array] All of the works that this work is a member of
+    def in_work_members
+      model.in_works.to_a
+    end
+
     def self.multiple?(term)
       return true if [:rights, :collection_ids].include? term
       super

data/app/helpers/batch_edits_helper.rb

@@ -8,7 +8,7 @@ module BatchEditsHelper
   # Displays a "check all" button with a dropdown that has "Select None"
   # and "Select current page" actions
   def render_check_all
-    return if controller_name == "my/collections"
+    return if params[:controller] == "my/collections"
     render 'batch_edits/check_all'
   end
 end

data/app/helpers/sufia/citations_behavior.rb

@@ -14,11 +14,6 @@ module Sufia
       Sufia::CitationsBehaviors::Formatters::ChicagoFormatter.new(self).format(work)
     end
 
-    # MIME: 'application/x-endnote-refer'
-    def export_as_endnote(work)
-      Sufia::CitationsBehaviors::Formatters::EndnoteFormatter.new(self).format(work)
-    end
-
     def export_as_mla_citation(work)
       Sufia::CitationsBehaviors::Formatters::MlaFormatter.new(self).format(work)
     end

data/app/helpers/sufia/citations_behaviors/formatters.rb

@@ -14,7 +14,6 @@ module Sufia
 
       autoload :ApaFormatter, 'sufia/citations_behaviors/formatters/apa_formatter'
       autoload :ChicagoFormatter, 'sufia/citations_behaviors/formatters/chicago_formatter'
-      autoload :EndnoteFormatter, 'sufia/citations_behaviors/formatters/endnote_formatter'
       autoload :MlaFormatter, 'sufia/citations_behaviors/formatters/mla_formatter'
       autoload :OpenUrlFormatter, 'sufia/citations_behaviors/formatters/open_url_formatter'
     end

data/app/helpers/sufia/sufia_helper_behavior.rb

@@ -16,6 +16,10 @@ module Sufia
       t('sufia.institution_name_full', default: institution_name)
     end
 
+    def banner_image
+      Sufia.config.banner_image
+    end
+
     def orcid_label(style_class = '')
       "#{image_tag 'orcid.png', alt: t('sufia.user_profile.orcid.alt'), class: style_class} #{t('sufia.user_profile.orcid.label')}".html_safe
     end
@@ -89,7 +93,7 @@ module Sufia
     # @see Blacklight::SearchState#initialize
     def link_to_field(name, value, label = nil, facet_hash = {})
       label ||= value
-      params = { search_field: 'advanced', name => "\"#{value}\"" }
+      params = { search_field: name, q: "\"#{value}\"" }
       state = search_state_with_facets(params, facet_hash)
       link_to(label, main_app.search_catalog_path(state))
     end
@@ -115,8 +119,35 @@ module Sufia
     def index_field_link(options)
       raise ArgumentError unless options[:config] && options[:config][:field_name]
       name = options[:config][:field_name]
-      values = options[:value]
-      safe_join(values.map { |item| link_to_field(name, item, item) }, ", ".html_safe)
+      links = options[:value].map { |item| link_to_field(name, item, item) }
+      safe_join(links, ", ")
+    end
+
+    # A Blacklight helper_method
+    #
+    # @example
+    #   link_to_each_facet_field({ value: "Imaging > Object Photography", config: { helper_facet: :document_types_sim }})
+    #   ```html
+    #   <a href=\"/catalog?f%5Bdocument_types_sim%5D%5B%5D=Imaging\">Imaging</a> &gt; <a href=\"/catalog?f%5Bdocument_types_sim%5D%5B%5D=Object+Photography\">Object Photography</a>
+    #   ```
+    #
+    # @param options [Hash] from blacklight invocation of helper_method
+    # @option options [Array<#strip>] :value
+    # @option options [Hash>] :config Example: { separator: '>', helper_facet: :document_types_sim, output_separator: '::' }
+    # @return the html_safe facet links separated by the given separator (default: ' > ') to indicate facet hierarchy
+    #
+    # @raise KeyError when the options are note properly configured
+    def link_to_each_facet_field(options)
+      config = options.fetch(:config)
+      separator = config.fetch(:separator, ' > ')
+      output_separator = config.fetch(:output_separator, separator)
+      facet_search = config.fetch(:helper_facet)
+      facet_fields = Array.wrap(options.fetch(:value)).first.split(separator).map(&:strip)
+
+      facet_links = facet_fields.map do |type|
+        link_to(type, main_app.search_catalog_path(f: { facet_search => [type] }))
+      end
+      safe_join(facet_links, output_separator)
     end
 
     # Uses Rails auto_link to add links to fields
@@ -143,7 +174,7 @@ module Sufia
       end
     end
 
-    # *Sometimes* a Blacklight helper_method
+    # *Sometimes* a Blacklight index field helper_method
     # @param [String,User,Hash{Symbol=>Array}] args if a hash, the user_key must be under :value
     # @return [ActiveSupport::SafeBuffer] the html_safe link
     def link_to_profile(args)
@@ -167,7 +198,7 @@ module Sufia
     end
     deprecation_deprecate rights_statement_links: "use licence_links instead"
 
-    # A Blacklight helper_method
+    # A Blacklight index field helper_method
     # @param [Hash] options from blacklight helper_method invocation. Maps rights URIs to links with labels.
     # @return [ActiveSupport::SafeBuffer] rights statement links, html_safe
     def license_links(options)
@@ -210,8 +241,9 @@ module Sufia
       user.respond_to?(:name) ? "#{user.name} (#{user_key})" : user_key
     end
 
+    # Used by the gallery view
     def collection_thumbnail(_document, _image_options = {}, _url_options = {})
-      content_tag(:span, "", class: ["fa", "fa-cubes", "collection-icon-search"])
+      content_tag(:span, "", class: [Sufia::ModelIcon.css_class_for(Collection), "collection-icon-search"])
     end
 
     private

data/app/indexers/sufia/collection_indexer.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Sufia
+  class CollectionIndexer < CurationConcerns::CollectionIndexer
+    self.thumbnail_path_service = Sufia::CollectionThumbnailPathService
+  end
+end

data/app/jobs/batch_create_job.rb

@@ -9,41 +9,33 @@ class BatchCreateJob < ActiveJob::Base
   # This copies metadata from the passed in attribute to all of the works that
   # are members of the given upload set
   # @param [User] user
-  # @param [Array<String>] titles
-  # @param [Array<String>] resource_types
-  # @param [Array<Sufia::UploadedFile>] uploaded_files
-  # @param [Hash] attributes attributes to apply to all works
+  # @param [Hash<String => String>] titles
+  # @param [Hash<String => String>] resource_types
+  # @param [Array<String>] uploaded_files Sufia::UploadedFile IDs
+  # @param [Hash] attributes attributes to apply to all works, including :model
   # @param [BatchCreateOperation] log
   def perform(user, titles, resource_types, uploaded_files, attributes, log)
     log.performing!
-
     titles ||= {}
     resource_types ||= {}
-
     create(user, titles, resource_types, uploaded_files, attributes, log)
   end
 
   private
 
     def create(user, titles, resource_types, uploaded_files, attributes, log)
+      model = attributes.delete(:model) || attributes.delete('model')
+      raise ArgumentError, 'attributes must include "model" => ClassName.to_s' unless model
       uploaded_files.each do |upload_id|
         title = [titles[upload_id]] if titles[upload_id]
-        resource_type = [resource_types[upload_id]] if resource_types[upload_id]
+        resource_type = Array.wrap(resource_types[upload_id]) if resource_types[upload_id]
         attributes = attributes.merge(uploaded_files: [upload_id],
                                       title: title,
                                       resource_type: resource_type)
-        model = model_to_create(attributes)
         child_log = CurationConcerns::Operation.create!(user: user,
                                                         operation_type: "Create Work",
                                                         parent: log)
         CreateWorkJob.perform_later(user, model, attributes, child_log)
       end
     end
-
-    # Override this method if you have a different rubric for choosing the model
-    # @param [Hash] attributes
-    # @return String the model to create
-    def model_to_create(attributes)
-      Sufia.config.model_to_create.call(attributes)
-    end
 end

data/app/models/batch_upload_item.rb

@@ -6,6 +6,8 @@ class BatchUploadItem < ActiveFedora::Base
   include ::CurationConcerns::BasicMetadata
   include Sufia::WorkBehavior
 
+  attr_accessor :payload_concern # a Class name: what is this a batch of?
+
   # This mocks out the behavior of Hydra::PCDM::PcdmBehavior
   def in_collection_ids
     []

data/app/models/concerns/sufia/ability.rb

@@ -18,6 +18,9 @@ module Sufia
       return unless registered_user?
       can :create, [UploadedFile, BatchUploadItem]
       can :destroy, UploadedFile, user: current_user
+      # BatchUploadItem permissions depend on the kind of objects being made by the batch,
+      # but it must be authorized directly in the controller, not here.
+      # Note: cannot call `authorized_models` without going recursive.
     end
 
     def proxy_deposit_abilities
@@ -63,7 +66,15 @@ module Sufia
     end
 
     def admin_set_abilities
-      can :manage, AdminSet if admin?
+      can :manage, [AdminSet, Sufia::PermissionTemplate, Sufia::PermissionTemplateAccess] if admin?
+
+      can [:create, :edit, :update, :destroy], Sufia::PermissionTemplate do |template|
+        test_edit(template.admin_set_id)
+      end
+
+      can [:create, :edit, :update, :destroy], Sufia::PermissionTemplateAccess do |access|
+        test_edit(access.permission_template.admin_set_id)
+      end
     end
 
     private