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

data/lib/wings/{value_mapper.rb → transformer_value_mapper.rb}

@@ -7,7 +7,26 @@ module Wings
   #
   # This top level matcher has registered several internal mappers which handle
   # indivdual value types from the source data.
-  class ValueMapper < ::Valkyrie::ValueMapper; end
+  class TransformerValueMapper < ::Valkyrie::ValueMapper; end
+
+  class NestedResourceMapper < ::Valkyrie::ValueMapper
+    # needs to register before the ResourceMapper or it will use that one
+    # instead
+    TransformerValueMapper.register(self)
+
+    def self.handles?(value)
+      value.is_a? Wings::ActiveFedoraConverter::NestedResource
+    end
+
+    def result
+      attributes = value.attributes.symbolize_keys
+      nested_object = Wings::ActiveFedoraConverter::NestedResource.new(attributes)
+      klass = Wings::ModelTransformer::ResourceClassCache.instance.fetch(Wings::ActiveFedoraConverter::NestedResource) do
+        ModelTransformer.to_valkyrie_resource_class(klass: nested_object.class)
+      end
+      klass.new(attributes)
+    end
+  end
 
   ##
   # Maps `RDF::Term` values to their underlying types.
@@ -18,8 +37,8 @@ module Wings
   # handled by `Valkyrie`.
   #
   # @see RDF::Term
-  class ResourceMapper < ValueMapper
-    ValueMapper.register(self)
+  class ResourceMapper < ::Valkyrie::ValueMapper
+    TransformerValueMapper.register(self)
 
     ##
     # @param value [Object]
@@ -41,8 +60,8 @@ module Wings
   # parent `ValueMapper` on each member.
   #
   # @note a common value type this mapper handles is `ActiveTriples::Relation`
-  class EnumerableMapper < ValueMapper
-    ValueMapper.register(self)
+  class EnumerableMapper < ::Valkyrie::ValueMapper
+    TransformerValueMapper.register(self)
 
     ##
     # @param value [Object]

data/lib/wings/valkyrie/persister.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module Wings
   module Valkyrie
     class Persister
@@ -17,34 +16,58 @@ module Wings
       # @param [Valkyrie::Resource] resource
       # @return [Valkyrie::Resource] the persisted/updated resource
       def save(resource:)
+        return save_file(file_metadata: resource) if resource.is_a? Hyrax::FileMetadata
         af_object = resource_factory.from_resource(resource: resource)
         af_object.save!
         resource_factory.to_resource(object: af_object)
+      rescue ActiveFedora::RecordInvalid => err
+        raise FailedSaveError.new(err.message, obj: af_object)
+      end
+
+      def save_file(file_metadata:)
+        # This is a no-op when the file is being created or updated through the FileActor.
+        # There may be other scenarios where something needs to happen here.
+        file_metadata
+
+        # TODO: potentially need to...
+        #   find existing af File
+        #   convert file_metadata resource into af File metadata
+        #   save af File
+      end
+
+      # Persists a resource using ActiveFedora
+      # @param [Valkyrie::Resource] resource
+      # @return [Valkyrie::Resource] the persisted/updated resource
+      def save_all(resources:)
+        resources.map do |resource|
+          save(resource: resource)
+        end
+      end
+
+      # Deletes a resource persisted using ActiveFedora
+      # @param [Valkyrie::Resource] resource
+      # @return [Valkyrie::Resource] the deleted resource
+      def delete(resource:)
+        af_object = ActiveFedora::Base.new
+        af_object.id = resource.alternate_ids.first.to_s
+        af_object.delete
       end
 
