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

data/app/actors/hyrax/actors/add_to_work_actor.rb

@@ -5,7 +5,10 @@ module Hyrax
       # @return [Boolean] true if create was successful
       def create(env)
         work_ids = env.attributes.delete(:in_works_ids)
-        next_actor.create(env) && add_to_works(env, work_ids)
+
+        can_edit_works?(env, work_ids) &&
+          next_actor.create(env) &&
+          add_to_works(env, work_ids)
       end
 
       # @param [Hyrax::Actors::Environment] env
@@ -21,6 +24,15 @@ module Hyrax
           env.current_ability.can?(:edit, work) && env.current_ability.can?(:edit, env.curation_concern)
         end
 
+        def can_edit_works?(env, work_ids)
+          unless Array(work_ids).all? { |work_id| env.current_ability.can?(:edit, work_id) }
+            add_permissions_error(env.curation_concern)
+            return false
+          end
+
+          true
+        end
+
         def add_to_works(env, new_work_ids)
           return true if new_work_ids.nil?
           cleanup_ids_to_remove_from_curation_concern(env, new_work_ids)
@@ -30,7 +42,7 @@ module Hyrax
 
         def cleanup_ids_to_remove_from_curation_concern(env, new_work_ids)
           (env.curation_concern.in_works_ids - new_work_ids).each do |old_id|
-            work = ::ActiveFedora::Base.find(old_id)
+            work = Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: old_id, use_valkyrie: false)
             work.ordered_members.delete(env.curation_concern)
             work.members.delete(env.curation_concern)
             work.save!
@@ -39,16 +51,27 @@ module Hyrax
 
         def add_new_work_ids_not_already_in_curation_concern(env, new_work_ids)
           # add to new so long as the depositor for the parent and child matches, otherwise inject an error
-          (new_work_ids - env.curation_concern.in_works_ids).each do |work_id|
-            work = ::ActiveFedora::Base.find(work_id)
+          new_works_for(env, new_work_ids).each do |work|
             if can_edit_both_works?(env, work)
               work.ordered_members << env.curation_concern
               work.save!
             else
-              env.curation_concern.errors[:in_works_ids] << "Works can only be related to each other if user has ability to edit both."
+              add_permissions_error(env.curation_concern)
             end
           end
         end
+
+        def new_works_for(env, new_work_ids)
+          query_service = Valkyrie.config.metadata_adapter.query_service
+
+          (new_work_ids - env.curation_concern.in_works_ids).map do |work_id|
+            query_service.find_by_alternate_identifier(alternate_identifier: work_id, use_valkyrie: false)
+          end
+        end
+
+        def add_permissions_error(work)
+          work.errors[:in_works_ids] << "Works can only be related to each other if user has ability to edit both."
+        end
     end
   end
 end

data/app/actors/hyrax/actors/apply_order_actor.rb

@@ -27,7 +27,7 @@ module Hyrax
         # @see Hyrax::Actors::AddToWorkActor for duplication
         def cleanup_ids_to_remove_from_curation_concern(curation_concern, ordered_member_ids)
           (curation_concern.ordered_member_ids - ordered_member_ids).each do |old_id|
-            work = ::ActiveFedora::Base.find(old_id)
+            work = Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: old_id, use_valkyrie: false)
             curation_concern.ordered_members.delete(work)
             curation_concern.members.delete(work)
           end
@@ -35,7 +35,7 @@ module Hyrax
 
         def add_new_work_ids_not_already_in_curation_concern(env, ordered_member_ids)
           (ordered_member_ids - env.curation_concern.ordered_member_ids).each do |work_id|
-            work = ::ActiveFedora::Base.find(work_id)
+            work = Hyrax.query_service.find_by_alternate_identifier(alternate_identifier: work_id, use_valkyrie: false)
             if can_edit_both_works?(env, work)
               env.curation_concern.ordered_members << work
               env.curation_concern.save!

data/app/actors/hyrax/actors/attach_members_actor.rb

