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

data/lib/hyrax/specs/shared_specs/indexers.rb

@@ -16,9 +16,11 @@ RSpec.shared_examples 'a Hyrax::Resource indexer' do
   let(:ids)          { ['id1', 'id2'] }
 
   describe '#to_solr' do
-    it 'indexes alternate_ids' do
+    it 'indexes base resource fields' do
       expect(indexer.to_solr)
-        .to include(alternate_ids_sm: a_collection_containing_exactly(*ids))
+        .to include(has_model_ssim: resource.class.name,
+                    human_readable_type_tesim: resource.human_readable_type,
+                    alternate_ids_sim: a_collection_containing_exactly(*ids))
     end
   end
 end
@@ -43,7 +45,7 @@ RSpec.shared_examples 'a permission indexer' do
   describe '#to_solr' do
     it 'indexes read permissions' do
       expect(indexer.to_solr)
-        .to include(Hydra.config.permissions.read.group => ['public'],
+        .to include(Hydra.config.permissions.read.group => [Hyrax.config.public_user_group_name],
                     Hydra.config.permissions.read.individual => read_users.map(&:user_key))
     end
 
@@ -117,7 +119,11 @@ RSpec.shared_examples 'a Basic metadata indexer' do
 
   let(:attributes) do
     {
+      based_near: ['helsinki', 'finland'],
+      date_created: ['tuesday'],
       keyword: ['comic strip'],
+      related_url: ['http://example.com/moomin'],
+      resource_type: ['book'],
       subject: ['moomins', 'snorks']
     }
   end
@@ -125,9 +131,15 @@ RSpec.shared_examples 'a Basic metadata indexer' do
   describe '#to_solr' do
     it 'indexes basic metadata' do
       expect(indexer.to_solr)
-        .to include(keyword_sim:   a_collection_containing_exactly(*attributes[:keyword]),
+        .to include(based_near_tesim: a_collection_containing_exactly(*attributes[:based_near]),
+                    based_near_sim: a_collection_containing_exactly(*attributes[:based_near]),
+                    date_created_tesim: a_collection_containing_exactly(*attributes[:date_created]),
+                    keyword_sim: a_collection_containing_exactly(*attributes[:keyword]),
+                    related_url_tesim: a_collection_containing_exactly(*attributes[:related_url]),
+                    resource_type_tesim: a_collection_containing_exactly(*attributes[:resource_type]),
+                    resource_type_sim: a_collection_containing_exactly(*attributes[:resource_type]),
                     subject_tesim: a_collection_containing_exactly(*attributes[:subject]),
-                    subject_sim:   a_collection_containing_exactly(*attributes[:subject]))
+                    subject_sim: a_collection_containing_exactly(*attributes[:subject]))
     end
   end
 end
@@ -162,6 +174,11 @@ RSpec.shared_examples 'a Collection indexer' do
   it_behaves_like 'a visibility indexer'
 
   describe '#to_solr' do
+    it 'indexes collection type gid' do
+      expect(indexer.to_solr)
+        .to include(collection_type_gid_ssim: a_collection_containing_exactly(an_instance_of(String)))
+    end
+
     it 'indexes generic type' do
       expect(indexer.to_solr)
         .to include(generic_type_sim: a_collection_containing_exactly('Collection'))

data/lib/hyrax/specs/shared_specs/metadata.rb

@@ -1,5 +1,69 @@
 # frozen_string_literal: true
 
+RSpec.shared_examples 'a model with basic metadata' do
+  subject(:resource) { described_class.new }
+
+  it 'has abstracts' do
+    expect { resource.abstract = ['lorem ipsum', 'a story about moomins'] }
+      .to change { resource.abstract }
+      .to contain_exactly 'lorem ipsum', 'a story about moomins'
+  end
+
+  it 'has a label' do
+    expect { resource.label = 'one single label' }
+      .to change { resource.label }
+      .to eq 'one single label'
+  end
+
+  it 'has language' do
+    expect { resource.language = ['en', 'fi'] }
+      .to change { resource.language }
+      .to contain_exactly 'en', 'fi'
+  end
+
+  it 'has licenses' do
+    expect { resource.license = ['http://example.com/li1', 'http://example.com/li2'] }
+      .to change { resource.license }
+      .to contain_exactly 'http://example.com/li1', 'http://example.com/li2'
+  end
+
+  it 'has a relative path' do
+    expect { resource.relative_path = 'hamburger' }
+      .to change { resource.relative_path }
+      .to eq 'hamburger'
+  end
+
+  it 'has resource types' do
+    expect { resource.resource_type = ['book', 'image'] }
+      .to change { resource.resource_type }
+      .to contain_exactly 'book', 'image'
+  end
+
+  it 'has rights notes' do
+    expect { resource.rights_notes = ['secret', 'do not use'] }
+      .to change { resource.rights_notes }
+      .to contain_exactly 'secret', 'do not use'
+  end
+
+  it 'has rights statements' do
+    expect { resource.rights_statement = ['http://example.com/rs1', 'http://example.com/rs2'] }
+      .to change { resource.rights_statement }
+      .to contain_exactly 'http://example.com/rs1', 'http://example.com/rs2'
+  end
+
+  it 'has sources' do
+    expect { resource.source = ['first', 'second'] }
+      .to change { resource.source }
+      .to contain_exactly 'first', 'second'
+  end
+
+  it 'has subjects' do
+    expect { resource.subject = ['moomin', 'snork'] }
+      .to change { resource.subject }
+      .to contain_exactly 'moomin', 'snork'
+  end
+end
+
 RSpec.shared_examples 'a model with core metadata' do
   subject(:resource) { described_class.new }
   let(:date)         { Time.zone.today }

data/lib/hyrax/specs/spy_listener.rb

@@ -2,37 +2,63 @@
 
 module Hyrax
   module Specs
+    # A spec support class for assisting in spec testing of the
+    # Hyrax::Publisher pub/sub behavior.
+    #
+    # For each registered event, there are two corresponding instance methods
+    #
+    # 1. `#on_<registered_event>`
+    # 2. `#<registered_event>`
+    #
+    # Then, for any spec you want to make sure Pub/Sub events fire,
+    # you can subscribe an instance of Hyrax::Specs::SpyListener.
+    # When your spec is completed, unsubscribe the instance.
+    #
+    # @example For RSpec, assuming "object.deposited" is a registered event
+    #   # Note, based on the assumption that "object.deposited", then the
+    #   # listener object will have two corresponding methods:
+    #   #
+    #   # 1. :on_object_deposited - the method called when we publish an event
+    #   # 2. :object_deposited    - the attr_reader that captures and exposed
+    #   #                           the event for verification
+    #   let(:listener) { Hyrax::Specs::SpyListener.new }
+    #   before { Hyrax.publisher.subscribe(listener) }
+    #   after  { Hyrax.publisher.unsubscribe(listener) }
+    #
+    #   it "publishes to the listener" do
+    #     Hyrax::Publisher.instance.publish("object.deposited", object: object, depositor: user)
+    #     expect(listener.object_deposited&.payload).to eq(object: object, depositor: user)
+    #   end
+    #
+    #
+    # @see Hyrax::Publisher
     class SpyListener
-      attr_reader :file_set_attached, :file_set_url_imported, :object_deleted,
-                  :object_deposited, :object_failed_deposit, :object_acl_updated,
-                  :object_metadata_updated
-
-      def on_object_deleted(event)
-        @object_deleted = event
-      end
-
-      def on_object_deposited(event)
-        @object_deposited = event
-      end
-
-      def on_object_failed_deposit(event)
-        @object_failed_deposit = event
+      Hyrax::Publisher.events.each_value do |registered_event|
+        listener_method = registered_event.listener_method
+        attr_name = registered_event.listener_method.to_s.sub(/^on_/, '')
+        attr_reader attr_name
+        define_method listener_method do |published_event|
+          instance_variable_set("@#{attr_name}", published_event)
+        end
       end
+    end
 
-      def on_object_acl_updated(event)
-        @object_acl_updated = event
-      end
+    ##
+    # A spy listener that accumulates events, so multiple events published by
+    # one unit-under-test can be collected for inspection.
+    class AppendingSpyListener
+      Hyrax::Publisher.events.each_value do |registered_event|
+        listener_method = registered_event.listener_method
+        attr_name = registered_event.listener_method.to_s.sub(/^on_/, '')
 
-      def on_object_metadata_updated(event)
-        @object_metadata_updated = event
-      end
-
-      def on_file_set_attached(event)
-        @file_set_attached = event
-      end
+        define_method attr_name.to_sym do
+          instance_variable_get("@#{attr_name}") ||
+            instance_variable_set("@#{attr_name}", [])
+        end
 
-      def on_file_set_url_imported(event)
-        @file_set_url_imported = event
+        define_method listener_method do |published_event|
+          send(attr_name.to_sym) << published_event
+        end
       end
     end
   end

data/lib/hyrax/transactions/container.rb

@@ -23,6 +23,7 @@ module Hyrax
       require 'hyrax/transactions/destroy_work'
       require 'hyrax/transactions/work_create'
       require 'hyrax/transactions/update_work'
+      require 'hyrax/transactions/steps/add_file_sets'
       require 'hyrax/transactions/steps/add_to_collections'
       require 'hyrax/transactions/steps/apply_collection_permission_template'
       require 'hyrax/transactions/steps/apply_permission_template'
@@ -32,6 +33,7 @@ module Hyrax
       require 'hyrax/transactions/steps/ensure_permission_template'
       require 'hyrax/transactions/steps/save'
       require 'hyrax/transactions/steps/save_work'
+      require 'hyrax/transactions/steps/save_access_control'
       require 'hyrax/transactions/steps/set_default_admin_set'
       require 'hyrax/transactions/steps/set_modified_date'
       require 'hyrax/transactions/steps/set_uploaded_date_unless_present'
@@ -88,7 +90,17 @@ module Hyrax
         end
       end
 
-      namespace 'work' do |ops|
+      namespace 'work_resource' do |ops| # valkyrie works
+        ops.register 'add_file_sets' do
+          Steps::AddFileSets.new
+        end
+
+        ops.register 'save_acl' do
+          Steps::SaveAccessControl.new
+        end
+      end
+
+      namespace 'work' do |ops| # legacy AF works
         ops.register 'apply_collection_permission_template' do
           Steps::ApplyCollectionPermissionTemplate.new
         end

data/lib/hyrax/transactions/steps/add_file_sets.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require 'dry/monads'
+
+module Hyrax
+  module Transactions
+    module Steps
+      ##
+      # Adds a Hyrax::FileSet
+      #
+      # @see https://wiki.lyrasis.org/display/samvera/Hydra::Works+Shared+Modeling
+      class AddFileSets
+        include Dry::Monads[:result]
+
+        ##
+        # @param [Class] handler
+        def initialize(handler: Hyrax::WorkUploadsHandler)
+          @handler = handler
+        end
+
+        ##
+        # @param [Hyrax::Work] obj
+        # @param [Enumerable<UploadedFile>] uploaded_files
+        #
+        # @return [Dry::Monads::Result]
+        def call(obj, uploaded_files: [])
+          if @handler.new(work: obj).add(files: uploaded_files).attach
+            Success(obj)
+          else
+            Failure[:failed_to_attach_file_sets, uploaded_files]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyrax/transactions/steps/save.rb

@@ -29,11 +29,17 @@ module Hyrax
         #   applied and the resource is saved;
         #   `Failure([#to_s, change_set.resource])`, otherwise.
         def call(change_set, user: nil)
-          saved = @persister.save(resource: change_set.sync)
+          unsaved = change_set.sync
+          saved = @persister.save(resource: unsaved)
 
-          Hyrax.publisher.publish('object.metadata.updated',
-                                  object: saved,
-                                  user: user)
+          # if we have a permission manager, it's acting as a local cache of another resource.
+          # we want to resync changes that we had in progress so we can persist them later.
+          saved.permission_manager.acl.permissions = unsaved.permission_manager.acl.permissions if
+            unsaved.respond_to?(:permission_manager)
+
+          user ||= ::User.find_by_user_key(saved.depositor)
+          Hyrax.publisher.publish('object.deposited', object: saved, user: user) if unsaved.new_record
+          Hyrax.publisher.publish('object.metadata.updated', object: saved, user: user)
 
           Success(saved)
         rescue StandardError => err

data/lib/hyrax/transactions/steps/save_access_control.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'dry/monads'
+
+module Hyrax
+  module Transactions
+    module Steps
+      ##
+      # Saves the Hyrax::AccessControlList for any resource with a `#permission_manager`.
+      # If `#permission_manager` is undefined, succeeds.
+      #
+      # @see https://dry-rb.org/gems/dry-monads/1.0/result/
+      class SaveAccessControl
+        include Dry::Monads[:result]
+
+        ##
+        # @param [Valkyrie::Resource] obj
+        #
+        # @return [Dry::Monads::Result]
+        def call(obj)
+          return Success(obj) unless obj.respond_to?(:permission_manager)
+          obj.permission_manager&.acl&.save ||
+            (return Failure[:failed_to_save_acl, acl])
+
+          Success(obj)
+        end
+      end
+    end
+  end
+end

data/lib/hyrax/transactions/steps/set_default_admin_set.rb

@@ -16,7 +16,7 @@ module Hyrax
         #
         # @return [Dry::Monads::Result]
         def call(obj)
-          obj.admin_set_id ||= AdminSet.find_or_create_default_admin_set_id
+          obj.admin_set_id ||= Hyrax::EnsureWellFormedAdminSetService.call
 
           Success(obj)
         end

data/lib/hyrax/transactions/update_work.rb

@@ -4,7 +4,9 @@ module Hyrax
     ##
     # @since 3.0.0
     class UpdateWork < Transaction
-      DEFAULT_STEPS = ['change_set.apply'].freeze
+      DEFAULT_STEPS = ['change_set.apply',
+                       'work_resource.save_acl',
+                       'work_resource.add_file_sets'].freeze
 
       ##
       # @see Hyrax::Transactions::Transaction

data/lib/hyrax/transactions/work_create.rb

@@ -12,7 +12,9 @@ module Hyrax
                        'change_set.ensure_admin_set',
                        'change_set.set_user_as_depositor',
                        'change_set.add_to_collections',
-                       'change_set.apply'].freeze
+                       'change_set.apply',
+                       'work_resource.save_acl',
+                       'work_resource.add_file_sets'].freeze
 
       ##
       # @see Hyrax::Transactions::Transaction

