sufia 7.2.0 → 7.3.0.rc1

data/app/models/sufia/permission_template.rb

@@ -0,0 +1,102 @@
+module Sufia
+  class PermissionTemplate < ActiveRecord::Base
+    has_many :access_grants, class_name: 'Sufia::PermissionTemplateAccess'
+    accepts_nested_attributes_for :access_grants, reject_if: :all_blank
+
+    # Valid Release Period values
+    RELEASE_TEXT_VALUE_FIXED = 'fixed'.freeze
+    RELEASE_TEXT_VALUE_NO_DELAY = 'now'.freeze
+
+    # Valid Release Varies sub-options
+    RELEASE_TEXT_VALUE_BEFORE_DATE = 'before'.freeze
+    RELEASE_TEXT_VALUE_EMBARGO = 'embargo'.freeze
+    RELEASE_TEXT_VALUE_6_MONTHS = '6mos'.freeze
+    RELEASE_TEXT_VALUE_1_YEAR = '1yr'.freeze
+    RELEASE_TEXT_VALUE_2_YEARS = '2yrs'.freeze
+    RELEASE_TEXT_VALUE_3_YEARS = '3yrs'.freeze
+
+    # Key/value pair of valid embargo periods. Values are number of months embargoed.
+    RELEASE_EMBARGO_PERIODS = {
+      RELEASE_TEXT_VALUE_6_MONTHS => 6,
+      RELEASE_TEXT_VALUE_1_YEAR => 12,
+      RELEASE_TEXT_VALUE_2_YEARS => 24,
+      RELEASE_TEXT_VALUE_3_YEARS => 36
+    }.freeze
+
+    # Does this permission template require a specific date of release for all works
+    # NOTE: date will be in release_date
+    def release_fixed_date?
+      release_period == RELEASE_TEXT_VALUE_FIXED
+    end
+
+    # Does this permission template require no release delays (i.e. no embargoes allowed)
+    def release_no_delay?
+      release_period == RELEASE_TEXT_VALUE_NO_DELAY
+    end
+
+    # Does this permission template require a date (or embargo) that all works are released before
+    # NOTE: date will be in release_date
+    def release_before_date?
+      # All PermissionTemplate embargoes are dynamically determined release before dates
+      release_period == RELEASE_TEXT_VALUE_BEFORE_DATE || release_max_embargo?
+    end
+
+    # Is there a maximum embargo period specified by this permission template
+    # NOTE: latest embargo date returned by release_date, maximum embargo period will be in release_period
+    def release_max_embargo?
+      # Is it a release period in one of our valid embargo periods?
+      RELEASE_EMBARGO_PERIODS.key?(release_period)
+    end
+
+    # Override release_date getter to return a dynamically calculated date of release
+    # based one release requirements. Returns embargo date when release_max_embargo?==true.
+    # Returns today's date when release_no_delay?==true.
+    def release_date
+      # If no release delays allowed, return today's date as release date
+      return Time.zone.today if release_no_delay?
+
+      # If this isn't an embargo, just return release_date from database
+      return self[:release_date] unless release_max_embargo?
+
+      # Otherwise (if an embargo), return latest embargo date by adding specified months to today's date
+      Time.zone.today + RELEASE_EMBARGO_PERIODS.fetch(release_period).months
+    end
+
+    # Determines whether a given release date is valid based on this template's requirements
+    # @param [Date] date to validate
+    def valid_release_date?(date)
+      # Validate date against all release date requirements
+      check_no_delay_requirements(date) && check_before_date_requirements(date) && check_fixed_date_requirements(date)
+    end
+
+    # Determines whether a given visibility setting is valid based on this template's requirements
+    # @param [String] visibility value to validate
+    def valid_visibility?(value)
+      # If template doesn't specify a visiblity (i.e. is "varies"), then any visibility is valid
+      return true unless visibility.present?
+
+      # Validate that passed in value matches visibility requirement exactly
+      visibility == value
+    end
+
+    private
+
+      # If template requires no delays, check if date is exactly today
+      def check_no_delay_requirements(date)
+        return true unless release_no_delay?
+        date == Time.zone.today
+      end
+
+      # If template requires a release before a specific date, check this date is valid
+      def check_before_date_requirements(date)
+        return true unless release_before_date? && release_date.present?
+        date <= release_date
+      end
+
+      # If template requires an exact date, check this date matches
+      def check_fixed_date_requirements(date)
+        return true unless release_fixed_date? && release_date.present?
+        date == release_date
+      end
+  end
+end