@@ -11,6 +11,9 @@ module Hyrax
     # The goal of this actor is to mutate the ordered_members with as few writes
     # as possible, because changing ordered_members is slow. This class only
     # writes changes, not the full ordered list.
+    #
+    # The `env` for this actor may contain a `Valkyrie::Resource` or an
+    # `ActiveFedora::Base` model, as required by the
     class AttachMembersActor < Hyrax::Actors::AbstractActor
       # @param [Hyrax::Actors::Environment] env
       # @return [Boolean] true if update was successful
@@ -24,43 +27,62 @@ module Hyrax
 
         # Attaches any unattached members.  Deletes those that are marked _delete
         # @param [Hash<Hash>] a collection of members
+        #
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # Complexity in this method is incleased by dual AF/Valkyrie support
+        # when removing AF, we should be able to reduce it substantially.
         def assign_nested_attributes_for_collection(env, attributes_collection)
           return true unless attributes_collection
-          attributes_collection = attributes_collection.sort_by { |i, _| i.to_i }.map { |_, attributes| attributes }
-          # checking for existing works to avoid rewriting/loading works that are
-          # already attached
-          existing_works = env.curation_concern.member_ids
-          attributes_collection.each do |attributes|
-            next if attributes['id'].blank?
-            if existing_works.include?(attributes['id'])
-              remove(env.curation_concern, attributes['id']) if has_destroy_flag?(attributes)
-            else
-              add(env, attributes['id'])
-            end
-          end
+
+          attributes         = extract_attributes(attributes_collection)
+          cast_concern       = !env.curation_concern.is_a?(Valkyrie::Resource)
+          resource           = cast_concern ? env.curation_concern.valkyrie_resource : env.curation_concern
+          inserts, destroys  = split_inserts_and_destroys(attributes, resource)
+
+          # short circuit to avoid casting unnecessarily
+          return true if destroys.empty? && inserts.empty?
+          # we fail silently if we can't insert the object; this is for legacy
+          # compatibility
+          return true unless check_permissions(ability: env.current_ability,
+                                               inserts: inserts,
+                                               destroys: destroys)
+
+          update_members(resource: resource, inserts: inserts, destroys: destroys)
+
+          return true unless cast_concern
+          env.curation_concern = Hyrax.metadata_adapter
+                                      .resource_factory
+                                      .from_resource(resource: resource)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def extract_attributes(collection)
+          collection
+            .sort_by { |i, _| i.to_i }
+            .map { |_, attributes| attributes }
+        end
+
+        def split_inserts_and_destroys(attributes, resource)
+          current_member_ids = resource.member_ids.map(&:id)
+
+          destroys = attributes.select do |col_hash|
+            ActiveModel::Type::Boolean.new.cast(col_hash['_destroy'])
+          end
+
+          inserts  = (attributes - destroys).map { |h| h['id'] }.compact - current_member_ids
+          destroys = destroys.map { |h| h['id'] }.compact & current_member_ids
 
-        # Adds the item to the ordered members so that it displays in the items
-        # along side the FileSets on the show page
-        def add(env, id)
-          member = ActiveFedora::Base.find(id)
-          return unless env.current_ability.can?(:edit, member)
-          env.curation_concern.ordered_members << member
+          [inserts, destroys]
         end
 
-        # Remove the object from the members set and the ordered members list
-        def remove(curation_concern, id)
-          member = ActiveFedora::Base.find(id)
-          curation_concern.ordered_members.delete(member)
-          curation_concern.members.delete(member)
+        def update_members(resource:, inserts: [], destroys: [])
+          resource.member_ids += inserts.map  { |id| Valkyrie::ID.new(id) }
+          resource.member_ids -= destroys.map { |id| Valkyrie::ID.new(id) }
         end
 
-        # Determines if a hash contains a truthy _destroy key.
-        # rubocop:disable Naming/PredicateName
-        def has_destroy_flag?(hash)
-          ActiveFedora::Type::Boolean.new.cast(hash['_destroy'])
+        def check_permissions(ability:, inserts: [], **_opts)
+          inserts.all? { |id| ability.can?(:edit, id) }
         end
