dor-services 4.25.1 → 5.0.0

data/lib/dor/datastreams/identity_metadata_ds.rb

@@ -1,11 +1,11 @@
 module Dor
-class IdentityMetadataDS < ActiveFedora::OmDatastream
+class IdentityMetadataDS < ActiveFedora::OmDatastream 
   include SolrDocHelper
-
+  
   set_terminology do |t|
     t.root(:path=>"identityMetadata")
-    t.objectId :index_as => [:searchable]
-    t.objectType :index_as => [:searchable, :facetable]
+    t.objectId :index_as => [:symbol, :searchable]
+    t.objectType :index_as => [:symbol, :searchable, :facetable]
     t.objectLabel
     t.citationCreator
     t.sourceId
@@ -13,41 +13,41 @@ class IdentityMetadataDS < ActiveFedora::OmDatastream
       t.name_(:path => { :attribute => 'name' })
     end
     t.agreementId :index_as => [:searchable, :facetable]
-    t.tag :index_as => [:searchable, :facetable]
+    t.tag :index_as => [:symbol, :searchable, :facetable]
     t.citationTitle
     t.objectCreator :index_as => [:searchable, :facetable]
     t.adminPolicy :index_as => [:not_searchable]
   end
-
+  
   define_template :value do |builder,name,value,attrs|
     builder.send(name.to_sym, value, attrs)
   end
-
+  
   def self.xml_template
     Nokogiri::XML('<identityMetadata/>')
   end #self.xml_template
-
-  def add_value(name, value, attrs = {})
+  
+  def add_value(name, value, attrs={})
     add_child_node(ng_xml.root, :value, name, value, attrs)
   end
-
+  
   def objectId
-    find_by_terms(:objectId).text
+    self.find_by_terms(:objectId).text
   end
-
+  
   def sourceId
-    node = find_by_terms(:sourceId).first
+    node = self.find_by_terms(:sourceId).first
     node ? [node['source'],node.text].join(':') : nil
   end
-
+  
   def sourceId=(value)
-    node = find_by_terms(:sourceId).first
+    node = self.find_by_terms(:sourceId).first
     unless value.present?
       node.remove unless node.nil?
       nil
     else
       (source,val) = value.split(/:/,2)
-      unless source.present? && value.present?
+      unless source.present? and value.present?
         raise ArgumentError, "Source ID must follow the format namespace:value"
       end
       node = ng_xml.root.add_child('<sourceId/>').first if node.nil?
@@ -58,13 +58,13 @@ class IdentityMetadataDS < ActiveFedora::OmDatastream
   end
   def tags()
       result=[]
-      ng_xml.search('//tag').each do |node|
+      self.ng_xml.search('//tag').each do |node|
         result << node.content
       end
       result
   end
   def otherId(type = nil)
-    result = find_by_terms(:otherId).to_a
+    result = self.find_by_terms(:otherId).to_a
     if type.nil?
       result.collect { |n| [n['name'],n.text].join(':') }
     else
@@ -79,31 +79,35 @@ class IdentityMetadataDS < ActiveFedora::OmDatastream
     node.content = val
     node
   end
-
-  def to_solr(solr_doc = Hash.new, *args)
+  
+  def to_solr(solr_doc=Hash.new, *args)
     super(solr_doc, *args)
     if digital_object.respond_to?(:profile)
       digital_object.profile.each_pair do |property,value|
-        add_solr_value(solr_doc, property.underscore, value, property =~ /Date/ ? :date : :string, [:searchable])
+        if property =~ /Date/
+          add_solr_value(solr_doc, property.underscore,  Time.parse(value).utc.xmlschema, :date, [:searchable, :stored_searchable])
+        else
+          add_solr_value(solr_doc, property.underscore, value, :string, [:searchable, :stored_searchable])
+        end
       end
     end
     if sourceId.present?
       (name,id) = sourceId.split(/:/,2)
