curation_concerns-models 0.1.0 → 0.2.0

data/app/models/curation_concerns/classify_concern.rb

@@ -7,7 +7,7 @@ module CurationConcerns
     validates(
       :curation_concern_type,
       presence: true,
-      inclusion: { in: lambda { |record| record.registered_curation_concern_types } }
+      inclusion: { in: ->(record) { record.registered_curation_concern_types } }
     )
 
     def all_curation_concern_classes
@@ -15,7 +15,7 @@ module CurationConcerns
     end
 
     def registered_curation_concern_types
-      CurationConcerns.configuration.registered_curation_concern_types
+      CurationConcerns.config.registered_curation_concern_types
     end
 
     def possible_curation_concern_types
@@ -25,17 +25,17 @@ module CurationConcerns
     end
 
     def curation_concern_class
-      if possible_curation_concern_types.detect{|name, class_name|
-          class_name == curation_concern_type
-        }
+      if possible_curation_concern_types.detect do|_name, class_name|
+        class_name == curation_concern_type
+      end
         self.class.to_class(curation_concern_type)
       else
-        raise RuntimeError, "Invalid :curation_concern_type"
+        fail 'Invalid :curation_concern_type'
       end
     end
 
     def self.to_class(type)
-      # TODO we may want to allow a different (or nil) namespace
+      # TODO: we may want to allow a different (or nil) namespace
       type.camelize.constantize
       # begin
       #   "::#{type.camelize}".constantize

data/app/models/curation_concerns/quick_classification_query.rb

@@ -1,6 +1,5 @@
 module CurationConcerns
   class QuickClassificationQuery
-
     def self.each_for_context(*args, &block)
       new(*args).all.each(&block)
     end
@@ -10,22 +9,22 @@ module CurationConcerns
     def initialize(user, options = {})
       @user = user
       @concern_name_normalizer = options.fetch(:concern_name_normalizer, ClassifyConcern.method(:to_class))
-      @registered_curation_concern_names = options.fetch(:registered_curation_concern_names, CurationConcerns.configuration.registered_curation_concern_types)
+      @registered_curation_concern_names = options.fetch(:registered_curation_concern_names, CurationConcerns.config.registered_curation_concern_types)
     end
 
     def all
       ActiveFedora::Base.logger.debug "User is #{user}"
       ActiveFedora::Base.logger.debug "try is #{normalized_curation_concern_names.first}"
       ActiveFedora::Base.logger.debug "can is  #{user.can?(:create, normalized_curation_concern_names.first)}"
-      normalized_curation_concern_names.select {|klass| user.can?(:create, klass)}
+      normalized_curation_concern_names.select { |klass| user.can?(:create, klass) }
     end
 
     private
 
-    attr_reader :concern_name_normalizer, :registered_curation_concern_names
+      attr_reader :concern_name_normalizer, :registered_curation_concern_names
 
-    def normalized_curation_concern_names
-      registered_curation_concern_names.collect{|name| concern_name_normalizer.call(name) }
-    end
+      def normalized_curation_concern_names
+        registered_curation_concern_names.collect { |name| concern_name_normalizer.call(name) }
+      end
   end
 end

data/app/models/single_use_link.rb

@@ -0,0 +1,34 @@
+class SingleUseLink < ActiveRecord::Base
+  validate :expiration_date_cannot_be_in_the_past
+  validate :cannot_be_destroyed
+
+  after_initialize :set_defaults
+
+  def create_for_path(path)
+    self.class.create(itemId: itemId, path: path)
+  end
+
+  def expired?
+    DateTime.now > expires
+  end
+
+  def to_param
+    downloadKey
+  end
+
+  protected
+
+    def expiration_date_cannot_be_in_the_past
+      errors.add(:expires, "can't be in the past") if expired?
+    end
+
+    def cannot_be_destroyed
+      errors[:base] << "Single Use Link has already been used" if destroyed?
+    end
+
+    def set_defaults
+      return unless new_record?
+      self.expires ||= DateTime.now.advance(hours: 24)
+      self.downloadKey ||= (Digest::SHA2.new << rand(1_000_000_000).to_s).to_s
+    end
+end

data/app/models/upload_set.rb

@@ -0,0 +1,3 @@
+class UploadSet < ActiveFedora::Base
+  include CurationConcerns::UploadSetBehavior
+end

data/app/services/curation_concerns/derivative_path.rb

