hyrax 4.0.0 → 5.0.0.rc2

data/app/services/hyrax/lease_manager.rb

@@ -4,7 +4,22 @@ module Hyrax
   ##
   # Provides utilities for managing the lifecycle of an `Hyrax::Lease` on a
   # `Hyrax::Resource`.
-  class LeaseManager
+  #
+  # The lease terminology used here is as follows:
+  #
+  #    - "Expiration Date" is the day a lease is scheduled to expire.
+  #    - "Under Lease" means the lease is "active"; i.e. that its expiration
+  #       date is today or later.
+  #    - "Applied" means the lease's pre-expiration visibility has been set on
+  #      the resource.
+  #    - "Released" means the lease's post-expiration visibility has been set on
+  #      the resource.
+  #    - "Enforced" means the object's visibility matches the pre-expiration
+  #      visibility of the lease; i.e. the lease has been applied,
+  #      but not released.
+  #    - "Deactivate" means that the existing lease will be removed
+  #
+  class LeaseManager # rubocop:disable Metrics/ClassLength
     ##
     # @!attribute [rw] resource
     #   @return [Hyrax::Resource]
@@ -47,6 +62,51 @@ module Hyrax
         new(resource: resource, query_service: query_service)
           .release!
       end
+
+      # Creates or updates an existing lease on a member to match the lease on the parent work
+      # @param [Array<Valkyrie::Resource>] members
+      # @param [Hyrax::Work] work
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def create_or_update_lease_on_members(members, work)
+        # TODO: account for all members and levels, not just file sets. ref: #6131
+
+        members.each do |member|
+          member_lease_needs_updating = work.lease.updated_at > member.lease&.updated_at if member.lease
+
+          if member.lease && member_lease_needs_updating
+            member.lease.lease_expiration_date = work.lease['lease_expiration_date']
+            member.lease.visibility_during_lease = work.lease['visibility_during_lease']
+            member.lease.visibility_after_lease = work.lease['visibility_after_lease']
+            member.lease = Hyrax.persister.save(resource: member.lease)
+          else
+            work_lease_manager = Hyrax::LeaseManager.new(resource: work)
+            work_lease_manager.copy_lease_to(target: member)
+            member = Hyrax.persister.save(resource: member)
+          end
+
+          user ||= ::User.find_by_user_key(member.depositor)
+          # the line below works in that it indexes the file set with the necessary lease properties
+          # I do not know however if this is the best event_id to pass
+          Hyrax.publisher.publish('object.metadata.updated', object: member, user: user)
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    end
+
+    # Deactivates the lease and logs a message to the lease_history property
+    def deactivate!
+      lease_state = lease.active? ? 'active' : 'expired'
+      lease_record = lease_history_message(
+        lease_state,
+        Time.zone.today,
+        lease.lease_expiration_date,
+        lease.visibility_during_lease,
+        lease.visibility_after_lease
+      )
+
+      release(force: true)
+      nullify(force: true)
+      lease.lease_history += [lease_record]
     end
 
     ##
@@ -58,7 +118,7 @@ module Hyrax
     def copy_lease_to(target:)
       return false unless under_lease?
 
-      target.lease = Lease.new(clone_attributes)
+      target.lease = Hyrax.persister.save(resource: Lease.new(clone_attributes))
       self.class.apply_lease_for(resource: target)
     end
 
@@ -80,7 +140,8 @@ module Hyrax
     ##
     # @return [Boolean]
     def enforced?
-      lease.visibility_during_lease.to_s == resource.visibility
+      lease.lease_expiration_date.present? &&
+        lease.visibility_during_lease.to_s == resource.visibility
     end
 
     ##
@@ -90,18 +151,27 @@ module Hyrax
     end
 
     ##
-    # Drop the lease by setting its release date to `nil`.
+    # Drop the lease by setting its release date and visibility settings to `nil`.
     #
+    # @param force [boolean] force the nullify even when the lease period is current
     # @return [void]
-    def nullify
-      return unless under_lease?
+    def nullify(force: false)
+      return false if !force && under_lease?
+
       lease.lease_expiration_date = nil
+      lease.visibility_during_lease = nil
+      lease.visibility_after_lease = nil
     end
 
     ##
+    # Sets the visibility of the resource to the lease's after lease visibility.
+    # no-op if the lease period is current and the force flag is false.
+    #
+    # @param force [boolean] force the release even when the lease period is current
+    #
     # @return [Boolean]
