hyrax 3.0.0.pre.beta2 → 3.0.0.pre.beta3

data/app/services/hyrax/file_set_csv_service.rb

@@ -1,3 +1,5 @@
+require 'csv'
+
 module Hyrax
   #
   # Generates CSV from a FileSet

data/app/services/hyrax/file_set_visibility_propagator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Propogates visibility from a given Work to its FileSets
+  class FileSetVisibilityPropagator
+    ##
+    # @!attribute [rw] source
+    #   @return [#visibility]
+    attr_accessor :source
+
+    ##
+    # @param source [#visibility] the object to propogate visibility from
+    def initialize(source:)
+      self.source = source
+    end
+
+    ##
+    # @return [void]
+    #
+    # @raise [RuntimeError] if visibility propogation fails
+    def propagate
+      source.file_sets.each do |file|
+        file.visibility = source.visibility # visibility must come first, because it can clear an embargo/lease
+        copy_visibility_modifier(source: source, file: file, modifier: :lease)
+        copy_visibility_modifier(source: source, file: file, modifier: :embargo)
+        file.save!
+      end
+    end
+
+    private
+
+      def copy_visibility_modifier(source:, file:, modifier:)
+        source_modifier = source.public_send(modifier)
+        return unless source_modifier
+        file.public_send("build_#{modifier}") unless file.public_send(modifier)
+        file.public_send(modifier).attributes = source_modifier.attributes.except('id')
+        file.public_send(modifier).save
+      end
+  end
+end

data/app/services/hyrax/graph_exporter.rb

@@ -20,7 +20,7 @@ module Hyrax
       end
     rescue Ldp::NotFound
       # this error is handled with a 404 page.
-      raise ActiveFedora::ObjectNotFoundError
+      raise Hyrax::ObjectNotFoundError
     end
 
     private

data/app/services/hyrax/lease_manager.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Hyrax
+  class LeaseManager
+    ##
+    # @!attribute [rw] resource
+    #   @return [Hyrax::Resource]
+    attr_accessor :resource
+
+    ##
+    # @!attribute [r] query_service
+    #   @return [#find_by]
+    attr_reader :query_service
+
+    ##
+    # @param resource [Hyrax::Resource]
+    def initialize(resource:, query_service: Hyrax.query_service)
+      @query_service = query_service
+      self.resource  = resource
+    end
+
+    class << self
+      def apply_lease_for(resource:, query_service: Hyrax.query_service)
+        new(resource: resource, query_service: query_service)
+          .apply
+      end
+
+      def lease_for(resource:, query_service: Hyrax.query_service)
+        new(resource: resource, query_service: query_service)
+          .lease
+      end
+    end
+
+    def copy_lease_to(target:)
+      return false unless under_lease?
+
+      target.lease = Lease.new(clone_attributes)
+      self.class.apply_lease_for(resource: target)
+    end
+
+    ##
+    # @return [Boolean]
+    def apply
+      return false unless under_lease?
+
+      resource.visibility = lease.visibility_during_lease
+    end
+
+    ##
+    # @return [Valkyrie::Resource]
+    def lease
+      resource.lease || Lease.new
+    end
+
+    ##
+    # @return [Boolean]
+    def under_lease?
+      lease.active?
+    end
+
+    private
+
+      def clone_attributes
+        lease.attributes.slice(*core_attribute_keys)
+      end
+
+      def core_attribute_keys
+        [:visibility_after_lease, :visibility_during_lease, :lease_expiration_date]
+      end
+  end
+end

data/app/services/hyrax/persist_directly_contained_output_file_service.rb

@@ -24,7 +24,7 @@ module Hyrax
     def self.retrieve_file_set(directives)
       uri = URI(directives.fetch(:url))
       raise ArgumentError, "#{uri} is not an http(s) uri" unless uri.is_a?(URI::HTTP)