@@ -0,0 +1,32 @@
+module CurationConcerns
+  class DerivativePath
+    class << self
+      # Path on file system where derivative file is stored
+      def derivative_path_for_reference(object, destination_name)
+        destination_name = destination_name.gsub(/^original_file_/, '')
+        derivative_path(object, extension_for(destination_name), destination_name)
+      end
+
+      private
+
+        def derivative_path(object, extension, destination_name)
+          file_name = destination_name + extension
+          File.join(CurationConcerns.config.derivatives_path, pair_path(object.id, file_name))
+        end
+
+        def pair_path(id, file_name)
+          pair = id.split('').each_slice(2).map(&:join).join('/')
+          "#{pair}-#{file_name}"
+        end
+
+        def extension_for(destination_name)
+          case destination_name
+          when 'thumbnail'
+            ".#{MIME::Types.type_for('jpg').first.extensions.first}"
+          else
+            ".#{destination_name}"
+          end
+        end
+    end
+  end
+end

data/app/services/curation_concerns/{generic_file_audit_service.rb → file_set_audit_service.rb}

@@ -1,8 +1,8 @@
 module CurationConcerns
-  class GenericFileAuditService
-    attr_reader :generic_file
+  class FileSetAuditService
+    attr_reader :file_set
     def initialize(file)
-      @generic_file = file
+      @file_set = file
     end
 
     NO_RUNS = 999
@@ -10,20 +10,20 @@ module CurationConcerns
     # provides a human readable version of the audit status
     def human_readable_audit_status(stat)
       case stat
-        when 0
-          'failing'
-        when 1
-          'passing'
-        else
-          stat
+      when 0
+        'failing'
+      when 1
+        'passing'
+      else
+        stat
       end
     end
 
     # Audits each version of each file if it hasn't been audited recently
     # Returns the set of most recent audit status for each version of the content file
     # @param [Hash] log container for messages, mapping file ids to status
-    def audit(log={})
-      generic_file.files.each { |f| log[f.id] = audit_file(f) }
+    def audit(log = {})
+      file_set.files.each { |f| log[f.id] = audit_file(f) }
       log
     end
 
@@ -32,7 +32,7 @@ module CurationConcerns
       # Retrieve or generate the audit check for a file (all versions are checked for versioned files)
       # @param [ActiveFedora::File] file to audit
       # @param [Array] log container for messages
-      def audit_file(file, log=[])
+      def audit_file(file, log = [])
         versions = file.has_versions? ? file.versions.all : file
         versions.each { |v| log << audit_file_version(file.id, v.uri) }
         log
@@ -41,9 +41,9 @@ module CurationConcerns
       # Retrieve or generate the audit check for a file and provide a human-readable status message.
       # @param [ActiveFedora::File] file to audit
       def audit_stat(file)
-        audit_results = audit_file(file).collect { |result| result["pass"] }
+        audit_results = audit_file(file).collect { |result| result['pass'] }
         # check how many non runs we had
-        non_runs = audit_results.reduce(0) { |sum, value| value == NO_RUNS ? sum += 1 : sum }
+        non_runs = audit_results.reduce(0) { |sum, value| value == NO_RUNS ? sum + 1 : sum }
         if non_runs == 0
           audit_results.reduce(true) { |sum, value| sum && value }
         elsif non_runs < audit_results.length
@@ -58,10 +58,10 @@ module CurationConcerns
       # @param [String] file_id used to find the file within its parent object (usually "original_file")
       # @param [String] version_uri the version to be audited (or the file uri for non-versioned files)
       def audit_file_version(file_id, version_uri)
-        latest_audit = ChecksumAuditLog.logs_for(generic_file.id, file_id).first
+        latest_audit = ChecksumAuditLog.logs_for(file_set.id, file_id).first
         return latest_audit unless needs_audit?(latest_audit)
-        CurationConcerns.queue.push(AuditJob.new(generic_file.id, file_id, version_uri))
-        latest_audit || ChecksumAuditLog.new(pass: NO_RUNS, generic_file_id: generic_file.id, file_id: file_id, version: version_uri)
+        AuditJob.perform_later(file_set.id, file_id, version_uri.to_s)
+        latest_audit || ChecksumAuditLog.new(pass: NO_RUNS, file_set_id: file_set.id, file_id: file_id, version: version_uri)
       end
 
       # Check if time since the last audit is greater than the maximum days allowed between audits
