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

data/lib/wings/model_transformer.rb

@@ -1,20 +1,81 @@
 # frozen_string_literal: true
 
-require 'wings/value_mapper'
+require 'wings/transformer_value_mapper'
+require 'wings/models/concerns/collection_behavior'
+require 'wings/hydra/works/models/concerns/work_valkyrie_behavior'
+require 'wings/hydra/works/models/concerns/file_set_valkyrie_behavior'
 
 module Wings
+  ##
+  # Transforms ActiveFedora models or objects into Valkyrie::Resource models or
+  # objects
   #
-  # This class is responsible for coordinating the transformation of a PCDM
-  # Model (be it the class or an instance of the class) to a [Valkyrie::Resource](https://github.com/samvera-labs/valkyrie/blob/master/lib/valkyrie/resource.rb).
-  # for the given PCDM model.
+  # @see https://github.com/samvera-labs/valkyrie/blob/master/lib/valkyrie/resource.rb
+  #
+  # Similar to an orm_converter class in other valkyrie persisters. Also used by
+  # the Valkyrizable mixin to make AF objects able to return their
+  # Valkyrie::Resource representation.
   #
   # @example getting a valkyrie resource
   #   work     = GenericWork.new(id: 'an_identifier')
-  #   resource = Wings::ModelTransformer.for(pcdm_object: work)
+  #   resource = Wings::ModelTransformer.for(work)
   #
   #   resource.alternate_ids # => [#<Valkyrie::ID:0x... id: 'an_identifier'>]
   #
+  # rubocop:disable Metrics/ClassLength
   class ModelTransformer
+    ##
+    # @!attribute [rw] pcdm_object
+    #   @return [ActiveFedora::Base]
+    attr_accessor :pcdm_object
+
+    ##
+    # @param pcdm_object [ActiveFedora::Base]
+    def initialize(pcdm_object:)
+      self.pcdm_object = pcdm_object
+    end
+
+    ##
+    # Factory
+    #
+    # @param pcdm_object [ActiveFedora::Base]
+    #
+    # @return [::Valkyrie::Resource] a resource mirroiring `pcdm_object`
+    def self.for(pcdm_object)
+      new(pcdm_object: pcdm_object).build
+    end
+
+    ##
+    # @param reflections [Hash<Symbol, Object>]
+    #
+    # @return [Array<Symbol>]
+    def self.relationship_keys_for(reflections:)
+      relationships = reflections
+                      .keys
+                      .reject { |k| k.to_s.include?('id') }
+                      .map { |k| k.to_s.singularize + '_ids' }
+      relationships.delete('member_ids') # Remove here.  Members will be extracted as ordered_members in attributes method.
+      relationships.delete('ordered_member_proxy_ids') # This does not have a Valkyrie equivalent.
+      relationships
+    end
+
+    ##
+    # Builds a `Valkyrie::Resource` equivalent to the `pcdm_object`
+    #
+    # @return [::Valkyrie::Resource] a resource mirroiring `pcdm_object`
+    def build
+      klass = ResourceClassCache.instance.fetch(pcdm_object) do
+        self.class.to_valkyrie_resource_class(klass: pcdm_object.class)
+      end
+
+      mint_id unless pcdm_object.id
+
+      attrs = attributes.tap { |hash| hash[:new_record] = pcdm_object.new_record? }
+      attrs[:alternate_ids] = [::Valkyrie::ID.new(pcdm_object.id)] if pcdm_object.id
+
+      klass.new(**attrs)
+    end
+
     ##
     # Caches dynamically generated `Valkyrie::Resource` subclasses mapped from
     # legacy `ActiveFedora` model classes.
@@ -27,6 +88,8 @@ module Wings
     #   end
     #
     class ResourceClassCache
+      include Singleton
+
       ##
       # @!attribute [r] cache
       #   @return [Hash<Class, Class>]
@@ -47,14 +110,19 @@ module Wings
       end
     end
 