-      # rubocop:enable Naming/PredicateName
     end
   end
 end

data/app/actors/hyrax/actors/base_actor.rb

@@ -18,7 +18,10 @@ module Hyrax
       def create(env)
         apply_creation_data_to_curation_concern(env)
         apply_save_data_to_curation_concern(env)
-        save(env) && next_actor.create(env) && run_callbacks(:after_create_concern, env)
+
+        save(env, use_valkyrie: false) &&
+          next_actor.create(env) &&
+          run_callbacks(:after_create_concern, env)
       end
 
       # @param [Hyrax::Actors::Environment] env
@@ -64,7 +67,19 @@ module Hyrax
           env.curation_concern.date_uploaded = TimeService.time_in_utc
         end
 
-        def save(env)
+        def save(env, use_valkyrie: false)
+          return env.curation_concern.save unless use_valkyrie
+
+          env.curation_concern.embargo&.save
+          env.curation_concern.lease&.save
+
+          resource = Hyrax.persister.save(resource: env.curation_concern.valkyrie_resource)
+
+          env.curation_concern = Hyrax.metadata_adapter.resource_factory.from_resource(resource: resource)
+        rescue Wings::Valkyrie::Persister::FailedSaveError => _err
+          # for now, just hit the validation error again
+          # later we should capture the _err.obj and pass it back
+          # through the environment
           env.curation_concern.save
         end
 

data/app/actors/hyrax/actors/cleanup_file_sets_actor.rb

@@ -22,7 +22,7 @@ module Hyrax
           curation_concern.list_source.destroy
           # Remove Work from Solr after it was removed from Fedora so that the
           # in_objects lookup does not break when FileSets are destroyed.
-          ActiveFedora::SolrService.delete(curation_concern.id)
+          Hyrax::SolrService.delete(curation_concern.id)
           fs.each(&:destroy)
         end
     end

data/app/actors/hyrax/actors/collections_membership_actor.rb

@@ -45,7 +45,8 @@ module Hyrax
           attributes_collection.each do |attributes|
             next if attributes['id'].blank?
             if existing_collections.include?(attributes['id'])
-              remove(env.curation_concern, attributes['id']) if has_destroy_flag?(attributes)
+              remove(env.curation_concern, attributes['id']) if
+                ActiveModel::Type::Boolean.new.cast(attributes['_destroy'])
             else
               add(env, attributes['id'])
             end
@@ -71,13 +72,6 @@ module Hyrax
           curation_concern.member_of_collections.delete(collection)
         end
 
-        # Determines if a hash contains a truthy _destroy key.
-        # rubocop:disable Naming/PredicateName
-        def has_destroy_flag?(hash)
-          ActiveFedora::Type::Boolean.new.cast(hash['_destroy'])
-        end
-        # rubocop:enable Naming/PredicateName
-
         # Extact a singleton collection id from the collection attributes and save it in env.  Later in the actor stack,
         # in apply_permission_template_actor.rb, `env.attributes[:collection_id]` will be used to apply the
         # permissions of the collection to the created work.  With one and only one collection, the work is seen as

data/app/actors/hyrax/actors/create_with_files_actor.rb

@@ -6,16 +6,26 @@ module Hyrax
       # @return [Boolean] true if create was successful
       def create(env)
         uploaded_file_ids = filter_file_ids(env.attributes.delete(:uploaded_files))
-        files = uploaded_files(uploaded_file_ids)
-        validate_files(files, env) && next_actor.create(env) && attach_files(files, env)
+        files             = uploaded_files(uploaded_file_ids)
+        # get a current copy of attributes, to protect against future mutations
+        attributes        = env.attributes.clone
+
+        validate_files(files, env) &&
+          next_actor.create(env) &&
+          attach_files(files, env.curation_concern, attributes)
       end
 
       # @param [Hyrax::Actors::Environment] env
       # @return [Boolean] true if update was successful
       def update(env)
         uploaded_file_ids = filter_file_ids(env.attributes.delete(:uploaded_files))
