dor-services 2.2.4 → 4.4.10

data/lib/dor/datastreams/version_metadata_ds.rb

@@ -0,0 +1,214 @@
+module Dor
+
+  class VersionTag
+    include Comparable
+
+    attr_reader :major, :minor, :admin
+
+    def <=>(anOther)
+      diff = @major <=> anOther.major
+      return diff if diff != 0
+      diff = @minor <=> anOther.minor
+      return diff if diff != 0
+      @admin <=> anOther.admin
+    end
+
+    # @param [String] raw_tag the value of the tag attribute from a Version node
+    def self.parse(raw_tag)
+      unless(raw_tag =~ /(\d+)\.(\d+)\.(\d+)/)
+        return nil
+      end
+      VersionTag.new $1, $2, $3
+    end
+
+    def initialize(maj, min, adm)
+      @major = maj.to_i
+      @minor = min.to_i
+      @admin = adm.to_i
+    end
+
+    # @param [Symbol] sig which part of the version tag to increment
+    #  :major, :minor, :admin
+    def increment(sig)
+      case sig
+      when :major
+        @major += 1
+        @minor = 0
+        @admin = 0
+      when :minor
+        @minor += 1
+        @admin = 0
+      when :admin
+        @admin += 1
+      end
+      self
+    end
+
+    def to_s
+      "#{@major.to_s}.#{@minor.to_s}.#{admin.to_s}"
+    end
+  end
+
+  class VersionMetadataDS < ActiveFedora::OmDatastream
+    before_create :ensure_non_versionable
+
+    set_terminology do |t|
+      t.root(:path => "versionMetadata")
+      t.version do
+        t.version_id :path => { :attribute => "versionID" }
+        t.tag :path => { :attribute => "tag" }
+        t.description
+      end
+    end
+
+    # Default EventsDS xml
+    def self.xml_template
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.versionMetadata {
+          xml.version(:versionId => '1', :tag => '1.0.0') {
+            xml.description 'Initial Version'
+          }
+        }
+      end
+      return builder.doc
+    end
+
+    def ensure_non_versionable
+      self.versionable = "false"
+    end
+
+    # @param [String] description optional text describing version change
+    # @param [Symbol] :significance optional which part of the version tag to increment
+    #  :major, :minor, :admin (see VersionTag#increment)
+    def increment_version(description = nil, significance = nil)
+      if( find_by_terms(:version).size == 0)
+        v = ng_xml.create_element "version",
+        :versionId => '1', :tag => '1.0.0'
+        d = ng_xml.create_element "description", "Initial Version"
+        ng_xml.root['objectId'] = pid
+        ng_xml.root.add_child(v)
+        v.add_child d
+      else
+        current = current_version_node
+        current_id = current[:versionId].to_i
+        current_tag = VersionTag.parse(current[:tag])
+
+        v = ng_xml.create_element "version", :versionId => (current_id + 1).to_s
+        if(significance && current_tag)
+          v[:tag] = current_tag.increment(significance).to_s
+        end
+        ng_xml.root['objectId'] = pid
+        ng_xml.root.add_child(v)
+
+        if(description)
+          d = ng_xml.create_element "description", description
+          v.add_child d
+        end
+      end
+    end
+
+    # @returns [Fixnum] value of the most current versionId
+    def current_version_id
+      current_version=current_version_node
+      if current_version.nil?
+        return '1'
+      else
+        current_version[:versionId].to_s
+      end
+    end
+
+    # @param [Hash] opts optional params
+    # @option opts [String] :description describes the version change
+    # @option opts [Symbol] :significance which part of the version tag to increment
+    #  :major, :minor, :admin (see VersionTag#increment)
+    def update_current_version(opts = {})
+      ng_xml.root['objectId'] = pid
+      return if find_by_terms(:version).size == 1
+      return if opts.empty?
+      current = current_version_node
+      if(opts.include? :description)
+        d = current.at_xpath('description')
+        if(d)
+          d.content = opts[:description]
+        else
+          d_node = ng_xml.create_element "description", opts[:description]
+          current.add_child d_node
+        end
+      end
+      if(opts.include? :significance)
+        # tricky because if there is no tag, we have to find the newest
+        if(current[:tag].nil?)
+          current[:tag] = newest_tag.increment(opts[:significance]).to_s
+        else
+          # get rid of the current tag
+          tags = find_by_terms(:version, :tag)
+          sorted_tags = tags.map{|t| VersionTag.parse(t.value)}.sort
+          current_tag = sorted_tags[sorted_tags.length - 2]           # Get the second greatest tag since we are dropping the current, greatest
+          current[:tag] = current_tag.increment(opts[:significance]).to_s
+        end
+
+      end
+      self.content = ng_xml.to_s
+    end
+
+    # @return [String] The value of the greatest versionId
+    def current_version_id
+      current_version_node[:versionId].to_s
+    end
+
+    # @return [Boolean] returns true if the current version has a tag and a description, false otherwise
+    def current_version_closeable?
+      current = current_version_node
+      if(current[:tag] && current.at_xpath('description'))
+        return true
+      else
+        return false
+      end
+    end
+
+    # @return [String] The tag for the newest version
+    def current_tag
+      current_version_node[:tag].to_s  
+    end
+    
+    def tag_for_version(versionId)
+      nodes=self.ng_xml.search('//version[@versionId=\''+versionId+'\']')
+      if nodes.length == 1
+        nodes.first['tag'].to_s
+      else
+        ''
+      end
+    end
+    # @return [String] The description for the specified version, or empty string if there is no description
+    def description_for_version(versionId)
+      nodes=self.ng_xml.search('//version[@versionId=\''+versionId+'\']')
+      if nodes.length == 1 and  nodes.first.at_xpath('description')
+        nodes.first.at_xpath('description').content.to_s
+      else
+        ''
+      end
+    end
+    
+    # @return [String] The description for the current version
+    def current_description
+      desc_node=current_version_node.at_xpath('description')
+      if desc_node
+        return desc_node.content
+      end
+      ''
+    end
+    
+    private
+
+    # @return [Nokogiri::XML::Node] Node representing the current version
+    def current_version_node
+      versions = find_by_terms(:version)
+      versions.max_by {|v| v[:versionId].to_i }
+    end
+
+    def newest_tag
+      tags = find_by_terms(:version, :tag)
+      tags.map{|t| VersionTag.parse(t.value)}.max
+    end
+  end
+end

