hyrax 3.0.0.pre.rc2 → 3.0.0.pre.rc3

data/app/services/hyrax/list_source_exporter.rb

@@ -1,45 +1,27 @@
 # frozen_string_literal: true
 module Hyrax
+  ##
+  # @deprecated see Hyrax::GraphExporter::ListSourceExporter
+  #
   # Retrieves the graph for an object with the internal triples removed
   # and the uris translated to external uris.
-  class ListSourceExporter
+  class ListSourceExporter < GraphExporter::ListSourceExporter
+    ##
     # @param [String] id
     # @param [ActionDispatch::Request] request the http request context
     # @param [String] parent_url
-    def initialize(id, request, parent_url)
-      @id = id
-      @request = request
-      @parent_url = parent_url
+    # @param [String] hostname  the current http host
+    def initialize(id, request, parent_url, hostname: nil)
+      Deprecation.warn("#{subject.class} is deprecated and replaced with the (private) Hyrax::GraphExporter::")
+      host = hostname || request.host
+      super(id: id, parent_url: parent_url, hostname: host)
     end
 
-    attr_reader :id, :request, :parent_url
-
-    # @return [RDF::Graph]
-    def fetch
-      clean_graph_repository.find(id)
-    end
-
-    private
-
-    def clean_graph_repository
-      Hydra::ContentNegotiation::CleanGraphRepository.new(connection, replacer)
-    end
-
-    def connection
-      @connection ||= CleanConnection.new(ActiveFedora.fedora.connection)
-    end
-
-    # This method is called once for each statement in the graph.
-    def replacer
-      lambda do |resource_id, _graph|
-        parent_id = Hyrax::Base.uri_to_id(parent_url)
-        return parent_url + resource_id.sub(parent_id, '') if resource_id.start_with?(parent_id)
-        Rails.application.routes.url_helpers.solr_document_url(resource_id, host: hostname)
-      end
-    end
-
-    def hostname
-      request.host
-    end
+    ##
+    # @!attribute [r] request
+    #   @deprecated use {#hostname} to access the host
+    #   @return [ActionDispatch::Request]
+    attr_reader :request
+    deprecation_deprecate :request
   end
 end

data/app/services/hyrax/listeners.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Hyrax
+  # @note
+  #    Did you encounter an exception similar to the following:
+  #
+  #    "A copy of Hyrax::Listeners::ObjectLifecycleListener has been removed from the module tree but is still active!"
+  #
+  #    You may need to register a listener as autoload.  See
+  #    ./app/services/hyrax/listeners.rb
+  module Listeners
+    extend ActiveSupport::Autoload
+
+    autoload :AclIndexListener
+    autoload :BatchNotificationListener
+    autoload :FileSetLifecycleListener
+    autoload :FileSetLifecycleNotificationListener
+    autoload :MetadataIndexListener
+    autoload :ObjectLifecycleListener
+    autoload :ProxyDepositListener
+    autoload :WorkflowListener
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module Listeners
+    ##
+    # Listens for deposit events, and checks for proxy situations. When a user
+    # deposits an item `on_behalf_of` another, ensures transfer is handled.
+    class ProxyDepositListener
+      ##
+      # @param event [Dry::Event]
+      def on_object_deposited(event)
+        return if event[:object].try(:on_behalf_of).blank? ||
+                  (event[:object].on_behalf_of == event[:object].depositor)
+
+        ContentDepositorChangeEventJob
+          .perform_later(event[:object], ::User.find_by_user_key(event[:object].on_behalf_of))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Hyrax
+  module Listeners
+    ##
+    # Listens for object lifecycle events that require workflow changes and
+    # 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
+      end
+
+      ##
+      # @param event [Dry::Event]
+      def on_object_deposited(event)
+        return Rails.logger.warn("Skipping workflow initialization for #{event[:object]}; no user is given\n\t#{event}") if
+          event[:user].blank?
+
+        factory.create(event[:object], {}, event[:user])
+      rescue Sipity::StateError, Sipity::ConversionError => err
+        # don't error on known sipity error types; log instead
+        Rails.logger.error(err)
+      end
+    end
+  end
+end

