curation_concerns-models 0.1.0 → 0.2.0

data/app/actors/curation_concerns/work_actor_behavior.rb

@@ -1,88 +1,85 @@
-
 module CurationConcerns::WorkActorBehavior
   include CurationConcerns::ManagesEmbargoesActor
+  attr_accessor :raw_attributes
 
   def create
     # set the @files ivar then remove the files attribute so it isn't set by default.
     files && attributes.delete(:files)
+    self.raw_attributes = attributes.dup
     # Files must be attached before saving in order to persist their relationship to the work
-    assign_pid && interpret_visibility && attach_files && super && assign_representative && copy_visibility
+    assign_pid && interpret_visibility && attach_files && super && assign_representative
   end
 
   def update
     add_to_collections(attributes.delete(:collection_ids)) &&
-        interpret_visibility && super && attach_files && copy_visibility
+      interpret_visibility && super && attach_files
   end
 
   delegate :visibility_changed?, to: :curation_concern
 
   protected
 
-  # Is this here to ensure that the curation_concern has a pid set before any of the other methods are executed?
-  def assign_pid
-    curation_concern.send(:assign_id)
-  end
-
-  def files
-    return @files if defined?(@files)
-    @files = [attributes[:files]].flatten.compact
-  end
+    # Is this here to ensure that the curation_concern has a pid set before any of the other methods are executed?
+    def assign_pid
+      curation_concern.send(:assign_id)
+    end
 
-  def attach_files
-    files.all? do |file|
-      attach_file(file)
+    def files
+      return @files if defined?(@files)
+      @files = [attributes[:files]].flatten.compact
     end
-  end
 
-  # The default behavior of active_fedora's aggregates association,
-  # when assigning the id accessor (e.g. collection_ids = ['foo:1']) is to add
-  # to new collections, but not remove from old collections.
-  # This method ensures it's removed from the old collections.
-  def add_to_collections(new_collection_ids)
-    return true unless new_collection_ids
-    # remove from old collections
-    # TODO Implement parent_collection_ids https://github.com/projecthydra-labs/hydra-pcdm/issues/157
-    (curation_concern.parent_collections.map(&:id) - new_collection_ids).each do |old_id|
-      Collection.find(old_id).members.delete(curation_concern)
+    def attach_files
+      files.all? do |file|
+        attach_file(file)
+      end
     end
 
-    #add to new
-    new_collection_ids.each do |coll_id|
-      collection = Collection.find(coll_id)
-      collection.members << curation_concern
-      collection.save
+    # The default behavior of active_fedora's aggregates association,
+    # when assigning the id accessor (e.g. collection_ids = ['foo:1']) is to add
+    # to new collections, but not remove from old collections.
+    # This method ensures it's removed from the old collections.
+    def add_to_collections(new_collection_ids)
+      return true unless new_collection_ids
+      # remove from old collections
+      # TODO: Implement in_collection_ids https://github.com/projecthydra-labs/hydra-pcdm/issues/157
+      (curation_concern.in_collections.map(&:id) - new_collection_ids).each do |old_id|
+        collection = Collection.find(old_id)
+        collection.members.delete(curation_concern)
+        collection.save
+      end
+
+      # add to new
+      new_collection_ids.each do |coll_id|
+        collection = Collection.find(coll_id)
+        collection.members << curation_concern
+        collection.save
+      end
+      true
     end
-    true
-  end
 
-  def assign_representative
-    @generic_files ||= []
-    unless curation_concern.representative
-      curation_concern.representative = @generic_files.first.id unless @generic_files.empty?
+    def assign_representative
+      @file_sets ||= []
+      unless curation_concern.representative_id
+        curation_concern.representative = @file_sets.first unless @file_sets.empty?
+      end
+      curation_concern.save
     end
-    curation_concern.save
-  end
 
   private
 
-  def attach_file(file)
-    generic_file = ::GenericFile.new
-    generic_file_actor = CurationConcerns::GenericFileActor.new(generic_file, user)
-    #TODO we're passing an ID rather than an object. This means the actor does an unnecessary lookup
-    generic_file_actor.create_metadata(curation_concern.id, curation_concern.id)
-    generic_file.visibility = visibility
-    generic_file_actor.create_content(file)
-    @generic_files ||= []
-    @generic_files << generic_file # This is so that other methods like assign_representative can access the generic_files wihtout reloading them from fedora
-    curation_concern.generic_files << generic_file
-  end
-
-  def valid_file?(file_path)
-    return file_path.present? && File.exists?(file_path) && !File.zero?(file_path)
-  end
+    def attach_file(file)
+      file_set = ::FileSet.new
+      file_set_actor = CurationConcerns::FileSetActor.new(file_set, user)
+      file_set_actor.create_metadata(curation_concern.id, curation_concern, visibility_attributes)
+      file_set_actor.create_content(file)
+      @file_sets ||= []
+      @file_sets << file_set # This is so that other methods like assign_representative can access the file_sets without reloading them from fedora
+    end
 