data/app/models/sufia/permission_template_access.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Sufia
+  class PermissionTemplateAccess < ActiveRecord::Base
+    belongs_to :permission_template
+
+    def view?
+      access == 'view'
+    end
+
+    def deposit?
+      access == 'deposit'
+    end
+
+    def manage?
+      access == 'manage'
+    end
+  end
+end

data/app/presenters/sufia/admin_set_presenter.rb

@@ -1,7 +1,7 @@
 module Sufia
   class AdminSetPresenter < CollectionPresenter
     def total_items
-      ActiveFedora::SolrService.count("{!field f=isPartOf_ssim}#{id}", fl: id)
+      ActiveFedora::SolrService.count("{!field f=isPartOf_ssim}#{id}")
     end
   end
 end

data/app/presenters/sufia/model_icon.rb

@@ -0,0 +1,7 @@
+module Sufia
+  class ModelIcon
+    def self.css_class_for(model)
+      I18n.t(:"sufia.icons.#{model.model_name.i18n_key}", default: :"sufia.icons.default")
+    end
+  end
+end

data/app/presenters/sufia/select_type_list_presenter.rb

@@ -0,0 +1,37 @@
+module Sufia
+  # Presents the list of work type options that a user may choose from when deciding to
+  # create a new work
+  class SelectTypeListPresenter
+    # @param current_user [User]
+    def initialize(current_user)
+      @current_user = current_user
+    end
+
+    class_attribute :row_presenter
+    self.row_presenter = SelectTypePresenter
+
+    # @return [Boolean] are there many differnt types to choose?
+    def many?
+      authorized_models.size > 1
+    end
+
+    def authorized_models
+      return [] unless @current_user
+      @authorized_models ||= CurationConcerns::QuickClassificationQuery.new(@current_user).authorized_models
+    end
+
+    # Return or yield the first model in the list. This is used when the list
+    # only has a single element.
+    # @yieldparam [Class] model a class that decends from ActiveFedora::Base
+    # @return [Class] a class that decends from ActiveFedora::Base
+    def first_model
+      yield(authorized_models.first) if block_given?
+      authorized_models.first
+    end
+
+    # @yieldparam [SelectTypePresenter] presenter a presenter for the item
+    def each
+      authorized_models.each { |model| yield row_presenter.new(model) }
+    end
+  end
+end

data/app/presenters/sufia/select_type_presenter.rb

@@ -0,0 +1,35 @@
+module Sufia
+  class SelectTypePresenter
+    def initialize(concern)
+      @concern = concern
+    end
+
+    attr_reader :concern
+
+    def icon_class
+      ModelIcon.css_class_for(concern)
+    end
+
+    def description
+      translate('description')
+    end
+
+    def name
+      translate('name')
+    end
+
+    private
+
+      def object_name
+        @object_name ||= concern.model_name.i18n_key
+      end
+
+      def translate(key)
+        defaults = []
+        defaults << :"sufia.select_type.#{object_name}.#{key}"
+        defaults << :"sufia.select_type.#{key}"
+        defaults << ''
+        I18n.t(defaults.shift, default: defaults)
+      end
+  end
+end

data/app/presenters/sufia/work_show_presenter.rb

@@ -4,8 +4,6 @@ module Sufia
     delegate :based_near, :related_url, :depositor, :identifier, :resource_type,
              :keyword, :itemtype, :admin_set, to: :solr_document
 
-    self.file_presenter_class = Sufia::FileSetPresenter
-
     def editor?
       current_ability.can?(:edit, solr_document)
     end

data/app/search_builders/collection_search_builder.rb

@@ -1,7 +1,5 @@
 # Finds the child objects contained within a collection
 class CollectionSearchBuilder < CurationConcerns::MemberSearchBuilder
-  include BlacklightAdvancedSearch::AdvancedSearchBuilder
-
   self.from_field = 'child_object_ids_ssim'
   self.default_processor_chain += [:include_contained_files]
 

data/app/search_builders/sufia/admin_set_search_builder.rb

@@ -0,0 +1,24 @@
+module Sufia
+  ### Allows :deposit as a valid type
+  class AdminSetSearchBuilder < CurationConcerns::AdminSetSearchBuilder
+    # We're going to check the permission_templates
+    def gated_discovery_filters
+      return super if @access != :deposit
+      ["{!terms f=id}#{admin_set_ids.join(',')}"]
+    end
+
+    private
+
+      def admin_set_ids
+        PermissionTemplateAccess.joins(:permission_template)
+                                .where(agent_type: 'user',
+                                       agent_id: user,
+                                       access: ['deposit', 'manage'])
+                                .pluck('DISTINCT admin_set_id')
+      end
+
+      def user
+        current_ability.current_user.user_key
+      end
+  end
+end

