dor-services 2.2.4 → 4.4.10

data/lib/dor/search_service.rb

@@ -1,86 +0,0 @@
-require 'json'
-require 'active_support/core_ext'
-
-module Dor
-  
-  class SearchService
-
-    RISEARCH_TEMPLATE = "select $object from <#ri> where $object <dc:identifier> '%s'"
-
-    Config.declare(:gsearch) { 
-      url nil 
-      instance_eval do
-        def client
-          RestClient::Resource.new(
-            self.url,
-            :ssl_client_cert  =>  OpenSSL::X509::Certificate.new(File.read(Config.fedora.cert_file)),
-            :ssl_client_key   =>  OpenSSL::PKey::RSA.new(File.read(Config.fedora.key_file), Config.fedora.key_pass)
-          )
-        end
-      end
-    }
-    
-    class << self
-      
-      def reindex(*pids)
-        fedora_client = Config.fedora.client
-        solr_client = Config.gsearch.client
-        xsl = Nokogiri::XSLT(File.read(File.expand_path('../../gsearch/demoFoxmlToSolr.xslt', __FILE__)))
-        pids.in_groups_of(20, false) do |group|
-          doc = Nokogiri::XML('<update/>')
-          group.each do |pid|
-            begin
-              foxml = Dor::Base.get_foxml(pid,true)
-              doc.root.add_child(xsl.transform(foxml).root)
-            rescue RestClient::ResourceNotFound
-              doc.root.add_child("<delete><id>#{pid}</id></delete>")
-            end
-          end
-          yield group if block_given?
-          solr_client['update'].post(doc.to_xml, :content_type => 'application/xml')
-        end
-        pids
-      end
-
-      def risearch(query, opts = {})
-        client = Config.fedora.client['risearch']
-        client.options[:timeout] = opts.delete(:timeout)
-        query_params = {
-          :type => 'tuples',
-          :lang => 'itql',
-          :format => 'CSV',
-          :limit => '1000',
-          :stream => 'on',
-          :query => query
-        }.merge(opts)
-        result = client.post(query_params)
-        result.split(/\n/)[1..-1].collect { |pid| pid.chomp.sub(/^info:fedora\//,'') }
-      end
-      
-      def gsearch(params)
-        client = Config.gsearch.client
-        query_params = params.merge(:wt => 'json')
-        query_string = query_params.collect { |k,v| 
-          if v.is_a?(Array)
-            v.collect { |vv| "#{k}=#{URI.encode(vv.to_s)}" }.join('&')
-          else
-            "#{k}=#{URI.encode(v.to_s)}" 
-          end
-        }.join('&')
-        result = JSON.parse(client["select?#{query_string}"].get)
-      end
-      
-      def query_by_id(id)
-        if id.is_a?(Hash) # Single valued: { :google => 'STANFORD_0123456789' }
-          id = id.collect { |*v| v.join(':') }.first
-        elsif id.is_a?(Array) # Two values: [ 'google', 'STANFORD_0123456789' ]
-          id = id.join(':')
-        end
-        self.risearch(RISEARCH_TEMPLATE % id)
-      end
-
-    end
-    
-  end
-  
-end

data/lib/dor/suri_service.rb

@@ -1,37 +0,0 @@
-require 'rest-client'
-require 'active_fedora'
-
-module Dor
-  class SuriService
-    
-    Config.declare(:suri) do
-  	  url nil
-  	  user nil
-  	  pass nil
-  	  id_namespace 'druid'
-  	  mint_ids false
-    end
-    
-    # If Dor::Config.suri.mint_ids is set to true, then this method
-    # returns Config.suri.id_namespace:id_from_suri
-    # Throws an exception if there were any problems
-    def self.mint_id
-      unless(Config.suri.mint_ids)
-        return Fedora::Repository.instance.nextid
-      end
-      
-      #Post with no body
-      resource = RestClient::Resource.new("#{Config.suri.url}/suri2/namespaces/#{Config.suri.id_namespace}/identifiers",
-                                :user => Config.suri.user, :password => Config.suri.pass)
-      id = resource.post('').chomp
-
-      return "#{Config.suri.id_namespace}:#{id.strip}"
-
-#    rescue Exception => e
-#      Rails.logger.error("Unable to mint id from suri: #{e.to_s}")
-#      raise e
-    end
-  
-    
-  end
-end

data/lib/dor/workflow_object.rb

@@ -1,13 +0,0 @@
-require 'datastreams/workflow_definition_ds'
-
-module Dor
-
-  class WorkflowObject < Base
-    has_metadata :name => "workflowDefinition", :type => WorkflowDefinitionDs
-
-    def definition
-      datastreams['workflowDefinition']
-    end
-  end
-  
-end

data/lib/dor/workflow_service.rb

@@ -1,111 +0,0 @@
-require 'rest-client'
-
-module Dor
-  
-  # Methods to create and update workflow
-  #
-  # ==== Required Constants
-  # - Dor::CREATE_WORKFLOW : true or false.  Can be used to turn of workflow in a particular environment, like development
-  # - Dor::WF_URI : The URI to the workflow service.  An example URI is 'http://lyberservices-dev.stanford.edu/workflow'
-  module WorkflowService
-
-    Config.declare(:workflow) { url nil }
-  
-    class << self
-      # Creates a workflow for a given object in the repository.  If this particular workflow for this objects exists,
-      # it will replace the old workflow with wf_xml passed to this method.  You have the option of creating a datastream or not.     
-      # Returns true on success.  Caller must handle any exceptions
-      #
-      # == Parameters
-      # - <b>repo</b> - The repository the object resides in.  The service recoginzes "dor" and "sdr" at the moment
-      # - <b>druid</b> - The id of the object
-      # - <b>workflow_name</b> - The name of the workflow you want to create
-      # - <b>wf_xml</b> - The xml that represents the workflow
-      # - <B>opts</b> - Options Hash where you can set
-      #       :create_ds - If true, a workflow datastream will be created in Fedora.  Set to false if you do not want a datastream to be created
-      #   If you do not pass in an <b>opts</b> Hash, then :create_ds is set to true by default
-      # 
-      def create_workflow(repo, druid, workflow_name, wf_xml, opts = {:create_ds => true})
-        workflow_resource["#{repo}/objects/#{druid}/workflows/#{workflow_name}"].put(wf_xml, :content_type => 'application/xml', 
-                                                                                     :params => {'create-ds' => opts[:create_ds] })
-        return true
-      end
-  
-      # Updates the status of one step in a workflow.      
-      # Returns true on success.  Caller must handle any exceptions
-      #
-      # == Required Parameters
-      # - <b>repo</b> - The repository the object resides in.  The service recoginzes "dor" and "sdr" at the moment
-      # - <b>druid</b> - The id of the object
-      # - <b>workflow_name</b> - The name of the workflow 
-      # - <b>status</b> - The status that you want to set.  Typical statuses are 'waiting', 'completed', 'error', but could be any string
-      # 
-      # == Optional Parameters
-      # - <b>elapsed</b> - The number of seconds it took to complete this step. Can have a decimal.  Is set to 0 if not passed in.
-      # - <b>lifecycle</b> - Bookeeping label for this particular workflow step.  Examples are: 'registered', 'shelved'
-      #
-      # == Http Call
-      # The method does an HTTP PUT to the URL defined in Dor::WF_URI.  As an example:
-      #   PUT "/dor/objects/pid:123/workflows/GoogleScannedWF/convert"
-      #   <process name=\"convert\" status=\"completed\" />"
-      def update_workflow_status(repo, druid, workflow, process, status, elapsed = 0, lifecycle = nil)
-        xml = create_process_xml(:name => process, :status => status, :elapsed => elapsed.to_s, :lifecycle => lifecycle)
-        workflow_resource["#{repo}/objects/#{druid}/workflows/#{workflow}/#{process}"].put(xml, :content_type => 'application/xml')
-        return true
-      end
-  
-      #
-      # Retrieves the process status of the given workflow for the given object identifier
-      #
-      def get_workflow_status(repo, druid, workflow, process)
-        workflow_md = workflow_resource["#{repo}/objects/#{druid}/workflows/#{workflow}"].get
-        doc = Nokogiri::XML(workflow_md)
-        raise Exception.new("Unable to parse response:\n#{workflow_md}") if(doc.root.nil?)
-    
-        status = doc.root.at_xpath("//process[@name='#{process}']/@status").content
-        return status
-      end
-  
-      def get_workflow_xml(repo, druid, workflow)
-        workflow_resource["#{repo}/objects/#{druid}/workflows/#{workflow}"].get
-      end    
-
-      # Updates the status of one step in a workflow to error.      
-      # Returns true on success.  Caller must handle any exceptions
-      #
-      # == Required Parameters
-      # - <b>repo</b> - The repository the object resides in.  The service recoginzes "dor" and "sdr" at the moment
-      # - <b>druid</b> - The id of the object
-      # - <b>workflow_name</b> - The name of the workflow 
-      # - <b>error_msg</b> - The error message.  Ideally, this is a brief message describing the error
-      # 
-      # == Optional Parameters
-      # - <b>error_txt</b> - A slot to hold more information about the error, like a full stacktrace
-      #
-      # == Http Call
-      # The method does an HTTP PUT to the URL defined in Dor::WF_URI.  As an example:
-      #   PUT "/dor/objects/pid:123/workflows/GoogleScannedWF/convert"
-      #   <process name=\"convert\" status=\"error\" />"
-      def update_workflow_error_status(repo, druid, workflow, process, error_msg, error_txt = nil)
-        xml = create_process_xml(:name => process, :status => 'error', :errorMessage => error_msg, :errorText => error_txt)
-        workflow_resource["#{repo}/objects/#{druid}/workflows/#{workflow}/#{process}"].put(xml, :content_type => 'application/xml')
-        return true
-      end
-      
-#      private
-      def create_process_xml(params)
-        builder = Nokogiri::XML::Builder.new do |xml|
-          attrs = params.reject { |k,v| v.nil? }
-          xml.process(attrs)
-        end
-        return builder.to_xml
-      end
-      
-      def workflow_resource
-        RestClient::Resource.new(Config.workflow.url,
-        :ssl_client_cert  =>  OpenSSL::X509::Certificate.new(File.read(Config.fedora.cert_file)),
-        :ssl_client_key   =>  OpenSSL::PKey::RSA.new(File.read(Config.fedora.key_file), Config.fedora.key_pass))
-      end
-    end
-  end
-end

data/lib/xml_models/foxml.rb

@@ -1,261 +0,0 @@
-require 'nokogiri'
-
-# TODO: Rewrite in OM
-
-class Foxml
-  attr_reader :xml
-
-  NAMESPACES = {
-    "dc"           => "http://purl.org/dc/elements/1.1/", 
-    "fedora-model" => "info:fedora/fedora-system:def/model#", 
-    "foxml"        => "info:fedora/fedora-system:def/foxml#",
-    "oai_dc"       => "http://www.openarchives.org/OAI/2.0/oai_dc/", 
-    "rdf"          => "http://www.w3.org/1999/02/22-rdf-syntax-ns#", 
-    "rel"          => "info:fedora/fedora-system:def/relations-external#",
-    "hydra"        => "http://projecthydra.org/ns/relations#"
-  } 
-  
-  def initialize(pid=nil, label=nil, content_model=nil, identity_metadata=nil, admin_policy_object=nil, parent = nil)
-    @xml = Nokogiri::XML(XML_TEMPLATE) { |config| config.default_xml.noblanks }
-    @defined_namespaces = { '' => nil }
-    @xml.traverse { |node|
-      if node.respond_to?(:namespace_definitions)
-        node.namespace_definitions.each { |ns|
-          @defined_namespaces[ns.prefix] = ns
-        }
-      end
-    }
-
-    self.pid = pid.to_s
-    self.label = label.to_s
-    self.content_model = content_model
-    self.identity_metadata = identity_metadata
-    self.admin_policy_object = admin_policy_object
-    self.parent = parent
-  end
-
-  def pid
-    self.xpath('/foxml:digitalObject/@PID').first.value
-  end
-  
-  def pid=(value)
-    self.xpath('/foxml:digitalObject/@PID').first.value = value
-    self.get_datastream("RELS-EXT","rdf:RDF/rdf:Description/@rdf:about").value = "info:fedora/#{value}"
-    update_dc_identifiers
-  end
-
-  def content_model
-    self.get_rels_ext_resource("fedora-model:hasModel")
-  end
-  
-  def content_model=(value)
-    self.set_rels_ext_resource("fedora-model:hasModel",value)
-  end
-  
-  def dublin_core
-    self.get_datastream("DC","oai_dc:dc")
-  end
-  
-  def dublin_core=(value)
-    self.set_datastream("DC",value,'<oai_dc:dc xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:oai_dc="http://www.openarchives.org/OAI/2.0/oai_dc/"/>')
-  end
-  
-  def identity_metadata
-    self.get_datastream("identityMetadata","identityMetadata")
-  end
-  
-  def identity_metadata=(value)
-    self.set_datastream("identityMetadata",value,"<identityMetadata/>")
-    # strip the namespace Nokogiri attaches to identityMetadata
-    self.get_datastream("identityMetadata","*[local-name()='identityMetadata']").traverse { |n| n.namespace = nil }
-    update_dc_identifiers
-  end
-  
-  def label
-    self.xpath('//foxml:property[@NAME="info:fedora/fedora-system:def/model#label"]/@VALUE').first
-  end
-  
-  def label=(value)
-    self.xpath('//foxml:property[@NAME="info:fedora/fedora-system:def/model#label"]/@VALUE').first.value = value[0..254]
-    if existing_title = self.get_datastream("DC","//dc:title")
-      existing_title.remove
-    end
-    new_child = @xml.create_element('dc:title')
-    new_child.content = value
-    self.dublin_core.add_child(new_child)
-    fix_namespaces(new_child)
-    return new_child
-  end
-
-  def admin_policy_object
-    self.get_rels_ext_resource("hydra:isGovernedBy")
-  end
-  
-  def admin_policy_object=(value)
-    self.set_rels_ext_resource("hydra:isGovernedBy",value)
-  end
-  
-  def parent
-    self.get_rels_ext_resource("rel:isPartOf")
-  end
-  
-  def parent=(value)
-    self.set_rels_ext_resource("rel:isPartOf",value)
-  end
-  
-  def get_rels_ext_resource(predicate)
-    resource = self.get_datastream("RELS-EXT","//#{predicate}/@rdf:resource")
-    if resource.nil?
-      nil
-    else
-      resource.value.split(/\//).last
-    end
-  end
-  
-  def set_rels_ext_resource(predicate,value)
-    if existing_parent = self.get_datastream("RELS-EXT","//#{predicate}")
-      existing_parent.remove
-    end
-    if value.nil?
-      return nil
-    else
-      new_child = @xml.create_element(predicate, 'rdf:resource' => "info:fedora/#{value}")
-      self.get_datastream("RELS-EXT","//rdf:Description").add_child(new_child)
-      fix_namespaces(new_child)
-      return new_child
-    end
-  end
-  
-  def get_datastream(ds_name, *paths)
-    result = self.xpath(%{//foxml:datastream[@ID="#{ds_name}"]/foxml:datastreamVersion/foxml:xmlContent}).first
-    paths.each do |path|
-      result = result.xpath(path, NAMESPACES).first
-    end
-    return result
-  end
-  
-  def set_datastream(ds_name, new_value, nil_value = nil)
-    new_value ||= nil_value
-    if new_value.is_a?(Nokogiri::XML::Document)
-      new_value = new_value.root.clone
-    elsif new_value.is_a?(Nokogiri::XML::Node)
-      new_value = new_value.clone
-    end
-    parent = self.get_datastream(ds_name)
-    parent.children.each { |c| c.remove }
-    unless new_value.nil?
-      parent.add_child(new_value)
-    end
-  end
-  
-  def to_xml(opts = {})
-    undent_datastreams = opts.delete(:undent_datastreams)
-    @xml.traverse { |node| if node.is_a?(Nokogiri::XML::Text) and node.text.chomp.strip.empty?; node.remove; end }
-    result = @xml.to_xml(opts)
-
-    # Fedora FOXML ingest treats some (but not all) whitespace as significant. In order to get
-    # our datastreams to look pretty, we need to un-indent them. This an ugly hack, and only
-    # works because we've strictly controlled Nokogiri's serialization of whitespace.
-    if undent_datastreams
-      result.gsub!(/^(\s*)<foxml:xmlContent>\n(.+?)\n\s*<\/foxml:xmlContent>/m) { |m|
-        sp = $1
-        data = $2
-        "#{sp}<foxml:xmlContent>\n" + data.gsub(/^#{sp}  /,'') + "\n#{sp}</foxml:xmlContent>"
-      }
-    end
-    return result
-  end
-  
-  def xpath(path)
-    @xml.xpath(path, NAMESPACES)
-  end
-  
-  def update_dc_identifiers
-    new_ids = self.identity_metadata.xpath('*[local-name() = "sourceId" or local-name() = "otherId"]').collect do |n| 
-      n.attribute_nodes.first.value + ":" + n.content
-    end
-    unless self.pid.nil? or self.pid.empty?
-      new_ids << self.pid 
-    end
-    
-    dc = self.dublin_core
-    dc.xpath('dc:identifier',NAMESPACES).each { |existing_id| existing_id.remove }
-    new_ids.uniq.each do |id|
-      new_child = @xml.create_element('dc:identifier')
-      new_child.content = id
-      dc.add_child(new_child)
-      fix_namespaces(new_child)
-    end
-    return new_ids
-  end
-  
-  def fix_namespaces(node)
-    if node.is_a?(Nokogiri::XML::CharacterData)
-      node.namespace = nil
-    else
-      if node.name =~ /:/
-        (prefix,name) = node.name.split(/:/)
-        node.name = name
-        node.namespace = @defined_namespaces[prefix]
-      end
-      unless node.is_a?(Nokogiri::XML::Attr)
-        node.children.each { |n| fix_namespaces(n) }
-        node.attribute_nodes.each { |n| fix_namespaces(n) }
-      end
-    end
-  end
-  
-  def method_missing(sym,*args)
-    if @xml.respond_to?(sym)
-      @xml.send(sym,*args)
-    else
-      super
-    end
-  end
-  
-  XML_TEMPLATE = %{
-<?xml version="1.0" encoding="UTF-8"?>
-<foxml:digitalObject PID="$$PID$$" VERSION="1.1"
-  xmlns:foxml="info:fedora/fedora-system:def/foxml#"
-  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="info:fedora/fedora-system:def/foxml# http://www.fedora.info/definitions/1/0/foxml1-1.xsd">
-  <foxml:objectProperties>
-    <foxml:property NAME="info:fedora/fedora-system:def/model#state" VALUE="Active"/>
-    <foxml:property NAME="info:fedora/fedora-system:def/model#label" VALUE="$$LABEL$$"/>
-    <foxml:property NAME="info:fedora/fedora-system:def/model#ownerId" VALUE="DOR"/>
-  </foxml:objectProperties>
-  <foxml:datastream CONTROL_GROUP="X" ID="DC" STATE="A" VERSIONABLE="false">
-    <foxml:datastreamVersion
-      FORMAT_URI="http://www.openarchives.org/OAI/2.0/oai_dc/" ID="DC1.0"
-      LABEL="Dublin Core Record for this object" MIMETYPE="text/xml">
-        <foxml:xmlContent>
-          <oai_dc:dc xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:oai_dc="http://www.openarchives.org/OAI/2.0/oai_dc/"/>
-        </foxml:xmlContent>
-    </foxml:datastreamVersion>
-  </foxml:datastream>
-  <foxml:datastream CONTROL_GROUP="X" ID="identityMetadata" STATE="A" VERSIONABLE="false">
-    <foxml:datastreamVersion
-      ID="identityMetadata.0" LABEL="Identity Metadata" MIMETYPE="text/xml">
-        <foxml:xmlContent>
-          <identityMetadata/>
-        </foxml:xmlContent>
-    </foxml:datastreamVersion>
-  </foxml:datastream>
-  <foxml:datastream CONTROL_GROUP="X" ID="RELS-EXT" STATE="A">
-    <foxml:datastreamVersion
-      FORMAT_URI="info:fedora/fedora-system:FedoraRELSExt-1.0" ID="RELS-EXT.0"
-      LABEL="RDF Statements about this object" MIMETYPE="application/rdf+xml">
-      <foxml:xmlContent>
-        <rdf:RDF xmlns:fedora-model="info:fedora/fedora-system:def/model#" 
-            xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
-            xmlns:fedora="info:fedora/fedora-system:def/relations-external#"
-            xmlns:hydra="http://projecthydra.org/ns/relations#">
-            <rdf:Description rdf:about="info:fedora/$$PID$$">
-            </rdf:Description>
-        </rdf:RDF>
-      </foxml:xmlContent>
-    </foxml:datastreamVersion>
-  </foxml:datastream>
-</foxml:digitalObject>
-}.strip
-
-end