-      # # Persists a resource using ActiveFedora
-      # # @param [Valkyrie::Resource] resource
-      # # @return [Valkyrie::Resource] the persisted/updated resource
-      # def save_all(resources:)
-      #   resources.map do |resource|
-      #     save(resource: resource)
-      #   end
-      # end
-      #
-      # # Deletes a resource persisted using ActiveFedora
-      # # @param [Valkyrie::Resource] resource
-      # # @return [Valkyrie::Resource] the deleted resource
-      # def delete(resource:)
-      #   af_object = resource_factory.from_resource(resource: resource)
-      #   af_object.delete
-      # end
-      #
-      # # Deletes all resources from Fedora and Solr
-      # def wipe!
-      #   ActiveFedora::SolrService.instance.conn.delete_by_query("*:*")
-      #   ActiveFedora::SolrService.instance.conn.commit
-      #   ActiveFedora::Cleaner.clean!
-      # end
+      # Deletes all resources from Fedora and Solr
+      def wipe!
+        Hyrax::SolrService.delete_by_query("*:*")
+        Hyrax::SolrService.commit
+        ActiveFedora::Cleaner.clean!
+      end
+
+      class FailedSaveError < RuntimeError
+        attr_accessor :obj
+
+        def initialize(msg = nil, obj:)
+          self.obj = obj
+          super(msg)
+        end
+      end
     end
   end
 end

data/lib/wings/valkyrie/query_service.rb

@@ -12,16 +12,144 @@ module Wings
         @adapter = adapter
       end
 
+      # WARNING: In general, prefer find_by_alternate_identifier over this
+      # method.
+      #
+      # Hyrax uses a shortened noid in place of an id, and this is what is
+      # stored in ActiveFedora, which is still the storage backend for Hyrax.
+      #
+      # If you do not heed this warning, then switch to Valyrie's Postgres
+      # MetadataAdapter, but continue passing noids to find_by, you will
+      # start getting ObjectNotFoundErrors instead of the objects you wanted
+      #
       # Find a record using a Valkyrie ID, and map it to a Valkyrie Resource
       # @param [Valkyrie::ID, String] id
       # @return [Valkyrie::Resource]
-      # @raise [Valkyrie::Persistence::ObjectNotFoundError]
+      # @raise [Hyrax::ObjectNotFoundError]
       def find_by(id:)