-  # The path of the fedora node where we store the file data
-  def file_path
-    'content'
-  end
+    # The attributes used for visibility - used to send as initial params to
+    # created FileSets.
+    def visibility_attributes
+      raw_attributes.slice(:visibility, :visibility_during_lease, :visibility_after_lease, :lease_expiration_date, :embargo_release_date, :visibility_during_embargo, :visibility_after_embargo)
+    end
 end

data/app/indexers/curation_concerns/collection_indexer.rb

@@ -0,0 +1,10 @@
+module CurationConcerns
+  class CollectionIndexer < Hydra::PCDM::CollectionIndexer
+    def generate_solr_document
+      super.tap do |solr_doc|
+        # Makes Collections show under the "Collections" tab
+        Solrizer.set_field(solr_doc, 'generic_type', 'Collection', :facetable)
+      end
+    end
+  end
+end

data/app/indexers/curation_concerns/file_set_indexing_service.rb

@@ -0,0 +1,24 @@
+module CurationConcerns
+  class FileSetIndexingService < ActiveFedora::IndexingService
+    include IndexesThumbnails
+
+    def generate_solr_document
+      super.tap do |solr_doc|
+        solr_doc[Solrizer.solr_name('hasRelatedMediaFragment', :symbol)] = object.representative_id
+        solr_doc[Solrizer.solr_name('hasRelatedImage', :symbol)] = object.thumbnail_id
+        # Label is the actual file name. It's not editable by the user.
+        solr_doc[Solrizer.solr_name('label')] = object.label
+        solr_doc[Solrizer.solr_name('label', :stored_sortable)] = object.label
+        solr_doc[Solrizer.solr_name('file_format')] = object.file_format
+        solr_doc[Solrizer.solr_name('file_format', :facetable)] = object.file_format
+        solr_doc[Solrizer.solr_name(:file_size, :symbol)] = object.file_size[0]
+        solr_doc['all_text_timv'] = object.full_text.content
+        solr_doc[Solrizer.solr_name('generic_work_ids', :symbol)] = object.generic_work_ids unless object.generic_work_ids.empty?
+        solr_doc['height_is'] = Integer(object.height.first) if object.height.present?
+        solr_doc['width_is'] = Integer(object.width.first) if object.width.present?
+        solr_doc[Solrizer.solr_name('mime_type', :stored_sortable)] = object.mime_type
+        solr_doc['thumbnail_path_ss'] = thumbnail_path
+      end
+    end
+  end
+end

data/app/{services/curation_concerns/generic_work_indexing_service.rb → indexers/curation_concerns/work_indexing_service.rb}

@@ -1,16 +1,16 @@
 module CurationConcerns
-  class GenericWorkIndexingService < ActiveFedora::IndexingService
-
+  class WorkIndexingService < ActiveFedora::IndexingService
+    include IndexesThumbnails
     def generate_solr_document
       super.tap do |solr_doc|
         # We know that all the members of GenericWorks are GenericFiles so we can use
-        # member_ids which requires fewer Fedora API calls than generic_file_ids.
-        # generic_file_ids requires loading all the members from Fedora but member_ids
+        # member_ids which requires fewer Fedora API calls than file_set_ids.
+        # file_set_ids requires loading all the members from Fedora but member_ids
         # looks just at solr
-        solr_doc[Solrizer.solr_name('generic_file_ids', :symbol)] = object.member_ids
+        solr_doc[Solrizer.solr_name('file_set_ids', :symbol)] = object.member_ids
         Solrizer.set_field(solr_doc, 'generic_type', 'Work', :facetable)
+        solr_doc['thumbnail_path_ss'] = thumbnail_path
       end
     end
-
   end
 end

data/app/jobs/active_fedora_id_based_job.rb

@@ -1,22 +1,15 @@
-class ActiveFedoraIdBasedJob
-  def queue_name
-    :id_based
-  end
+class ActiveFedoraIdBasedJob < ActiveJob::Base
+  queue_as :id_based
 
   attr_accessor :id
 
-  def initialize(id)
-    self.id = id
-  end
-
   def object
     @object ||= ActiveFedora::Base.find(id)
   end
 
-  alias_method :generic_file, :object
-  alias_method :generic_file_id, :id
+  alias_method :file_set, :object
 