-    def release
-      return false if under_lease?
+    def release(force: false)
+      return false if !force && under_lease?
       return true if lease.visibility_after_lease.nil?
 
       resource.visibility = lease.visibility_after_lease
@@ -131,5 +201,15 @@ module Hyrax
     def core_attribute_keys
       [:visibility_after_lease, :visibility_during_lease, :lease_expiration_date]
     end
+
+    # Create the log message used when deactivating a lease
+    def lease_history_message(state, deactivate_date, expiration_date, visibility_during, visibility_after)
+      I18n.t 'hydra.lease.history_message',
+              state: state,
+              deactivate_date: deactivate_date,
+              expiration_date: expiration_date,
+              visibility_during: visibility_during,
+              visibility_after: visibility_after
+    end
   end
 end

data/app/services/hyrax/listeners/file_metadata_listener.rb

@@ -12,8 +12,16 @@ module Hyrax
       # @param [Dry::Events::Event] event
       # @return [void]
       def on_file_characterized(event)
-        CreateDerivativesJob
-          .perform_later(event[:file_set], event[:file_id], event[:path_hint])
+        file_set = event[:file_set]
+
+        case file_set
+        when ActiveFedora::Base # ActiveFedora
+          CreateDerivativesJob
+            .perform_later(file_set, event[:file_id], event[:path_hint])
+        else
+          ValkyrieCreateDerivativesJob
+            .perform_later(file_set.id.to_s, event[:file_id])
+        end
       end
 
       ##
@@ -35,14 +43,14 @@ module Hyrax
       end
 
       ##
-      # Called when 'object.file.uploaded' event is published
+      # Called when 'file.uploaded' event is published
       # @param [Dry::Events::Event] event
       # @return [void]
-      def on_object_file_uploaded(event)
-        # Run characterization
-        Hyrax.config
-             .characterization_service
-             .run(metadata: event[:metadata], file: event[:metadata].file)
+      def on_file_uploaded(event)
+        # Run characterization for original file only
+        return unless event[:metadata]&.original_file?
+
+        ValkyrieCharacterizationJob.perform_later(event[:metadata].id.to_s)
       end
     end
   end

data/app/services/hyrax/listeners/member_cleanup_listener.rb

@@ -8,38 +8,12 @@ module Hyrax
       # Called when 'object.deleted' event is published
       # @param [Dry::Events::Event] event
       # @return [void]
-      def on_object_deleted(event)
-        return unless event.payload.key?(:object) # legacy callback
-        return if event[:object].is_a?(ActiveFedora::Base) # handled by legacy code
-
-        Hyrax.custom_queries.find_child_file_sets(resource: event[:object]).each do |file_set|
-          Hyrax.persister.delete(resource: file_set)
-          Hyrax.publisher
-               .publish('object.deleted', object: file_set, id: file_set.id, user: event[:user])
-        rescue StandardError # we don't uncaught errors looping filesets
-          Hyrax.logger.warn "Failed to delete #{file_set.class}:#{file_set.id} " \
-                            "during cleanup for resource: #{event[:object]}. " \
-                            'This member may now be orphaned.'
-        end
-      end
+      def on_object_deleted(event); end
 
       # Called when 'collection.deleted' event is published
       # @param [Dry::Events::Event] event
       # @return [void]
-      def on_collection_deleted(event)
-        return unless event.payload.key?(:collection) # legacy callback
-        return if event[:collection].is_a?(ActiveFedora::Base) # handled by legacy code
-
-        Hyrax.custom_queries.find_members_of(collection: event[:collection]).each do |resource|
-          resource.member_of_collection_ids -= [event[:collection].id]
-          Hyrax.persister.save(resource: resource)
-          Hyrax.publisher
-               .publish('collection.membership.updated', collection: event[:collection], user: event[:user])
-        rescue StandardError
-          Hyrax.logger.warn "Failed to remove collection reference from #{work.class}:#{work.id} " \
-                            "during cleanup for collection: #{event[:collection]}. "
-        end
-      end
+      def on_collection_deleted(event); end
     end
   end
 end

data/app/services/hyrax/listeners/metadata_index_listener.rb

@@ -83,6 +83,17 @@ module Hyrax
         Hyrax.index_adapter.delete(resource: event[:collection])
       end
 
+      ##
+      # Remove the resource from the index.
+      #
+      # Called when 'file.metadata.deleted' event is published
+      # @param [Dry::Events::Event] event
+      # @return [void]
+      def on_file_metadata_deleted(event)
+        return unless resource? event.payload[:metadata]
+        Hyrax.index_adapter.delete(resource: event[:metadata])
+      end
+
       private
 
       def resource?(resource)

