ddr-models 2.11.0 → 3.0.0.alpha.1

data/lib/ddr/index/query_clause.rb

@@ -1,110 +1,50 @@
-require "virtus"
-
 module Ddr::Index
   class QueryClause
-    include Virtus.value_object
-
-    ANY_FIELD = Field.new('*').freeze
-    ANY_VALUE = "[* TO *]"
-    QUOTE     = '"'
-
-    TERM_QUERY      = "{!term f=%{field}}%{value}"
-    STANDARD_QUERY  = "%{field}:%{value}"
-    NEGATIVE_QUERY  = "-%{field}:%{value}"
-    DISJUNCTION     = "{!lucene q.op=OR df=%{field}}%{value}"
-    REGEXP_QUERY    = "%{field}:/%{value}/"
-
-    values do
-      attribute :field,       FieldAttribute
-      attribute :value,       String
-      attribute :quote_value, Boolean, default: false
-      attribute :template,    String,  default: STANDARD_QUERY
-    end
-
-    def to_s
-      template % { field: field, value: quote_value ? quote(value) : value }
-    end
 
-    def quote(value)
-      self.class.quote(value)
-    end
+    PRESENT = "[* TO *]"
+    TERM = "{!term f=%s}%s"
+    BEFORE_DAYS = "[* TO NOW-%sDAYS]"
 
     class << self
-      def quote(value)
-        # Derived from Blacklight::Solr::SearchBuilderBehavior#solr_param_quote
-        unless value =~ /\A[a-zA-Z0-9$_\-\^]+\z/
-          QUOTE + value.gsub("'", "\\\\\'").gsub('"', "\\\\\"") + QUOTE
-        else
-          value
-        end
+      # Standard Solr query, no escaping applied
+      def build(field, value)
+        [field, value].join(":")
       end
 
-      # Builds a query clause to retrieve the index document by unique key.
       def unique_key(value)
         term(UniqueKeyField.instance, value)
       end
       alias_method :id, :unique_key
+      alias_method :pid, :unique_key
 
-      def where(field, value)
-         values = Array(value)
-        if values.size > 1
-          disjunction(field, values)
-        else
-          new(field: field, value: values.first, quote_value: true)
-        end
-      end
-
-      # Builds a query clause to filter where field does not have the given value.
       def negative(field, value)
-        new(field: field, value: value, template: NEGATIVE_QUERY, quote_value: true)
+        build "-#{field}", value
       end
 
-      # Builds a query clause to filter where field is present (i.e, has any value)
       def present(field)
-        new(field: field, value: ANY_VALUE)
+        build field, PRESENT
       end
 
-      # Builds a query clause to filter where field is NOT present (no values)
       def absent(field)
-        new(field: field, value: ANY_VALUE, template: NEGATIVE_QUERY)
+        negative field, PRESENT
       end
 
-      # Builds a query clause to filter where field contains at least one of a set of values.
-      def disjunction(field, values)
-        value = values.map { |v| quote(v) }.join(" ")
-        new(field: field, value: value, template: DISJUNCTION)
+      def or_values(field, *values)
+        build field, QueryValue.or_values(*values)
       end
 
-      # Builds a Solr join clause
-      # @see https://wiki.apache.org/solr/Join
-      def join(from:, to:, where:)
-        field, value = where.to_a.first
-        from_field = FieldAttribute.coerce(from)
-        to_field   = FieldAttribute.coerce(to)
-        template = "{!join from=#{from_field} to=#{to_field}}%{field}:%{value}"
-        new(field: field, value: value, template: template, quote_value: true)
+      def before(field, date_time)
+        value = "[* TO %s]" % Ddr::Utils.solr_date(date_time)
+        build field, value
       end
 
-      # Builds a query clause to filter where date field value is earlier than a date/time value.
-      def before(field, value)
-        new(field: field, value: "[* TO %s]" % Ddr::Utils.solr_date(value))
+      def before_days(field, days)
+        value = BEFORE_DAYS % days.to_i
+        build field, value
       end
-      alias_method :before_date_time, :before
 
-      # Builds a query clause to filter where date field value is earlier than a number of days before now.
-      def before_days(field, value)
-        new(field: field, value: "[* TO NOW-%iDAYS]" % value)
-      end
-
-      # Builds a "term query" clause to filter where field contains value.
       def term(field, value)