-      ActiveFedora::Base.find(ActiveFedora::Base.uri_to_id(uri.to_s))
+      Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: ActiveFedora::Base.uri_to_id(uri.to_s), use_valkyrie: false)
     end
     private_class_method :retrieve_file_set
 

data/app/services/hyrax/resource_visibility_propagator.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Propagates visibility from a valkyrie Work to its FileSets
+  class ResourceVisibilityPropagator
+    ##
+    # @!attribute [rw] source
+    #   @return [#visibility]
+    attr_accessor :source
+
+    ##
+    # @!attribute [r] embargo_manager
+    #   @return [Hyrax::EmbargoManager]
+    # @!attribute [r] lease_manager
+    #   @return [Hyrax::LeaseManager]
+    # @!attribute [r] persister
+    #   @return [#save]
+    # @!attribute [r] queries
+    #   @returrn [Valkyrie::Persistence::CustomQueryContainer]
+    attr_reader :embargo_manager, :lease_manager, :persister, :queries
+
+    ##
+    # @param source [#visibility] the object to propogate visibility from
+    def initialize(source:,
+                   embargo_manager: Hyrax::EmbargoManager,
+                   lease_manager:   Hyrax::LeaseManager,
+                   persister:       Hyrax.persister,
+                   queries:         Hyrax.query_service.custom_queries)
+      @persister       = persister
+      @queries         = queries
+      self.source      = source
+      @embargo_manager = embargo_manager.new(resource: source)
+      @lease_manager   = lease_manager.new(resource: source)
+    end
+
+    ##
+    # @return [void]
+    #
+    # @raise [RuntimeError] if visibility propogation fails
+    def propagate
+      queries.find_child_filesets(resource: source).each do |file_set|
+        file_set.visibility = source.visibility
+        embargo_manager.copy_embargo_to(target: file_set)
+        lease_manager.copy_lease_to(target: file_set)
+        persister.save(resource: file_set)
+      end
+    end
+  end
+end

data/app/services/hyrax/solr_query_builder_service.rb

@@ -0,0 +1,71 @@
+module Hyrax
+  # Methods in this class are from/based on ActiveFedora::SolrQueryBuilder
+  class SolrQueryBuilderService
+    class << self
+      # Construct a solr query for a list of ids
+      # This is used to get a solr response based on the list of ids in an object's RELS-EXT relationhsips
+      # If the id_array is empty, defaults to a query of "id:NEVER_USE_THIS_ID", which will return an empty solr response
+      # @param [Array] id_array the ids that you want included in the query
+      def construct_query_for_ids(id_array)
+        ids = id_array.reject(&:blank?)
+        return "id:NEVER_USE_THIS_ID" if ids.empty?
+        "{!terms f=#{Hyrax.config.id_field}}#{ids.join(',')}"
+      end
+
+      # Construct a solr query from a list of pairs (e.g. [field name, values])
+      # @param [Array<Array>] field_pairs a list of pairs of property name and values
+      # @param [String] join_with ('AND') the value we're joining the clauses with
+      # @param [String] type ('field') The type of query to run. Either 'raw' or 'field'
+      # @return [String] a solr query
+      # @example
+      #   construct_query([['library_id_ssim', '123'], ['owner_ssim', 'Fred']])
+      #   # => "_query_:\"{!field f=library_id_ssim}123\" AND _query_:\"{!field f=owner_ssim}Fred\""
+      def construct_query(field_pairs, join_with = default_join_with, type = 'field'.freeze)
+        clauses = pairs_to_clauses(field_pairs, type)
+        return "" if clauses.count.zero?
+        return clauses.first if clauses.count == 1
+        "(#{clauses.join(join_with)})"
+      end
+
+      def default_join_with
+        ' AND '
+      end
+
+      private
+
+        # @param [Array<Array>] pairs a list of (key, value) pairs. The value itself may
+        # @param [String] type  The type of query to run. Either 'raw' or 'field'
+        # @return [Array] a list of solr clauses
+        def pairs_to_clauses(pairs, type)
+          pairs.flat_map do |field, value|
+            condition_to_clauses(field, value, type)
+          end
+        end
+
+        # @param [String] field
+        # @param [String, Array<String>] values
+        # @param [String] type The type of query to run. Either 'raw' or 'field'
+        # @return [Array<String>]
+        def condition_to_clauses(field, values, type)
+          values = Array(values)
+          values << nil if values.empty?
+          values.map do |value|
+            if value.present?
+              query_clause(type, field, value)
+            else
+              # Check that the field is not present. In SQL: "WHERE field IS NULL"
+              "-#{field}:[* TO *]"
+            end
+          end
+        end
+
+        # Create a raw query clause suitable for sending to solr as an fq element
+        # @param [String] type The type of query to run. Either 'raw' or 'field'
+        # @param [String] key
+        # @param [String] value
+        def query_clause(type, key, value)
+          "_query_:\"{!#{type} f=#{key}}#{value.gsub('"', '\"')}\""
+        end
+    end
+  end
+end

