dor-services 2.2.4

data/lib/datastreams/content_metadata_ds.rb

@@ -0,0 +1,12 @@
+class ContentMetadataDS < ActiveFedora::NokogiriDatastream 
+  
+  def public_xml
+    result = self.ng_xml.clone
+    result.xpath('/contentMetadata/resource[not(file[(@deliver="yes" or @publish="yes")])]').each { |n| n.remove }
+    result.xpath('/contentMetadata/resource/file[not(@deliver="yes" or @publish="yes")]').each { |n| n.remove }
+    result.xpath('/contentMetadata/resource/file').xpath('@preserve|@shelve|@publish|@deliver').each { |n| n.remove }
+    result.xpath('/contentMetadata/resource/file/checksum').each { |n| n.remove }
+    result
+  end
+  
+end

data/lib/datastreams/embargo_metadata_ds.rb

@@ -0,0 +1,107 @@
+require 'active_fedora'
+require 'nokogiri'
+require 'time'
+
+class EmbargoMetadataDS < ActiveFedora::NokogiriDatastream
+
+  set_terminology do |t|
+    t.root(:path => "embargoMetadata", :xmlns => '', :namespace_prefix => nil)
+    t.status(:namespace_prefix => nil)
+    t.release_date(:path => "releaseDate", :namespace_prefix => nil)
+    t.twenty_pct_status( :path => "twentyPctVisibilityStatus", :namespace_prefix => nil)
+    t.twenty_pct_release_date(:path => "twentyPctVisibilityReleaseDate", :namespace_prefix => nil)
+
+    t.release_access(:path => "releaseAccess", :namespace_prefix => nil)
+  end
+
+  # Default EmbargoMetadataDS xml
+  def self.xml_template
+    builder = Nokogiri::XML::Builder.new do |xml|
+      xml.embargoMetadata {
+        xml.status
+        xml.releaseDate
+        xml.releaseAccess
+        xml.twentyPctVisibilityStatus
+        xml.twentyPctVisibilityReleaseDate
+      }
+    end
+    return builder.doc
+  end
+
+  def initialize(attrs=nil)
+    super
+    @attributes[:versionable] = false
+  end
+
+  #################################################################################
+  # Convenience methods to get and set embargo properties
+  # Hides complexity/verbosity of OM TermOperators for simple, non-repeating values
+  #################################################################################
+
+  def status=(new_status)
+    update_values([:status] => new_status)
+    self.dirty = true
+  end
+
+  def status
+    term_values(:status).first
+  end
+
+  # Sets the release date.  Converts the date to beginning-of-day, UTC to help with Solr indexing
+  # @param [Time] rd A Time object represeting the release date.  By default, it is set to now
+  def release_date=(rd=Time.now)
+    update_values([:release_date] => rd.beginning_of_day.utc.xmlschema)
+    self.dirty = true
+  end
+
+  # Current releaseDate value
+  # @return [Time]
+  def release_date
+    Time.parse(term_values(:release_date).first)
+  end
+
+  def twenty_pct_status=(new_status)
+    update_values([:twenty_pct_status] => new_status)
+    self.dirty = true
+  end
+
+  def twenty_pct_status
+    term_values(:twenty_pct_status).first
+  end
+
+  # Sets the 20% visibility release date.  Converts the date to beginning-of-day, UTC to help with Solr indexing
+  # @param [Time] rd A Time object represeting the release date.  By default, it is set to now
+  def twenty_pct_release_date=(rd=Time.now)
+    update_values([:twenty_pct_release_date] => rd.beginning_of_day.utc.xmlschema)
+    self.dirty = true
+  end
+
+  # Current twentyPctVisibilityReleaseDate value
+  # @return [Time]
+  def twenty_pct_release_date
+    Time.parse(term_values(:twenty_pct_release_date).first)
+  end
+
+  # @return [Nokogiri::XML::Element] The releaseAccess node
+  def release_access_node
+    find_by_terms(:release_access).first
+  end
+
+  # @return [Nokogiri::XML::Element] The releaseAccess node
+  def release_access_node
+    find_by_terms(:release_access).first
+  end
+
+  # Sets the embargaAccess node
+  # @param [Nokogiri::XML::Document] new_node Document that will replace the existing releaseAccess node
+  def release_access_node=(new_doc)
+    if(new_doc.root.name != 'releaseAccess')
+      raise "Trying to replace releaseAccess with a non-releaseAccess document"
+    end
+
+    term_value_delete(:select => '//embargoMetadata/releaseAccess')
+    ng_xml.root.add_child(new_doc.root.clone)
+    self.dirty = true
+  end
+
+end

data/lib/datastreams/events_ds.rb