-      add_solr_value(solr_doc, "dor_id", id, :string, [:searchable])
-      add_solr_value(solr_doc, "identifier", sourceId, :string, [:searchable])
-      add_solr_value(solr_doc, "source_id", sourceId, :string, [:searchable])
+      add_solr_value(solr_doc, "dor_id", id, :string, [:searchable, :facetable])
+      add_solr_value(solr_doc, "identifier", sourceId, :string, [:searchable, :facetable, :symbol])
+      add_solr_value(solr_doc, "source_id", sourceId, :string, [:symbol, :searchable, :facetable])
     end
     otherId.compact.each { |qid|
       (name,id) = qid.split(/:/,2)
-      add_solr_value(solr_doc, "dor_id", id, :string, [:searchable])
-      add_solr_value(solr_doc, "identifier", qid, :string, [:searchable])
-      add_solr_value(solr_doc, "#{name}_id", id, :string, [:searchable])
+      add_solr_value(solr_doc, "dor_id", id, :string, [:searchable, :facetable])
+      add_solr_value(solr_doc, "identifier", qid, :string, [:searchable, :facetable, :symbol])
+      add_solr_value(solr_doc, "#{name}_id", id, :string, [:symbol, :searchable, :facetable])
     }
-
-    find_by_terms(:tag).each { |tag|
+        
+    self.find_by_terms(:tag).each { |tag|
       (top,rest) = tag.text.split(/:/,2)
       unless rest.nil?
-        add_solr_value(solr_doc, "#{top.downcase.strip.gsub(/\s/,'_')}_tag", rest.strip, :string, [:searchable, :facetable])
+        add_solr_value(solr_doc, "#{top.downcase.strip.gsub(/\s/,'_')}_tag", rest.strip, :string, [:symbol, :searchable, :facetable])
       end
     }
     solr_doc

data/lib/dor/datastreams/role_metadata_ds.rb

@@ -34,14 +34,14 @@ class RoleMetadataDS < ActiveFedora::OmDatastream
   end
 
 
-  def to_solr(solr_doc = Hash.new, *args)
-    find_by_xpath('/roleMetadata/role/*').each do |actor|
+  def to_solr(solr_doc=Hash.new, *args)
+    self.find_by_xpath('/roleMetadata/role/*').each do |actor|
       role_type = actor.parent['type']
       val = [actor.at_xpath('identifier/@type'),actor.at_xpath('identifier/text()')].join ':'
-      add_solr_value(solr_doc, "apo_role_#{actor.name}_#{role_type}", val, :string, [:searchable, :facetable])
-      add_solr_value(solr_doc, "apo_role_#{role_type}", val, :string, [:searchable, :facetable])
-      unless role_type =~ /^hydrus/
-        add_solr_value(solr_doc, "apo_register_permissions", val, :string, [:searchable, :facetable])
+      add_solr_value(solr_doc, "apo_role_#{actor.name}_#{role_type}", val, :string, [:searchable, :facetable, :symbol])
+      add_solr_value(solr_doc, "apo_role_#{role_type}", val, :string, [:searchable, :facetable, :symbol])
+      if ['dor-apo-manager','dor-apo-depositor'].include? role_type
+        add_solr_value(solr_doc, "apo_register_permissions", val, :string, [:searchable, :facetable, :symbol])
       end
     end
     solr_doc

data/lib/dor/datastreams/simple_dublin_core_ds.rb

@@ -1,10 +1,11 @@
+module Dor
 class SimpleDublinCoreDs < ActiveFedora::OmDatastream
 
   set_terminology do |t|
     t.root(:path=>"dc", :xmlns=>"http://www.openarchives.org/OAI/2.0/oai_dc/", :schema=>"http://cosimo.stanford.edu/standards/oai_dc/v2/oai_dc.xsd", :namespace_prefix => 'oai_dc', :index_as => [:not_searchable])
-    t.title(:index_as=>[:searchable, :displayable, :facetable], :xmlns => "http://purl.org/dc/elements/1.1/", :namespace_prefix => 'dc')
-    t.creator(:index_as=>[:searchable, :displayable, :facetable], :xmlns => "http://purl.org/dc/elements/1.1/", :namespace_prefix => 'dc')
-    t.identifier(:index_as=>[:searchable, :displayable], :xmlns => "http://purl.org/dc/elements/1.1/", :namespace_prefix => 'dc')
+    t.title(     :index_as=>[:displayable, :facetable, :stored_searchable], :xmlns => "http://purl.org/dc/elements/1.1/", :namespace_prefix => 'dc')
+    t.creator(   :index_as=>[:displayable, :facetable, :stored_searchable], :xmlns => "http://purl.org/dc/elements/1.1/", :namespace_prefix => 'dc')
+    t.identifier(:index_as=>[:displayable, :stored_searchable],             :xmlns => "http://purl.org/dc/elements/1.1/", :namespace_prefix => 'dc')
   end
 
   def self.xml_template
@@ -17,29 +18,31 @@ class SimpleDublinCoreDs < ActiveFedora::OmDatastream
       }
     end
 