data/app/services/hyrax/listeners/workflow_listener.rb

@@ -7,17 +7,14 @@ module Hyrax
     # manages workflow accordingly.
     class WorkflowListener
       ##
-      # @note respects class attribute configuration at
-      #   {Hyrax::Actors::InitializeWorkflowActor.workflow_factory}, but falls
-      #   back on {Hyrax::Workflow::WorkflowFactory} to prepare for removal of
-      #   Actors
-      # @return [#create] default: {Hyrax::Workflow::WorkflowFactory}
-      def factory
-        if defined?(Hyrax::Actors::InitializeWorkflowActor)
-          Hyrax::Actors::InitializeWorkflowActor.workflow_factory
-        else
-          Hyrax::Workflow::WorkflowFactory
-        end
+      # @!attribute [rw] factory
+      #   @return [#create]
+      attr_accessor :factory
+
+      ##
+      # @param [#create] factory
+      def initialize(factory: Hyrax::Workflow::WorkflowFactory)
+        @factory = factory
       end
 
       ##

data/app/services/hyrax/lock_manager.rb

@@ -47,11 +47,10 @@ module Hyrax
     # @api private
     #
     # @note support both a ConnectionPool and a raw Redis client for now.
-    #   we should drop support for `Redis.current` in 5.0.0.
     #   `#then` supports both options. for a ConnectionPool it will block
     #   until a connection is available.
     def pool
-      Hyrax.config.redis_connection || Redis.current
+      Hyrax.config.redis_connection || Redis.new
     end
   end
 end

data/app/services/hyrax/persist_directly_contained_output_file_service.rb

@@ -24,11 +24,33 @@ module Hyrax
     # @option directives [String] url URI for the parent object.
     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)
-      Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: Hyrax::Base.uri_to_id(uri.to_s), use_valkyrie: false)
+      if uri.is_a?(URI::HTTP)
+        Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: Hyrax::Base.uri_to_id(uri.to_s), use_valkyrie: false)
+      else
+        raise ArgumentError, "#{uri} is not an file/http(s) uri" unless uri.is_a?(URI::File)
+
+        fileset_for_directives(directives)
+      end
     end
     private_class_method :retrieve_file_set
 
+    # The filepath will look something like
+    # /app/samvera/hyrax-webapp/derivatives/95/93/tv/12/3-thumbnail.jpeg and
+    # we want to extract the FileSet id, which in this case would be 9593tv123
+    #
+    # @param [String] path
+    # @return [Hyrax::FileSet]
+    def self.fileset_for_directives(directives)
+      path = URI(directives.fetch(:url)).path
+      id = path.sub(Hyrax.config.derivatives_path.to_s, "")
+               .delete('/')
+               .match(/^(.*)-\w*(\.\w+)*$/) { |m| m[1] }
+      raise "Could not extract fileset id from path #{path}" unless id
+
+      Hyrax.metadata_adapter.query_service.find_by(id: id)
+    end
+    private_class_method :fileset_for_directives
+
     # Override this implementation if you need a remote file from a different location
     # @param file_set [FileSet] the container of the remote file
     # @param directives [Hash] directions which can be used to determine where to persist to

data/app/services/hyrax/riiif_file_resolver.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Hyrax
+  # Riiif file resolver for valkyrie resources
+  class RiiifFileResolver
+    include ActiveSupport::Benchmarkable
+
+    # @param [String] id from iiif manifest
+    # @return [Riiif::File]
+    def find(id)
+      path = nil
+      file_locks[id].with_write_lock do
+        path = build_path(id)
+        path = build_path(id, force: true) unless File.exist?(path) # Ensures the file is locally available
+      end
+      RiiifFile.new(path, id: id)
+    end
+
+    # tracks individual file locks
+    # @see RiiifFile
+    # @return [Concurrent::Map<Concurrent::ReadWriteLock>]
+    def file_locks
+      @file_locks ||= Concurrent::Map.new do |k, v|
+        k.compute_if_absent(v) { Concurrent::ReadWriteLock.new }
+      end
+    end
+
+    private
+
+    def build_path(id, force: false)
+      Riiif::Image.cache.fetch("riiif:" + Digest::MD5.hexdigest("path:#{id}"),
+                               expires_in: Riiif::Image.expires_in,
+                               force: force) do
+        load_file(id)
+      end
+    end
+
+    def load_file(id)
+      benchmark "RiiifFileResolver loaded #{id}", level: :debug do
+        fs_id = id.sub(/\A([^\/]*)\/.*/, '\1')
+        file_set = Hyrax.query_service.find_by(id: fs_id)
+        file_metadata = Hyrax.custom_queries.find_original_file(file_set: file_set)
+        file_metadata.file.disk_path.to_s # Stores a local copy in tmpdir
+      end
+    end
+
+    def logger
+      Hyrax.logger
+    end
+  end
+end