@@ -0,0 +1,58 @@
+require 'active_fedora'
+
+class EventsDS < ActiveFedora::NokogiriDatastream
+  
+  set_terminology do |t|
+    t.root(:path => "events", :xmlns => '', :namespace_prefix => nil)
+    t.event(:namespace_prefix => nil)
+  end
+  
+  # Default EventsDS xml 
+  def self.xml_template
+    builder = Nokogiri::XML::Builder.new do |xml|
+      xml.events
+    end
+    return builder.doc
+  end
+  
+  def initialize(attrs=nil)
+    super
+    @attributes[:versionable] = false
+  end
+  
+  # Adds an event to the datastream
+  # @param [String] type a tag used to group events together. Sets the type attribute for the event
+  # @param [String] who who is responsible for this event. Sets the who attribute for the event
+  # @param [String] message what happened. Sets the content of the event with this message
+  def add_event(type, who, message)
+    ev = ng_xml.create_element "event", message, 
+      :type => type, :who => who, :when => Time.now.xmlschema
+    ng_xml.root.add_child(ev)
+    self.dirty = true
+  end
+  
+  # Finds events with the desired type attribute
+  # @param [String] tag events where type == tag will be returned
+  # @yield [who, timestamp, message] The values of the current event
+  # @yieldparam [String] who thing responsible for creating the event. Value of the 'who' attribute
+  # @yieldparam [Time] timestamp when this event was logged.  Value of the 'when' attribute
+  # @yieldparam [String] message what happened. Content of the event node
+  def find_events_by_type(tag, &block)
+    find_by_terms(:event).xpath("//event[@type='#{tag}']").each do |node|
+      block.call(node['who'], Time.parse(node['when']), node.content)
+    end
+  end
+  
+  # Returns all the events in the datastream
+  # @yield [type, who, timestamp, message] The values of the current event
+  # @yieldparam [String] type tag for this particular event.  Value of the 'type' attribute
+  # @yieldparam [String] who thing responsible for creating the event. Value of the 'who' attribute
+  # @yieldparam [Time] timestamp when this event was logged.  Value of the 'when' attribute
+  # @yieldparam [String] message what happened. Content of the event node
+  def each_event(&block)
+    find_by_terms(:event).each do |node|
+      block.call(node['type'], node['who'], Time.parse(node['when']), node.content)
+    end
+  end
+  
+end

data/lib/datastreams/identity_metadata_ds.rb

@@ -0,0 +1,28 @@
+class IdentityMetadataDS < ActiveFedora::NokogiriDatastream 
+  
+  set_terminology do |t|
+    t.root(:path=>"identityMetadata", :xmlns => '')
+    t.objectId(:index_as=>[:searchable, :displayable, :facetable, :sortable],  :required=>:true, :type=>:string, :namespace_prefix => nil )
+    t.objectType(:index_as=>[:searchable, :displayable, :facetable, :sortable],  :required=>:true, :type=>:string, :namespace_prefix => nil )  
+    t.objectLabel(:index_as=>[:searchable, :displayable, :facetable, :sortable],  :required=>:true, :type=>:string, :namespace_prefix => nil )  
+    t.citationCreator(:index_as=>[:searchable, :displayable, :facetable, :sortable],  :required=>:true, :type=>:string, :namespace_prefix => nil )  
+    t.sourceId(:index_as=>[:searchable,  :displayable, :facetable, :sortable], :attributes=>{:type=>"source"},  :required=>:true, :type=>:string, :namespace_prefix => nil )  
+    t.otherId(:index_as=>[:searchable,  :displayable, :facetable, :sortable], :attributes=>{:type=>"name"},  :required=>:true, :type=>:string, :namespace_prefix => nil )  
+    t.agreementId(:index_as=>[:searchable, :displayable, :facetable, :sortable],  :required=>:true, :type=>:string, :namespace_prefix => nil )  
+    t.tag(:index_as=>[:searchable, :displayable, :facetable, :sortable],  :required=>:true, :type=>:string, :namespace_prefix => nil )  
+    t.citationTitle(:index_as=>[:searchable, :displayable, :facetable, :sortable],  :required=>:true, :type=>:string, :namespace_prefix => nil )  
+    t.objectCreator(:index_as=>[:searchable, :displayable, :facetable, :sortable], :required=>:true, :type=>:string, :namespace_prefix => nil )
+    t.adminPolicy(:index_as=>[:searchable, :displayable, :facetable, :sortable], :required=>:true, :type=>:string, :namespace_prefix => nil )
+  end
+  
+  def self.xml_template
+    builder = Nokogiri::XML::Builder.new do |xml|
+      xml.identityMetadata {
+        xml.citationTitle
+        xml.objectCreator
+      }
+    end
+    return builder.doc
+  end #self.xml_template
+  
+end #class

