test_hyrax 0.0.1.alpha

data/app/services/hyrax/contextual_path.rb

@@ -0,0 +1,21 @@
+module Hyrax
+  class ContextualPath
+    include Rails.application.routes.url_helpers
+    include ActionDispatch::Routing::PolymorphicRoutes
+    attr_reader :presenter, :parent_presenter
+    def initialize(presenter, parent_presenter)
+      @presenter = presenter
+      @parent_presenter = parent_presenter
+    end
+
+    def show
+      if parent_presenter
+        polymorphic_path([:hyrax, :parent, presenter.model_name.singular],
+                         parent_id: parent_presenter.id,
+                         id: presenter.id)
+      else
+        polymorphic_path([presenter])
+      end
+    end
+  end
+end

data/app/services/hyrax/curation_concern.rb

@@ -0,0 +1,15 @@
+module Hyrax
+  class CurationConcern
+    class_attribute :actor_factory
+    self.actor_factory = Hyrax::Actors::ActorFactory
+
+    # A consumer of this method can inject a different factory
+    # into this class in order to change the behavior of this method.
+    # @param [ActiveFedora::Base] curation_concern a work to be updated
+    # @param [User] current_user the depositor/updater of the work
+    # @return [#create, #update] an actor that can create and update the work
+    def self.actor(curation_concern, current_user)
+      actor_factory.build(curation_concern, current_user)
+    end
+  end
+end

data/app/services/hyrax/derivative_path.rb

@@ -0,0 +1,67 @@
+module Hyrax
+  class DerivativePath
+    attr_reader :id, :destination_name
+
+    class << self
+      # Path on file system where derivative file is stored
+      # @param [ActiveFedora::Base or String] object either the AF object or its id
+      # @param [String] destintation_name
+      def derivative_path_for_reference(object, destination_name)
+        new(object, destination_name).derivative_path
+      end
+
+      # @param [ActiveFedora::Base or String] object either the AF object or its id
+      # @return [Array<String>] Array of paths to derivatives for this object.
+      def derivatives_for_reference(object)
+        new(object).all_paths
+      end
+    end
+
+    # @param [ActiveFedora::Base, String] object either the AF object or its id
+    # @param [String] destination_name
+    def initialize(object, destination_name = nil)
+      @id = object.is_a?(String) ? object : object.id
+      @destination_name = destination_name.gsub(/^original_file_/, '') if destination_name
+    end
+
+    def derivative_path
+      "#{path_prefix}-#{file_name}"
+    end
+
+    def all_paths
+      Dir.glob(root_path.join("*")).select do |path|
+        path.start_with?(path_prefix.to_s)
+      end
+    end
+
+    private
+
+      # @return [String] Returns the root path where derivatives will be generated into.
+      def root_path
+        Pathname.new(derivative_path).dirname
+      end
+
+      # @return <Pathname> Full prefix of the path for object.
+      def path_prefix
+        Pathname.new(Hyrax.config.derivatives_path).join(pair_path)
+      end
+
+      def pair_path
+        id.split('').each_slice(2).map(&:join).join('/')
+      end
+
+      def file_name
+        return unless destination_name
+        destination_name + extension
+      end
+
+      def extension
+        case destination_name
+        when 'thumbnail'
+          ".#{MIME::Types.type_for('jpg').first.extensions.first}"
+        else
+          ".#{destination_name}"
+        end
+      end
+  end
+end

data/app/services/hyrax/embargo_service.rb

@@ -0,0 +1,35 @@
+module Hyrax
+  class EmbargoService < RestrictionService
+    class << self
+      #
+      # Methods for Querying Repository to find Embargoed Objects
+      #
+
+      # Returns all assets with embargo release date set to a date in the past
+      def assets_with_expired_embargoes
+        builder = Hyrax::ExpiredEmbargoSearchBuilder.new(self)
+        presenters(builder)
+      end
+
+      # Returns all assets with embargo release date set
+      #   (assumes that when lease visibility is applied to assets
+      #    whose leases have expired, the lease expiration date will be removed from its metadata)
+      def assets_under_embargo
+        builder = Hyrax::EmbargoSearchBuilder.new(self)
+        presenters(builder)
+      end
+
+      # Returns all assets that have had embargoes deactivated in the past.
+      def assets_with_deactivated_embargoes
+        builder = Hyrax::DeactivatedEmbargoSearchBuilder.new(self)
+        presenters(builder)
+      end
+
+      private
+
+        def presenter_class
+          Hyrax::EmbargoPresenter
+        end
+    end
+  end
+end