data/app/services/hyrax/simple_schema_loader.rb

@@ -43,6 +43,12 @@ module Hyrax
       end
     end
 
+    def permissive_schema_for_valkrie_adapter
+      metadata_files.each_with_object({}) do |schema_name, ret_hsh|
+        predicate_pairs(ret_hsh, schema_name)
+      end
+    end
+
     ##
     # @api private
     class AttributeDefinition
@@ -154,5 +160,30 @@ module Hyrax
     def config_search_paths
       [Rails.root, Hyrax::Engine.root]
     end
+
+    def metadata_files
+      file_name_arr = []
+      config_search_paths.each { |root_path| file_name_arr += Dir.entries(root_path.to_s + "/config/metadata/") }
+      file_name_arr.reject { |fn| !fn.include?('.yaml') }.uniq.map { |y| y.gsub('.yaml', '') }
+    end
+
+    def predicate_pairs(ret_hsh, schema_name)
+      schema_config(schema_name)['attributes'].each do |name, config|
+        predicate = RDF::URI(config['predicate'])
+        if ret_hsh[name].blank?
+          ret_hsh[name.to_sym] = predicate
+        elsif ret_hsh[name] != predicate
+          multiple_predicate_message(name, ret_hsh[name], predicate)
+        end
+      end
+    end
+
+    def multiple_predicate_message(name, existing, incoming)
+      message =  "The attribute of #{name} has been assigned a predicate multiple times " \
+                 "within the metadata YAMLs. Please be aware that once the attribute's " \
+                 "predicate value is first assigned, any other value will be ignored. " \
+                 "The existing value is #{existing} preventing the use of #{incoming}"
+      Hyrax.logger.warn(message)
+    end
   end
 end

data/app/services/hyrax/solr_query_service.rb

@@ -28,21 +28,21 @@ module Hyrax
     ##
     # execute the query using a GET request
     # @return [Hash] the results returned from solr for the current query
-    def get
-      solr_service.get(build)
+    def get(**args)
+      solr_service.get(build, **args)
     end
 
     ##
     # execute the solr query and return results
     # @return [Hash] the results returned from solr for the current query
-    def query_result
-      solr_service.query_result(build)
+    def query_result(**args)
+      solr_service.query_result(build, **args)
     end
 
     ##
     # @return [Enumerable<SolrDocument>]
-    def solr_documents
-      query_result['response']['docs'].map { |doc| self.class.document_model.new(doc) }
+    def solr_documents(**args)
+      query_result(**args)['response']['docs'].map { |doc| self.class.document_model.new(doc) }
     end
 
     ##
@@ -107,6 +107,7 @@ module Hyrax
     def with_generic_type(generic_type: 'Work')
       # TODO: Generic type was originally stored as `sim`.  Since it is never multi-valued, it is moving to being stored
       #       as `si`.  Until a migration is created to correct existing solr docs, this query searches in both fields.
+      #       @see https://github.com/samvera/hyrax/issues/6086
       field_pairs = { generic_type_si: generic_type, generic_type_sim: generic_type }
       type_query = construct_query_for_pairs(field_pairs, ' OR ', 'field')
       @query += [type_query]

data/app/services/hyrax/statistics/depositors/summary.rb

@@ -58,7 +58,7 @@ module Hyrax
         end
 
         def query_service
-          Hyrax::Statistics::QueryService.new
+          Hyrax::Statistics::ValkyrieQueryService.new
         end
       end
     end

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

@@ -40,7 +40,7 @@ module Hyrax
       end
 
       def query_service
-        Hyrax::Statistics::QueryService.new
+        Hyrax::Statistics::ValkyrieQueryService.new
       end
 
       # How many points are in this data set

data/app/services/hyrax/statistics/users/over_time.rb

@@ -26,7 +26,9 @@ module Hyrax
         end
 
         def point(date_string)
-          relation.where(query(date_string)).count
+          # convert the User::ActiveRecord_Relation to an array so that ".size" returns a number,
+          # instead of a hash of { user_id: size }
+          relation.where(query(date_string)).to_a.size
         end
       end
     end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Hyrax