data/lib/hyrax/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Hyrax
-  VERSION = '3.0.0-rc2'
+  VERSION = '3.0.0-rc3'
 end

data/lib/tasks/collection_type_global_id.rake

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+namespace :hyrax do
+  namespace :collections do
+    desc 'Update CollectionType global id references for Hyrax 3.0.0'
+    task :update_collection_type_global_ids do
+      puts 'Updating collection -> collection type GlobalId references.'
+
+      count = 0
+
+      Collection.all.each do |collection|
+        next if collection.collection_type_gid == collection.collection_type.to_global_id.to_s
+
+        collection.public_send(:collection_type_gid=, collection.collection_type.to_global_id, force: true)
+
+        collection.save &&
+          count += 1
+      end
+
+      puts "Updated #{count} collections."
+    end
+  end
+end

data/lib/tasks/default_admin_set.rake

@@ -4,6 +4,11 @@ namespace :hyrax do
     desc "Create the Default Admin Set"
     task create: :environment do
       id = AdminSet.find_or_create_default_admin_set_id
+      # I have found that when I come back to a development
+      # environment, that I may have an AdminSet in Fedora, but it is
+      # not indexed in Solr.  This remediates that situation by
+      # ensuring we have an indexed AdminSet
+      AdminSet.find(id).update_index
       if Hyrax::PermissionTemplate.find_by(source_id: id)
         puts "Successfully created default admin set"
       else