data/app/services/hyrax/multiple_membership_checker.rb

@@ -52,7 +52,8 @@ module Hyrax
 
     def single_membership_collections(collection_ids)
       return [] if collection_ids.blank?
-      ::Collection.where(id: collection_ids, collection_type_gid_ssim: collection_type_gids_that_disallow_multiple_membership)
+
+      ::Collection.where(:id => collection_ids, Hyrax.config.collection_type_index_field.to_sym => collection_type_gids_that_disallow_multiple_membership)
     end
 
     def collection_type_gids_that_disallow_multiple_membership

data/app/services/hyrax/quick_classification_query.rb

@@ -12,9 +12,8 @@ module Hyrax
     attr_reader :user
 
     # @param [::User] user the current user
-    # @param [Hash] options
-    # @option options [#call] :concern_name_normalizer (String#constantize) a proc that translates names to classes
-    # @option options [Array<String>] :models the options to display, defaults to everything.
+    # @param [#call] concern_name_normalizer (String#constantize) a proc that translates names to classes
+    # @param [Array<String>] models the options to display, defaults to everything.
     def initialize(user,
                    models: Hyrax.config.registered_curation_concern_types,
                    concern_name_normalizer: ->(str) { str.constantize })

data/app/services/hyrax/resource_visibility_propagator.rb

@@ -17,7 +17,7 @@ module Hyrax
     # @!attribute [r] persister
     #   @return [#save]
     # @!attribute [r] queries
-    #   @returrn [Valkyrie::Persistence::CustomQueryContainer]
+    #   @return [Valkyrie::Persistence::CustomQueryContainer]
     attr_reader :embargo_manager, :lease_manager, :persister, :queries
 
     ##