-        files = uploaded_files(uploaded_file_ids)
-        validate_files(files, env) && next_actor.update(env) && attach_files(files, env)
+        files             = uploaded_files(uploaded_file_ids)
+        # get a current copy of attributes, to protect against future mutations
+        attributes        = env.attributes.clone
+
+        validate_files(files, env) &&
+          next_actor.update(env) &&
+          attach_files(files, env.curation_concern, attributes)
       end
 
       private
@@ -37,9 +47,9 @@ module Hyrax
         end
 
         # @return [TrueClass]
-        def attach_files(files, env)
+        def attach_files(files, curation_concern, attributes)
           return true if files.blank?
-          AttachFilesToWorkJob.perform_later(env.curation_concern, files, env.attributes.to_h.symbolize_keys)
+          AttachFilesToWorkJob.perform_later(curation_concern, files, attributes.to_h.symbolize_keys)
           true
         end
 

data/app/actors/hyrax/actors/create_with_files_ordered_members_actor.rb

@@ -35,9 +35,9 @@ module Hyrax
     # Creates a work and attaches files to the work
     class CreateWithFilesOrderedMembersActor < CreateWithFilesActor
       # @return [TrueClass]
-      def attach_files(files, env)
+      def attach_files(files, curation_concern, attributes)
         return true if files.blank?
-        AttachFilesToWorkWithOrderedMembersJob.perform_later(env.curation_concern, files, env.attributes.to_h.symbolize_keys)
+        AttachFilesToWorkWithOrderedMembersJob.perform_later(curation_concern, files, attributes.to_h.symbolize_keys)
         true
       end
     end

data/app/actors/hyrax/actors/create_with_remote_files_actor.rb

@@ -64,7 +64,8 @@ module Hyrax
         # Generic utility for creating FileSet from a URL
         # Used in to import files using URLs from a file picker like browse_everything
         def create_file_from_url(env, uri, file_name, auth_header = {})
-          ::FileSet.new(import_url: uri.to_s, label: file_name) do |fs|
+          import_url = URI.decode_www_form_component(uri.to_s)
+          ::FileSet.new(import_url: import_url, label: file_name) do |fs|
             actor = Hyrax::Actors::FileSetActor.new(fs, env.user)
             actor.create_metadata(visibility: env.curation_concern.visibility)
             actor.attach_to_work(env.curation_concern)

data/app/actors/hyrax/actors/create_with_remote_files_ordered_members_actor.rb

@@ -42,11 +42,13 @@ module Hyrax
     # Browse everything may also return a local file. And although it's in the
     # url property, it may have spaces, and not be a valid URI.
     class CreateWithRemoteFilesOrderedMembersActor < CreateWithRemoteFilesActor
+      attr_reader :ordered_members
+
       # @param [HashWithIndifferentAccess] remote_files
       # @return [TrueClass]
       def attach_files(env, remote_files)
         return true unless remote_files
-        env.store(self, :ordered_members, env.curation_concern.ordered_members.to_a)
+        @ordered_members = env.curation_concern.ordered_members.to_a
         remote_files.each do |file_info|
           next if file_info.blank? || file_info[:url].blank?
           # Escape any space characters, so that this is a legal URI
@@ -58,7 +60,7 @@ module Hyrax
           auth_header = file_info.fetch(:auth_header, {})
           create_file_from_url(env, uri, file_info[:file_name], auth_header)
         end
-        add_ordered_members(env)
+        add_ordered_members(env.user, env.curation_concern)
         true
       end
 
@@ -70,7 +72,7 @@ module Hyrax
           actor.create_metadata(visibility: env.curation_concern.visibility)
           actor.attach_to_work(env.curation_concern)
           fs.save!
