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

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

@@ -5,7 +5,7 @@ module Hyrax
         private
 
           def index_key
-            ActiveFedora.index_field_mapper.solr_name("resource_type", :facetable)
+            "resource_type_sim"
           end
       end
     end

data/app/services/hyrax/thumbnail_path_service.rb

@@ -7,8 +7,9 @@ module Hyrax
         return default_image unless object.thumbnail_id
 
         thumb = fetch_thumbnail(object)
+
         return unless thumb
-        return call(thumb) unless thumb.is_a?(::FileSet)
+        return call(thumb) unless thumb.file_set?
         if thumb.audio?
           audio_image
         elsif thumbnail?(thumb)
@@ -22,8 +23,8 @@ module Hyrax
 
         def fetch_thumbnail(object)
           return object if object.thumbnail_id == object.id
-          ::ActiveFedora::Base.find(object.thumbnail_id)
-        rescue ActiveFedora::ObjectNotFoundError
+          Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: object.thumbnail_id)
+        rescue Hyrax::ObjectNotFoundError
           Rails.logger.error("Couldn't find thumbnail #{object.thumbnail_id} for #{object.id}")
           nil
         end

data/app/services/hyrax/versioning_service.rb

@@ -1,26 +1,81 @@
+require 'wings/services/file_metadata_builder'
+
 module Hyrax
   class VersioningService
-    # Make a version and record the version committer
-    # @param [ActiveFedora::File] content
-    # @param [User, String] user
-    def self.create(content, user = nil)
-      content.create_version
-      record_committer(content, user) if user
-    end
+    class << self
+      # Make a version and record the version committer
+      # @param [ActiveFedora::File | Hyrax::FileMetadata] content
+      # @param [User, String] user
+      def create(content, user = nil)
+        use_valkyrie = content.is_a? Hyrax::FileMetadata
+        perform_create(content, user, use_valkyrie)
+      end
 
-    # @param [ActiveFedora::File] file
-    def self.latest_version_of(file)
-      file.versions.last
-    end
+      # @param [ActiveFedora::File | Hyrax::FileMetadata] content
+      def latest_version_of(file)
+        file.versions.last
+      end
+
+      # @param [ActiveFedora::File | Hyrax::FileMetadata] content
+      def versioned_file_id(file)
+        versions = file.versions.all
+        if versions.present?
+          ActiveFedora::File.uri_to_id versions.last.uri
+        else
+          file.id
+        end
+      end
+
+      # Record the version committer of the last version
+      # @param [ActiveFedora::File | Hyrax::FileMetadata] content
+      # @param [User, String] user_key
+      def record_committer(content, user_key)
+        user_key = user_key.user_key if user_key.respond_to?(:user_key)
+        version = latest_version_of(content)
+        return if version.nil?
+        version_id = content.is_a?(Hyrax::FileMetadata) ? version.id.to_s : version.uri
+        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)
+        end
+
+        def perform_create_through_active_fedora(content, user)
+          content.create_version
+          record_committer(content, user) if user
+        end
 
-    # Record the version committer of the last version
-    # @param [ActiveFedora::File] content
-    # @param [User, String] user_key
-    def self.record_committer(content, user_key)
-      user_key = user_key.user_key if user_key.respond_to?(:user_key)
-      version = latest_version_of(content)
-      return if version.nil?
-      VersionCommitter.create(version_id: version.uri, committer_login: user_key)
+        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
+        end
     end
   end
 end

data/app/services/hyrax/virus_checker_service.rb

@@ -0,0 +1,52 @@
+module Hyrax
+  # Responsible for checking if the given file is a virus. Coordinates
+  # with the underlying system virus scanner.
+  class VirusCheckerService
+    attr_accessor :original_file, :system_virus_scanner
+
+    # @api public
+    # @param original_file [String, #path]
+    # @return true or false result from system_virus_scanner
+    def self.file_has_virus?(original_file)
+      new(original_file).file_has_virus?
+    end
+
+    def initialize(original_file, system_virus_scanner = Hyrax.primary_work_type.default_system_virus_scanner)
+      self.original_file = original_file
+      self.system_virus_scanner = system_virus_scanner
+    end
+
+    # Default behavior is to raise a validation error and halt the save if a virus is found
+    def file_has_virus?
+      path = original_file.is_a?(String) ? original_file : local_path_for_file(original_file)
+      system_virus_scanner.infected?(path)
+    end
+
+    private
+
+      # Returns a path for reading the content of +file+
+      # @param [File] file object to retrieve a path for
+      def local_path_for_file(file)
+        return file.path if file.respond_to?(:path)
+        return file.content.path if file.content.respond_to?(:path)
+
+        Tempfile.open('') do |t|
+          t.binmode
+          write_to_temp_file(file, t)
+          t.close
+          t.path
+        end
+      end
+
+      def write_to_temp_file(file, temp_file)
+        if file.new_record?
+          temp_file.write(file.content.read)
+          file.content.rewind
+        else
+          file.stream.each do |chunk|
+            temp_file.write(chunk)
+          end
+        end
+      end
+  end
+end