data/lib/dor/datastreams/workflow_definition_ds.rb

@@ -0,0 +1,113 @@
+module Dor
+class WorkflowDefinitionDs < ActiveFedora::OmDatastream 
+  include SolrDocHelper
+  
+  set_terminology do |t|
+    t.root(:path => "workflow-def", :index_as => [:not_searchable])
+    t.process(:index_as => [:not_searchable])
+  end
+  
+  define_template :process do |builder,workflow,attrs|
+    prereqs = attrs.delete('prerequisite')
+    if prereqs.is_a?(String)
+      prereqs = prereqs.split(/\s*,\s*/)
+    end
+    attrs.keys.each { |k| attrs[k.to_s.dasherize.to_sym] = attrs.delete(k) }
+    builder.process(attrs) do |node|
+      Array(prereqs).each do |prereq|
+        (repo,wf,prereq_name) = prereq.split(/:/)
+        if prereq_name.nil?
+          prereq_name = repo
+          repo = nil
+        end
+        if (repo == workflow.repo and wf = workflow.name)
+          repo = nil
+          wf = nil
+        end
+        attrs = (repo.nil? and wf.nil?) ? {} : { :repository => repo, :workflow => wf }
+        node.prereq(attrs) { node.text prereq_name }
+      end
+    end
+  end
+
+  def self.xml_template
+    Nokogiri::XML('<workflow-def/>')
+  end
+  
+  def add_process(attributes)
+    add_child_node(ng_xml.at_xpath('/workflow-def'), :process, self, attributes)
+  end
+  
+  def graph(parent = nil)
+    Workflow::Graph.from_processes(self.repo, self.name, self.processes, parent)
+  end
+  
+  def processes
+    ng_xml.xpath('/workflow-def/process').collect do |node|
+      Workflow::Process.new(self.repo, self.name, node)
+    end.sort { |a,b| (a.sequence || 0) <=> (b.sequence || 0) }
+  end
+
+  def name
+    ng_xml.at_xpath('/workflow-def/@id').to_s
+  end
+  
+  def repo
+    ng_xml.at_xpath('/workflow-def/@repository').to_s
+  end
+
+  def configuration
+    result = ActiveSupport::OrderedHash.new
+    result['repository'] = repo
+    result['name'] = name
+    processes.each { |process| result[process.name] = process.to_hash }
+    result
+  end
+  
+  def configuration=(hash)
+    self.ng_xml = Nokogiri::XML(%{<workflow-def id="#{hash['name']}" repository="#{hash['repository']}"/>})
+    i = 0
+    hash.each_pair do |k,v| 
+      if v.is_a?(Hash)
+        add_process(v.merge({:name => k, :sequence => i+=1}))
+      end
+    end
+  end
+  
+  # Creates the xml used by Dor::WorkflowService.create_workflow
+  # @return [String] An object's initial workflow as defined by the <workflow-def> in content
+  def initial_workflow
+    doc = Nokogiri::XML("<workflow/>")
+    root = doc.root
+    root['id'] = name
+    processes.each { |proc|
+      doc.create_element 'process' do |node|
+        node['name'] = proc.name
+        if(proc.status)
+          node['status'] = proc.status
+          node['attempts'] = '1'
+        else
+          node['status'] = 'waiting'
+        end
+        node['lifecycle'] = proc.lifecycle if proc.lifecycle
+        root.add_child node
+      end
+    }
+    Nokogiri::XML(doc.to_xml) { |x| x.noblanks }.to_xml { |config| config.no_declaration }
+  end
+  
+  def to_solr(solr_doc=Hash.new,*args)
+    super(solr_doc,*args)
+    add_solr_value(solr_doc, "workflow_name", self.name, :symbol, [:searchable])
+    processes.each do |p|
+      add_solr_value(solr_doc, "process", "#{p.name}|#{p.label}", :symbol, [:displayable])
+    end
+    solr_doc
+  end
+  
+  def to_yaml
+    YAML.dump(self.configuration)
+  end
+  
+end
+end