data/app/services/hyrax/solr_service.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Supports a range of basic Solr interactions.
+  #
+  # This class replaces `ActiveFedora::SolrService`, which is deprecated for
+  # internal use.
+  class SolrService
+    COMMIT_PARAMS = { softCommit: true }.freeze
+
+    def initialize
+      @old_service = ActiveFedora::SolrService
+    end
+
+    def instance
+      # Deprecation warning for calling from outside of the Hyrax::SolrService class
+      Deprecation.warn(self, rsolr_call_warning) unless caller[1].include?("#{self.class.name.underscore}.rb")
+
+      @old_service.instance
+    end
+
+    class << self
+      ##
+      # We don't implement `.select_path` instead configuring this at the Hyrax
+      # level
+      def select_path
+        raise NotImplementedError, 'This method is not available on this subclass.' \
+                                   'Use `Hyrax.config.solr_select_path` instead'
+      end
+
+      delegate :add, :commit, :count, :delete, :get, :instance, :post, :query, :delete_by_query, to: :new
+    end
+
+    # Wraps rsolr get
+    # @return [Hash] the hash straight form rsolr
+    def get(query = nil, use_valkyrie: Hyrax.config.query_index_from_valkyrie, **args)
+      # Make Hyrax.config.solr_select_path the default SOLR path
+      solr_path = args.delete(:path) || Hyrax.config.solr_select_path
+      args = args.merge(q: query) unless query.blank?
+
+      if use_valkyrie
+        valkyrie_index.connection.get(solr_path, params: args)
+      else
+        args = args.merge(qt: 'standard') unless query.blank?
+        self.class.instance.conn.get(solr_path, params: args)
+      end
+    end
+
+    # Wraps rsolr post
+    # @return [Hash] the hash straight form rsolr
+    def post(query = nil, use_valkyrie: Hyrax.config.query_index_from_valkyrie, **args)
+      # Make Hyrax.config.solr_select_path the default SOLR path
+      solr_path = args.delete(:path) || Hyrax.config.solr_select_path
+      args = args.merge(q: query) unless query.blank?
+
+      if use_valkyrie
+        valkyrie_index.connection.post(solr_path, data: args)
+      else
+        args = args.merge(qt: 'standard') unless query.blank?
+        self.class.instance.conn.post(solr_path, data: args)
+      end
+    end
+
+    # Wraps get by default
+    # @return [Array<SolrHit>] the response docs wrapped in SolrHit objects
+    def query(query, use_valkyrie: Hyrax.config.query_index_from_valkyrie, **args)
+      Rails.logger.warn rows_warning unless args.key?(:rows)
+      method = args.delete(:method) || :get
+
+      result = case method
+               when :get
+                 get(query, use_valkyrie: use_valkyrie, **args)
+               when :post
+                 post(query, use_valkyrie: use_valkyrie, **args)
+               else
+                 raise "Unsupported HTTP method for querying SolrService (#{method.inspect})"
+               end
+      result['response']['docs'].map do |doc|
+        ::SolrHit.new(doc)
+      end
+    end
+
+    # Wraps rsolr :commit
+    def commit(use_valkyrie: Hyrax.config.query_index_from_valkyrie)
+      if use_valkyrie
+        valkyrie_index.connection.commit
+      else
+        self.class.instance.conn.commit
+      end
+    end
+
+    # Wraps rsolr :delete_by_query
+    def delete_by_query(query, use_valkyrie: Hyrax.config.query_index_from_valkyrie, **args)
+      if use_valkyrie
+        valkyrie_index.connection.delete_by_query(query, params: args)
+      else
+        self.class.instance.conn.delete_by_query(query, params: args)
+      end
+    end
+
+    # Wraps rsolr delete
+    def delete(id, use_valkyrie: Hyrax.config.query_index_from_valkyrie)
+      if use_valkyrie
+        valkyrie_index.connection.delete_by_id(id, params: COMMIT_PARAMS)
+      else
+        self.class.instance.conn.delete_by_id(id, params: COMMIT_PARAMS)
+      end
+    end
+
+    # Wraps rsolr add
+    # @return [Hash] the hash straight form rsolr
+    def add(solr_doc, use_valkyrie: Hyrax.config.query_index_from_valkyrie, commit: true)
+      params = { softCommit: commit }
+
+      if use_valkyrie
+        valkyrie_index.connection.add(solr_doc, params: params)
+      else
+        self.class.instance.conn.add(solr_doc, params: params)
+      end
+    end
+
+    # Wraps rsolr count
+    # @return [Hash] the hash straight form rsolr
+    def count(query, use_valkyrie: Hyrax.config.query_index_from_valkyrie)
+      args = { rows: 0 }
+      get(query, use_valkyrie: use_valkyrie, **args)['response']['numFound'].to_i
+    end
+
+    private
+
+      def valkyrie_index
+        Valkyrie::IndexingAdapter.find(:solr_index)
+      end
+
+      def rows_warning
+        "Calling Hyrax::SolrService.get without passing an explicit value for ':rows' is not recommended. You will end up with Solr's default (usually set to 10)\nCalled by #{caller[0]}"
+      end
+
+      def rsolr_call_warning
+        "Calls to Hyrax::SolrService.instance are deprecated and support will be removed from Hyrax 4.0. Use methods in Hyrax::SolrService instead."
+      end
+  end
+end