-  def run
-    raise RuntimeError, "Define #run in a subclass"
+  def perform(_)
+    fail 'Define #run in a subclass'
   end
 end

data/app/jobs/audit_job.rb

@@ -1,7 +1,5 @@
 class AuditJob < ActiveFedoraIdBasedJob
-  def queue_name
-    :audit
-  end
+  queue_as :audit
 
   attr_accessor :uri, :id, :file_id
 
@@ -13,21 +11,17 @@ class AuditJob < ActiveFedoraIdBasedJob
   # @param [String] id of the parent object
   # @param [String] file_id used to find the file within its parent object (usually "original_file")
   # @param [String] uri of the specific file/version to be audited
-  def initialize(id, file_id, uri)
-    super(id)
-    self.file_id = file_id
-    self.uri = uri
-  end
-
-  def run
-    fixity_ok = false
+  def perform(id, file_id, uri)
+    @id = id
+    @file_id = file_id
+    @uri = uri
     log = run_audit
-    fixity_ok = (log.pass == 1)
+    fixity_ok = log.pass == 1
     unless fixity_ok
-      if CurationConcerns.config.respond_to?(:after_audit_failure)
-        login = generic_file.depositor
+      if CurationConcerns.config.callback.set?(:after_audit_failure)
+        login = file_set.depositor
         user = User.find_by_user_key(login)
-        CurationConcerns.config.after_audit_failure.call(generic_file, user, log.created_at)
+        CurationConcerns.config.callback.run(:after_audit_failure, file_set, user, log.created_at)
       end
     end
     fixity_ok
@@ -39,7 +33,7 @@ class AuditJob < ActiveFedoraIdBasedJob
       begin
         fixity_ok = ActiveFedora::FixityService.new(uri).check
       rescue Ldp::NotFound
-        error_msg = "resource not found"
+        error_msg = 'resource not found'
       end
 
       if fixity_ok
@@ -49,7 +43,7 @@ class AuditJob < ActiveFedoraIdBasedJob
         logger.warn "***AUDIT*** Audit failed for #{uri} #{error_msg}"
         passing = 0
       end
-      ChecksumAuditLog.create!(pass: passing, generic_file_id: id, version: uri, file_id: file_id)
+      ChecksumAuditLog.create!(pass: passing, file_set_id: id, version: uri, file_id: file_id)
     end
 
     def logger

data/app/jobs/characterize_job.rb

@@ -1,11 +1,12 @@
 class CharacterizeJob < ActiveFedoraIdBasedJob
-  def queue_name
-    :characterize
-  end
+  queue_as :characterize
 
-  def run
-    CurationConcerns::CharacterizationService.run(generic_file)
-    generic_file.save
-    CurationConcerns.queue.push(CreateDerivativesJob.new(generic_file.id))
+  # @param [String] id
+  # @param [String] filename a local path for the file to characterize. By using this, we don't have to pull a copy out of fedora.
+  def perform(id, filename)
+    @id = id
+    Hydra::Works::CharacterizationService.run(file_set, filename)
+    file_set.save
+    CreateDerivativesJob.perform_later(file_set.id, filename)
   end
 end

data/app/jobs/create_derivatives_job.rb

@@ -1,15 +1,12 @@
 class CreateDerivativesJob < ActiveFedoraIdBasedJob
-  def queue_name
-    :derivatives
-  end
+  queue_as :derivatives
+
+  def perform(id, file_name)
+    @id = id
+    return if file_set.video? && !CurationConcerns.config.enable_ffmpeg
 
-  def run
-    return unless generic_file.original_file.has_content?
-    if generic_file.video?
-      return unless CurationConcerns.config.enable_ffmpeg
-    end
-    
-    generic_file.create_derivatives
-    generic_file.save
+    file_set.create_derivatives(file_name)
+    # The thumbnail is indexed in the solr document, so reindex
+    file_set.update_index
   end
 end

data/app/jobs/import_url_job.rb

@@ -3,39 +3,30 @@ require 'uri'
 require 'tempfile'
 
 class ImportUrlJob < ActiveFedoraIdBasedJob
+  queue_as :import_url
 
-  def queue_name
-    :import_url
-  end
-
-  def run
-    user = User.find_by_user_key(generic_file.depositor)
+  def perform(id)
+    @id = id
+    user = User.find_by_user_key(file_set.depositor)
 
-    Tempfile.open(id.gsub('/', '_')) do |f|
-      copy_remote_file(generic_file.import_url, f)
+    Tempfile.open(id.tr('/', '_')) do |f|
+      copy_remote_file(file_set.import_url, f)
       # attach downloaded file to generic file stubbed out