-    builder.doc
+    return builder.doc
   end
 
-  def to_solr(solr_doc = Hash.new, *args)
+  def to_solr(solr_doc=Hash.new, *args)
     # There are a whole bunch of namespace-related things that can go
     # wrong with this terminology. Until it's fixed in OM, ignore them all.
     begin
       doc = super solr_doc, *args
 
-      add_solr_value(doc, 'dc_title', title.first, :string, [:sortable])
-      add_solr_value(doc, 'dc_creator', creator.first, :string, [:sortable])
+      add_solr_value(doc, 'dc_title',   self.title.first,   :string, [:sortable])
+      add_solr_value(doc, 'dc_creator', self.creator.first, :string, [:sortable])
 
       identifiers = {}
 
-      identifier.each { |i| ns, val = i.split(":"); identifiers[ns] ||= val }
+      self.identifier.each { |i| ns, val = i.split(":"); identifiers[ns] ||= val }
 
       identifiers.each do |ns, val|
         add_solr_value(doc, "dc_identifier_#{ns}", val, :string, [:sortable])
       end
 
       return doc
-    rescue
+    rescue Exception => e
+      warn "ERROR in SimpleDublinCoreDs to_solr()! #{e}"
       solr_doc
     end
   end
 end
+end

data/lib/dor/datastreams/version_metadata_ds.rb

@@ -70,7 +70,7 @@ module Dor
           }
         }
       end
-      builder.doc
+      return builder.doc
     end
 
     def ensure_non_versionable
@@ -107,7 +107,7 @@ module Dor
       end
     end
 
-    # @return [String] value of the most current versionId
+    # @return [Fixnum] value of the most current versionId
     def current_version_id
       current_version=current_version_node
       if current_version.nil?
@@ -151,6 +151,11 @@ module Dor
       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
@@ -163,28 +168,27 @@ module Dor
 
     # @return [String] The tag for the newest version
     def current_tag
-      current_version_node[:tag].to_s
+      current_version_node[:tag].to_s  
     end
-
+    
     def tag_for_version(versionId)
-      nodes=ng_xml.search('//version[@versionId=\''+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=ng_xml.search('//version[@versionId=\''+versionId+'\']')
-      if nodes.length == 1 &&  nodes.first.at_xpath('description')
+      nodes=self.ng_xml.search('//version[@versionId=\''+versionId+'\']')
+      if nodes.length == 1 && 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')
@@ -193,29 +197,7 @@ module Dor
       end
       ''
     end
-
-    # Compares the current_version with the passed in known_version (usually SDRs version)
-    #   If the known_version is greater than the current version, then all version nodes greater than the known_version are removed,
-    #   then the current_version is incremented.  This repairs the case where a previous call to open a new verison
-    #   updates the versionMetadata datastream, but versioningWF is not initiated.  Prevents the versions from getting
-    #   out of synch with SDR
-    #
-    # @param [Integer] known_version object version you wish to synch to, usually SDR's version
-    # @param [Hash] opts optional parameters
-    # @option opts [String] :description describes the version change
-    # @option opts [Symbol] :significance which part of the version tag to increment
-    def sync_then_increment_version known_version, opts = {}
-      cv = current_version_id.to_i
-      raise Dor::Exception.new("Cannot sync to a version greater than current: #{cv}, requested #{known_version}") if cv < known_version
-
-      while cv != known_version &&
-        current_version_node.remove
-        cv = current_version_id.to_i
-      end
-
-      increment_version(opts[:description], opts[:significance])
-    end
-
+    
     private
 
     # @return [Nokogiri::XML::Node] Node representing the current version
@@ -228,6 +210,5 @@ module Dor
       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

@@ -1,12 +1,12 @@
 module Dor
-class WorkflowDefinitionDs < ActiveFedora::OmDatastream
+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)
@@ -33,25 +33,25 @@ class WorkflowDefinitionDs < ActiveFedora::OmDatastream
   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(repo, name, processes, parent)