data/lib/datastreams/ng_tidy.rb

@@ -0,0 +1,19 @@
+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

data/lib/datastreams/simple_dublin_core_ds.rb

@@ -0,0 +1,23 @@
+class SimpleDublinCoreDs < ActiveFedora::NokogiriDatastream 
+  
+  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')
+    t.title(:index_as=>[:searchable, :displayable, :facetable, :sortable], :xmlns => "http://purl.org/dc/elements/1.1/", :namespace_prefix => 'dc')
+    t.creator(:index_as=>[:searchable, :displayable, :facetable, :sortable], :xmlns => "http://purl.org/dc/elements/1.1/", :namespace_prefix => 'dc')
+    t.identifier(:index_as=>[:searchable, :displayable, :sortable], :xmlns => "http://purl.org/dc/elements/1.1/", :namespace_prefix => 'dc')
+  end
+  
+  def self.xml_template
+    builder = Nokogiri::XML::Builder.new do |xml|
+      xml.dc(:xmlns=>"http://www.openarchives.org/OAI/2.0/oai_dc/", 
+        'xmlns:dc'=>'http://purl.org/dc/elements/1.1/') {
+          xml['dc'].title
+          xml['dc'].creator
+          xml['dc'].identifier
+      }   
+    end
+
+    return builder.doc
+  end
+  
+end

data/lib/datastreams/workflow_definition_ds.rb