data/app/search_builders/sufia/catalog_search_builder.rb

@@ -1,17 +1,23 @@
 class Sufia::CatalogSearchBuilder < Sufia::SearchBuilder
   self.default_processor_chain += [
     :add_access_controls_to_solr_params,
-    :add_advanced_parse_q_to_solr,
-    :show_works_or_works_that_contain_files
+    :show_works_or_works_that_contain_files,
+    :show_only_active_records
   ]
 
   # show both works that match the query and works that contain files that match the query
   def show_works_or_works_that_contain_files(solr_parameters)
-    return if solr_parameters[:q].blank?
-    solr_parameters[:user_query] = solr_parameters[:q]
+    return if blacklight_params[:q].blank? || blacklight_params[:search_field]
+    solr_parameters[:user_query] = blacklight_params[:q]
     solr_parameters[:q] = new_query
   end
 
+  # show works that are in the active state.
+  def show_only_active_records(solr_parameters)
+    solr_parameters[:fq] ||= []
+    solr_parameters[:fq] << '-suppressed_bsi:true'
+  end
+
   private
 
     # the {!lucene} gives us the OR syntax

data/app/search_builders/sufia/find_works_search_builder.rb

@@ -0,0 +1,44 @@
+# Search for possible works that user can edit and could be a work's child or parent.
+class Sufia::FindWorksSearchBuilder < Sufia::SearchBuilder
+  include Sufia::MySearchBuilderBehavior
+  include CurationConcerns::FilterByType
+
+  self.default_processor_chain += [:filter_on_title, :show_only_resources_deposited_by_current_user, :show_only_other_works, :show_only_works_not_child, :show_only_works_not_parent]
+
+  def initialize(context)
+    super(context)
+    @id = context.params[:id]
+    @q = context.params[:q]
+  end
+
+  def filter_on_title(solr_parameters)
+    solr_parameters[:fq] ||= []
+    solr_parameters[:fq] += [ActiveFedora::SolrQueryBuilder.construct_query(title_tesim: @q)]
+  end
+
+  def show_only_other_works(solr_parameters)
+    solr_parameters[:fq] ||= []
+    solr_parameters[:fq] += [
+      "-" + ActiveFedora::SolrQueryBuilder.construct_query_for_ids([@id])
+    ]
+  end
+
+  def show_only_works_not_child(solr_parameters)
+    ids = ActiveFedora::SolrService.query("{!field f=id}#{@id}", fl: "member_ids_ssim", rows: 10_000).flat_map { |x| x.fetch("member_ids_ssim", []) }
+    solr_parameters[:fq] ||= []
+    solr_parameters[:fq]  += [
+      "-" + ActiveFedora::SolrQueryBuilder.construct_query_for_ids(ids)
+    ]
+  end
+
+  def show_only_works_not_parent(solr_parameters)
+    solr_parameters[:fq] ||= []
+    solr_parameters[:fq]  += [
+      "-" + ActiveFedora::SolrQueryBuilder.construct_query(member_ids_ssim: @id)
+    ]
+  end
+
+  def only_works?
+    true
+  end
+end

data/app/search_builders/sufia/my_search_builder_behavior.rb

@@ -5,10 +5,6 @@
 module Sufia::MySearchBuilderBehavior
   extend ActiveSupport::Concern
 
-  included do
-    self.default_processor_chain += [:add_advanced_parse_q_to_solr]
-  end
-
   # show only files with edit permissions in lib/hydra/access_controls_enforcement.rb apply_gated_discovery
   def discovery_permissions
     ["edit"]

data/app/search_builders/sufia/my_works_search_builder.rb

@@ -3,7 +3,7 @@ class Sufia::MyWorksSearchBuilder < Sufia::SearchBuilder
   include Sufia::MySearchBuilderBehavior
   include CurationConcerns::FilterByType
 
-  self.default_processor_chain += [:add_advanced_search_to_solr, :show_only_resources_deposited_by_current_user]
+  self.default_processor_chain += [:show_only_resources_deposited_by_current_user]
 
   def only_works?
     true

data/app/services/sufia/actor_factory.rb