-    # we really want a class var here. maybe we could use a singleton instead?
-    # rubocop:disable Style/ClassVars
-    @@resource_class_cache = ResourceClassCache.new
-
     ##
-    # @!attribute [rw] pcdm_object
-    #   @return [ActiveFedora::Base]
-    attr_accessor :pcdm_object
+    # Selects an existing base class for the generated valkyrie class
+    #
+    # @return [Class]
+    def self.base_for(klass:)
+      if klass == Hydra::AccessControls::Embargo
+        Hyrax::Embargo
+      elsif klass == Hydra::AccessControls::Lease
+        Hyrax::Lease
+      else
+        Hyrax::Resource
+      end
+    end
 
     ##
     # @note The method signature is to conform to Valkyrie's method signature
@@ -77,30 +145,44 @@ module Wings
     # @return [Class] a dyamically generated `Valkyrie::Resource` subclass
     #   mirroring the provided `ActiveFedora` model
     #
+    # rubocop:disable Metrics/AbcSize
     # rubocop:disable Metrics/MethodLength because metaprogramming a class
     #   results in long methods
     def self.to_valkyrie_resource_class(klass:)
-      Class.new(ActiveFedoraResource) do
+      relationship_keys = klass.respond_to?(:reflections) ? relationship_keys_for(reflections: klass.reflections) : []
+      relationship_keys.delete('member_ids')
+      relationship_keys.delete('member_of_collection_ids')
+      reflection_id_keys = klass.respond_to?(:reflections) ? klass.reflections.keys.select { |k| k.to_s.end_with? '_id' } : []
+
+      Class.new(base_for(klass: klass)) do
+        include Wings::CollectionBehavior if klass.included_modules.include?(Hyrax::CollectionBehavior)
+        include Wings::Works::WorkValkyrieBehavior if klass.included_modules.include?(Hyrax::WorkBehavior)
+        include Wings::Works::FileSetValkyrieBehavior if klass.included_modules.include?(Hyrax::FileSetBehavior)
+
         # Based on Valkyrie implementation, we call Class.to_s to define
         # the internal resource.
-        @internal_resource = klass
+        @internal_resource = klass.to_s
 
         class << self
           attr_reader :internal_resource
         end
 
         def self.to_s
-          internal_resource.to_s
+          internal_resource
         end
 
         klass.properties.each_key do |property_name|
           attribute property_name.to_sym, ::Valkyrie::Types::String
         end
-        relationship_keys = klass.reflections.keys.reject { |k| k.to_s.include?('id') }.map { |k| k.to_s.singularize + '_ids' }
+
         relationship_keys.each do |linked_property_name|
           attribute linked_property_name.to_sym, ::Valkyrie::Types::Set.of(::Valkyrie::Types::ID)
         end
 
+        reflection_id_keys.each do |property_name|
+          attribute property_name, ::Valkyrie::Types::ID
+        end
+
         # Defined after properties in case we have an `internal_resource` property.
         # This may not be ideal, but based on my understanding of the `internal_resource`
         # usage in Valkyrie, I'd rather keep synchronized the instance_method and class_method value for
@@ -111,48 +193,91 @@ module Wings
       end
     end
     # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
 
-    ##
-    # @param pcdm_object [ActiveFedora::Base]
-    def initialize(pcdm_object:)
-      self.pcdm_object = pcdm_object
-    end
-
-    ##
-    # @param pcdm_object [ActiveFedora::Base]
-    #
-    # @return [::Valkyrie::Resource] a resource mirroiring `pcdm_object`
-    def self.for(pcdm_object)
-      new(pcdm_object: pcdm_object).build
-    end
-
-    ##
-    # Builds a `Valkyrie::Resource` equivalent to the `pcdm_object`
-    #
-    # @return [::Valkyrie::Resource] a resource mirroiring `pcdm_object`
-    def build
-      klass = @@resource_class_cache.fetch(pcdm_object) do
-        self.class.to_valkyrie_resource_class(klass: pcdm_object.class)
+    class AttributeTransformer
+      def self.run(obj, keys)
+        # TODO: There is an open question about whether we want to treat all these relationships the same.  See Issue #3904.
+        attrs = keys.select { |k| k.to_s.end_with? '_ids' }.each_with_object({}) do |attr_name, mem|
+          mem[attr_name.to_sym] =
+            TransformerValueMapper.for(obj.try(attr_name)).result ||
+            TransformerValueMapper.for(attribute_ids_for(name: attr_name.chomp('_ids'), obj: obj)).result ||
+            TransformerValueMapper.for(attribute_ids_for(name: attr_name.chomp('_ids').pluralize, obj: obj)).result || []
+        end
+        keys.each_with_object(attrs) do |attr_name, mem|
+          next unless obj.respond_to?(attr_name) && !mem.key?(attr_name.to_sym)
+          mem[attr_name.to_sym] = TransformerValueMapper.for(obj.public_send(attr_name)).result
+        end
       end