data/app/services/hyrax/search_service.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+# SearchService returns search results from the repository
+module Hyrax
+  # Copied from Blacklight 7
+  class SearchService
+    def initialize(config:, user_params: nil, search_builder_class: config.search_builder_class, **context)
+      @blacklight_config = config
+      @user_params = user_params || {}
+      @search_builder_class = search_builder_class
+      @context = context
+    end
+
+    # The blacklight_config + controller are accessed by the search_builder
+    attr_reader :blacklight_config, :context
+
+    def search_builder
+      search_builder_class.new(self)
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    # a solr query method
+    # @yield [search_builder] optional block yields configured SearchBuilder, caller can modify or create new SearchBuilder to be used. Block should return SearchBuilder to be used.
+    # @return [Blacklight::Solr::Response] the solr response object
+    def search_results
+      builder = search_builder.with(user_params)
+      builder.page = user_params[:page] if user_params[:page]
+      builder.rows = (user_params[:per_page] || user_params[:rows]) if user_params[:per_page] || user_params[:rows]
+
+      builder = yield(builder) if block_given?
+      response = repository.search(builder)
+
+      if response.grouped? && grouped_key_for_results
+        [response.group(grouped_key_for_results), []]
+      elsif response.grouped? && response.grouped.length == 1
+        [response.grouped.first, []]
+      else
+        [response, response.documents]
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    # retrieve a document, given the doc id
+    # @param [Array{#to_s},#to_s] id
+    # @return [Blacklight::Solr::Response, Blacklight::SolrDocument] the solr response object and the first document
+    def fetch(id = nil, extra_controller_params = {})
+      if id.is_a? Array
+        fetch_many(id, extra_controller_params)
+      else
+        fetch_one(id, extra_controller_params)
+      end
+    end
+
+    private
+
+    attr_reader :search_builder_class, :user_params, :search_state
+
+    def repository
+      blacklight_config.repository || blacklight_config.repository_class.new(blacklight_config)
+    end
+
+    def scope
+      @context[:scope]
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      if scope&.respond_to?(method_name)
+        Deprecation.warn(self.class, "Calling `#{method_name}` on scope " \
+          'is deprecated and will be removed in Blacklight 8. Call #to_h first if you ' \
+          ' need to use hash methods (or, preferably, use your own SearchState implementation)')
+        scope&.public_send(method_name, *arguments, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      scope&.respond_to?(method_name, include_private) || super
+    end
+
+    def current_ability
+      @current_ability || @context[:current_ability]
+    end
+
+    ##
+    # Retrieve a set of documents by id
+    # @param [Array] ids
+    # @param [HashWithIndifferentAccess] extra_controller_params
+    def fetch_many(ids, extra_controller_params)
+      extra_controller_params ||= {}
+
+      query = search_builder
+              .with(user_params)
+              .where(blacklight_config.document_model.unique_key => ids)
+              .merge(blacklight_config.fetch_many_document_params)
+              .merge(extra_controller_params)
+
+      solr_response = repository.search(query)
+
+      [solr_response, solr_response.documents]
+    end
+
+    def fetch_one(id, extra_controller_params)
+      solr_response = repository.find id, extra_controller_params
+      [solr_response, solr_response.documents.first]
+    end
+  end
+end

data/app/services/hyrax/simple_schema_loader.rb

@@ -34,7 +34,7 @@ module Hyrax
     ##
     # @param [Symbol] schema
     #
-    # @return [Hash<Symbol, Symbol>] a map from index keys to attribute names
+    # @return [{Symbol => Symbol}] a map from index keys to attribute names
     def index_rules_for(schema:)
       definitions(schema).each_with_object({}) do |definition, hash|
         definition.index_keys.each do |key|
@@ -108,6 +108,8 @@ module Hyrax
       # @return [Dry::Types::Type]
       def type_for(type)
         case type
+        when 'id'
+          Valkyrie::Types::ID
         when 'uri'
           Valkyrie::Types::URI
         when 'date_time'

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

@@ -50,7 +50,6 @@ module Hyrax
           DepositSearchBuilder.new([:include_depositor_facet, :filter_models], self)
         end
 
-        # TODO: This can probably be pushed into the DepositSearchBuilder
         def query
           search_builder.merge(q: date_query).query
         end

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

@@ -2,7 +2,6 @@
 module Hyrax
   module Statistics
     # A class that retrieves system level statistics about the system
-    # TODO: this class could be refactored into several classes.
     #
     # @attr_reader [Integer] limit      limits the results returned from top_depositors and top_formats
     #                             Default is 5, maximum is 20, minimum is 5

data/app/services/hyrax/thumbnail_path_service.rb

@@ -11,7 +11,7 @@ module Hyrax
 
         return unless thumb
         return call(thumb) unless thumb.file_set?
-        if thumb.audio?
+        if audio?(thumb)
           audio_image
         elsif thumbnail?(thumb)
           thumbnail_path(thumb)
@@ -22,6 +22,11 @@ module Hyrax
 
       private
 
+      def audio?(thumb)
+        service = thumb.respond_to?(:audio?) ? thumb : Hyrax::FileSetTypeService.new(file_set: thumb)
+        service.audio?
+      end
+
       def fetch_thumbnail(object)
         return object if object.thumbnail_id == object.id
         Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: object.thumbnail_id)

data/app/services/hyrax/time_service.rb

@@ -1,6 +1,16 @@
 # frozen_string_literal: true
 module Hyrax
+  ##
+  # Give the current time in UTC
+  #
+  # Use of this service allows a single integration point timestamps. If your
+  # application (or test suite) needs to provide a special time for "now", you
+  # can override it here.
+  #
+  # @example
+  #   Hyrax::TimeService.time_in_utc
   class TimeService
+    ##
     # @return [DateTime] the current time in UTC
     def self.time_in_utc
       DateTime.current

data/app/services/hyrax/versioning_service.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'wings/services/file_metadata_builder'
 
 module Hyrax
   class VersioningService
@@ -38,27 +37,12 @@ module Hyrax
         Hyrax::VersionCommitter.create(version_id: version_id, committer_login: user_key)
       end
 