-        id = ::Valkyrie::ID.new(id.to_s) if id.is_a?(String)
-        validate_id(id)
-        resource_factory.to_resource(object: ::ActiveFedora::Base.find(id.to_s))
-      rescue ::ActiveFedora::ObjectNotFoundError
-        raise ::Valkyrie::Persistence::ObjectNotFoundError
+        find_by_alternate_identifier(alternate_identifier: id)
+      end
+
+      # Find all work/collection records, and map to Valkyrie Resources
+      # @return [Array<Valkyrie::Resource>]
+      def find_all
+        klasses = Hyrax.config.curation_concerns.append(::Collection)
+        objects = ::ActiveFedora::Base.all.select do |object|
+          klasses.include? object.class
+        end
+        objects.map do |id|
+          resource_factory.to_resource(object: id)
+        end
+      end
+
+      # Find all work/collection records of a given model, and map to Valkyrie Resources
+      # @param [Valkyrie::ResourceClass]
+      # @return [Array<Valkyrie::Resource>]
+      def find_all_of_model(model:)
+        find_model = model.internal_resource.constantize
+        objects = ::ActiveFedora::Base.all.select do |object|
+          object.class == find_model
+        end
+        objects.map do |id|
+          resource_factory.to_resource(object: id)
+        end
+      end
+
+      # Find an array of record using Valkyrie IDs, and map them to Valkyrie Resources maintaining order based on given ids
+      # @param [Array<Valkyrie::ID, String>] ids
+      # @return [Array<Valkyrie::Resource>]
+      # NOTE: Ignores non-existent ids.
+      def find_many_by_ids(ids:)
+        ids.each do |id|
+          id = ::Valkyrie::ID.new(id.to_s) if id.is_a?(String)
+          validate_id(id)
+        end
+        resources = []
+        ids.uniq.map(&:to_s).each do |id|
+          begin
+            af_object = ActiveFedora::Base.find(id)
+            resources << resource_factory.to_resource(object: af_object)
+          rescue ::ActiveFedora::ObjectNotFoundError, Ldp::Gone
+            next
+          end
+        end
+        resources
+      end
+
+      # Find a record using an alternate ID, and map it to a Valkyrie Resource
+      # @param [Valkyrie::ID, String] id
+      # @param [boolean] optionally return ActiveFedora object/errors
+      # @return [Valkyrie::Resource]
+      # @raise [Hyrax::ObjectNotFoundError]
+      def find_by_alternate_identifier(alternate_identifier:, use_valkyrie: true)
+        alternate_identifier = ::Valkyrie::ID.new(alternate_identifier.to_s) if alternate_identifier.is_a?(String)
+        validate_id(alternate_identifier)
+        object = ::ActiveFedora::Base.find(alternate_identifier.to_s)
+        return object if use_valkyrie == false
+        resource_factory.to_resource(object: object)
+      rescue ActiveFedora::ObjectNotFoundError, Ldp::Gone
+        raise Hyrax::ObjectNotFoundError
+      end
+
+      # Find all members of a given resource, and map to Valkyrie Resources
+      # @param [Valkyrie::Resource]
+      # @param [Valkyrie::ResourceClass]
+      # @return [Array<Valkyrie::Resource>]
+      def find_members(resource:, model: nil)
+        return [] unless resource.respond_to?(:member_ids) && resource.member_ids.present?
+        all_members = find_many_by_ids(ids: resource.member_ids)
+        return all_members unless model
+        find_model = model.internal_resource.constantize if model
+        all_members.select { |member_resource| member_resource.internal_resource.constantize == find_model }
+      end
+
+      # Find the Valkyrie Resources referenced by another Valkyrie Resource
+      # @param [<Valkyrie::Resource>]
+      # @param [Symbol] the property holding the references to another resource
+      # @return [Array<Valkyrie::Resource>]
+      def find_references_by(resource:, property:)
+        object = resource_factory.from_resource(resource: resource)
+        object.send(property).map do |reference|
+          af_id = find_id_for(reference)
+          resource_factory.to_resource(object: ::ActiveFedora::Base.find(af_id))
+        end
+      rescue ActiveFedora::ObjectNotFoundError
+        return []
+      end
+
+      # Get all resources which link to a resource or id with a given property.
+      # @param resource [Valkyrie::Resource] The resource which is being referenced by
+      #   other resources.
+      # @param resource [Valkyrie::ID] The id of the resource which is being referenced by
+      #   other resources.
+      # @param property [Symbol] The property which, on other resources, is
+      #   referencing the given `resource`. Note: the property needs to be
+      #   indexed as a `*_ssim` field and indexing either ActiveFedora IDs or full URIs
+      # @raise [ArgumentError] Raised when the ID is not in the persistence backend.
+      # @return [Array<Valkyrie::Resource>] All resources in the persistence backend
+      #   which have the ID of the given `resource` in their `property` property. Not
+      #   in order.
+      def find_inverse_references_by(resource: nil, id: nil, property:)
+        raise ArgumentError, "Provide resource or id" unless resource || id
+        id ||= resource.alternate_ids.first
+        raise ArgumentError, "Resource has no id; is it persisted?" unless id
+        uri = ActiveFedora::Base.id_to_uri(id.to_s)
+        ActiveFedora::Base.where("+(#{property}_ssim: \"#{uri}\" OR #{property}_ssim: \"#{id}\")").map do |obj|
+          resource_factory.to_resource(object: obj)
+        end
+      end
+
+      # Find all parents of a given resource.
+      # @param resource [Valkyrie::Resource] The resource whose parents are being searched
+      #   for.
+      # @return [Array<Valkyrie::Resource>] All resources which are parents of the given
+      #   `resource`. This means the resource's `id` appears in their `member_ids`
+      #   array.
+      def find_parents(resource:)
+        id = resource.alternate_ids.first
+        ActiveFedora::Base.where("member_ids_ssim: \"#{id}\"").map do |obj|
+          resource_factory.to_resource(object: obj)
+        end
       end
 
       # Constructs a Valkyrie::Persistence::CustomQueryContainer using this query service