-      klass.new(alternate_ids: [::Valkyrie::ID.new(pcdm_object.id)], **attributes)
-    end
 
-    class ActiveFedoraResource < ::Valkyrie::Resource
-      attribute :alternate_ids, ::Valkyrie::Types::Array
+      def self.attribute_ids_for(name:, obj:)
+        attribute_value = obj.try(name)
+        return unless attribute_value.present?
+        Array(attribute_value).map(&:id)
+      end
     end
 
     private
 
+      def mint_id
+        id = pcdm_object.assign_id
+
+        pcdm_object.id = id unless id.blank?
+      end
+
       def attributes
-        relationship_keys = pcdm_object.reflections.keys.reject { |k| k.to_s.include?('id') }.map { |k| k.to_s.singularize + '_ids' }
+        all_keys =
+          pcdm_object.attributes.keys +
+          self.class.relationship_keys_for(reflections: pcdm_object.reflections)
+
+        result = AttributeTransformer.run(pcdm_object, all_keys).merge(reflection_ids).merge(additional_attributes)
+
+        append_embargo(result)
+        append_lease(result)
 
-        attrs_with_relationships = pcdm_object.attributes.keys + relationship_keys
+        result
+      end
 
-        attrs_with_relationships.each_with_object({}) do |attr_name, mem|
-          next unless pcdm_object.respond_to? attr_name
-          mem[attr_name.to_sym] = ValueMapper.for(pcdm_object.public_send(attr_name)).result
+      def reflection_ids
+        pcdm_object.reflections.keys.select { |k| k.to_s.end_with? '_id' }.each_with_object({}) do |k, mem|
+          mem[k] = pcdm_object.try(k)
         end
       end
+
+      def additional_attributes
+        { created_at: pcdm_object.try(:create_date),
+          updated_at: pcdm_object.try(:modified_date),
+          read_groups: pcdm_object.try(:read_groups),
+          read_users: pcdm_object.try(:read_users),
+          edit_groups: pcdm_object.try(:edit_groups),
+          edit_users: pcdm_object.try(:edit_users),
+          member_ids: member_ids }
+      end
+
+      # Prefer ordered members, but if ordered members don't exist, use non-ordered members.
+      def member_ids
+        ordered_member_ids = pcdm_object.try(:ordered_member_ids)
+        return ordered_member_ids if ordered_member_ids.present?
+        pcdm_object.try(:member_ids)
+      end
+
+      def append_embargo(attrs)
+        return unless pcdm_object.try(:embargo)
+        embargo_attrs = pcdm_object.embargo.attributes.symbolize_keys
+        embargo_attrs[:embargo_history] = embargo_attrs[:embargo_history].to_a
+        embargo_attrs[:id] = ::Valkyrie::ID.new(embargo_attrs[:id]) if embargo_attrs[:id]
+
+        attrs[:embargo] = Hyrax::Embargo.new(**embargo_attrs)
+      end
+
+      def append_lease(attrs)
+        return unless pcdm_object.try(:lease)
+        lease_attrs = pcdm_object.lease.attributes.symbolize_keys
+        lease_attrs[:lease_history] = lease_attrs[:embargo_history].to_a
+        lease_attrs[:id] = ::Valkyrie::ID.new(lease_attrs[:id]) if lease_attrs[:id]
+
+        attrs[:lease] = Hyrax::Lease.new(**lease_attrs)
+      end
   end
