dor-services 2.2.4 → 4.4.10

data/lib/dor/embargo.rb

@@ -1,41 +0,0 @@
-require 'datastreams/embargo_metadata_ds'
-require 'datastreams/events_ds'
-
-module Dor
-  
-  # These methods manipulate the object for embargo purposes
-  # They assume the object has embargoMetadata, rightsMetadata, and events datastreams
-  module Embargo
-    
-    # Manipulates datastreams in the object when embargo is lifted:
-    # Sets embargo status to released in embargoMetadata
-    # Modifies rightsMetadata to remove embargoReleaseDate and updates/adds access from embargoMetadata/releaseAccess
-    # @param [String] release_agent name of the person, application or thing that released embargo
-    # @note The caller should save the object to fedora to commit the changes
-    def release_embargo(release_agent="unknown")
-      # Set status to released
-      embargo_md = datastreams['embargoMetadata']
-      embargo_md.status = 'released'
-      
-      # Remove embargoReleaseDate from rights
-      rights_xml = datastreams['rightsMetadata'].ng_xml
-      rights_xml.xpath("//rightsMetadata/access[@type='read']/machine/embargoReleaseDate").remove
-      
-      # Replace rights <access> nodes with those from embargoMetadta
-      release_access = embargo_md.release_access_node
-      release_access.xpath('//releaseAccess/access').each do |new_access|
-        type = new_access['type']
-        rights_xml.xpath("//rightsMetadata/access[@type='#{type}']").remove
-        access_sibling = rights_xml.at_xpath("//rightsMetadata/access[last()]")
-        if(access_sibling)
-          access_sibling.add_next_sibling(new_access.clone)
-        else
-          rights_xml.root.add_child(new_access.clone)
-        end
-      end
-      
-      datastreams['rightsMetadata'].dirty = true
-      datastreams['events'].add_event("embargo", release_agent, "Embargo released")
-    end
-  end
-end

data/lib/dor/item.rb