@@ -0,0 +1,105 @@
+class WorkflowProcess
+
+  def initialize(workflow, node)
+    @workflow = workflow
+    @node = node
+  end
+  
+  def name
+    @node['name']
+  end
+  
+  def sequence
+    @node['sequence']
+  end
+  
+  def lifecycle
+    @node['lifecycle']
+  end
+  
+  def label
+    @node.at_xpath('label/text()').to_s
+  end
+  
+  def prerequisites
+    @node.xpath('prereq').collect do |p| 
+      if (p['repository'].nil? and p['workflow'].nil?) or (p['repository'] == workflow.repository and p['workflow'] == workflow.name)
+        p.text.to_s
+      else
+        [(p['repository'] or workflow.repository),(p['workflow'] or workflow.name),p.text.to_s].join(':')
+      end
+    end
+  end
+  
+end
+
+class WorkflowDefinitionDs < ActiveFedora::NokogiriDatastream 
+  
+  define_template :process do |builder,workflow,name,seq,label,lifecycle,prereqs|
+    attrs = {:name => name}
+    attrs[:sequence] = seq unless seq.nil?
+    attrs[:lifecycle] = lifecycle unless lifecycle.nil?
+    builder.process(attrs) do |node|
+      prereqs.each do |prereq|
+        (repo,wf,prereq_name) = prereq.split(/:/)
+        if prereq_name.nil?
+          prereq_name = repo
+          repo = nil
+        end
+        if (repo == workflow.repository 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 add_process(name, seq, label, lifecycle, prereqs)
+    add_child_node(ng_xml.at_xpath('/workflow'), :process, self, name, seq, label, lifecycle, prereqs)
+  end
+  
+  def processes
+    ng_xml.xpath('/workflow/process').collect do |node|
+      WorkflowProcess.new(self, node)
+    end
+  end
+
+  def name
+    ng_xml.at_xpath('/workflow/@id').to_s
+  end
+  
+  def repository
+    ng_xml.at_xpath('/workflow/@repository').to_s
+  end
+  
+  def configuration
+    result = {
+      'repository' => repository,
+      'name' => name
+    }
+    processes.each_pair do |process_name,process|
+      result[process_name] = {
+        'prerequisites' => process.prerequisites.collect { |p| p.name }
+      }
+    end
+  end
+  
+  def configuration=(hash)
+    ng_xml = Nokogiri::XML(%{<workflow id="#{hash['name']}" repository="#{hash['repository']}"/>})
+    i = 0
+    hash.each_pair do |k,v| 
+      if v.is_a?(Hash)
+        add_process(k,i+=1,nil,nil,v['prerequisite'])
+      end
+    end
+  end
+  
+  def to_yaml
+    s = StringIO.new('')
+    YAML.dump(self.configuration, s)
+    s.string
+  end
+  
+end

data/lib/datastreams/workflow_ds.rb

@@ -0,0 +1,16 @@
+class WorkflowDs < ActiveFedora::NokogiriDatastream 
+  
+  set_terminology do |t|
+    t.root(:path=>"workflow", :xmlns => '', :namespace_prefix => nil)
+    t.workflowId(:path=>{:attribute => "id"}, :index_as => [:displayable, :facetable])
+    t.process(:path=>'process', :namespace_prefix => nil) {
+      t._name(:path=>{:attribute=>"name"}, :index_as => [:displayable, :facetable, :sortable])
+      t.status(:path=>{:attribute=>"status"}, :index_as => [:displayable, :facetable, :sortable])
+      t.timestamp(:path=>{:attribute=>"datetime"}, :index_as => [:searchable, :sortable])
+      t.elapsed(:path=>{:attribute=>"elapsed"})
+      t.lifecycle(:path=>{:attribute=>"lifecycle"}, :index_as => [:displayable, :facetable, :sortable])
+      t.attempts(:path=>{:attribute=>"attempts"})
+    }
+  end
+    
+end

data/lib/dor-services.rb

@@ -0,0 +1,19 @@
+require 'dor/config'
+require 'dor/exceptions'
+
+# ActiveFedora Classes
+require 'dor/base'
+require 'dor/item'
+require 'dor/admin_policy_object'
+require 'dor/workflow_object'
+
+# Services
+require 'dor/metadata_service'
+require 'dor/registration_service'
+require 'dor/suri_service'
+require 'dor/workflow_service'
+require 'dor/digital_stacks_service'
+require 'dor/druid_utils'
+require 'dor/sdr_ingest_service'
+require 'dor/cleanup_service'
+require 'dor/provenance_metadata_service'

data/lib/dor/admin_policy_object.rb

@@ -0,0 +1,11 @@
+module Dor
+  
+  class AdminPolicyObject < Base
+    
+    has_metadata :name => "administrativeMetadata", :type => ActiveFedora::NokogiriDatastream
+    has_metadata :name => "roleMetadata", :type => ActiveFedora::NokogiriDatastream
+    has_metadata :name => "defaultObjectRights", :type => ActiveFedora::NokogiriDatastream
+    
+  end
+  
+end

data/lib/dor/base.rb

@@ -0,0 +1,81 @@
+require 'active_fedora'
+require 'datastreams/identity_metadata_ds'
+require 'datastreams/simple_dublin_core_ds'
+require 'datastreams/workflow_ds'
+require 'dor/suri_service'
+
+module Dor
+
+  class Base < ::ActiveFedora::Base
+    
+    attr_reader :workflows
+
+    has_metadata :name => "DC", :type => SimpleDublinCoreDs
+    has_metadata :name => "RELS-EXT", :type => ActiveFedora::RelsExtDatastream
+    has_metadata :name => "identityMetadata", :type => IdentityMetadataDS
+
+    # Make a random (and harmless) API-M call to get gsearch to reindex the object
+    def self.touch(*pids)
+      client = Dor::Config.fedora.client
+      pids.collect { |pid|
+        response = client["objects/#{pid}/datastreams/DC?dsState=A&ignoreContent=true"].put('', :content_type => 'text/xml')
+        response.code
+      }
+    end
+    
+    def self.get_foxml(pid, interpolate_refs = false)
+      foxml = Nokogiri::XML(Dor::Config.fedora.client["objects/#{pid}/objectXML"].get)
+      if interpolate_refs
+        external_refs = foxml.xpath('//foxml:contentLocation[contains(@REF,"/workflows/")]')
+        external_refs.each do |ref|
+          begin
+            external_doc = Nokogiri::XML(RestClient.get(ref['REF']))
+            external_root = external_doc.root
+            ref.replace('<foxml:xmlContent/>').first.add_child(external_doc.root)
+            external_root.traverse { |node| node.namespace = nil }
+          rescue
+            ref.remove
+          end
+        end
+      end
+      return foxml
+    end
+    
+    def initialize(attrs = {})
+      unless attrs[:pid]
+        attrs = attrs.merge!({:pid=>Dor::SuriService.mint_id})  
+        @new_object=true
+      else
+        @new_object = attrs[:new_object] == false ? false : true
+      end
+      @inner_object = Fedora::FedoraObject.new(attrs)
+      @datastreams = {}
+      @workflows = {}
+      configure_defined_datastreams
+    end  
+
+    def identity_metadata
+      if self.datastreams.has_key?('identityMetadata')
+        IdentityMetadata.from_xml(self.datastreams['identityMetadata'].content)
+      else
+        nil
+      end
+    end
+    
+    # Self-aware datastream builders
+    def build_datastream(datastream, force = false)
+      ds = datastreams[datastream]
+      if force or ds.new_object? or (ds.content.to_s.empty?)
+        proc = "build_#{datastream}_datastream".to_sym
+        content = self.send(proc, ds)
+        ds.save
+      end
+      return ds
+    end
+    
+    def reindex
+      Dor::SearchService.reindex(self.pid)
+    end
+
+  end
+end