data/app/services/hyrax/visibility_intention_applicator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module Hyrax
+  ##
+  # Applies a `VisibilityIntention` to a repository object.
+  class VisibilityIntentionApplicator
+    ##
+    # @!attribute [rw] intention
+    #   @return [VisibilityIntention]
+    attr_accessor :intention
+
+    ##
+    # @param [VisibilityIntention] intention
+    def initialize(intention:)
+      self.intention = intention
+    end
+
+    ##
+    # @param [VisibilityIntention] intention
+    #
+    # @return [VisibilityIntentionApplicator]
+    def self.apply(intention)
+      new(intention: intention)
+    end
+
+    ##
+    # @param [Object] model an object; this probably needs to be leasable,
+    #   embargoable, has visibility, and an AdminSet/PermissionTemplate.
+    def apply_to(model:)
+      if intention.wants_embargo?
+        raise InvalidIntentionError unless intention.valid_embargo?
+        model.apply_embargo(*intention.embargo_params)
+      elsif intention.wants_lease?
+        raise InvalidIntentionError unless intention.valid_lease?
+        model.apply_lease(*intention.lease_params)
+      else
+        model.visibility = intention.visibility
+      end
+    end
+    alias to apply_to
+
+    class InvalidIntentionError < ArgumentError; end
+  end
+end

data/app/services/hyrax/visibility_map.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Defines a map from a visibility string value to appropriate permissions
+  # representing that visibility.
+  #
+  # @see Hyrax::VisibilityReader
+  # @see Hyrax::VisibilityWriter
+  # @see Hyrax::Resource#visibility
+  class VisibilityMap
+    DEFAULT_MAP = {
+      Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC => {
+        permission: Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_PUBLIC,
+        additions: [Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_PUBLIC].freeze,
+        deletions: [].freeze
+      }.freeze,
+      Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED => {
+        permission: Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_AUTHENTICATED,
+        additions: [Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_AUTHENTICATED].freeze,
+        deletions: [Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_PUBLIC].freeze
+      }.freeze,
+      Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE => {
+        permission: :PRIVATE,
+        additions: [].freeze,
+        deletions: [Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_PUBLIC,
+                    Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_AUTHENTICATED].freeze
+      }.freeze
+    }.freeze
+
+    extend Forwardable
+    include Singleton
+
+    def_delegators :@map, :[]
+
+    ##
+    # @!attribute [r] map
+    #   @return [Hash<String, Hash>]
+    attr_reader :map
+
+    ##
+    # @param map [Hash<String, String>]
+    def initialize(map: DEFAULT_MAP)
+      @map = map
+    end
+
+    ##
+    # Reverse lookup a visibility stirng from the permission group value
+    def visibility_for(group:)
+      @map.find { |_, v| v[:permission] == group }&.first
+    end
+
+    def additions_for(visibility:)
+      self[visibility][:additions]
+    end
+
+    def deletions_for(visibility:)
+      self[visibility][:deletions]
+    end
+
+    def visibilities
+      @map.keys
+    end
+  end
+end

data/app/services/hyrax/visibility_propagator.rb

@@ -0,0 +1,19 @@
+module Hyrax
+  ##
+  # @abstract Propogates visibility from a provided object (e.g. a Work) to some
+  # group of its members (e.g. file_sets).
+  class VisibilityPropagator
+    ##
+    # @param source [#visibility] the object to propogate visibility from
+    #
+    # @return [#propogate]
+    def self.for(source:)
+      case source
+      when Hyrax::WorkBehavior # ActiveFedora
+        FileSetVisibilityPropagator.new(source: source)
+      when Hyrax::Resource # Valkyrie
+        ResourceVisibilityPropagator.new(source: source)
+      end
+    end
+  end
+end

data/app/services/hyrax/visibility_reader.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Translates a set of ACLs into a visibility string.
+  #
+  # @example
+  #   resource = Hyrax::Resource.new
+  #   reader   = Hyrax::VisibilityReader.new(resource: resource)
+  #   reader.read # => "restricted"
+  #
+  #   resource.read_groups = ["public"]
+  #   reader.read # => "open"
+  #
+  class VisibilityReader
+    ##
+    # @!attribute [rw] resource
+    #   @return [Valkyrie::Resource::AccessControls]
+    attr_accessor :resource
+
+    ##
+    # @param resource [Valkyrie::Resource::AccessControls]
+    def initialize(resource:)
+      self.resource = resource
+    end
+
+    ##
+    # @return [String]
+    def read
+      if resource.read_groups.include? Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_PUBLIC
+        visibility_map.visibility_for(group: Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_PUBLIC)
+      elsif resource.read_groups.include? Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_AUTHENTICATED
+        visibility_map.visibility_for(group: Hydra::AccessControls::AccessRight::PERMISSION_TEXT_VALUE_AUTHENTICATED)
+      else
+        visibility_map.visibility_for(group: :PRIVATE)
+      end
+    end
+
+    def visibility_map
+      Hyrax::VisibilityMap.instance
+    end
+  end
+end

