dor-services 2.2.4 → 4.4.10

data/lib/dor/utils/ng_tidy.rb

@@ -0,0 +1,37 @@
+class Nokogiri::XML::Text
+  
+  def normalize
+    self.content =~ /\S/ ? self.content.gsub(/\s+/,' ').strip : self.content
+  end
+  
+  def normalize!
+    self.content = self.normalize
+  end
+
+end
+
+class Nokogiri::XML::Node
+
+  def normalize_text!
+    self.xpath('//text()').each { |t| t.normalize! }
+  end
+  
+end
+
+class Nokogiri::XML::Document
+  
+  def prettify
+    xslt = Nokogiri::XSLT <<-EOC
+    <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+      <xsl:output omit-xml-declaration="yes" indent="yes"/>
+      <xsl:template match="node()|@*">
+        <xsl:copy>
+          <xsl:apply-templates select="node()|@*"/>
+        </xsl:copy>
+      </xsl:template>
+    </xsl:stylesheet>
+    EOC
+    xslt.transform(self).to_xml
+  end
+  
+end

data/lib/dor/utils/predicate_patch.rb

@@ -0,0 +1,23 @@
+# Monkey patch ActiveFedora::RelsExtDatastream.short_predicate to
+# create missing mappings on the fly.
+
+module ActiveFedora
+  class RelsExtDatastream
+    def self.short_predicate(predicate)
+      # for this regex to short-circuit correctly, namespaces must be sorted into descending order by length
+      if match = /^(#{Predicates.predicate_mappings.keys.sort.reverse.join('|')})(.+)$/.match(predicate.to_str)
+        namespace = match[1]
+        predicate = match[2]
+        ns_mapping = Predicates.predicate_mappings[namespace] ||= {}
+        pred = ns_mapping.invert[predicate]
+        if pred.nil?
+          pred = predicate.underscore.to_sym
+          ns_mapping[pred] = predicate
+        end
+        pred
+      else
+        raise "Unable to parse predicate: #{predicate}"
+      end
+    end
+  end
+end

data/lib/dor/utils/solr_doc_helper.rb

@@ -0,0 +1,9 @@
+module SolrDocHelper
+  
+  def add_solr_value(solr_doc, field_name, value, field_type = :default, index_types = [:searchable])
+    index_types.each { |index_type|
+      ::Solrizer::Extractor.insert_solr_field_value(solr_doc, ::ActiveFedora::SolrService.solr_name(field_name, field_type, index_type), value)
+    }
+  end
+  
+end

data/lib/dor/utils/utc_date_field_mapper.rb

@@ -0,0 +1,7 @@
+class UtcDateFieldMapper < Solrizer::FieldMapper::Default
+  [:searchable,:facetable,:displayable,:sortable,:unstemmed_searchable].each do |index_type|
+    index_as index_type do |type|
+      type.date { |value| Time.parse(value).utc.xmlschema }
+    end
+  end
+end

data/lib/dor/version.rb

@@ -0,0 +1,3 @@
+module Dor
+  VERSION = '4.4.10'
+end

data/lib/dor/workflow/document.rb

@@ -0,0 +1,131 @@
+module Dor
+module Workflow
+  class Document
+    include SolrDocHelper
+    include OM::XML::Document
+
+    set_terminology do |t|
+      t.root(:path => 'workflow')
+      t.repository(:path=>{:attribute => "repository"})
+      t.workflowId(:path=>{:attribute => "id"})
+      t.process {
+        t.name_(:path=>{:attribute=>"name"})
+        t.status(:path=>{:attribute=>"status"})
+        t.timestamp(:path=>{:attribute=>"datetime"})#, :data_type => :date)
+        t.elapsed(:path=>{:attribute=>"elapsed"})
+        t.lifecycle(:path=>{:attribute=>"lifecycle"})
+        t.attempts(:path=>{:attribute=>"attempts"}, :index_as => [:not_searchable])
+      }
+    end
+    @@definitions={}
+    def initialize node
+      self.ng_xml = Nokogiri::XML(node)
+    end
+    #is this an incomplete workflow with steps that have a priority > 0
+    def expedited?
+      processes.any? { |proc| !proc.completed? && proc.priority.to_i > 0 }
+    end
+
+    # @return [Integer] value of the first > 0 priority.  Defaults to 0
+    def priority
+      processes.map {|proc| proc.priority.to_i }.detect(0) {|p| p > 0}
+    end
+    
+    def active?
+      processes.any? { |proc| !proc.version }
+    end
+
+    def definition
+      @definition ||= begin
+        if @@definitions.has_key? self.workflowId.first
+          @@definitions[self.workflowId.first]
+        else
+        wfo = Dor::WorkflowObject.find_by_name(self.workflowId.first)
+        wf_def=wfo ? wfo.definition : nil
+        @@definitions[self.workflowId.first] = wf_def
+        wf_def
+        end
+      end
+    end
+
+    def graph(parent=nil, dir=nil)
+      wf_definition = self.definition
+      result = wf_definition ? Workflow::Graph.from_processes(wf_definition.repo, wf_definition.name, self.processes, parent) : nil
+      unless result.nil?
+        result['rankdir'] = dir || 'TB'
+      end
+      result
+    end
+
+    def [](value)
+      self.processes.find { |p| p.name == value }
+    end
+
+    def processes
+      #if the workflow service didnt return any processes, dont return any processes from the reified wf
+      if ng_xml.search("/workflow/process").length == 0
+        return []
+      end
+      @processes ||= if self.definition
+        self.definition.processes.collect do |process|
+          node = ng_xml.at("/workflow/process[@name = '#{process.name}']")
+          process.update!(node,self) unless node.nil?
+          process
+        end
+      else
+        self.find_by_terms(:workflow, :process).collect do |x|
+          pnode = Dor::Workflow::Process.new(self.repository, self.workflowId, {})
+          pnode.update!(x,self)
+          pnode
+        end.sort_by(&:datetime)
+      end
+    end
+
+    def to_solr(solr_doc=Hash.new, *args)
+      wf_name = self.workflowId.first
+      repo=self.repository.first
+      add_solr_value(solr_doc, 'wf', wf_name, :string, [:facetable])
+      add_solr_value(solr_doc, 'wf_wps', wf_name, :string, [:facetable])
+      add_solr_value(solr_doc, 'wf_wsp', wf_name, :string, [:facetable])
+      status = processes.empty? ? 'empty' : (processes.all?(&:completed?) ? 'completed' : 'active')
+      errors = processes.select(&:error?).count
+      add_solr_value(solr_doc, 'workflow_status', [wf_name,status,errors,repo].join('|'), :string, [:displayable])
+
+      processes.each do |process|
+        if process.status.present?
+          #add a record of the robot having operated on this item, so we can track robot activity
+          if process.date_time and process.status and (process.status == 'completed' || process.status == 'error')
+            add_solr_value(solr_doc, "wf_#{wf_name}_#{process.name}", process.date_time+'Z', :date)
+          end
+          add_solr_value(solr_doc, 'wf_error', "#{wf_name}:#{process.name}:#{process.error_message}", :string, [:facetable,:displayable]) if process.error_message #index the error message without the druid so we hopefully get some overlap
+          add_solr_value(solr_doc, 'wf_wsp', "#{wf_name}:#{process.status}", :string, [:facetable])
+          add_solr_value(solr_doc, 'wf_wsp', "#{wf_name}:#{process.status}:#{process.name}", :string, [:facetable])
+          add_solr_value(solr_doc, 'wf_wps', "#{wf_name}:#{process.name}", :string, [:facetable])
+          add_solr_value(solr_doc, 'wf_wps', "#{wf_name}:#{process.name}:#{process.status}", :string, [:facetable])
+          add_solr_value(solr_doc, 'wf_swp', "#{process.status}", :string, [:facetable])
+          add_solr_value(solr_doc, 'wf_swp', "#{process.status}:#{wf_name}", :string, [:facetable])
+          add_solr_value(solr_doc, 'wf_swp', "#{process.status}:#{wf_name}:#{process.name}", :string, [:facetable])
+          if process.state != process.status
+            add_solr_value(solr_doc, 'wf_wsp', "#{wf_name}:#{process.state}:#{process.name}", :string, [:facetable])
+            add_solr_value(solr_doc, 'wf_wps', "#{wf_name}:#{process.name}:#{process.state}", :string, [:facetable])
+            add_solr_value(solr_doc, 'wf_swp', "#{process.state}", :string, [:facetable])
+            add_solr_value(solr_doc, 'wf_swp', "#{process.state}:#{wf_name}", :string, [:facetable])
+            add_solr_value(solr_doc, 'wf_swp', "#{process.state}:#{wf_name}:#{process.name}", :string, [:facetable])
+          end
+        end
+      end
+
+      solr_doc['wf_wps_facet'].uniq!    if solr_doc['wf_wps_facet']
+      solr_doc['wf_wsp_facet'].uniq!    if solr_doc['wf_wsp_facet']
+      solr_doc['wf_swp_facet'].uniq!    if solr_doc['wf_swp_facet']
+      solr_doc['workflow_status'].uniq! if solr_doc['workflow_status']
+
+      solr_doc
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{self.object_id}>"
+    end
+  end
+end
+end

data/lib/dor/workflow/graph.rb

@@ -0,0 +1,166 @@
+require 'graphviz'
+
+module Dor
+module Workflow
+class Graph
+  
+  FILL_COLORS = { 'waiting' => "white", 'ready' => "white", 'error' => "#8B0000", 'blocked' => "white", 'completed' => "darkgreen", 'unknown' => "#CFCFCF" }
+  TEXT_COLORS = { 'waiting' => "black", 'ready' => "black", 'error' => "white", 'blocked' => "#8B0000", 'completed' => "white", 'unknown' => "black" }
+  PATTERNS    = { 'waiting' => "diagonals", 'ready' => "filled", 'error' => "filled", 'blocked' => "diagonals", 'completed' => "filled", 'unknown' => "filled" }
+  RESERVED_KEYS = ['repository','name']
+
+  attr_reader :repo, :name, :processes, :graph, :root
+  
+  def self.from_config(name, config, parent = nil)
+    wf = self.new(config['repository'], name, parent)
+    config.keys.each { |p| wf.add_process(p.to_s) unless RESERVED_KEYS.include?(p) }
+    config.keys.each { |p|
+      if wf.processes[p]
+        Array(config[p]['prerequisite']).each { |prereq|
+          prereq.sub!(/^#{config['repository']}:#{name}:/e,'')
+          if wf.processes[prereq]
+            wf.processes[p].depends_on(wf.processes[prereq])
+          else
+            wf.processes[p].depends_on(wf.add_process(prereq).set_status('external'))
+          end
+        }
+      end
+    }
+    wf.finish
+    return wf
+  end
+  
+  def self.from_processes(repo, name, processes, parent = nil)
+    wf = self.new(repo, name, parent)
+    processes.each { |p| 
+      wf.add_process(p.name).status = p.state || 'unknown'
+    }
+    processes.each { |p|
+      p.prerequisite.each { |prereq|
+        prereq.sub!(/^#{repo}:#{name}:/e,'')
+        if wf.processes[prereq]
+          wf.processes[p.name].depends_on(wf.processes[prereq])
+        else
+          wf.processes[p.name].depends_on(wf.add_process(prereq).set_status('external'))
+        end
+      }
+    }
+    wf.finish
+    return wf
+  end
+  
+  def initialize(repo, name, parent = nil)
+    @repo = repo
+    @name = name
+    if parent.nil?
+      @graph = GraphViz.new(qname)
+      @root = self.add_nodes(name)
+    else
+      @graph = parent.subgraph(qname)
+      @root = parent.add_nodes(name)
+    end
+    @graph[:truecolor => true]
+    @root.shape = 'plaintext'
+    @processes = {}
+  end
+  
+  def qname
+    [@repo,@name].join(':')
+  end
+  
+  def add_process(name, external = false)
+    pqname = name.split(/:/).length == 3 ? name : [qname,name].join(':')
+    p = Process.new(self, pqname, name)
+    @processes[name] = p
+    return p
+  end
+  
+  def finish
+    @processes.values.each do |process|
+      process.node.fontname = 'Helvetica'
+      if process.id =~ %r{^#{qname}} and process.prerequisites.length == 0
+        (@root << process.node)[:arrowhead => 'none', :arrowtail => 'none', :dir => 'both', :style => 'invisible']
+      end
+    end
+
+    @root.fontname = 'Helvetica'
+    return self
+  end
+  
+  def inspect
+    "#{self.to_s[0..-2]} #{repo}:#{name} (#{processes.keys.join(', ')})>"
+  end
+  
+  def method_missing(sym,*args)
+    if @graph.respond_to?(sym)
+      @graph.send(sym,*args)
+    else
+      super
+    end
+  end
+  
+  class Process
+    
+    attr_reader :name, :status, :node, :prerequisites
+    
+    def initialize(graph, id, name)
+      @name = name
+      @graph = graph
+      @node = @graph.add_nodes(id)
+      @node.shape = 'box'
+      @node.label = name
+      @prerequisites = []
+      self.set_status('unknown')
+    end
+    
+    def id
+      @node.id
+    end
+    
+    def status=(s)
+      @status = s
+      if s == 'external'
+        @node.fillcolor = "gray"
+        @node.fontcolor = "black"
+        @node.style = "dashed"
+      else
+        @node.fillcolor = FILL_COLORS[s] || "yellow"
+        @node.fontcolor = TEXT_COLORS[s]
+        @node.style = PATTERNS[s]
+      end
+    end
+    
+    def set_status(s)
+      self.status = s
+      return self
+    end
+    
+    def depends_on(*processes)
+      wf1 = self.id.split(/:/)[0..1].join(':')
+      processes.each { |process|
+        wf2 = process.id.split(/:/)[0..1].join(':')
+        edge = (process.node << @node)
+        edge.dir = 'both'
+        edge.arrowhead = 'none'
+        edge.arrowtail = 'none'
+        if (wf1 != wf2)
+          edge.style = 'dashed'
+        end
+        self.prerequisites << process
+      }
+      return self
+    end
+    
+    def same_as(process)
+      @node = process.node  
+    end
+    
+    def all_prerequisites
+      prerequisites.collect { |p| p.all_prerequisites + [p.name] }.flatten.uniq
+    end
+    
+  end
+
+end
+end
+end

data/lib/dor/workflow/process.rb

@@ -0,0 +1,99 @@
+module Dor
+module Workflow
+  class Process
+    attr_reader :owner, :repo, :workflow
+
+    def initialize(repo, workflow, attrs)
+      @workflow = workflow
+      @repo = repo
+      if attrs.is_a? Nokogiri::XML::Node
+        init_from_node(attrs)
+      else
+        @attrs = attrs
+      end
+    end
+
+    def init_from_node(node)
+      @attrs = {
+        'name' => node['name'],
+        'sequence' => node['sequence'] ? node['sequence'].to_i : nil,
+        'status' => node['status'],    # TODO see how this affects argo
+        'lifecycle' => node['lifecycle'],
+        'label' => node.at_xpath('label/text()').to_s,
+        'batch_limit' => node['batch-limit'] ? node['batch-limit'].to_i : nil,
+        'error_limit' => node['error-limit'] ? node['error-limit'].to_i : nil,
+        'prerequisite' => node.xpath('prereq').collect { |p|
+          repo = (p['repository'].nil? or p['repository'] == @repo) ? nil : p['repository']
+          wf = (p['workflow'].nil? or p['workflow'] == @workflow) ? nil : p['workflow']
+          [repo,wf,p.text.to_s].compact.join(':')
+        },
+        'priority' => node['priority'] ? node['priority'].to_i : 0
+      }
+    end
+
+    def name          ; @attrs['name']          ; end
+    def sequence      ; @attrs['sequence']      ; end
+    def lifecycle     ; @attrs['lifecycle']     ; end
+    def label         ; @attrs['label']         ; end
+    def batch_limit   ; @attrs['batch_limit']   ; end
+    def error_limit   ; @attrs['error_limit']   ; end
+    def error_message ; @attrs['errorMessage']  ; end
+    def prerequisite  ; @attrs['prerequisite']  ; end
+    def status        ; @attrs['status']        ; end
+    def note          ; @attrs['note']          ; end
+    def version       ; @attrs['version']       ; end
+    def priority      ; @attrs['priority']      ; end
+    def completed?    ; self.status == 'completed' ; end
+    def error?        ; self.status == 'error'     ; end
+    def waiting?      ; self.status == 'waiting'   ; end
+    def date_time     ;@attrs['datetime']       ; end 
+
+    def archived?
+      return true if(@attrs['archived'] =~ /true$/i)
+      return false
+    end
+
+    def ready?
+      self.waiting? and (not self.prerequisite.nil?) and self.prerequisite.all? { |pr| (prq = self.owner[pr]) && prq.completed? }
+    end
+
+    def blocked?
+      self.waiting? and (not self.prerequisite.nil?) and self.prerequisite.any? { |pr| (prq = self.owner[pr]) && (prq.error? or prq.blocked?) }
+    end
+
+    def state
+      if blocked?
+        'blocked'
+      elsif ready?
+        'ready'
+      else
+        status
+      end
+    end
+
+    def attempts
+      @attrs['attempts'].to_i
+    end
+
+    def datetime
+      @attrs['datetime'] ? Time.parse(@attrs['datetime']) : nil
+    end
+
+    def elapsed
+      @attrs['elapsed'].nil? ? nil : @attrs['elapsed'].to_f
+    end
+
+    def update!(info, new_owner=nil)
+      @owner = new_owner unless new_owner.nil?
+      if info.is_a? Nokogiri::XML::Node
+        info = Hash[info.attributes.collect { |k,v| [k,v.value] }]
+      end
+      @attrs.merge! info
+    end
+
+    def to_hash
+      @attrs.reject { |k,v| v.nil? or v == 0 or (v.respond_to?(:empty?) and v.empty?) }
+    end
+  end
+end
+end