+    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(repo, name, 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
@@ -63,17 +63,17 @@ class WorkflowDefinitionDs < ActiveFedora::OmDatastream
     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|
+    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
@@ -95,19 +95,19 @@ class WorkflowDefinitionDs < ActiveFedora::OmDatastream
     }
     Nokogiri::XML(doc.to_xml) { |x| x.noblanks }.to_xml { |config| config.no_declaration }
   end
-
-  def to_solr(solr_doc = Hash.new,*args)
+  
+  def to_solr(solr_doc=Hash.new,*args)
     super(solr_doc,*args)
-    add_solr_value(solr_doc, "workflow_name", name, :symbol, [:searchable])
+    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(configuration)
+    YAML.dump(self.configuration)
   end
-
+  
 end
 end

data/lib/dor/datastreams/workflow_ds.rb

@@ -1,88 +1,97 @@
 module Dor
-  # TODO: class docs
-  class WorkflowDs < ActiveFedora::OmDatastream
-    include SolrDocHelper
+class WorkflowDs < ActiveFedora::OmDatastream
 
-    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] )
-        }
+  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
+    }
+  end
 
-    def initialize(*args)
-      self.field_mapper = UtcDateFieldMapper.new
-      super
+  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 get_workflow(wf, repo = 'dor')
-      xml = Dor::WorkflowService.get_workflow_xml(repo, pid, wf)
-      xml = Nokogiri::XML(xml)
-      return nil if xml.xpath('workflow').length == 0
+  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
 
-    alias :[] :get_workflow
-
-    def ensure_xml_loaded
-      ng_xml
-      self.xml_loaded = true
-    end
+  def ensure_xml_loaded
+    ng_xml
+    self.xml_loaded = true
+  end
 
-    def ng_xml
-      @ng_xml ||= Nokogiri::XML::Document.parse(content)
-    end
+  def ng_xml
+    @ng_xml ||= Nokogiri::XML::Document.parse(content)
+  end
 
-    def content
-      @content ||= Dor::WorkflowService.get_workflow_xml 'dor', pid, nil
+  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="#{pid}"/>))
-      digital_object.datastreams.keys.each do |dsid|
-        next unless dsid =~ /WF$/
-        ds_content = Nokogiri::XML(Dor::WorkflowService.get_workflow_xml 'dor', pid, dsid)
-        xml.root.add_child(ds_content.root)
+      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 ||= workflow.nodeset.collect { |wf_node| Workflow::Document.new wf_node.to_xml }
-    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(pid)
-      sg = result.add_graph('rank') { |g| g[:rank => 'same'] }
-      workflows.each do |wf|
-        unless wf.nil?
-          g = wf.graph(result)
-          sg.add_node(g.root.id) unless g.nil?
-        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
-      result['rankdir'] = dir || 'TB'
-      result
     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 &:expedited?
-      return 0 if cp.nil?
-      cp.priority.to_i
-    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 = {}, *args)
-      # super solr_doc, *args
-      workflows.each { |wf| wf.to_solr(solr_doc, *args) }
-      solr_doc
-    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