@@ -1,141 +0,0 @@
-require 'dor/base'
-require 'datastreams/content_metadata_ds'
-require 'datastreams/ng_tidy'
-require 'tmpdir'
-
-module Dor
-  
-  class Item < Base
-    
-    has_metadata :name => "contentMetadata", :type => ContentMetadataDS
-    has_metadata :name => "descMetadata", :type => ActiveFedora::NokogiriDatastream
-    has_metadata :name => "rightsMetadata", :type => ActiveFedora::NokogiriDatastream
-    has_metadata :name => "provenanceMetadata", :type => ActiveFedora::NokogiriDatastream
-    has_metadata :name => "technicalMetadata", :type => ActiveFedora::NokogiriDatastream
-
-    def admin_policy_object
-      apo_ref = Array(self.rels_ext.relationships[:self]['hydra_isGovernedBy']).first
-      if apo_ref.nil?
-        return nil
-      else
-        apo_id = apo_ref.value.split(%r{/}).last
-        if apo_id.empty?
-          return nil
-        else
-          return Dor::AdminPolicyObject.load_instance(apo_id)
-        end
-      end
-    end
-  
-    def fetch_descMetadata_datastream
-      candidates = self.identity_metadata.otherIds.collect { |oid| oid.to_s }
-      metadata_id = Dor::MetadataService.resolvable(candidates).first
-      unless metadata_id.nil?
-        return Dor::MetadataService.fetch(metadata_id.to_s)
-      else
-        return nil
-      end
-    end
-
-    def build_contentMetadata_datastream(ds)
-      path = Druid.new(self.pid).path(Dor::Config.stacks.local_workspace_root)
-      if File.exists?(File.join(path, 'content_metadata.xml'))
-        ds.label = 'Content Metadata'
-        ds.ng_xml = Nokogiri::XML(File.read(File.join(path, 'content_metadata.xml')))
-      end
-    end
-    
-    def build_descMetadata_datastream(ds)
-      content = fetch_descMetadata_datastream
-      unless content.nil?
-        ds.label = 'Descriptive Metadata'
-        ds.ng_xml = Nokogiri::XML(content)
-        ds.ng_xml.normalize_text!
-      end
-    end
-    
-    def build_rightsMetadata_datastream(ds)
-      content_ds = self.admin_policy_object.datastreams['defaultObjectRights']
-      ds.label = 'Rights Metadata'
-      ds.ng_xml = content_ds.ng_xml.clone
-    end
-
-    def public_xml      
-      pub = Nokogiri::XML("<publicObject/>").root
-      pub['id'] = pid
-      pub.add_child(self.datastreams['identityMetadata'].ng_xml.root.clone)
-      pub.add_child(self.datastreams['contentMetadata'].public_xml.root.clone)
-      pub.add_child(self.datastreams['rightsMetadata'].ng_xml.root.clone)
-      pub.add_child(generate_dublin_core.root)
-      Nokogiri::XML(pub.to_xml) { |x| x.noblanks }.to_xml { |config| config.no_declaration }
-    end
-    
-    # Generates Dublin Core from the MODS in the descMetadata datastream using the LoC mods2dc stylesheet
-    # Should not be used for the Fedora DC datastream
-    def generate_dublin_core
-      apo = self.admin_policy_object
-      format = apo.nil? ? 'mods' : apo.datastreams['administrativeMetadata'].ng_xml.at('/administrativeMetadata/descMetadata/format').text.downcase
-      xslt = Nokogiri::XSLT(File.new(File.expand_path(File.dirname(__FILE__) + "/#{format}2dc.xslt")) )
-      xslt.transform(self.datastreams['descMetadata'].ng_xml)
-    end
-    
-    def publish_metadata
-      DigitalStacksService.transfer_to_document_store(pid, self.datastreams['identityMetadata'].to_xml, 'identityMetadata')
-      DigitalStacksService.transfer_to_document_store(pid, self.datastreams['contentMetadata'].to_xml, 'contentMetadata')
-      DigitalStacksService.transfer_to_document_store(pid, self.datastreams['rightsMetadata'].to_xml, 'rightsMetadata')
-      dc_xml = self.generate_dublin_core.to_xml {|config| config.no_declaration}
-      DigitalStacksService.transfer_to_document_store(pid, dc_xml, 'dc')
-      DigitalStacksService.transfer_to_document_store(pid, public_xml, 'public')
-    end
-
-    def build_provenanceMetadata_datastream(workflow_id, event_text)
-      ProvenanceMetadataService.add_provenance(self, workflow_id, event_text)
-    end
-
-    def build_technicalMetadata_datastream(ds)
-      unless defined? ::JhoveService
-        begin
-          require 'jhove_service'
-        rescue LoadError => e
-          puts e.inspect
-          raise "jhove-service dependency gem was not found.  Please add it to your Gemfile and run bundle install"
-        end
-      end
-      begin
-        content_dir = Druid.new(self.pid).path(Config.sdr.local_workspace_root)
-        temp_dir = Dir.mktmpdir(self.pid)
-        jhove_service = ::JhoveService.new(temp_dir)
-        jhove_output_file = jhove_service.run_jhove(content_dir)
-        tech_md_file = jhove_service.create_technical_metadata(jhove_output_file)
-        ds.label = 'Technical Metadata'
-        ds.ng_xml = Nokogiri::XML(IO.read(tech_md_file))
-      ensure
-        FileUtils.remove_entry_secure(temp_dir) if File.exist?(temp_dir)
-      end
-    end
-
-    def shelve
-      files = [] # doc.xpath("//file").select {|f| f['shelve'] == 'yes'}.map{|f| f['id']}
-      self.datastreams['contentMetadata'].ng_xml.xpath('//file').each do |file|
-        files << file['id'] if(file['shelve'].downcase == 'yes')
-      end
-      
-      DigitalStacksService.shelve_to_stacks(pid, files)
-    end
-
-    def sdr_ingest_transfer(agreement_id)
-      SdrIngestService.transfer(self,agreement_id)
-    end
-
-    def cleanup()
-      CleanupService.cleanup(self)
-    end
-
-    def initiate_apo_workflow(name)
-      wf_xml = admin_policy_object.datastreams['administrativeMetadata'].ng_xml.xpath(%{//workflow[@id="#{name}"]}).first.to_xml
-      Dor::WorkflowService.create_workflow('dor',self.pid,name,wf_xml)
-    end
-    
-  end
-
-end

data/lib/dor/provenance_metadata_service.rb

@@ -1,65 +0,0 @@
-require 'nokogiri'
-require 'date'
-require 'time'
-
-module Dor
-  class ProvenanceMetadataService
-
-    def self.add_provenance(dor_item, workflow_id, event_text)
-      druid = dor_item.pid
-      # workflow_xml = get_workflow_xml(druid, workflow_id)
-      workflow_provenance = create_workflow_provenance(druid, workflow_id, event_text)
-      dsname = 'provenanceMetadata'
-      if dor_item.datastream_names.include?(dsname)
-        ds = dor_item.datastreams[dsname]
-        old_provenance = ds.content
-        ds.ng_xml = update_provenance(old_provenance, workflow_provenance)
-      else
-        ds = dor_item.datastreams[dsname]
-        ds.label = 'Provenance Metadata'
-        ds.ng_xml = workflow_provenance
-      end
-      ds.save
-    end
-
-    # not used
-    def self.get_workflow_xml(druid, workflow_id)
-      Dor::WorkflowService.get_workflow_xml('dor', druid, workflow_id)
-    end
-
-    # @return [String]
-    def self.create_workflow_provenance(druid, workflow_id, event_text)
-      builder = Nokogiri::XML::Builder.new do |xml|
-        xml.provenanceMetadata(:objectId => druid) {
-          xml.agent(:name => 'DOR') {
-            xml.what(:object => druid) {
-              xml.event(:who => "DOR-#{workflow_id}", :when => Time.new.iso8601) {
-                xml.text(event_text)
-              }
-            }
-          }
-        }
-      end
-      builder.doc
-    end
-
-  # Reformat the XML
-  # @param[String]
-  def self.parse_xml_remove_blank_nodes(old_provenance)
-    # http://blog.slashpoundbang.com/post/1454850669/how-to-pretty-print-xml-with-nokogiri
-    Nokogiri::XML(old_provenance) { |x| x.noblanks }
-  end
-
-      # Append new stanzas in the contentMetadata for the googleMETS and technicalMetadata files
-  # @param[String, Hash<Symbol,String>]
-  def self.update_provenance(old_provenance, workflow_provenance)
-    pm_xml = Nokogiri::XML(old_provenance)
-    builder = Nokogiri::XML::Builder.with(pm_xml.at 'provenanceMetadata') do |xml|
-      xml << workflow_provenance.xpath('/provenanceMetadata/agent').first.to_xml
-    end
-    parse_xml_remove_blank_nodes(builder.to_xml)
-  end
-
-  end
-
-end

data/lib/dor/registration_service.rb

@@ -1,87 +0,0 @@
-require 'active_fedora'
-require 'uuidtools'
-require 'xml_models/foxml'
-require 'xml_models/identity_metadata/identity_metadata'
-
-require 'dor/search_service'
-
-module Dor
-  
-  class RegistrationService
-    
-    class << self
-      def register_object(params = {})
-        [:object_type, :label].each do |required_param|
-          unless params[required_param]
-            raise Dor::ParameterError, "#{required_param.inspect} must be specified in call to #{self.name}.register_object"
-          end
-        end
-
-        object_type = params[:object_type]
-        content_model = params[:content_model]
-        admin_policy = params[:admin_policy]
-        label = params[:label]
-        source_id = params[:source_id] || {}
-        other_ids = params[:other_ids] || {}
-        tags = params[:tags] || []
-        parent = params[:parent]
-        pid = nil
-        if params[:pid]
-          pid = params[:pid]
-          existing_pid = SearchService.query_by_id(pid).first
-          unless existing_pid.nil?
-            raise Dor::DuplicateIdError.new(existing_pid), "An object with the PID #{pid} has already been registered."
-          end
-        else
-          pid = Dor::SuriService.mint_id
-        end
-
-        if (other_ids.has_key?(:uuid) or other_ids.has_key?('uuid')) == false
-          other_ids[:uuid] = UUIDTools::UUID.timestamp_create.to_s
-        end
-
-        apo_object = Dor::AdminPolicyObject.load_instance(admin_policy)
-        adm_xml = apo_object.datastreams['administrativeMetadata'].ng_xml
-        agreement_id = adm_xml.at('/administrativeMetadata/registration/agreementId/text()').to_s
-        
-        idmd = IdentityMetadata.new
-
-        unless source_id.empty?
-          source_name = source_id.keys.first
-          source_value = source_id[source_name]
-          existing_pid = SearchService.query_by_id("#{source_name}:#{source_value}").first
-          unless existing_pid.nil?
-            raise Dor::DuplicateIdError.new(existing_pid), "An object with the source ID '#{source_name}:#{source_value}' has already been registered."
-          end
-          idmd.sourceId.source = source_name
-          idmd.sourceId.value = source_value
-        end
-        
-        idmd.objectId = pid
-        idmd.objectCreators << 'DOR'
-        idmd.objectLabels << label
-        idmd.objectTypes << object_type
-        idmd.adminPolicy = admin_policy
-        idmd.agreementId = agreement_id
-        other_ids.each_pair { |name,value| idmd.add_identifier(name,value) }
-        tags.each { |tag| idmd.add_tag(tag) }
-    
-        foxml = Foxml.new(pid, label, content_model, idmd.to_xml, parent)
-        foxml.admin_policy_object = admin_policy
-        rdf = foxml.xml.at('//rdf:Description', { 'rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' })
-        rels = adm_xml.xpath('/administrativeMetadata/relationships/*')
-        rels.each { |rel| rdf.add_child(rel.clone) }
-    
-        repo = ActiveFedora.fedora
-        http_response = repo.ingest(foxml.to_xml(:undent_datastreams => true))
-        result = {
-          :response => http_response,
-          :pid => pid
-        }
-        return(result)
-      end
-    end
-    
-  end
-
-end

data/lib/dor/rsolr.rb

@@ -1,27 +0,0 @@
-require 'rest-client'
-
-module Dor
-  
-  class RSolrConnection
-
-    def execute client, request_context
-      $stderr.puts request_context.inspect
-      resource = RestClient::Resource.new(
-        request_context[:uri].to_s,
-        :ssl_client_cert  =>  OpenSSL::X509::Certificate.new(File.read(Dor::Config.fedora.cert_file)),
-        :ssl_client_key   =>  OpenSSL::PKey::RSA.new(File.read(Dor::Config.fedora.key_file), Dor::Config.fedora.key_pass)
-      )
-      result = {}
-      resource.send(request_context[:method]) { |response, request, result, &block|
-        result = {
-          :status => response.net_http_res.code.to_i,
-          :headers => response.net_http_res.to_hash,
-          :body => response.net_http_res.body
-        }
-      }
-      result
-    end
-
-  end
-  
-end

data/lib/dor/sdr_ingest_service.rb

@@ -1,117 +0,0 @@
-require 'lyber-utils'
-
-module Dor
-  class SdrIngestService
-
-    Config.declare(:sdr) do
-  	  local_workspace_root '/dor/workspace'
-      local_export_home '/dor/export'
-      datastreams do
-        contentMetadata 'required'
-        descMetadata 'required'
-        identityMetadata 'required'
-        provenanceMetadata 'required'
-        relationshipMetadata 'required'
-        technicalMetadata 'required'
-        rightsMetadata 'optional'
-        sourceMetadata 'optional'
-      end
-    end
-
-    # Some boilerplace entries for the bagit metadata file
-    METADATA_INFO =  {
-        'Source-Organization' => 'Stanford University Libraries',
-        'Stanford-Content-Metadata'  =>  'data/metadata/contentMetadata.xml',
-        'Stanford-Identity-Metadata'  =>  'data/metadata/identityMetadata.xml',
-        'Stanford-Provenance-Metadata'  =>  'data/metadata/provenanceMetadata.xml'
-    }
-
-    # Create a bagit object and fill it with content
-    # Then tar it
-    # @param [LyberCore::Robots::WorkItem]
-    def self.transfer(dor_item, agreement_id)
-      druid = dor_item.pid
-      content_dir = Druid.new(druid).path(Config.sdr.local_workspace_root)
-
-      # Create the bag
-      bag_dir = File.join(Config.sdr.local_export_home, druid)
-      export_bag = LyberUtils::BagitBag.new(bag_dir)
-
-      # Fill the bag
-      export_bag.add_content_files(content_dir, use_links=true)
-      add_metadata_datastreams(dor_item, export_bag)
-      export_bag.write_metadata_info(metadata_info(druid, agreement_id))
-      export_bag.write_manifests()
-      export_bag.validate()
-
-      unless LyberUtils::FileUtilities.tar_object(bag_dir)
-        raise 'Unable to tar the bag'
-      end
-
-      # Now bootstrap SDR workflow queue to start SDR robots
-      Dor::WorkflowService.create_workflow('sdr', druid, 'sdrIngestWF', read_sdr_workflow_xml(), {:create_ds => false})
-    end
-
-    # Read in the XML file needed to initialize the SDR workflow
-    # @return [String]
-    def self.read_sdr_workflow_xml()
-      return IO.read(File.join("#{ROBOT_ROOT}", "config", "workflows", "sdrIngestWF", "sdrIngestWF.xml"))
-    end
-
-    # For each of the metadata files or datastreams, create a file in in the bag's data/metadata folder
-    # @param[String, LyberUtils::BagitBag]
-    def self.add_metadata_datastreams(dor_item, export_bag)
-      Config.sdr.datastreams.to_hash.each_pair do |ds_name, required|
-        # ds_name in this context is a symbol, so convert it to a string
-        filename = "#{ds_name.to_s}.xml"
-        metadata_string = self.get_datastream_content(dor_item, ds_name.to_s, required)
-        self.export_metadata_string(metadata_string, filename, export_bag) unless metadata_string.nil?
-      end
-    end
-
-    # create a link to a metadata file in the bag's data/metadata folder
-    def self.export_metadata_file(metadata_dir, filename, bag)
-      metadata_file = File.join(metadata_dir, filename)
-      bag_metadata_dir = File.join(bag.bag_dir, 'data', 'metadata')
-      if (File.exist?(metadata_file))
-        bag_file = File.join(bag_metadata_dir, filename)
-        File.link(metadata_file, bag_file)
-        return true
-      else
-        return false
-      end
-    end
-
-    # return the content of the specied datastream if it exists
-    # if non-existant, return nil or raise exception depending on value of required
-    def self.get_datastream_content(dor_item, ds_name, required)
-      ds = (ds_name == 'relationshipMetadata' ? 'RELS-EXT' : ds_name)
-      if dor_item.datastreams_in_fedora.keys.include?(ds)
-        return dor_item.datastreams[ds].content
-      elsif (required == 'optional')
-        return nil
-      else
-        raise "required datastream #{ds_name} not found in DOR"
-      end
-    end
-
-    # create a file in the bag's data/metadata folder containing the metadata string
-    # @param[String, String, LyberUtils::BagitBag]
-    def self.export_metadata_string(metadata_string, filename, bag)
-      bag.add_metadata_file_from_string(metadata_string, filename)
-    end
-
-    # merge item-specific data into the standard hash of metadata information
-    # @param [String, String]
-    def self.metadata_info(druid, agreement_id)
-       item_info = {
-              'External-Identifier' =>  druid,
-              'Stanford-Agreement-ID'  =>  agreement_id
-      }
-      merged_info = item_info.merge(METADATA_INFO)
-      return merged_info
-    end
-
-  end
-
-end