data/app/services/hyrax/statistics/file_sets/by_format.rb

@@ -6,7 +6,7 @@ module Hyrax
 
           # Returns 'file_format_sim'
           def index_key
-            ActiveFedora.index_field_mapper.solr_name('file_format', :facetable)
+            "file_format_sim"
           end
       end
     end

data/app/services/hyrax/statistics/term_query.rb

@@ -19,12 +19,13 @@ module Hyrax
       def query
         term = index_key
         # Grab JSON response (looks like {"terms": {"depositor_tesim": {"mjg36": 3}}} for depositor)
-        json = solr_connection.get 'terms', params: { 'terms.fl' => term,
-                                                      'terms.sort' => 'count',
-                                                      'terms.limit' => @limit,
-                                                      wt: 'json',
-                                                      'json.nl' => 'map',
-                                                      omitHeader: 'true' }
+        json = Hyrax::SolrService.get(path: 'terms',
+                                      'terms.fl': term,
+                                      'terms.sort': 'count',
+                                      'terms.limit': @limit,
+                                      wt: 'json',
+                                      'json.nl': 'map',
+                                      omitHeader: 'true')
         unless json
           Rails.logger.error "Unable to reach TermsComponent via Solr connection. Is it enabled in your solr config?"
           return []
@@ -61,12 +62,6 @@ module Hyrax
           @data.as_json(opts)
         end
       end
-
-      private
-
-        def solr_connection
-          ActiveFedora::SolrService.instance.conn
-        end
     end
   end
 end