-          env.retrieve(self, :ordered_members) << fs
+          ordered_members << fs
           if uri.scheme == 'file'
             # Turn any %20 into spaces.
             file_path = CGI.unescape(uri.path)
@@ -82,9 +84,9 @@ module Hyrax
       end
 
       # Add all file_sets as ordered_members in a single action
-      def add_ordered_members(env)
-        actor = Hyrax::Actors::OrderedMembersActor.new(env.retrieve(self, :ordered_members), env.user)
-        actor.attach_ordered_members_to_work(env.curation_concern)
+      def add_ordered_members(user, work)
+        actor = Hyrax::Actors::OrderedMembersActor.new(ordered_members, user)
+        actor.attach_ordered_members_to_work(work)
       end
 
       class_attribute :file_set_actor_class

data/app/actors/hyrax/actors/environment.rb

@@ -8,29 +8,21 @@ module Hyrax
         @curation_concern = curation_concern
         @current_ability = current_ability
         @attributes = attributes.to_h.with_indifferent_access
-        @actor_storage = {}
       end
 
-      attr_reader :curation_concern, :current_ability, :attributes
+      ##
+      # @!attribute [rw] attributes
+      #   @return [Hash]
+      # @!attribute [rw] curation_concern
+      #   @return [Object]
+      # @!attribute [rw] current_ability
+      #   @return [Hyrax::Ability]
+      attr_accessor :attributes, :curation_concern, :current_ability
 
       # @return [User] the user from the current_ability
       def user
         current_ability.current_user
       end
-
-      def store(actor, key, value)
-        store_for(actor)[key] = value
-      end
-
-      def retrieve(actor, key)
-        store_for(actor)[key]
-      end
-
-      private
-
-        def store_for(actor)
-          @actor_storage[actor] ||= {}
-        end
     end
   end
 end

data/app/actors/hyrax/actors/file_actor.rb

@@ -1,3 +1,5 @@
+require 'wings/services/file_metadata_builder'
+
 module Hyrax
   module Actors
     # Actions for a file identified by file_set and relation (maps to use predicate)
@@ -8,10 +10,11 @@ module Hyrax
       # @param [FileSet] file_set the parent FileSet
       # @param [Symbol, #to_sym] relation the type/use for the file
       # @param [User] user the user to record as the Agent acting upon the file
-      def initialize(file_set, relation, user)
+      def initialize(file_set, relation, user, use_valkyrie: false)
         @file_set = file_set
-        @relation = relation.to_sym
+        @relation = normalize_relation(relation, use_valkyrie: use_valkyrie)
         @user = user
+        @use_valkyrie = use_valkyrie
       end
 
       # Persists file as part of file_set and spawns async job to characterize and create derivatives.
@@ -21,16 +24,7 @@ module Hyrax
       # @see IngestJob
       # @todo create a job to monitor the temp directory (or in a multi-worker system, directories!) to prune old files that have made it into the repo
       def ingest_file(io)
-        # Skip versioning because versions will be minted by VersionCommitter as necessary during save_characterize_and_record_committer.
-        Hydra::Works::AddFileToFileSet.call(file_set,
-                                            io,
-                                            relation,
-                                            versioning: false)
-        return false unless file_set.save
-        repository_file = related_file
-        Hyrax::VersioningService.create(repository_file, user)
-        pathhint = io.uploaded_file.uploader.path if io.uploaded_file # in case next worker is on same filesystem
-        CharacterizeJob.perform_later(file_set, repository_file.id, pathhint || io.path)
+        perform_ingest_file(io, use_valkyrie: @use_valkyrie)
       end
 
       # Reverts file and spawns async job to characterize and create derivatives.
@@ -55,7 +49,75 @@ module Hyrax
 
         # @return [Hydra::PCDM::File] the file referenced by relation
         def related_file