-  # rubocop:enable Style/ClassVars
+  # rubocop:enable Style/ClassVars Metrics/ClassLength
 end

data/lib/wings/models/concerns/collection_behavior.rb

@@ -0,0 +1,38 @@
+require 'wings/services/id_converter_service'
+require 'wings/hydra/works/models/concerns/collection_valkyrie_behavior'
+
+module Wings
+  module CollectionBehavior
+    extend ActiveSupport::Concern
+
+    included do
+      include Wings::Works::CollectionValkyrieBehavior
+    end
+
+    # Add member objects by adding this collection to the objects' member_of_collection association.
+    # @param [Enumerable<String> | Enumerable<Valkyrie::ID] the ids of the new child collections and works collection ids
+    def add_collections_and_works(new_member_ids, valkyrie: false)
+      ### TODO: Change to do this through Valkyrie.  Right now using existing AF method to get multi-membership check.
+      af_self = Wings::ActiveFedoraConverter.new(resource: self).convert
+      af_ids = valkyrie ? Wings::IdConverterService.convert_to_active_fedora_ids(new_member_ids) : new_member_ids
+      af_self.add_member_objects(af_ids)
+    end
+    alias add_member_objects add_collections_and_works
+
+    ##
+    # @return [Enumerable<ActiveFedora::Base> | Enumerable<Valkyrie::Resource>] an enumerable over the children of this collection
+    def child_collections_and_works(valkyrie: false)
+      af_collections_and_works = ActiveFedora::Base.where("member_of_collection_ids_ssim:#{id.id}")
+      return af_collections_and_works unless valkyrie
+      af_collections_and_works.map(&:valkyrie_resource)
+    end
+    alias member_objects child_collections_and_works
+
+    ##
+    # @return [Enumerable<ActiveFedora::Base> | Enumerable<Valkyrie::Resource>] an enumerable over the children of this collection
+    def child_collections_and_works_ids(valkyrie: false)
+      child_collections_and_works(valkyrie: valkyrie).map(&:id)
+    end
+    alias member_object_ids child_collections_and_works_ids
+  end
+end

data/lib/wings/models/multi_checksum.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Wings
+  class MultiChecksum < ::Valkyrie::Resource
+    attribute :sha256, ::Valkyrie::Types::SingleValuedString
+    attribute :md5, ::Valkyrie::Types::SingleValuedString
+    attribute :sha1, ::Valkyrie::Types::SingleValuedString
+
+    def self.for(file_object)
+      digests = file_object.checksum(digests: [::Digest::MD5.new, ::Digest::SHA256.new, ::Digest::SHA1.new])
+      MultiChecksum.new(
+        md5: digests.shift,
+        sha256: digests.shift,
+        sha1: digests.shift
+      )
+    end
+  end
+end