-      if CurationConcerns::GenericFileActor.new(generic_file, user).create_content(f)
-
+      if CurationConcerns::FileSetActor.new(file_set, user).create_content(f)
         # send message to user on download success
-        if CurationConcerns.config.respond_to?(:after_import_url_success)
-          CurationConcerns.config.after_import_url_success.call(generic_file, user)
-        end
+        CurationConcerns.config.callback.run(:after_import_url_success, file_set, user)
       else
-
-        # send message to user on download failure
-        if CurationConcerns.config.respond_to?(:after_import_url_failure)
-          CurationConcerns.config.after_import_url_failure.call(generic_file, user)
-        end
+        CurationConcerns.config.callback.run(:after_import_url_failure, file_set, user)
       end
     end
   end
 
-  def copy_remote_file(import_url, f)
+  def copy_remote_file(_import_url, f)
     f.binmode
     # download file from url
-    uri = URI(generic_file.import_url)
+    uri = URI(file_set.import_url)
     http = Net::HTTP.new(uri.host, uri.port)
-    http.use_ssl = uri.scheme == "https"  # enable SSL/TLS
+    http.use_ssl = uri.scheme == 'https' # enable SSL/TLS
     http.verify_mode = OpenSSL::SSL::VERIFY_NONE
     mime_type = nil
 
@@ -49,8 +40,4 @@ class ImportUrlJob < ActiveFedoraIdBasedJob
     end
     f.rewind
   end
-
-  def job_user
-    User.batchuser
-  end
 end

data/app/jobs/ingest_file_job.rb

@@ -0,0 +1,16 @@
+class IngestFileJob < ActiveJob::Base
+  queue_as :ingest
+
+  def perform(file_set_id, filename, mime_type, user_key)
+    file_set = FileSet.find(file_set_id)
+    file = Hydra::Derivatives::IoDecorator.new(File.open(filename, "rb"))
+    file.mime_type = mime_type
+    file.original_name = File.basename(filename)
+
+    # Tell UploadFileToGenericFile service to skip versioning because versions will be minted by VersionCommitter (called by save_characterize_and_record_committer) when necessary
+    Hydra::Works::UploadFileToFileSet.call(file_set, file, versioning: false)
+    file_set.save!
+    CurationConcerns::VersioningService.create(file_set.original_file, user_key)
+    CurationConcerns.config.callback.run(:after_create_content, file_set, user_key)
+  end
+end

data/app/jobs/ingest_local_file_job.rb

@@ -1,48 +1,27 @@
-class IngestLocalFileJob
-  attr_accessor :directory, :filename, :user_key, :generic_file_id
+class IngestLocalFileJob < ActiveJob::Base
+  attr_accessor :directory, :filename, :user_key, :file_set_id
 
-  def queue_name
-    :ingest
-  end
+  queue_as :ingest_local
 
-  def initialize(generic_file_id, directory, filename, user_key)
-    self.generic_file_id = generic_file_id
-    self.directory = directory
-    self.filename = filename
-    self.user_key = user_key
-  end
+  def perform(file_set_id, directory, filename, user_key)
+    @file_set_id = file_set_id
+    @directory = directory
+    @filename = filename
+    @user_key = user_key
 
-  def run
     user = User.find_by_user_key(user_key)
-    raise "Unable to find user for #{user_key}" unless user
-    generic_file = GenericFile.find(generic_file_id)
-    generic_file.label ||= filename
+    fail "Unable to find user for #{user_key}" unless user
+    file_set = FileSet.find(file_set_id)
+    file_set.label ||= filename
     path = File.join(directory, filename)
 
-    actor = CurationConcerns::GenericFileActor.new(generic_file, user)
+    actor = CurationConcerns::FileSetActor.new(file_set, user)
 
     if actor.create_content(File.open(path))
       FileUtils.rm(path)
-
-      # send message to user on import success
-      if CurationConcerns.config.respond_to?(:after_import_local_file_success)
-        CurationConcerns.config.after_import_local_file_success.call(generic_file, user, filename)
-      end
+      CurationConcerns.config.callback.run(:after_import_local_file_success, file_set, user, filename)
     else
-
-      # send message to user on import failure
-      if CurationConcerns.config.respond_to?(:after_import_local_file_failure)
-        CurationConcerns.config.after_import_local_file_failure.call(generic_file, user, filename)
-      end
+      CurationConcerns.config.callback.run(:after_import_local_file_failure, file_set, user, filename)
     end
   end
-
-  def job_user
-    User.batchuser
-  end
-
-  def mime_type(file_name)
-    mime_types = MIME::Types.of(file_name)
-    mime_types.empty? ? "application/octet-stream" : mime_types.first.content_type
-  end
 end