@@ -1,14 +1,18 @@
 module Sufia
   class ActorFactory < CurationConcerns::Actors::ActorFactory
     def self.stack_actors(curation_concern)
-      [CreateWithRemoteFilesActor,
+      [CurationConcerns::OptimisticLockValidator,
+       CreateWithRemoteFilesActor,
        CreateWithFilesActor,
        CurationConcerns::Actors::AddToCollectionActor,
        CurationConcerns::Actors::AddToWorkActor,
        CurationConcerns::Actors::AssignRepresentativeActor,
        CurationConcerns::Actors::AttachFilesActor,
        CurationConcerns::Actors::ApplyOrderActor,
-       CurationConcerns::Actors::InterpretVisibilityActor,
+       InterpretVisibilityActor,
+       DefaultAdminSetActor,
+       CurationConcerns::Actors::InitializeWorkflowActor,
+       ApplyPermissionTemplateActor,
        model_actor(curation_concern)]
     end
   end

data/app/services/sufia/admin_set_create_service.rb

@@ -0,0 +1,22 @@
+module Sufia
+  # Creates AdminSets
+  class AdminSetCreateService
+    # @param admin_set [AdminSet] the admin set to operate on
+    # @param creating_user [User] the user who created the admin set.
+    def initialize(admin_set, creating_user)
+      @admin_set = admin_set
+      @creating_user = creating_user
+    end
+
+    attr_reader :creating_user, :admin_set
+
+    # Creates an admin set, setting the creator and the default access controls.
+    # @return [TrueClass, FalseClass] true if it was successful
+    def create
+      admin_set.read_groups = ['public']
+      admin_set.edit_groups = ['admin']
+      admin_set.creator = [creating_user.user_key]
+      admin_set.save
+    end
+  end
+end

data/app/services/sufia/admin_set_service.rb

@@ -1,22 +1,52 @@
+# frozen_string_literal: true
 module Sufia
-  # Creates AdminSets
-  class AdminSetService
-    # @param admin_set [AdminSet] the admin set to operate on
-    # @param creating_user [User] the user who created the admin set.
-    def initialize(admin_set, creating_user)
-      @admin_set = admin_set
-      @creating_user = creating_user
+  # Returns AdminSets that the current user has permission to use.
+  class AdminSetService < CurationConcerns::AdminSetService
+    # This performs a two pass query, first getting the AdminSets and then getting the work counts
+    # @param [Symbol] access :read or :edit
+    # @return [Array<Array>] a list with document, then work count
+    def search_results_with_work_count(access)
+      documents = search_results(access)
+      ids = documents.map(&:id).join(',')
+      join_field = "isPartOf_ssim"
+      query = "{!terms f=#{join_field}}#{ids}"
+      results = ActiveFedora::SolrService.instance.conn.get(
+        ActiveFedora::SolrService.select_path,
+        params: { fq: query,
+                  'facet.field' => join_field }
+      )
+      counts = results['facet_counts']['facet_fields'][join_field].each_slice(2).to_h
+      documents.map do |doc|
+        [doc, counts[doc.id]]
+      end
     end
 
-    attr_reader :creating_user, :admin_set
-
-    # Creates an admin set, setting the creator and the default access controls.
-    # @return [TrueClass, FalseClass] true if it was successful
-    def create
-      admin_set.read_groups = ['public']
-      admin_set.edit_groups = ['admin']
-      admin_set.creator = [creating_user.user_key]
-      admin_set.save
+    # Return AdminSet selectbox options based on access type
+    # @param [Symbol] access :read or :edit
+    def select_options(access = :read)
+      search_results(access).map do |admin_set|
+        [admin_set.to_s, admin_set.id, data_attributes(admin_set)]
+      end
     end
+
+    private
+
+      # Create a hash of HTML5 'data' attributes. These attributes are added to select_options and
+      # later utilized by Javascript to limit new Work options based on AdminSet selected
+      def data_attributes(admin_set)
+        attrs = {}
+        # Get permission template associated with this AdminSet (if any)
+        permission_template = PermissionTemplate.find_by(admin_set_id: admin_set.id)
+
+        # Only add data attributes if permission template exists
+        if permission_template
+          # Save all PermissionTemplate release & visibility data attributes (if not blank or false)
+          attrs['data-release-date'] = permission_template.release_date unless permission_template.release_date.blank?
+          attrs['data-release-before-date'] = true if permission_template.release_before_date?
+          attrs['data-visibility'] = permission_template.visibility unless permission_template.visibility.blank?
+        end
+
+        attrs
+      end
   end
 end