data/lib/wings.rb

@@ -94,8 +94,8 @@ require 'wings/valkyrizable'
 require 'wings/valkyrie/metadata_adapter'
 require 'wings/valkyrie/resource_factory'
 require 'wings/valkyrie/persister'
+require 'wings/valkyrie/storage'
 require 'wings/valkyrie/query_service'
-require 'wings/valkyrie/storage/active_fedora'
 
 Hydra::AccessControl.send(:define_method, :valkyrie_resource) do
   attrs = attributes.symbolize_keys

data/lib/wings/active_fedora_converter.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'wings/converter_value_mapper'
+require 'wings/active_fedora_converter/default_work'
+require 'wings/active_fedora_converter/nested_resource'
 
 module Wings
   ##
@@ -22,6 +24,14 @@ module Wings
       ActiveFedoraAttributes
     end
 
+    ##
+    # A class level cache mapping from Valkyrie resource classes to generated
+    # ActiveFedora classes
+    # @return [Hash<Class, Class>]
+    def self.class_cache
+      @class_cache ||= {}
+    end
+
     ##
     # @params [Valkyrie::Resource] resource
     #
@@ -46,31 +56,33 @@ module Wings
     #
     # @return [Hash] attributes with values mapped for building an ActiveFedora model
     def attributes