-      # TODO: WINGS - Copied from valkyrie6 branch.  Need to explore whether this is needed?
-      # # @param [FileSet] file_set
-      # # @param [Hyrax::FileMetadata] content
-      # # @param [String] revision_id
-      # # @param [User, String] user
-      # def restore_version(file_set, content, revision_id, user = nil)
-      #   found_version = content.versions.find { |x| x.label == Array.wrap(revision_id) }
-      #   return unless found_version
-      #   file_metadata = Wings::FileMetadataBuilder.new(storage_adapter: nil, persister: indexing_adapter.persister).attach_file_metadata(file_metadata: found_version, file_set: file_set)
-      #   create(file_metadata, user)
-      # end
-
       private
 
-      # # TODO: WINGS - Should we create and use indexing adapter for persistence?  This is what was used in branch valkyrie6.  See issue #3800.
-      # def indexing_adapter
-      #   Valkyrie::MetadataAdapter.find(:indexing_persister)
-      # end
-
       def perform_create(content, user, use_valkyrie)
         use_valkyrie ? perform_create_through_valkyrie(content, user) : perform_create_through_active_fedora(content, user)
+      rescue NotImplementedError
+        Rails.logger.warn "Declining to create a Version for #{content}; #{self} doesn't support versioning with use_valkyrie: #{use_valkyrie}"
       end
 
       def perform_create_through_active_fedora(content, user)
@@ -66,16 +50,8 @@ module Hyrax
         record_committer(content, user) if user
       end
 
-      def perform_create_through_valkyrie(content, user)
-        return # TODO: WINGS - Just return for now.  This method won't work until #indexing_adapter method is complete.  See issue #3800.
-        # rubocop:disable Lint/UnreachableCode
-        new_version = content.new(id: nil)
-        new_version.label = "version#{content.member_ids.length + 1}"
-        new_version = indexing_adapter.persister.save(resource: new_version)
-        content.member_ids = content.member_ids + [new_version.id]
-        content = indexing_adapter.persister.save(resource: content)
-        record_committer(content, user) if user
-        # rubocop:enable Lint/UnreachableCode
+      def perform_create_through_valkyrie(content, user) # no-op
+        raise NotImplementedError
       end
     end
   end