+  module Statistics
+    class ValkyrieQueryService < QueryService
+      # query to find works created during the time range
+      # @param [DateTime] start_datetime starting date time for range query
+      # @param [DateTime] end_datetime ending date time for range query
+      def find_by_date_created(start_datetime, end_datetime = nil)
+        return [] if start_datetime.blank? # no date just return nothing
+        return super unless non_wings_valkyire?
+
+        Hyrax.query_service.custom_queries.find_by_date_range(start_datetime: start_datetime,
+                                                              end_datetime: end_datetime,
+                                                              models: relation.allowable_types).to_a
+      end
+
+      def find_registered_in_date_range(start_datetime, end_datetime = nil)
+        return super unless non_wings_valkyire?
+        find_by_date_created(start_datetime, end_datetime) & where_registered.to_a
+      end
+
+      def find_public_in_date_range(start_datetime, end_datetime = nil)
+        return super unless non_wings_valkyire?
+        find_by_date_created(start_datetime, end_datetime) & where_public.to_a
+      end
+
+      def relation
+        return super unless non_wings_valkyire?
+        Hyrax::ValkyrieWorkRelation.new
+      end
+
+      private
+
+      def where_access_is(access_level)
+        # returns all works where the access level is public
+        return super unless non_wings_valkyire?
+
+        Hyrax.custom_queries.find_models_by_access(mode: 'read',
+                                                   models: relation.allowable_types,
+                                                   group: true,
+                                                   agent: access_level)
+      end
+
+      def non_wings_valkyire?
+        Hyrax.config.use_valkyrie? && (!defined?(Wings) || (defined?(Wings) && Hyrax.config.disable_wings))
+      end
+    end
+  end
+end

data/app/services/hyrax/statistics/works/count.rb

@@ -44,7 +44,7 @@ module Hyrax
         private
 
         def query_service
-          @query_service ||= Hyrax::Statistics::QueryService.new
+          @query_service ||= Hyrax::Statistics::ValkyrieQueryService.new
         end
 
         def by_date_and_permission

data/app/services/hyrax/thumbnail_path_service.rb

@@ -30,6 +30,11 @@ module Hyrax
       def fetch_thumbnail(object)
         return object if object.thumbnail_id == object.id ||
                          object.try(:file_ids)&.detect { |fid| fid == object.thumbnail_id }
+        begin
+          return Hyrax.query_service.find_by(id: object.thumbnail_id)
+        rescue
+          nil
+        end
         Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: object.thumbnail_id)
       rescue Valkyrie::Persistence::ObjectNotFoundError, Hyrax::ObjectNotFoundError
         Hyrax.logger.error("Couldn't find thumbnail #{object.thumbnail_id} for #{object.id}")

data/app/services/hyrax/valkyrie_persist_derivatives.rb

@@ -22,20 +22,17 @@ module Hyrax
       file_set = fileset_for_directives(directives)
 
       # Valkyrie storage adapters will typically expect an IO-like object that
-      # responds to #path -- here we only have a StringIO, so some
-      # transformation is in order
+      # responds to #rewind and #read so we have created a StringIO
       tmpfile = Tempfile.new(file_set.id, encoding: 'ascii-8bit')
-      tmpfile.write stream.read
+      stream = StringIO.new(stream) if stream.is_a?(String)
+      stream.rewind
+      output = tmpfile.write(stream.read)
+      tmpfile.flush
+      raise 'blank file detected' if output.zero?
 
       filename = filename(directives)
-      Hyrax.logger.debug "Uploading thumbnail for FileSet #{file_set.id} as #{filename}"
-
-      uploader.upload(
-        io: tmpfile,
-        filename: filename,
-        file_set: file_set,
-        use: Hyrax::FileMetadata::Use::THUMBNAIL
-      )
+      Hyrax.logger.debug "Uploading derivative for FileSet #{file_set.id} as #{filename}"
+      uploader.upload(io: tmpfile, filename: filename, file_set: file_set, use: file_metadata(directives), mime_type: directives[:mime_type])
     end
 
     # The filepath will look something like
@@ -57,5 +54,13 @@ module Hyrax
     def self.filename(directives)
       URI(directives.fetch(:url)).path.split('/').last
     end
+
+    def self.file_metadata(directives)
+      if directives.key?(:container)
+        "Hyrax::FileMetadata::Use::#{directives[:container].upcase}".constantize
+      else
+        Hyrax::FileMetadata::Use::THUMBNAIL
+      end
+    end
   end
 end