-      @attributes ||= self.class.attributes_class.mapped_attributes(attributes: resource.attributes)
+      @attributes ||= attributes_class.mapped_attributes(attributes: resource.attributes).select do |attr|
+        active_fedora_class.supports_property?(attr)
+      end
     end
 
     ##
     # @return [ActiveFedora::Base]
     def convert
-      active_fedora_class.new(normal_attributes).tap do |af_object|
-        af_object.id = id unless id.empty?
-        add_access_control_attributes(af_object)
-        convert_members(af_object)
-        convert_member_of_collections(af_object)
-        convert_files(af_object)
+      instance.tap do |af_object|
+        af_object.id ||= id unless id.empty?
+        apply_attributes_to_model(af_object)
       end
     end
 
     def active_fedora_class
-      klass = begin
-                resource.internal_resource.constantize
-              rescue NameError
-                Wings::ActiveFedoraClassifier.new(resource.internal_resource).best_model
-              end
+      @active_fedora_class ||= # cache the class at the instance level
+        begin
+          klass = begin
+                    resource.internal_resource.constantize
+                  rescue NameError
+                    Wings::ActiveFedoraClassifier.new(resource.internal_resource).best_model
+                  end
 
-      return klass if klass <= ActiveFedora::Base
+          return klass if klass <= ActiveFedora::Common
 