data/lib/dor/datastreams/workflow_ds.rb

@@ -0,0 +1,103 @@
+module Dor
+class WorkflowDs < ActiveFedora::OmDatastream
+  include SolrDocHelper
+
+  set_terminology do |t|
+    t.root(:path=>"workflows")
+    t.workflow {
+      t.workflowId(:path=>{:attribute => "id"})
+      t.process {
+        t.name_(:path=>{:attribute=>"name"}, :index_as => [:displayable, :not_searchable])
+        t.status(:path=>{:attribute=>"status"}, :index_as => [:displayable, :not_searchable])
+        t.timestamp(:path=>{:attribute=>"datetime"}, :index_as => [:displayable, :not_searchable])#, :data_type => :date)
+        t.elapsed(:path=>{:attribute=>"elapsed"}, :index_as => [:displayable, :not_searchable])
+        t.lifecycle(:path=>{:attribute=>"lifecycle"}, :index_as => [:displayable, :not_searchable])
+        t.attempts(:path=>{:attribute=>"attempts"}, :index_as => [:displayable, :not_searchable])
+      }
+    }
+  end
+
+  def initialize *args
+    self.field_mapper = UtcDateFieldMapper.new
+    super
+  end
+
+  def get_workflow (wf,repo='dor')
+    xml=Dor::WorkflowService.get_workflow_xml(repo, self.pid, wf)
+    xml=Nokogiri::XML(xml)
+    if xml.xpath('workflow').length == 0
+      nil
+    else
+      Workflow::Document.new(xml.to_s)
+    end
+  end
+
+  def [](wf)
+    xml=Dor::WorkflowService.get_workflow_xml('dor', self.pid, wf)
+    xml=Nokogiri::XML(xml)
+    if xml.xpath('workflow').length == 0
+      nil
+    else
+      Workflow::Document.new(xml.to_s)
+    end
+  end
+
+  def ensure_xml_loaded
+    ng_xml
+    self.xml_loaded = true
+  end
+
+  def ng_xml
+    @ng_xml ||= Nokogiri::XML::Document.parse(content)
+  end
+
+  def content
+    begin
+      @content ||= Dor::WorkflowService.get_workflow_xml 'dor', self.pid, nil
+    rescue RestClient::ResourceNotFound
+      xml = Nokogiri::XML(%{<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<workflows objectId="#{self.pid}"/>})
+      self.digital_object.datastreams.keys.each do |dsid|
+        if dsid =~ /WF$/
+          ds_content = Nokogiri::XML(Dor::WorkflowService.get_workflow_xml 'dor', self.pid, dsid)
+          xml.root.add_child(ds_content.root)
+        end
+      end
+      @content ||= xml.to_xml
+    end
+  end
+
+  def workflows
+    @workflows ||= self.workflow.nodeset.collect { |wf_node| Workflow::Document.new wf_node.to_xml }
+  end
+
+  def graph(dir=nil)
+    result = GraphViz.digraph(self.pid)
+    sg = result.add_graph('rank') { |g| g[:rank => 'same'] }
+    workflows.each do |wf|
+      wf_name = wf.workflowId.first
+      unless wf.nil?
+        g = wf.graph(result)
+        sg.add_node(g.root.id) unless g.nil?
+      end
+    end
+    result['rankdir'] = dir || 'TB'
+    result
+  end
+
+  # Finds the first workflow that is expedited, then returns the value of its priority
+  #
+  # @return [Integer] value of the priority.  Defaults to 0 if none of the workflows are expedited
+  def current_priority
+    cp = workflows.detect {|wf| wf.expedited? }
+    return 0 if(cp.nil?)
+    cp.priority.to_i
+  end
+
+  def to_solr(solr_doc=Hash.new, *args)
+#    super solr_doc, *args
+    self.workflows.each { |wf| wf.to_solr(solr_doc, *args) }
+    solr_doc
+  end
+
+end
+end

data/lib/dor/exceptions.rb

@@ -9,5 +9,4 @@ module Dor
       @pid = pid
     end
   end
-  
 end

data/lib/dor/migrations/content_metadata_ds/change_content_type.rb

@@ -0,0 +1,7 @@
+Dor::ContentMetadataDS.on_upgrade '3.6.0', 'Change contentMetadata type attribute' do |ds|
+  translations = { 'googleScannedBook' => 'book', 'etd' => 'file', 'eem' => 'file' }
+  translations.any? do |old_type, new_type|
+    current_type = (ds.contentType.to_ary.first) rescue ds.contentType
+    (current_type == old_type) && (ds.contentType = new_type)
+  end
+end

data/lib/dor/migrations/identifiable/assert_adminPolicy.rb

@@ -0,0 +1,9 @@
+Dor::Identifiable.on_upgrade '3.5.0', 'Assert hydra:isGovernedBy' do |obj|
+  # Assign hydra:isGovernedBy based on identityMetadata/adminPolicy
+  if obj.admin_policy_object.nil?
+    apo_id = obj.identityMetadata.adminPolicy.first
+    apo_id.present? && obj.admin_policy_object = Dor.find(apo_id) unless apo_id.nil?
+  else
+    false
+  end
+end