data/lib/wings/services/file_metadata_builder.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+require 'wings/hydra/works/services/add_file_metadata_to_file_set'
+
+# TODO: The file_metadata resource and the file_metadata_builder should be in Hyrax as they will be needed for non-wings valkyrie implementations too.
+
+module Wings
+  # Stores a file and an associated Hyrax::FileMetadata
+  class FileMetadataBuilder
+    include Hyrax::Noid
+
+    attr_reader :storage_adapter, :persister
+    def initialize(storage_adapter:, persister:)
+      @storage_adapter = storage_adapter
+      @persister = persister
+    end
+
+    # @param io_wrapper [JobIOWrapper] with details about the uploaded file
+    # @param file_metadata [Hyrax::FileMetadata] the metadata to represent the file
+    # @param file_set [Valkyrie::Resouce, Hydra::Works::FileSet] the associated FileSet # TODO: WINGS - Remove Hydra::Works::FileSet as a potential type when valkyrization is complete.
+    # @return [Hyrax::FileMetadata] the persisted metadata file_metadata that represents the file
+    def create(io_wrapper:, file_metadata:, file_set:)
+      io_wrapper = build_file(io_wrapper, file_metadata.use)
+      file_set.save unless file_set.persisted?
+      file_metadata.id = ::Valkyrie::ID.new(assign_id)
+      file_metadata.file_set_id = file_set.id
+      stored_file = storage_adapter.upload(file: io_wrapper,
+                                           original_filename: io_wrapper.original_filename,
+                                           content_type: io_wrapper.content_type,
+                                           resource: file_metadata,
+                                           resource_uri_transformer: Hyrax.config.resource_id_to_uri_transformer)
+      file_metadata.file_identifiers = [stored_file.id]
+      attach_file_metadata(file_metadata: file_metadata, file_set: file_set)
+    end
+
+    # @param file_metadata [Hyrax::FileMetadata] the metadata to represent the file
+    # @param file_set [Valkyrie::Resouce, Hydra::Works::FileSet] the associated FileSet # TODO: WINGS - Remove Hydra::Works::FileSet as a potential type when valkyrization is complete.
+    # @return [Hyrax::FileMetadata] the persisted metadata file_metadata that represents the file
+    def attach_file_metadata(file_metadata:, file_set:)
+      file_set.is_a?(::Valkyrie::Resource) ? attach_file_metadata_to_valkyrie_file_set(file_metadata, file_set) : file_metadata
+    end
+
+    private
+
+      def attach_file_metadata_to_valkyrie_file_set(file_metadata, file_set)
+        # This is for storage adapters other than wings.  The wings storage adapter already attached the file to the file_set.
+        # This process is a no-op for wings.  # TODO: WINGS - May need to verify this is a no-op for wings once file_set is passed in as a resource.
+        # TODO: WINGS - Need to test this against other adapters once they are available for use.
+        existing_file_metadata = file_set.original_file || file_metadata
+        file_metadata = existing_file_metadata.new(file_metadata.to_h.except(:id))
+        saved_file_metadata = persister.save(resource: file_metadata)
+        file_set.file_ids = [saved_file_metadata.id]
+        persister.save(resource: file_set)
+        saved_file_metadata
+      end
+
+      # Class for wrapping the file being ingested
+      class IoDecorator < SimpleDelegator
+        attr_reader :original_filename, :content_type, :length, :use, :tempfile
+
+        # @param [IO] io stream for the file content
+        # @param [String] original_filename
+        # @param [String] content_type
+        # @param [RDF::URI] use the URI for the PCDM predicate indicating the use for this resource
+        def initialize(io, original_filename, content_type, content_length, use)
+          @original_filename = original_filename
+          @content_type = content_type
+          @length = content_length
+          @use = use
+          @tempfile = io
+          super(io)
+        end
+      end
+
+      # Constructs the IoDecorator for ingesting the intermediate file
+      # @param [JobIOWrapper] io wrapper with details about the uploaded file
+      # @param [RDF::URI] use the URI for the PCDM predicate indicating the use for this resource
+      def build_file(io_wrapper, use)
+        IoDecorator.new(io_wrapper.file, io_wrapper.original_name, io_wrapper.mime_type, io_wrapper.size, use)
+      end
+  end
+end

data/lib/wings/services/id_converter_service.rb

@@ -0,0 +1,14 @@
+# Converson service for going between valkyrie_ids and fedora_ids
+# NOTE: This is pretty heavy handed since it loads objects to get the converted ids.
+module Wings
+  class IdConverterService
+    def self.convert_to_active_fedora_ids(valkyrie_ids)
+      resources = valkyrie_ids.map { |id| Hyrax.query_service.find_by(id: id) }
+      resources.map { |resource| resource.id.id } # TODO: What if id.id is empty?
+    end
+
+    def self.convert_to_valkyrie_resource_ids(fedora_ids)
+      fedora_ids.map { |id| ActiveFedora::Base.find(id).valkyrie_resource.id }
+    end
+  end
+end