-      ModelRegistry.lookup(klass)
+          ModelRegistry.lookup(klass)
+        end
     end
 
     ##
@@ -85,105 +97,16 @@ module Wings
       resource.alternate_ids.first.to_s
     end
 
-    def self.DefaultWork(resource_class)
-      Class.new(DefaultWork) do
-        self.valkyrie_class = resource_class
-
-        # extract AF properties from the Valkyrie schema;
-        # skip reserved attributes, proctected properties, and those already defined
-        resource_class.schema.each do |schema_key|
-          next if resource_class.reserved_attributes.include?(schema_key.name)
-          next if protected_property_name?(schema_key.name)
-          next if properties.keys.include?(schema_key.name.to_s)
-
-          property schema_key.name, predicate: RDF::URI("http://hyrax.samvera.org/ns/wings##{schema_key.name}")
-        end
-
-        # nested attributes in AF don't inherit! this needs to be here until we can drop it completely.
-        accepts_nested_attributes_for :nested_resource
-      end
-    end
-
-    ##
-    # A base model class for valkyrie resources that don't have corresponding
-    # ActiveFedora::Base models.
-    class DefaultWork < ActiveFedora::Base
-      include Hyrax::WorkBehavior
-      property :nested_resource, predicate: ::RDF::URI("http://example.com/nested_resource"), class_name: "Wings::ActiveFedoraConverter::NestedResource"
-
-      class_attribute :valkyrie_class
-      self.valkyrie_class = Hyrax::Resource
-
-      class << self
-        delegate :human_readable_type, to: :valkyrie_class
-
-        def model_name(*)
-          _hyrax_default_name_class.new(valkyrie_class)
-        end
-
-        def to_rdf_representation
-          "Wings(#{valkyrie_class})"
-        end
-        alias inspect to_rdf_representation
-        alias to_s inspect
-      end
-
-      def to_global_id
-        GlobalID.create(valkyrie_class.new(id: id))
-      end
-    end
-
-    class NestedResource < ActiveTriples::Resource
-      property :title, predicate: ::RDF::Vocab::DC.title
-      property :ordered_authors, predicate: ::RDF::Vocab::DC.creator
-      property :ordered_nested, predicate: ::RDF::URI("http://example.com/ordered_nested")
-
-      def initialize(uri = RDF::Node.new, _parent = ActiveTriples::Resource.new)
-        uri = if uri.try(:node?)
-                RDF::URI("#nested_resource_#{uri.to_s.gsub('_:', '')}")
-              elsif uri.to_s.include?('#')
-                RDF::URI(uri)
-              end
-        super
-      end
-
-      include ::Hyrax::BasicMetadata
-    end
-
     private
 