@@ -38,6 +166,13 @@ module Wings
         def validate_id(id)
           raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? ::Valkyrie::ID
         end
+
+        def find_id_for(reference)
+          return ::ActiveFedora::Base.uri_to_id(reference.id) if reference.class == ActiveTriples::Resource
+          return reference if reference.class == String
+          # not a supported type
+          ''
+        end
     end
   end
 end

data/lib/wings/valkyrie/storage/active_fedora.rb

@@ -0,0 +1,27 @@
+require 'wings/hydra/works/services/add_file_metadata_to_file_set'
+
+# frozen_string_literal: true
+module Wings::Storage
+  # Implements the DataMapper Pattern to store binary data in fedora following the ActiveFedora structures
+  class ActiveFedora < Valkyrie::Storage::Fedora
+    # @param file [IO]
+    # @param original_filename [String]
+    # @param resource [Valkyrie::Resource]
+    # @param content_type [String] content type of file (e.g. 'image/tiff') (default='application/octet-stream')
+    # @param resource_uri_transformer [Lambda] transforms the resource's id (e.g. 'DDS78RK') into a uri (optional)
+    # @param extra_arguments [Hash] additional arguments which may be passed to other adapters
+    # @return [Valkyrie::StorageAdapter::StreamFile]
+    def upload(file:, original_filename:, resource:, resource_uri_transformer: default_resource_uri_transformer, **_extra_arguments) # rubocop:disable Lint/UnusedMethodArgument
+      Wings::Works::AddFileMetadataToFileSet.call(file_set: file_set(resource), file_metadata: resource, file: file)
+      identifier = resource_uri_transformer.call(resource, base_url)
+      find_by(id: Valkyrie::ID.new(identifier.to_s.sub(/^.+\/\//, PROTOCOL)))
+    end
+
+    private
+
+      def file_set(file_metadata)
+        file_set_id = file_metadata.file_set_id
+        Hyrax.query_service.find_by(id: file_set_id)
+      end
+  end
+end

data/spec/abilities/proxies_and_transfer_abilities_spec.rb

@@ -8,13 +8,15 @@ RSpec.describe 'Proxy and Transfer Abilities' do
 
   describe "Transfers" do
     before do
-      allow(Flipflop).to receive(:transfer_works?).and_return(enabled)
+      allow(Flipflop).to receive(:transfer_works?).and_return(transfer_enabled)
       allow(ability).to receive(:user_is_depositor?).with('777').and_return(mine)
+      allow(Flipflop).to receive(:proxy_deposit?).and_return(proxy_enabled)
     end
     let(:work_id) { '777' }
 
-    describe "when transfers are enabled" do
-      let(:enabled) { true }
+    describe "when transfers are enabled and proxies are enabled" do
+      let(:transfer_enabled) { true }
+      let(:proxy_enabled) { true }
 
       context "a work belonging to someone else" do
         let(:mine) { false }
@@ -29,8 +31,35 @@ RSpec.describe 'Proxy and Transfer Abilities' do
       end
     end
 
-    describe "when transfers are disabled" do
-      let(:enabled) { false }
+    describe "when transfers are enabled and proxies are disabled" do
+      let(:transfer_enabled) { true }
+      let(:proxy_enabled) { false }
+
+      context "a work belonging to someone else" do
+        let(:mine) { false }
+
+        it { is_expected.not_to be_able_to(:transfer, work_id) }
+      end
+
+      context "my own work" do
+        let(:mine) { true }
+
+        it { is_expected.to be_able_to(:transfer, work_id) }
+      end
+    end
+
+    describe "when transfers are disabled and proxy is enabled" do
+      let(:transfer_enabled) { false }
+      let(:proxy_enabled) { true }
+
+      let(:mine) { true }
+
+      it { is_expected.not_to be_able_to(:transfer, work_id) }
+    end
+
+    describe "when transfers are disabled and proxy is disabled" do
+      let(:transfer_enabled) { false }
+      let(:proxy_enabled) { false }
 
       let(:mine) { true }
 
@@ -52,10 +81,13 @@ RSpec.describe 'Proxy and Transfer Abilities' do
 
     context "creating a ProxyDepositRequest" do
       before do
-        allow(Flipflop).to receive(:proxy_deposit?).and_return(enabled)
+        allow(Flipflop).to receive(:proxy_deposit?).and_return(proxy_enabled)
+        allow(Flipflop).to receive(:transfer_works?).and_return(transfer_enabled)
       end
-      describe "when proxy deposit is enabled" do
-        let(:enabled) { true }
+
+      describe "when proxy deposit is enabled and transfer is disabled" do
+        let(:proxy_enabled) { true }
+        let(:transfer_enabled) { false }
 
         context "for a registered user" do
           it { is_expected.to be_able_to(:create, ProxyDepositRequest) }
@@ -67,11 +99,19 @@ RSpec.describe 'Proxy and Transfer Abilities' do
         end
       end
 
-      context "when disabled" do
-        let(:enabled) { false }
+      context "when proxy is disabled and trasfer is disabled" do
+        let(:proxy_enabled) { false }
+        let(:transfer_enabled) { false }
 
         it { is_expected.not_to be_able_to(:create, ProxyDepositRequest) }
       end
+
+      context "when proxy is disabled and trasfer is enabled" do
+        let(:proxy_enabled) { false }
+        let(:transfer_enabled) { true }
+
+        it { is_expected.to be_able_to(:create, ProxyDepositRequest) }
+      end
     end
 
     context "with a ProxyDepositRequest that they receive" do

data/spec/actors/hyrax/actors/active_fedora_to_valkyrie_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.describe Hyrax::Actors::ActiveFedoraToValkyrie do
+  let(:ability)    { :FAKE_ABILITY }
+  let(:attrs)      { {} }
+  let(:env)        { Hyrax::Actors::Environment.new(work, ability, attrs) }
+  let(:spy)        { middleware.next_actor }
+  let(:terminator) { Hyrax::Actors::Terminator.new }
+  let(:work)       { FactoryBot.build(:work) }
+
+  subject(:middleware) do
+    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
+      middleware.use described_class
+      middleware.use FakeActor
+    end
+
+    stack.build(terminator)
+  end
+
+  shared_examples 'casts to Valkyrie' do |method|
+    it 'returns true' do
+      expect(middleware.public_send(method, env)).to be true
+    end
+
+    it 'casts to Valkyrie' do
+      expect { middleware.public_send(method, env) }
+        .to change { env.curation_concern }
+        .to be_a Valkyrie::Resource
+    end
+
+    context 'when concern is not an ActiveFedora::Base' do
+      let(:work) { :FAKE_WORK }
+
+      it 'is a no-op' do
+        expect { middleware.public_send(method, env) }
+          .not_to change { env.curation_concern }
+      end
+    end
+  end
+
+  describe '#create' do
+    include_examples 'casts to Valkyrie', :create
+
+    it 'calls create on next actor' do
+      expect { middleware.create(env) }
+        .to change { spy.created }
+        .from be_falsey
+    end
+  end
+
+  describe '#update' do
+    include_examples 'casts to Valkyrie', :update
+
+    it 'calls update on next actor' do
+      expect { middleware.update(env) }
+        .to change { spy.updated }
+        .from be_falsey
+    end
+  end
+
+  describe '#destroy' do
+    include_examples 'casts to Valkyrie', :destroy
+
+    it 'calls update on next actor' do
+      expect { middleware.destroy(env) }
+        .to change { spy.destroyed }
+        .from be_falsey
+    end
+  end
+end