@@ -80,6 +80,5 @@ module CurationConcerns
       def days_since_last_audit(latest_audit)
         (DateTime.now - latest_audit.updated_at.to_date).to_i
       end
-
   end
 end

data/app/services/curation_concerns/indexes_thumbnails.rb

@@ -0,0 +1,14 @@
+module CurationConcerns
+  module IndexesThumbnails
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :thumbnail_path_service
+      self.thumbnail_path_service = ThumbnailPathService
+    end
+
+    def thumbnail_path
+      self.class.thumbnail_path_service.call(object)
+    end
+  end
+end

data/app/services/curation_concerns/local_file_service.rb

@@ -0,0 +1,10 @@
+module CurationConcerns
+  class LocalFileService
+    # @param [String] file_name path to the file
+    # @param [Hash] _options
+    # @yield [File] opens the file and yields it to the block
+    def self.call(file_name, _options)
+      yield File.open(file_name)
+    end
+  end
+end

data/app/services/curation_concerns/lock_manager.rb

@@ -0,0 +1,40 @@
+require 'redlock'
+module CurationConcerns
+  class LockManager
+    class UnableToAcquireLockError < StandardError; end
+
+    attr_reader :client
+
+    # @param [Fixnum] time_to_live How long to hold the lock in milliseconds
+    # @param [Fixnum] retry_count How many times to retry to acquire the lock before raising UnableToAcquireLockError
+    # @param [Fixnum] retry_delay Maximum wait time in milliseconds before retrying. Wait time is a random value between 0 and retry_delay.
+    def initialize(time_to_live, retry_count, retry_delay)
+      @ttl = time_to_live
+      @client = Redlock::Client.new([uri], retry_count: retry_count, retry_delay: retry_delay)
+    end
+
+    # Blocks until lock is acquired or timeout.
+    def lock(key)
+      client.lock(key, @ttl) do |locked|
+        if locked
+          yield
+        else
+          raise UnableToAcquireLockError
+        end
+      end
+    end
+
+    private
+
+      def uri
+        @uri ||= begin
+          opts = options
+          URI("#{opts[:scheme]}://#{opts[:host]}:#{opts[:port]}").to_s
+        end
+      end
+
+      def options
+        ::Resque.redis.redis.client.options
+      end
+  end
+end

data/app/services/curation_concerns/noid.rb

@@ -20,4 +20,4 @@ module CurationConcerns
         @service ||= ActiveFedora::Noid::Service.new
       end
   end
-end
+end

data/app/services/curation_concerns/persist_derivatives.rb

@@ -0,0 +1,33 @@
+module CurationConcerns
+  class PersistDerivatives < Hydra::Derivatives::PersistOutputFileService
+    # Persists a derivative to the local file system.
+    # This Service conforms to the signature of `Hydra::Derivatives::PersistOutputFileService`.
+    # This service is an alternative to the default Hydra::Derivatives::PersistOutputFileService.
+    # This service will always update existing and does not do versioning of persisted files.
+    #
+    # @param [#read] stream the derivative filestream
+    # @param [Hash] directives
+    # @option directives [String] :url a url to the file destination
+    def self.call(stream, directives)
+      output_file(directives) do |output|
+        IO.copy_stream(stream, output)
+      end
+    end
+
+    # Open the output file to write and yield the block to the
+    # file. It makes the directories in the path if necessary.
+    def self.output_file(directives, &blk)
+      # name = derivative_path_factory.derivative_path_for_reference(object, destination_name)
+      raise ArgumentError, "No :url was provided in the transcoding directives" unless directives.key?(:url)
+      uri = URI(directives.fetch(:url))
+      raise ArgumentError, "Must provide a file uri" unless uri.scheme == 'file'
+      output_file_dir = File.dirname(uri.path)
+      FileUtils.mkdir_p(output_file_dir) unless File.directory?(output_file_dir)
+      File.open(uri.path, 'wb', &blk)
+    end
+
+    def self.derivative_path_factory
+      DerivativePath
+    end
+  end
+end

data/app/services/curation_concerns/persist_directly_contained_output_file_service.rb