data/app/services/hyrax/visibility_writer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Hyrax
+  ##
+  # Sets ACLs from a visibility string
+  #
+  # @example
+  #   resource = Hyrax::Resource.new
+  #   writer   = Hyrax::VisibilityWriter.new(resource: resource)
+  #   resource.read_groups # => []
+  #
+  #   writer.assign_access_for(visibility: 'open')
+  #   resource.read_groups # => ["public"]
+  #
+  #   writer.assign_access_for(visibility: 'authenticated')
+  #   resource.read_groups # => ["registered"]
+  #
+  class VisibilityWriter
+    ##
+    # @!attribute [rw] resource
+    #   @return [Valkyrie::Resource::AccessControls]
+    attr_accessor :resource
+
+    ##
+    # @param resource [Valkyrie::Resource::AccessControls]
+    def initialize(resource:)
+      self.resource = resource
+    end
+
+    ##
+    # @param visibility [String]
+    #
+    # @return [void]
+    def assign_access_for(visibility:)
+      resource.read_groups -= visibility_map.deletions_for(visibility: visibility)
+      resource.read_groups += visibility_map.additions_for(visibility: visibility)
+    end
+
+    def visibility_map
+      Hyrax::VisibilityMap.instance
+    end
+  end
+end

data/app/services/hyrax/work_query_service.rb

@@ -4,7 +4,7 @@ module Hyrax
   # @see ProxyDepositRequest
   # @see Hyrax::WorkRelation
   # @see SolrDocument
-  # @see ActiveFedora::SolrService
+  # @see Hyrax::SolrService
   # @see ActiveFedora::SolrQueryBuilder
   # @note This was extracted from the ProxyDepositRequest, which was coordinating lots of effort. It was also an ActiveRecord object that required lots of Fedora/Solr interactions.
   class WorkQueryService
@@ -48,11 +48,11 @@ module Hyrax
       end
 
       def solr_response
-        @solr_response ||= ActiveFedora::SolrService.get(query)
+        @solr_response ||= Hyrax::SolrService.get(query)
       end
 
       def query
-        ActiveFedora::SolrQueryBuilder.construct_query_for_ids([id])
+        Hyrax::SolrQueryBuilderService.construct_query_for_ids([id])
       end
   end
 end

data/app/services/hyrax/workflow/deposited_notification.rb

@@ -13,7 +13,7 @@ module Hyrax
         end
 
         def users_to_notify
-          user_key = ActiveFedora::Base.find(work_id).depositor
+          user_key = Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: work_id).depositor
           super << ::User.find_by(email: user_key)
         end
     end

data/app/services/hyrax/works/migration_service.rb

@@ -0,0 +1,33 @@
+module Hyrax
+  module Works
+    class MigrationService
+      # @api public
+      #
+      # Migrate data stored in FCrepo from one predicate to another
+      #   The main use case is where the predicate used for a specific property is changed.
+      #   Data already stored in Fedora under the original predicate needs to be transfered
+      #   and the original data cleaned up.
+      def self.migrate_predicate(predicate_from, predicate_to, works_to_update = ActiveFedora::Base.all)
+        migrated = 0
+        Rails.logger.info "*** Migrating #{predicate_from} to #{predicate_to} in #{works_to_update.count} works"
+        works_to_update.each do |work|
+          next unless work.ldp_source.content.include?(predicate_from.to_s)
+          migrate_data(predicate_from, predicate_to, work)
+          migrated += 1
+        end
+        Rails.logger.info "--- Migration Complete (#{migrated} migrated)"
+      end
+
+      # @api private
+      #
+      # Migrate data
+      def self.migrate_data(predicate_from, predicate_to, work)
+        orm = Ldp::Orm.new(work.ldp_source)
+        orm.value(predicate_from).each { |val| orm.graph.insert([orm.resource.subject_uri, predicate_to, val.to_s]) }
+        orm.graph.delete([orm.resource.subject_uri, predicate_from, nil])
+        orm.save
+        Rails.logger.info " Data migrated from #{predicate_from} to #{predicate_to} - id: #{work.id}"
+      end
+    end
+  end
+end