data/app/services/hyrax/work_uploads_handler.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # @api public
+  #
+  # Mediates uploads to a work.
+  #
+  # Given an existing Work object, `#add` some set of files, then call `#attach`
+  # to handle creation/attachment of File Sets, and trigger persistence of files
+  # to the storage backend.
+  #
+  # This class provides both an interface and a concrete implementation.
+  # Applications that want to handle file attachment differently (e.g. by making
+  # them completely synchronous, by attaching file sets to a different work
+  # attribute, by supporting another file/IO class, etc...) can use a different
+  # `Handler` implementation. The only guarantee made by the _interface_ is that
+  # the process of persisting the relationship between `work` and the provided
+  # `files` will start when `#attach` is called.
+  #
+  # This base implementation accepts only `Hyrax::UploadedFile` instances and,
+  # for each one, creates a `Hyrax::FileSet` with permissions matching those on
+  # `work`, and appends that FileSet to `member_ids`. The `FileSet` will be
+  # added in the order that the `UploadedFiles` are passed in. If the work has a
+  # `nil` `representative_id` and/or `thumbnail_id`, the first `FileSet` will be
+  # set to that value. An `IngestJob` will be equeued, for each `FileSet`. When
+  # all of the `files` have been processed, the work will be saved with the
+  # added members. While this is happening, we take a lock on the work via
+  # `Lockable` (Redis/Redlock).
+  #
+  # This also publishes events as required by `Hyrax.publisher`.
+  #
+  # @todo make this genuinely retry-able. if we fail after creating some of
+  #   the file_sets, but not attaching them to works, we should resolve that
+  #   incomplete work on subsequent runs.
+  #
+  #
+  # @example
+  #   Hyrax::WorkUploadsHandler.new(work: my_work)
+  #     .add(files: [file1, file2])
+  #     .attach
+  #
+  class WorkUploadsHandler
+    include Lockable
+
+    ##
+    # @!attribute [r] files
+    #   @return [Enumberable<Hyrax::UploadedFile>]
+    # @!attribute [r] work
+    #   @return [Hyrax::Work]
+    attr_reader :files, :work
+
+    ##
+    # @param [Hyrax::Work] work
+    # @param [#save] persister the valkyrie persister to use
+    def initialize(work:, persister: Hyrax.persister)
+      @work = work
+      @persister = persister
+    end
+
+    ##
+    # @api public
+    #
+    # @note we immediately and silently discard uploads with an existing
+    #   file_set_uri, in a half-considered attempt at supporting idempotency
+    #   (for job retries). this is for legacy/AttachFilesToWorkJob
+    #   compatibility, but could stand for a roubst reimplementation.
+    #
+    # @param [Enumberable<Hyrax::UploadedFile>] files  files to add
+    #
+    # @return [WorkFileSetManager] self
+    # @raise [ArgumentError] if any of the uploaded files are not an
+    #   `UploadedFile`
+    def add(files:)
+      validate_files(files) &&
+        @files = Array.wrap(files).reject { |f| f.file_set_uri.present? }
+      self
+    end
+
+    ##
+    # @api public
+    #
+    # Create filesets for each added file
+    #
+    # @return [Boolean] true if all requested files were attached
+    def attach
+      return true if Array.wrap(files).empty? # short circuit to avoid aquiring a lock we won't use
+
+      acquire_lock_for(work.id) do
+        event_payloads = files.each_with_object([]) { |file, arry| arry << make_file_set_and_ingest(file) }
+        Hyrax.persister.save(resource: work)
+        event_payloads.each { |payload| Hyrax.publisher.publish('file.set.attached', payload) }
+      end
+    end
+
+    private
+
+    ##
+    # @api private
+    def make_file_set_and_ingest(file)
+      file_set = @persister.save(resource: Hyrax::FileSet.new(file_set_args(file)))
+      Hyrax.publisher.publish('object.deposited', object: file_set, user: file.user)
+      file.add_file_set!(file_set)
+
+      # copy ACLs; should we also be propogating embargo/lease?
+      Hyrax::AccessControlList.copy_permissions(source: target_permissions, target: file_set)
+      append_to_work(file_set)
+      IngestJob.perform_later(wrap_file(file, file_set))
+      { file_set: file_set, user: file.user }
+    end
+
+    ##
+    # @api private
+    #
+    # @todo figure out how to know less about Work's ideas about FileSet use here. Maybe post-Wings, work.
+    def append_to_work(file_set)
+      work.member_ids << file_set.id
+      work.representative_id = file_set.id if work.respond_to?(:representative_id) && work.representative_id.blank?
+      work.thumbnail_id = file_set.id if work.respond_to?(:thumbnail_id) && work.thumbnail_id.blank?
+    end
+
+    ##
+    # @api private
+    #
+    # @return [Hash{Symbol => Object}]
+    def file_set_args(file)
+      { depositor: file.user.user_key,
+        creator: file.user.user_key,
+        date_uploaded: file.created_at,
+        date_modified: Hyrax::TimeService.time_in_utc,
+        label: file.uploader.filename,
+        title: file.uploader.filename }
+    end
+
+    ##
+    # @api private
+    #
+    # @note cache these per instance to avoid repeated lookups.
+    #
+    # @return [Hyrax::AccessControlList] permissions to set on created filesets
+    def target_permissions
+      @target_permissions ||= Hyrax::AccessControlList.new(resource: work)
+    end
+
+    ##
+    # @api private
+    # @return [JobIoWrapper]
+    def wrap_file(file, file_set)
+      JobIoWrapper.create_with_varied_file_handling!(user: file.user, file: file, relation: :original_file, file_set: file_set)
+    end
+
+    ##
+    # @api private
+    #
+    # @note ported from AttachFilesToWorkJob. do we need this? maybe we should
+    #   validate something other than type?
+    #
+    # @raise [ArgumentError] if any of the uploaded files aren't the right class
+    def validate_files(files)
+      files.each do |file|
+        next if file.is_a? Hyrax::UploadedFile
+        raise ArgumentError, "Hyrax::UploadedFile required, but #{file.class} received: #{file.inspect}"
+      end
+    end
+  end
+end