@@ -0,0 +1,26 @@
+module CurationConcerns
+  # This Service is an implementation of the Hydra::Derivatives::PersistOutputFileService
+  # It supports directly contained files
+  class PersistDirectlyContainedOutputFileService < Hydra::Derivatives::PersistBasicContainedOutputFileService
+    # This method conforms to the signature of the .call method on Hydra::Derivatives::PersistOutputFileService
+    # * Persists the file within the DirectContainer specified by :container
+    #
+    # @param [#read] stream the data to be persisted
+    # @param [Hash] directives directions which can be used to determine where to persist to.
+    # @option directives [String] url URI for the parent object.
+    # @option directives [String] container Name of the container association.
+    def self.call(stream, directives)
+      file = Hydra::Derivatives::IoDecorator.new(stream, new_mime_type(directives.fetch(:format)))
+      o_name = determine_original_name(file)
+      m_type = determine_mime_type(file)
+      uri = URI(directives.fetch(:url))
+      raise ArgumentError, "#{uri} is not an http uri" unless uri.scheme == 'http'
+      file_set = ActiveFedora::Base.find(ActiveFedora::Base.uri_to_id(uri.to_s))
+      remote_file = file_set.send("build_#{directives.fetch(:container)}".to_sym)
+      remote_file.content = file
+      remote_file.mime_type = m_type
+      remote_file.original_name = o_name
+      file_set.save
+    end
+  end
+end

data/app/services/curation_concerns/repository_audit_service.rb

@@ -1,9 +1,7 @@
 module CurationConcerns
   class RepositoryAuditService
     def self.audit_everything
-      ::GenericFile.find_each do |gf|
-        gf.audit
-      end
+      ::FileSet.find_each(&:audit)
     end
   end
 end

data/app/services/curation_concerns/thumbnail_path_service.rb

@@ -0,0 +1,46 @@
+module CurationConcerns
+  class ThumbnailPathService
+    class << self
+      # @param [Work, FileSet] the object to get the thumbnail for
+      # @return [String] a path to the thumbnail
+      def call(object)
+        return default_image unless object.thumbnail_id
+
+        thumb = fetch_thumbnail(object)
+        return unless thumb
+        if thumb.audio?
+          audio_image
+        elsif thumbnail?(thumb)
+          Rails.application.routes.url_helpers.download_path(object.thumbnail_id, file: 'thumbnail')
+        else
+          default_image
+        end
+      end
+
+      def fetch_thumbnail(object)
+        return object if object.thumbnail_id == object.id
+        ::FileSet.load_instance_from_solr(object.thumbnail_id)
+      rescue ActiveFedora::ObjectNotFoundError
+        Rails.logger.error("Couldn't find thumbnail #{object.thumbnail_id} for #{object.id}")
+        nil
+      end
+
+      def default_image
+        ActionController::Base.helpers.image_path 'default.png'
+      end
+
+      def audio_image
+        ActionController::Base.helpers.image_path 'audio.png'
+      end
+
+      # @return true if there a file on disk for this object, otherwise false
+      def thumbnail?(thumb)
+        File.exist?(thumbnail_filepath(thumb))
+      end
+
+      def thumbnail_filepath(thumb)
+        CurationConcerns::DerivativePath.derivative_path_for_reference(thumb, 'thumbnail')
+      end
+    end
+  end
+end

data/app/services/curation_concerns/time_service.rb

@@ -0,0 +1,7 @@
+module CurationConcerns
+  class TimeService
+    def self.time_in_utc
+      DateTime.now.utc
+    end
+  end
+end

data/app/services/curation_concerns/versioning_service.rb

@@ -2,8 +2,8 @@ module CurationConcerns
   class VersioningService
     # Make a version and record the version committer
     # @param [ActiveFedora::File] content
-    # @param [User] user
-    def self.create(content, user=nil)
+    # @param [User, String] user
+    def self.create(content, user = nil)
       content.create_version
       record_committer(content, user) if user
     end
@@ -13,15 +13,14 @@ module CurationConcerns
       file.versions.last
     end
 
-    protected
-
-      # Record the version committer of the last version
-      # @param [ActiveFedora::File] content
-      # @param [User] user
-      def self.record_committer(content, user)
-        version = latest_version_of(content)
-        return if version.nil?
-        VersionCommitter.create(version_id: version.uri, committer_login: user.user_key)
-      end
+    # Record the version committer of the last version
+    # @param [ActiveFedora::File] content
+    # @param [User, String] user_key
+    def self.record_committer(content, user_key)
+      user_key = user_key.user_key if user_key.respond_to?(:user_key)
+      version = latest_version_of(content)
+      return if version.nil?
+      VersionCommitter.create(version_id: version.uri, committer_login: user_key)
+    end
   end
 end