-        new(field: field, value: value, template: TERM_QUERY)
-      end
-
-      # Builds a regular expression query clause
-      def regexp(field, value)
-        val = value.gsub(/\//, "\\/")
-        new(field: field, value: val, template: REGEXP_QUERY)
+        TERM % [field, value.gsub(/"/, '\"')]
       end
     end
 

data/lib/ddr/index/query_result.rb

@@ -1,6 +1,5 @@
 module Ddr::Index
   class QueryResult < AbstractQueryResult
-    extend Deprecation
 
     PAGE_SIZE = 1000
 
@@ -15,7 +14,7 @@ module Ddr::Index
     end
 
     def each_unpaginated(&block)
-      Connection.select(params).docs.each(&block)
+      conn.select(params).docs.each(&block)
     end
 
     def each_paginated(&block)
@@ -23,31 +22,15 @@ module Ddr::Index
     end
 
     def pids
-      Deprecation.warn(QueryResult,
-                       "`pids` is deprecated; use `ids` instead." \
-                       " (called from #{caller.first})"
-                      )
-      ids
-    end
-
-    def ids
       Enumerator.new do |e|
         each do |doc|
-          e << doc[Fields::ID]
+          e << doc[Fields::PID]
         end
       end
     end
 
     def each_pid(&block)
-      Deprecation.warn(QueryResult,
-                       "`each_pid` is deprecated; use `each_id` instead." \
-                       " (called from #{caller.first})"
-                      )
-      each_id(&block)
-    end
-
-    def each_id(&block)
-      ids.each(&block)
+      pids.each(&block)
     end
 
     def docs
@@ -58,21 +41,6 @@ module Ddr::Index
       end
     end
 
-    def objects
-      Enumerator.new do |e|
-        each_id do |id|
-          e << ActiveFedora::Base.find(id)
-        end
-      end
-    end
-
-    def facet_fields
-      response = Connection.select(params, rows: 0)
-      response.facet_fields.each_with_object({}) do |(field, values), memo|
-        memo[field] = Hash[*values]
-      end
-    end
-
     def all
       to_a
     end
@@ -94,7 +62,7 @@ module Ddr::Index
     def page(num)
       page_params = params.dup
       page_size = page_params.delete(:rows) || PAGE_SIZE
-      response = Connection.page(num, page_size, "select", params: page_params)
+      response = conn.page num, page_size, "select", params: page_params
       response.docs
     end
 

data/lib/ddr/index/query_value.rb

@@ -0,0 +1,18 @@
+require "rsolr"
+
+module Ddr::Index
+  class QueryValue
+
+    class << self
+      def build(value)
+        RSolr.solr_escape(value)
+      end
+
+      def or_values(*values)
+        value = values.map { |v| build(v) }.join(" OR ")
+        "(#{value})"
+      end
+    end
+
+  end
+end

data/lib/ddr/index/response.rb

@@ -1,29 +1,12 @@
-require "delegate"
-
 module Ddr::Index
-  #
-  # Wraps an index query response
-  #
   class Response < SimpleDelegator
 
     def docs
-      response["docs"]
+      self["response"]["docs"]
     end
 
     def num_found
-      response["numFound"].to_i
-    end
-
-    def facet_counts
-      self["facet_counts"] || {}
-    end
-
-    def facet_fields
-      facet_counts["facet_fields"] || {}
-    end
-
-    def response
-      self["response"]
+      self["response"]["numFound"].to_i
     end
 
   end

data/lib/ddr/jobs.rb

@@ -0,0 +1,12 @@
+module Ddr
+  module Jobs
+    extend ActiveSupport::Autoload
+
+    autoload :PermanentId
+    autoload :FitsFileCharacterization
+
+    autoload_at 'ddr/jobs/permanent_id' do
+      autoload :MakeUnavailable
+    end
+  end
+end

data/lib/ddr/jobs/fits_file_characterization.rb

@@ -0,0 +1,51 @@
+require 'open3'
+
+module Ddr::Jobs
+  class FitsFileCharacterization
+
+    @queue = :file_characterization
+
+    EVENT_SUMMARY = 'FITS characterization of content file'.freeze
+
+    def self.perform(pid)
+      obj = ActiveFedora::Base.find(pid)
+      tmp_filename = Ddr::Utils::sanitize_filename(obj.original_filename) || obj.content.default_file_name
+      Dir.mktmpdir do |dir|
+        infile = create_temp_infile(dir, tmp_filename, obj.content.content)
+        fits_output, err, status = Open3.capture3(fits_command, '-i', infile)
+        if status.success? && fits_output.present?
+          obj.reload
+          obj.fits.content = fits_output
+          obj.save!
+        end
+        notify_event(pid, err, status)
+      end
+    end
+
+    def self.fits_command
+      File.join(Ddr::Models.fits_home, 'fits.sh')
+    end
+
+    def self.fits_version
+      `#{fits_command} -v`.strip
+    end
+
+    private
+
+    def self.create_temp_infile(dir, tmp_filename, content)
+      temp_infile = File.join(dir, tmp_filename)
+      File.open(temp_infile, 'wb') do |f|
+        f.write content
+      end
+      temp_infile
+    end
+
+    def self.notify_event(pid, err, status)
+      details = status.success? ? nil : err
+      event_args = { pid: pid, summary: EVENT_SUMMARY, software:  "fits #{fits_version}", detail: details }
+      event_args[:outcome] = status.success? ? Ddr::Events::Event::SUCCESS : Ddr::Events::Event::FAILURE
+      Ddr::Notifications.notify_event(:update, event_args)
+    end
+
+  end
+end

data/lib/ddr/jobs/permanent_id.rb

@@ -0,0 +1,23 @@
+require "ezid-client"
+
+module Ddr
+  module Jobs
+    module PermanentId
+
+      class Job
+        def self.inherited(subclass)
+          subclass.instance_variable_set("@queue", :permanent_id)
+        end
+      end
+
+      class MakeUnavailable < Job
+        def self.perform(id, reason = nil)
+          identifier = Ezid::Identifier.find(id)
+          identifier.unavailable!(reason)
+          identifier.save
+        end
+      end
+
+    end
+  end
+end

data/lib/ddr/managers.rb

@@ -4,6 +4,7 @@ module Ddr
 
     autoload :Manager
     autoload :DerivativesManager
+    autoload :PermanentIdManager
     autoload :TechnicalMetadataManager
     autoload :WorkflowManager
 

data/lib/ddr/managers/derivatives_manager.rb

@@ -1,115 +1,75 @@
 require "resque"
 
-module Ddr::Managers
-  class DerivativesManager < Manager
-    extend Deprecation
+module Ddr
+  module Managers
+    class DerivativesManager < Manager
 
-    SCHEDULE_LATER = :later
-    SCHEDULE_NOW = :now
-    SCHEDULES = [ SCHEDULE_LATER, SCHEDULE_NOW ]
+      SCHEDULE_LATER = :later
+      SCHEDULE_NOW = :now
+      SCHEDULES = [ SCHEDULE_LATER, SCHEDULE_NOW ]
 
-    ACTION_DELETE = "delete"
-    ACTION_GENERATE = "generate"
+      ACTION_DELETE = "delete"
+      ACTION_GENERATE = "generate"
 
-    def update_derivatives(schedule=SCHEDULE_LATER)
-      raise ArgumentError, "Must be one of #{SCHEDULES}" unless SCHEDULES.include?(schedule)
-      Ddr::Derivatives::DERIVATIVES.values.each do |derivative|
-        if Ddr::Derivatives.update_derivatives.include?(derivative.name)
-          # Need to update derivative if object has a datastream for this type of derivative and
-          # either (or both) of the following conditions are true:
-          # - object already has content in the derivative's datastream (need to delete or replace it)
-          # - the derivative can be generated for this object
-          if object.datastreams.include?(derivative.datastream) &&
-             (object.datastreams[derivative.datastream].has_content? || generatable?(derivative))
-            schedule == SCHEDULE_NOW ? update_derivative(derivative) : Resque.enqueue(DerivativeJob, object.pid, derivative.name)
+      def update_derivatives(schedule=SCHEDULE_LATER)
+        raise ArgumentError, "Must be one of #{SCHEDULES}" unless SCHEDULES.include?(schedule)
+        Ddr::Derivatives.update_derivatives.each do |derivative_to_update|
+          derivative = Ddr::Derivatives::DERIVATIVES[derivative_to_update]
+            # Need to update derivative if either (or both) of the following conditions are true:
+            # - object already has this derivative (need to delete or replace it)
+            # - the derivative can be generated for this object
+          if derivative.class.has_derivative?(object) || derivative.class.generatable?(object)
+            schedule == SCHEDULE_NOW ? update_derivative(derivative) : Resque.enqueue(DerivativeJob, object.pid, derivative_to_update)
           end
         end
       end
-    end
 
-    def update_derivative(derivative)
-      raise ArgumentError, "This object does not have a datastream for #{derivative.name} derivatives" unless
-        object.datastreams.include?(derivative.datastream)
-      if generatable? derivative
-        generate_derivative derivative
-      else
-        # Delete existing derivative (if there is one) if that type of derivative is no longer
-        # applicable to the object
-        if object.datastreams[derivative.datastream].has_content?
-          delete_derivative derivative
+      def update_derivative(derivative)
+        if derivative.class.generatable?(object)
+          generate_derivative(derivative)
+        else
+          # Delete existing derivative (if there is one) if that type of derivative is no longer
+          # applicable to the object
+          if derivative.class.has_derivative?(object)
+            delete_derivative(derivative)
+          end
         end
       end
-    end
 
-    def generate_derivative!(derivative)
-      tempdir_path = File.join(Dir.tmpdir, Dir::Tmpname.make_tmpname('',nil))
-      begin
-        tempdir = FileUtils.mkdir(tempdir_path).first
-        generator_source_path = source_datastream.external? ? source_datastream.file_path
-                                                            : create_source_file(source_datastream,tempdir)
-        generator_output_path = File.new(File.join(tempdir, "output.out"), 'wb').path
-        exitstatus = derivative.generator.new(generator_source_path, generator_output_path, derivative.options).generate
-        if exitstatus == 0
-          generator_output = File.open(generator_output_path, 'rb')
-          object.reload if object.persisted?
-          object.add_file generator_output, derivative.datastream, mime_type: derivative.generator.output_mime_type
-          object.save!
-        else
-          raise Ddr::Models::DerivativeGenerationFailure,
-                "Failure generating #{derivative.name} for #{object.pid}"
+      def generate_derivative(derivative)
+        ActiveSupport::Notifications.instrument(Ddr::Notifications::UPDATE,
+                                                pid: object.pid,
+                                                summary: "Generate #{derivative.class.name} derivative"
+                                                ) do |payload|
+          derivative.generate!(object)
         end
-        generator_output.close unless generator_output.closed?
-      ensure
-        FileUtils.remove_dir(tempdir_path) if File.exist?(tempdir_path)
       end
-    end
-
-    alias_method :generate_derivative, :generate_derivative!
-
-    def delete_derivative!(derivative)
-      File.unlink *object.datastreams[derivative.datastream].file_paths if
-        object.datastreams[derivative.datastream].external?
-      object.datastreams[derivative.datastream].delete
-      object.save!
-    end
-
-    alias_method :delete_derivative, :delete_derivative!
 
-    def source_datastream
-      @source_datastream ||= object.has_intermediate_file? ? object.datastreams[Ddr::Datastreams::INTERMEDIATE_FILE]
-                                                           : object.datastreams[Ddr::Datastreams::CONTENT]
-    end
-
-    class DerivativeJob
-      @queue = :derivatives
-      def self.perform(pid, derivative_name)
-        object = ActiveFedora::Base.find(pid)
-        derivative = Ddr::Derivatives::DERIVATIVES[derivative_name.to_sym]
-        object.derivatives.update_derivative(derivative)
+      def delete_derivative(derivative)
+        ActiveSupport::Notifications.instrument(Ddr::Notifications::UPDATE,
+                                                pid: object.pid,
+                                                summary: "Delete derivative #{derivative.class.name}"
+                                                ) do |payload|
+          derivative.delete!(object)
+        end
       end
-    end
-
-    private
 
-    def create_source_file(datastream, dir)
-      generator_source = File.new(File.join(dir, "source"), "wb")
-      source_content = datastream.content
-      generator_source.write(source_content)
-      generator_source.close
-      generator_source
-    end
+      def delete_derivative!(derivative)
+        File.unlink *object.datastreams[derivative.datastream].file_paths if
+                                                      object.datastreams[derivative.datastream].external?
+        object.datastreams[derivative.datastream].delete
+        object.save!
+      end
 
-    def generatable?(derivative)
-      return false unless object.has_content?
-      case derivative.name
-      when :multires_image
-        object.content_type == "image/tiff" || object.content_type == "image/jpeg"
-      when :thumbnail
-        object.image?
-      else
-        false
+      class DerivativeJob
+        @queue = :derivatives
+        def self.perform(pid, derivative_name)
+          object = ActiveFedora::Base.find(pid)
+          derivative = Ddr::Derivatives::DERIVATIVES[derivative_name.to_sym]
+          object.derivatives.update_derivative(derivative)
+        end
       end
-    end
 
+    end
   end
 end