data/app/services/hyrax/file_set_audit_service.rb

@@ -0,0 +1,122 @@
+module Hyrax
+  class FileSetAuditService
+    attr_reader :file_set, :id
+
+    # @param file_set [ActiveFedora::Base, String] file_set
+    def initialize(file_set)
+      if file_set.is_a?(String)
+        @id = file_set
+      else
+        @id = file_set.id
+        @file_set = file_set
+      end
+    end
+
+    NO_RUNS = 999
+
+    # provides a human readable version of the audit status
+    # This may trigger audits to be run if required
+    # @param [Hydra::PCDM::File] file the file to get the audit status for, defaults to the original_file.
+    def human_readable_audit_status(file = file_set.original_file)
+      audit_stat(file)
+    end
+
+    # Check the file by only what is in the audit log.
+    # Do not try to access the versions if we do not have access to them.
+    # Use this when a file_set is loaded from solr instead of fedora
+    def logged_audit_status
+      audit_results = ChecksumAuditLog.logs_for(id, "original_file")
+                                      .collect { |result| result["pass"] }
+
+      if !audit_results.empty?
+        stat_to_string(audit_results.reduce(true) { |sum, value| sum && value })
+      else
+        'Audits have not yet been run on this file.'
+      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 = {})
+      file_set.files.each { |f| log[f.id] = audit_file(f) }
+      log
+    end
+
+    private
+
+      def stat_to_string(stat)
+        case stat
+        when 0
+          'failing'
+        when 1
+          'passing'
+        else
+          raise ArgumentError, "Unknown status `#{stat}'"
+        end
+      end
+
+      # 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 = [])
+        versions = file.has_versions? ? file.versions.all : file
+        versions.each { |v| log << audit_file_version(file.id, v.uri) }
+        log
+      end
+
+      # 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'] }
+        # check how many non runs we had
+        non_runs = audit_results.reduce(0) { |sum, value| value == NO_RUNS ? sum + 1 : sum }
+        build_audit_stat_message(audit_results, non_runs)
+      end
+
+      def build_audit_stat_message(audit_results, non_runs)
+        if non_runs.zero?
+          result = audit_results.reduce(true) { |sum, value| sum && value }
+          stat_to_string(result)
+        elsif non_runs < audit_results.length
+          result = audit_results.reduce(true) { |sum, value| value == NO_RUNS ? sum : sum && value }
+          "Some audits have not been run, but the ones run were #{stat_to_string(result)}."
+        else
+          'Audits have not yet been run on this file.'
+        end
+      end
+      private :build_audit_stat_message
+
+      # Retrieve or generate the audit check for a specific version of a file
+      # @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(file_set.id, file_id).first
+        return latest_audit unless needs_audit?(latest_audit)
+        AuditJob.perform_later(file_set, 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
+      # @param [ChecksumAuditLog] latest_audit the most recent audit event
+      def needs_audit?(latest_audit)
+        return true unless latest_audit
+        unless latest_audit.updated_at
+          logger.warn "***AUDIT*** problem with audit log! Latest Audit is not nil, but updated_at is not set #{latest_audit}"
+          return true
+        end
+        days_since_last_audit(latest_audit) >= Hyrax.config.max_days_between_audits
+      end
+
+      # Return the number of days since the latest audit event
+      # @param [ChecksumAuditLog] latest_audit the most recent audit event
+      def days_since_last_audit(latest_audit)
+        (DateTime.current - latest_audit.updated_at.to_date).to_i
+      end
+
+      # Loads the FileSet from Fedora if needed
+      def file_set
+        @file_set ||= FileSet.find(id)
+      end
+  end
+end

data/app/services/hyrax/file_set_csv_service.rb

@@ -0,0 +1,41 @@
+module Hyrax
+  #
+  # Generates CSV from a FileSet
+  #
+  # @attr_reader [FileSet] file_set file that will be examined to generate the CSVs
+  # @attr_reader [Array] terms list of terms that will be output in CSV form
+  # @attr_reader [String] multi_value_separator separator for terms that have more than one value
+  class FileSetCSVService
+    attr_reader :file_set, :terms, :multi_value_separator
+
+    # @param [SolrDocument] file solr document that will be examined to generate the CSVs
+    # @param [Array]        terms list of terms that will be output in CSV form
+    #                       defaults if nil to list below
+    # @param [String]       multi_value_separator separator for terms that have more than one value
+    #                       defaults to '|'
+    def initialize(file, terms = nil, multi_value_separator = '|')
+      @file_set = file
+      @terms = terms
+      @terms ||= [:id, :title, :depositor, :creator, :visibility, :resource_type, :rights, :file_format]
+      @multi_value_separator = multi_value_separator
+    end
+
+    # provide csv version of the GenericFile
+    def csv
+      ::CSV.generate do |csv|
+        csv << terms.map do |term|
+          values = file_set.send(term)
+          values = values.respond_to?(:to_a) ? values.to_a : [values] # make sure we have an array
+          values.join(multi_value_separator)
+        end
+      end
+    end
+
+    # provide csv header line for a GenericFile
+    def csv_header
+      ::CSV.generate do |csv|
+        csv << terms
+      end
+    end
+  end
+end

data/app/services/hyrax/file_set_derivatives_service.rb

@@ -0,0 +1,75 @@
+module Hyrax
+  # Responsible for creating and cleaning up the derivatives of a file_set
+  class FileSetDerivativesService
+    attr_reader :file_set
+    delegate :uri, :mime_type, to: :file_set
+
+    # @param file_set [Hyrax::FileSet] At least for this class, it must have #uri and #mime_type
+    def initialize(file_set)
+      @file_set = file_set
+    end
+
+    def cleanup_derivatives
+      derivative_path_factory.derivatives_for_reference(file_set).each do |path|
+        FileUtils.rm_f(path)
+      end
+    end
+
+    def create_derivatives(filename)
+      case mime_type
+      when *file_set.class.pdf_mime_types             then create_pdf_derivatives(filename)
+      when *file_set.class.office_document_mime_types then create_office_document_derivatives(filename)
+      when *file_set.class.audio_mime_types           then create_audio_derivatives(filename)
+      when *file_set.class.video_mime_types           then create_video_derivatives(filename)
+      when *file_set.class.image_mime_types           then create_image_derivatives(filename)
+      end
+    end
+
+    private
+
+      def create_pdf_derivatives(filename)
+        Hydra::Derivatives::PdfDerivatives.create(filename,
+                                                  outputs: [{ label: :thumbnail, format: 'jpg', size: '338x493', url: derivative_url('thumbnail') }])
+        Hydra::Derivatives::FullTextExtract.create(filename,
+                                                   outputs: [{ url: uri, container: "extracted_text" }])
+      end
+
+      def create_office_document_derivatives(filename)
+        Hydra::Derivatives::DocumentDerivatives.create(filename,
+                                                       outputs: [{ label: :thumbnail, format: 'jpg',
+                                                                   size: '200x150>',
+                                                                   url: derivative_url('thumbnail') }])
+        Hydra::Derivatives::FullTextExtract.create(filename,
+                                                   outputs: [{ url: uri, container: "extracted_text" }])
+      end
+
+      def create_audio_derivatives(filename)
+        Hydra::Derivatives::AudioDerivatives.create(filename,
+                                                    outputs: [{ label: 'mp3', format: 'mp3', url: derivative_url('mp3') },
+                                                              { label: 'ogg', format: 'ogg', url: derivative_url('ogg') }])
+      end
+
+      def create_video_derivatives(filename)
+        Hydra::Derivatives::VideoDerivatives.create(filename,
+                                                    outputs: [{ label: :thumbnail, format: 'jpg', url: derivative_url('thumbnail') },
+                                                              { label: 'webm', format: 'webm', url: derivative_url('webm') },
+                                                              { label: 'mp4', format: 'mp4', url: derivative_url('mp4') }])
+      end
+
+      def create_image_derivatives(filename)
+        Hydra::Derivatives::ImageDerivatives.create(filename,
+                                                    outputs: [{ label: :thumbnail, format: 'jpg', size: '200x150>', url: derivative_url('thumbnail') }])
+      end
+
+      # The destination_name parameter has to match up with the file parameter
+      # passed to the DownloadsController
+      def derivative_url(destination_name)
+        path = derivative_path_factory.derivative_path_for_reference(file_set, destination_name)
+        URI("file://#{path}").to_s
+      end
+
+      def derivative_path_factory
+        Hyrax::DerivativePath
+      end
+  end
+end

data/app/services/hyrax/graph_exporter.rb

@@ -0,0 +1,84 @@
+module Hyrax
+  # Retrieves the graph for an object with the internal triples removed
+  # and the uris translated to external uris.
+  class GraphExporter
+    # @param [SolrDocument] solr_document idea here is that in the future, ActiveFedora may serialize the object as JSON+LD
+    # @param [ActionDispatch::Request] request the http request context
+    def initialize(solr_document, request)
+      @solr_document = solr_document
+      @request = request
+      @additional_resources = []
+    end
+
+    attr_reader :solr_document, :request, :additional_resources
+
+    # @return [RDF::Graph]
+    def fetch
+      clean_graph_repository.find(solr_document.id).tap do |g|
+        additional_resources.uniq.each do |stmt|
+          g << stmt
+        end
+      end
+    rescue Ldp::NotFound
+      # this error is handled with a 404 page.
+      raise ActiveFedora::ObjectNotFoundError
+    end
+
+    private
+
+      def clean_graph_repository
+        Hydra::ContentNegotiation::CleanGraphRepository.new(connection, replacer)
+      end
+
+      def connection
+        @connection ||= CleanConnection.new(ActiveFedora.fedora.connection)
+      end
+
+      # This method is called once for each statement in the graph.
+      def replacer
+        lambda do |resource_id, graph|
+          url = ActiveFedora::Base.id_to_uri(resource_id)
+          result = graph.query([RDF::URI(url), ActiveFedora::RDF::Fcrepo::Model.hasModel, nil]).first
+          if result
+            subject_replacer(result, resource_id)
+          elsif resource_id.start_with? solr_document.id
+            subresource_replacer(resource_id, graph)
+          else
+            object_replacer(resource_id, graph)
+          end
+        end
+      end
+
+      def subresource_replacer(resource_id, graph)
+        parent_id, local = resource_id.split('/', 2)
+        parent_url = ActiveFedora::Base.id_to_uri(parent_id)
+        result = graph.query([RDF::URI(parent_url), ActiveFedora::RDF::Fcrepo::Model.hasModel, nil]).first
+
+        # OPTIMIZE: we only need to fetch each subresource once.
+        additional_resources << ListSourceExporter.new(resource_id, request, subject_replacer(result, parent_id)).fetch
+        parent = subject_replacer(result, parent_id)
+        "#{parent}/#{local}"
+      end
+
+      def subject_replacer(result, resource_id, anchor = nil)
+        klass = result.object.to_s.constantize
+        route_key = if Hyrax.config.curation_concerns.include?(klass)
+                      klass.model_name.singular_route_key
+                    else
+                      SolrDocument.model_name.singular_route_key
+                    end
+        routes = Rails.application.routes.url_helpers
+        builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder
+        builder.polymorphic_method routes, route_key, nil, :url, id: resource_id, host: hostname, anchor: anchor
+      end
+
+      def object_replacer(id, _graph)
+        id, anchor = id.split('/', 2)
+        Rails.application.routes.url_helpers.solr_document_url(id, host: hostname, anchor: anchor)
+      end
+
+      def hostname
+        request.host
+      end
+  end
+end