-    def convert_members(af_object)
-      return unless resource.respond_to?(:member_ids) && resource.member_ids
-      # TODO: It would be better to find a way to add the members without resuming all the member AF objects
-      af_object.ordered_members = resource.member_ids.map { |valkyrie_id| ActiveFedora::Base.find(valkyrie_id.to_s) }
+    def instance
+      id.present? ? active_fedora_class.find(id) : active_fedora_class.new
+    rescue ActiveFedora::ObjectNotFoundError
+      active_fedora_class.new
     end
 
-    def convert_member_of_collections(af_object)
-      return unless resource.respond_to?(:member_of_collection_ids) && resource.member_of_collection_ids
-      # TODO: It would be better to find a way to set the parent collections without resuming all the collection AF objects
-      af_object.member_of_collections = resource.member_of_collection_ids.map { |valkyrie_id| ActiveFedora::Base.find(valkyrie_id.to_s) }
-    end
-
-    def convert_files(af_object)
-      return unless resource.respond_to? :file_ids
-
-      af_object.files = resource.file_ids.map do |fid|
-        pcdm_file = Hydra::PCDM::File.new(fid.id)
-        assign_association_target(af_object, pcdm_file)
-      end
-    end
-
-    def assign_association_target(af_object, pcdm_file)
-      case pcdm_file.metadata_node.type
-      when ->(types) { types.include?(RDF::URI.new('http://pcdm.org/use#OriginalFile')) }
-        af_object.association(:original_file).target = pcdm_file
-      when ->(types) { types.include?(RDF::URI.new('http://pcdm.org/use#ExtractedText')) }
-        af_object.association(:extracted_text).target = pcdm_file
-      when ->(types) { types.include?(RDF::URI.new('http://pcdm.org/use#Thumbnail')) }
-        af_object.association(:thumbnail).target = pcdm_file
-      else
-        pcdm_file
-      end
+    def attributes_class
+      self.class.attributes_class
     end
 
     # Normalizes the attributes parsed from the resource
@@ -193,25 +116,50 @@ module Wings
     def normal_attributes
       attributes.each_with_object({}) do |(attr, value), hash|
         property = active_fedora_class.properties[attr.to_s]
-        hash[attr] = property&.multiple? ? Array.wrap(value) : value
+        hash[attr] = if property.nil?
+                       value
+                     elsif property.multiple?
+                       Array.wrap(value)
+                     elsif Array.wrap(value).length < 2
+                       Array.wrap(value).first
+                     else
+                       value
+                     end
+      end
+    end
+
+    ##
+    # apply attributes to the ActiveFedora model
+    def apply_attributes_to_model(af_object)
+      case af_object
+      when Hydra::AccessControl
+        add_access_control_attributes(af_object)
+      when ActiveFedora::File
+        add_file_attributes(af_object)
+      else
+        converted_attrs = normal_attributes
+        members = Array.wrap(converted_attrs.delete(:members))
+        files = converted_attrs.delete(:files)
+        af_object.attributes = converted_attrs
+        members.empty? ? af_object.try(:ordered_members)&.clear : af_object.try(:ordered_members=, members)
+        af_object.try(:members)&.replace(members)
+        af_object.files.build_or_set(files) if files
       end
     end
 
     # Add attributes from resource which aren't AF properties into af_object
     def add_access_control_attributes(af_object)
-      return unless af_object.is_a? Hydra::AccessControl
-      cache = af_object.permissions.to_a
-
-      # if we've saved this before, it has a cache that won't clear
-      # when setting permissions! we need to reset it manually and
-      # rewrite with the values already in there, or saving will fail
-      # to delete cached items
-      af_object.permissions.reset if af_object.persisted?
-
-      af_object.permissions = cache.map do |permission|
-        permission.access_to_id = resource.try(:access_to)&.id
-        permission
-      end
+      normal_attributes[:permissions].each { |p| p.access_to_id = resource.access_to&.id }
+      af_object.permissions = normal_attributes[:permissions]
+    end
+
+    # for files, add attributes to metadata_node, plus some other work
+    def add_file_attributes(af_object)
+      af_object.metadata_node.attributes = normal_attributes
+      af_object.original_name = resource.original_filename
+      new_type = (resource.type - af_object.metadata_node.type.to_a).first
+      af_object.metadata_node.type = new_type if new_type
+      af_object.mime_type = resource.mime_type
     end
   end
 end