-          file_set.public_send(relation) || raise("No #{relation} returned for FileSet #{file_set.id}")
+          file_set.public_send(normalize_relation(relation)) || raise("No #{relation} returned for FileSet #{file_set.id}")
+        end
+
+        # Persists file as part of file_set and records a new version.
+        # Also spawns an async job to characterize and create derivatives.
+        # @param [JobIoWrapper] io the file to save in the repository, with mime_type and original_name
+        # @return [FileMetadata, FalseClass] the created file metadata on success, false on failure
+        # @todo create a job to monitor the temp directory (or in a multi-worker system, directories!) to prune old files that have made it into the repo
+        def perform_ingest_file(io, use_valkyrie: false)
+          use_valkyrie ? perform_ingest_file_through_valkyrie(io) : perform_ingest_file_through_active_fedora(io)
+        end
+
+        def perform_ingest_file_through_active_fedora(io)
+          # Skip versioning because versions will be minted by VersionCommitter as necessary during save_characterize_and_record_committer.
+          Hydra::Works::AddFileToFileSet.call(file_set,
+                                              io,
+                                              relation,
+                                              versioning: false)
+          return false unless file_set.save
+          repository_file = related_file
+          Hyrax::VersioningService.create(repository_file, user)
+          pathhint = io.uploaded_file.uploader.path if io.uploaded_file # in case next worker is on same filesystem
+          CharacterizeJob.perform_later(file_set, repository_file.id, pathhint || io.path)
+        end
+
+        def perform_ingest_file_through_valkyrie(io)
+          # Skip versioning because versions will be minted by VersionCommitter as necessary during save_characterize_and_record_committer.
+          unsaved_file_metadata = io.to_file_metadata
+          unsaved_file_metadata.use = relation
+          begin
+            saved_file_metadata = file_metadata_builder.create(io_wrapper: io, file_metadata: unsaved_file_metadata, file_set: file_set)
+          rescue StandardError => e # Handle error persisting file metadata
+            Rails.logger.error("Failed to save file_metadata through valkyrie: #{e.message}")
+            return false
+          end
+          Hyrax::VersioningService.create(saved_file_metadata, user)
+          pathhint = io.uploaded_file.uploader.path if io.uploaded_file # in case next worker is on same filesystem
+          id = Hyrax.config.translate_uri_to_id.call saved_file_metadata.file_identifiers.first
+          CharacterizeJob.perform_later(file_set, id, pathhint || io.path)
+        end
+
+        def file_metadata_builder
+          Wings::FileMetadataBuilder.new(storage_adapter: Hyrax.storage_adapter,
+                                         persister:       Hyrax.persister)
+        end
+
+        def normalize_relation(relation, use_valkyrie: false)
+          use_valkyrie ? normalize_relation_for_valkyrie(relation) : normalize_relation_for_active_fedora(relation)
+        end
+
+        def normalize_relation_for_active_fedora(relation)
+          return relation if relation.is_a? Symbol
+          return relation.to_sym if relation.respond_to? :to_sym
+
+          # TODO: whereever these are set, they should use Valkyrie::Vocab::PCDMUse... making the casecmp unnecessary
+          return :original_file if relation.to_s.casecmp(Valkyrie::Vocab::PCDMUse.original_file.to_s)
+          return :extracted_file if relation.to_s.casecmp(Valkyrie::Vocab::PCDMUse.extracted_file.to_s)
+          return :thumbnail_file if relation.to_s.casecmp(Valkyrie::Vocab::PCDMUse.thumbnail_file.to_s)
+          :original_file
+        end
+
+        def normalize_relation_for_valkyrie(relation)
+          # TODO: When this is fully switched to valkyrie, this should probably be removed and relation should always be passed
+          #       in as a valid URI already set to the file's use
+          relation = relation.to_s.to_sym
+          return Valkyrie::Vocab::PCDMUse.original_file if relation == :original_file
+          return Valkyrie::Vocab::PCDMUse.extracted_file if relation == :extracted_file
+          return Valkyrie::Vocab::PCDMUse.thumbnail_file if relation == :thumbnail_file
+          Valkyrie::Vocab::PCDMUse.original_file
         end
     end
   end