dor-services 2.2.4 → 4.4.10

data/lib/dor/models/workflow_object.rb

@@ -0,0 +1,54 @@
+require 'dor/datastreams/workflow_definition_ds'
+
+module Dor
+  class WorkflowObject < ::ActiveFedora::Base
+    include Identifiable
+    include SolrDocHelper
+    include Governable
+    @@xml_cache = {}
+
+    has_object_type 'workflow'
+    has_metadata :name => "workflowDefinition", :type => Dor::WorkflowDefinitionDs, :label => 'Workflow Definition'
+
+    def self.find_by_name(name, opts={})
+      Dor.find_all(%{objectType_t:"#{self.object_type}" workflow_name_s:"#{name}"}, opts).first
+    end
+    
+    # Searches for the workflow definition object in DOR, then 
+    # returns an object's initial workflow as defined in the worfklowDefinition datastream
+    # It will cache the result for subsequent requests
+    # @param [String] name the name of the workflow
+    # @return [String] the initial workflow xml
+    def self.initial_workflow(name)
+      return @@xml_cache[name] if(@@xml_cache.include?(name))
+
+      wobj = self.find_by_name(name)
+      wf_xml = wobj.generate_initial_workflow
+      @@xml_cache[name] = wf_xml
+    end
+
+    def definition
+      datastreams['workflowDefinition']
+    end
+    
+    def graph *args
+      self.definition.graph *args
+    end
+    
+    def to_solr solr_doc=Hash.new, *args
+      super solr_doc, *args
+      client = Dor::WorkflowService.workflow_resource
+      xml = client["workflow_archive?repository=#{definition.repo}&workflow=#{definition.name}&count-only=true"].get
+      count = Nokogiri::XML(xml).at_xpath('/objects/@count').value
+      add_solr_value(solr_doc,"#{definition.name}_archived",count,:integer,[:displayable])
+      solr_doc
+    end
+
+    def generate_initial_workflow
+      datastreams['workflowDefinition'].initial_workflow
+    end
+
+    alias_method :generate_intial_workflow, :generate_initial_workflow
+
+  end
+end

data/lib/dor/services/cleanup_service.rb

@@ -0,0 +1,47 @@
+require 'pathname'
+
+module Dor
+
+  # Remove all traces of the object's data files from the workspace and export areas
+  class CleanupService
+
+    # @param [LyberCore::Robots::WorkItem] dor_item The DOR work item whose workspace should be cleaned up
+    # @return [void] Delete all workspace and export entities for the druid
+    def self.cleanup(dor_item)
+      druid = dor_item.druid
+      cleanup_by_druid druid
+    end
+
+    def self.cleanup_by_druid(druid)
+      cleanup_workspace_content(druid, Config.cleanup.local_workspace_root)
+      cleanup_workspace_content(druid, Config.cleanup.local_assembly_root)
+      cleanup_export(druid)
+    end
+
+    # @param [String] druid The identifier for the object whose data is to be removed
+    # @param [String] base The base directory to delete from
+    # @return [void] remove the object's data files from the workspace area
+    def self.cleanup_workspace_content(druid, base)
+      DruidTools::Druid.new(druid, base).prune!
+    end
+
+    # @param [String] druid The identifier for the object whose data is to be removed
+    # @return [void] remove copy of the data that was exported to preservation core
+    def self.cleanup_export(druid)
+      id = druid.split(':').last
+      bag_dir = File.join(Config.cleanup.local_export_home, id)
+      self.remove_branch(bag_dir)
+      tarfile = "#{bag_dir}.tar"
+      self.remove_branch(tarfile)
+    end
+
+    # @param [Pathname,String] pathname The full path of the branch to be removed
+    # @return [void] Remove the specified directory and all its children
+    def self.remove_branch(pathname)
+      pathname = Pathname(pathname) if pathname.instance_of? String
+      pathname.rmtree if pathname.exist?
+    end
+
+  end
+
+end

data/lib/dor/services/digital_stacks_service.rb

@@ -0,0 +1,55 @@
+require 'net/ssh'
+require 'net/sftp'
+
+module Dor
+  class DigitalStacksService
+
+    def self.transfer_to_document_store(id, content, filename)
+      druid = DruidTools::PurlDruid.new id, Config.stacks.local_document_cache_root
+      druid.content_dir # create the druid tree if it doesn't exist yet
+      File.open(File.join(druid.content_dir, filename), 'w') {|f| f.write content }
+    end
+
+    def self.remove_from_stacks(id, files)
+      files.each do |file|
+        dr = DruidTools::StacksDruid.new id, Config.stacks.local_stacks_root
+        content = dr.find_content file
+        FileUtils.rm content if content
+      end
+    end
+
+    # @param [String] id object pid
+    # @param [Array<Array<String>>] file_map an array of two string arrays.  Each inner array represents old-file/new-file mappings.  First string is the old file name, second string is the new file name. e.g:
+    #   [ ['src1.file', 'dest1.file'], ['src2.file', 'dest2.file'] ]
+    def self.rename_in_stacks(id, file_map)
+      dr = DruidTools::StacksDruid.new id, Config.stacks.local_stacks_root
+      content_dir = dr.find_filelist_parent('content', file_map.first.first)
+      file_map.each do |src, dest|
+        File.rename(File.join(content_dir, src), File.join(content_dir, dest))
+      end
+    end
+
+    def self.shelve_to_stacks(id, files)
+      workspace_druid = DruidTools::Druid.new(id,Config.stacks.local_workspace_root)
+      stacks_druid = DruidTools::StacksDruid.new(id,Config.stacks.local_stacks_root)
+      files.each do |file|
+        stacks_druid.content_dir
+        workspace_file = workspace_druid.find_content(file)
+        FileUtils.cp workspace_file, stacks_druid.content_dir
+      end
+    end
+
+    # Assumes the digital stacks storage root is mounted to the local file system
+    # TODO since this is delegating to the Druid, this method may not be necessary
+    def self.prune_stacks_dir(id)
+      stacks_druid_tree = DruidTools::StacksDruid.new(id, Config.stacks.local_stacks_root)
+      stacks_druid_tree.prune!
+    end
+
+    def self.prune_purl_dir(id)
+      druid = DruidTools::PurlDruid.new(id, Dor::Config.stacks.local_document_cache_root)
+      druid.prune!
+    end
+  end
+
+end

data/lib/dor/services/merge_service.rb

@@ -0,0 +1,96 @@
+module Dor
+
+  class MergeService
+
+    def MergeService.merge_into_primary primary_druid, secondary_druids, tag, logger = nil
+      # TODO test the secondary_obj to see if we've processed it already
+      merge_service = Dor::MergeService.new primary_druid, secondary_druids, tag, logger
+      merge_service.check_objects_editable
+      merge_service.move_metadata_and_content
+      merge_service.decomission_secondaries
+      # kick off commonAccessioning for the primary?
+    end
+
+    def initialize primary_druid, secondary_pids, tag, logger = nil
+      @primary = Dor::Item.find primary_druid
+      @secondary_pids = secondary_pids
+      @secondary_objs = secondary_pids.map {|pid|  Dor::Item.find pid }
+      if logger.nil?
+        @logger = Logger.new(STDERR)
+      else
+        @logger = logger
+      end
+      @tag = tag
+    end
+
+    def check_objects_editable
+      unless @primary.allows_modification?
+        raise Dor::Exception.new "Primary object is not editable: #{@primary.pid}"
+      end
+      if ( non_editable = (@secondary_objs.detect {|obj| ! obj.allows_modification? } ))
+        raise Dor::Exception.new "Secondary object is not editable: #{non_editable.pid}"
+      end
+    end
+
+    def move_metadata_and_content
+      @primary.copy_file_resources @secondary_pids
+      @primary.save
+      copy_workspace_content
+    end
+
+    # Copies the content from the secondary object workspace to the primary object's workspace
+    #   Depends on Dor::Config.stacks.local_workspace_root
+    def copy_workspace_content
+      pri_file = @primary.contentMetadata.resource(0).file(0).id.first
+      pri_druid = DruidTools::Druid.new @primary.pid, Dor::Config.stacks.local_workspace_root
+      dest_path = pri_druid.find_filelist_parent 'content', pri_file
+      primary_cm = @primary.contentMetadata.ng_xml
+
+      @secondary_objs.each do |secondary|
+
+        sec_druid = DruidTools::Druid.new secondary.pid, Dor::Config.stacks.local_workspace_root
+        secondary.contentMetadata.ng_xml.xpath("//resource").each do |src_resource|
+          primary_resource = primary_cm.at_xpath "//resource[attr[@name = 'mergedFromPid']/text() = '#{secondary.pid}' and
+                                                             attr[@name = 'mergedFromResource']/text() = '#{src_resource['id']}' ]"
+          sequence = primary_resource['sequence']
+          src_resource.xpath("//file/@id").map {|id| id.value }.each do |file_id|
+            copy_path = sec_druid.find_content file_id
+            new_name = secondary.new_secondary_file_name(file_id, sequence)
+            # TODO verify new_name exists in primary_cm?
+            FileUtils.cp(copy_path, File.join(dest_path, "/#{new_name}"))
+          end
+        end
+      end
+    end
+
+    def decomission_secondaries
+      @secondary_objs.each do |secondary_obj|
+        begin
+          @current_secondary = secondary_obj
+          @current_secondary.decomission @tag
+          @current_secondary.save
+
+          unshelve
+          unpublish
+          Dor::CleanupService.cleanup_by_druid @current_secondary.pid
+          Dor::WorkflowService.archive_active_workflow 'dor', @current_secondary.pid
+        rescue => e
+          @logger.error "Unable to decomission #{@current_secondary.pid} with primary object #{@primary.pid}: #{e.inspect}"
+          @logger.error e.backtrace.join("\n")
+        end
+      end
+    end
+
+    # Remove content from stacks
+    # TODO might set workflow status in future for robot to do
+    def unshelve
+      DigitalStacksService.prune_stacks_dir @current_secondary.pid
+    end
+
+    # Withdraw item from Purl
+    # TODO might set workflow status in future for robot to do
+    def unpublish
+      @current_secondary.publish_metadata
+    end
+  end
+end

data/lib/dor/{metadata_handlers → services/metadata_handlers}/catalog_handler.rb

@@ -1,8 +1,6 @@
 require 'rest-client'
 
 handler = Class.new do
-  Dor::Config.metadata.declare(:catalog) { url nil }
-  
   def fetch(prefix, identifier)
     client = RestClient::Resource.new(Dor::Config.metadata.catalog.url)
     client["?#{prefix.chomp}=#{identifier.chomp}"].get

data/lib/dor/{metadata_handlers → services/metadata_handlers}/mdtoolkit_handler.rb

@@ -2,8 +2,6 @@ require 'nokogiri'
 require 'rest-client'
 
 handler = Class.new do
-  Dor::Config.metadata.declare(:exist) { url nil }
-  
   def fetch(prefix, identifier)
     query = <<-QUERY
 <?xml version="1.0" encoding="UTF-8"?>

data/lib/dor/{metadata_service.rb → services/metadata_service.rb}

@@ -18,14 +18,12 @@ module Dor
   
   class MetadataService
     
-    Config.declare(:metadata)
-    
     class << self
       @@cache = Cache.new(nil, nil, 250, 300)
       
       def register(handler_class)
         ['fetch', 'label', 'prefixes'].each do |method|
-          unless handler_class.instance_methods.include?(method)
+          unless handler_class.instance_methods.include?(method) or handler_class.instance_methods.include?(method.to_sym) 
             raise TypeError, "Metadata handlers must define ##{method.to_s}"
           end
         end

data/lib/dor/services/registration_service.rb

@@ -0,0 +1,181 @@
+require 'uuidtools'
+
+module Dor
+  
+  class RegistrationService
+    
+    class << self
+      def register_object(params = {})
+        Dor.ensure_models_loaded!
+        [:object_type, :label].each do |required_param|
+          raise Dor::ParameterError, "#{required_param.inspect} must be specified in call to #{self.name}.register_object" unless params[required_param]
+        end
+        metadata_source=params[:metadata_source]
+        if params[:label].length<1 and (metadata_source=='label' || metadata_source=='none')
+          raise Dor::ParameterError, "label cannot be empty to call #{self.name}.register_object"
+        end
+        object_type = params[:object_type]        
+        item_class = Dor.registered_classes[object_type]
+        raise Dor::ParameterError, "Unknown item type: '#{object_type}'" if item_class.nil?
+        
+        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]
+        collection = params[:collection]
+        pid = nil
+        metadata_source=params[:metadata_source]
+        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
+        
+        rights=nil
+        if params[:rights]
+          rights=params[:rights]
+          if not ['world','stanford','dark','default','none'].include? rights
+            raise Dor::ParameterError,"Unknown rights setting" + rights + "when calling #{self.name}.register_object"
+          end
+        end
+
+        source_id_string = [source_id.keys.first,source_id[source_id.keys.first]].compact.join(':')
+        unless source_id.empty?
+          existing_pid = SearchService.query_by_id("#{source_id_string}").first
+          unless existing_pid.nil?
+            raise Dor::DuplicateIdError.new(existing_pid), "An object with the source ID '#{source_id_string}' has already been registered."
+          end
+        end
+
+        if (other_ids.has_key?(:uuid) or other_ids.has_key?('uuid')) == false
+          other_ids[:uuid] = UUIDTools::UUID.timestamp_create.to_s
+        end
+        short_label=label
+        if label.length>254
+          short_label=label[0,254]
+        end
+        
+        apo_object = Dor.find(admin_policy, :lightweight => true)
+        adm_xml = apo_object.administrativeMetadata.ng_xml
+        
+        new_item = item_class.new(:pid => pid)
+        new_item.label = short_label
+        idmd = new_item.identityMetadata
+        idmd.sourceId = source_id_string
+        idmd.add_value(:objectId, pid)
+        idmd.add_value(:objectCreator, 'DOR')
+        idmd.add_value(:objectLabel, label)
+        idmd.add_value(:objectType, object_type)
+        idmd.add_value(:adminPolicy, admin_policy)
+        other_ids.each_pair { |name,value| idmd.add_otherId("#{name}:#{value}") }
+        tags.each { |tag| idmd.add_value(:tag, tag) }
+        new_item.admin_policy_object = apo_object
+        
+        adm_xml.xpath('/administrativeMetadata/relationships/*').each do |rel|
+          short_predicate = ActiveFedora::RelsExtDatastream.short_predicate rel.namespace.href+rel.name
+          if short_predicate.nil?
+            ix = 0
+            ix += 1 while ActiveFedora::Predicates.predicate_mappings[rel.namespace.href].has_key?(short_predicate = :"extra_predicate_#{ix}")
+            ActiveFedora::Predicates.predicate_mappings[rel.namespace.href][short_predicate] = rel.name
+          end
+          new_item.add_relationship short_predicate, rel['rdf:resource']
+        end
+        if collection
+          new_item.add_collection(collection)
+        end
+        if(rights and ['item','collection'].include? object_type  )
+          rights_xml=apo_object.defaultObjectRights.ng_xml
+          new_item.datastreams['rightsMetadata'].content=rights_xml.to_s
+          new_item.set_read_rights(rights)
+        end
+        #create basic mods from the label
+        if(metadata_source=='label')
+          ds=new_item.build_datastream('descMetadata');
+          builder = Nokogiri::XML::Builder.new { |xml|
+            xml.mods( 'xmlns' => 'http://www.loc.gov/mods/v3', 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',:version => '3.3', "xsi:schemaLocation" => 'http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-3.xsd'){
+              xml.titleInfo{
+                xml.title label
+              }
+            }
+          }
+      
+      ds.content=builder.to_xml
+         
+      end
+        
+        workflow_priority = params[:workflow_priority] ? params[:workflow_priority].to_i : 0
+        
+        Array(params[:seed_datastream]).each { |datastream_name| new_item.build_datastream(datastream_name) }
+        Array(params[:initiate_workflow]).each { |workflow_id| new_item.initialize_workflow(workflow_id, 'dor', !new_item.new_object?, workflow_priority)}
+
+        new_item.assert_content_model
+        new_item.save
+        begin
+          new_item.update_index if ::ENABLE_SOLR_UPDATES
+        rescue StandardError => e
+          Dor.logger.warn "Dor::RegistrationService.register_object failed to update solr index for #{new_item.pid}: #<#{e.class.name}: #{e.message}>"
+        end
+        return(new_item)
+      end
+      
+      def create_from_request(params)
+        other_ids = Array(params[:other_id]).collect do |id|
+          if id =~ /^symphony:(.+)$/
+            "#{$1.length < 14 ? 'catkey' : 'barcode'}:#{$1}"
+          else
+            id
+          end
+        end
+    
+        if params[:label] == ':auto'
+          params.delete(:label)
+          params.delete('label')
+          metadata_id = Dor::MetadataService.resolvable(other_ids).first
+          params[:label] = Dor::MetadataService.label_for(metadata_id)
+        end
+          
+        dor_params = {
+          :pid                => params[:pid],
+          :admin_policy       => params[:admin_policy],
+          :content_model      => params[:model],
+          :label              => params[:label],
+          :object_type        => params[:object_type],
+          :other_ids          => ids_to_hash(other_ids),
+          :parent             => params[:parent],
+          :source_id          => ids_to_hash(params[:source_id]),
+          :tags               => params[:tag] || [],
+          :seed_datastream    => params[:seed_datastream],
+          :initiate_workflow  => Array(params[:initiate_workflow]) + Array(params[:workflow_id]),
+          :rights             => params[:rights],
+          :metadata_source    => params[:metadata_source],
+          :collection         => params[:collection],
+          :workflow_priority  => params[:workflow_priority]
+        }
+        dor_params.delete_if { |k,v| v.nil? }
+    
+        dor_obj = self.register_object(dor_params)
+        pid = dor_obj.pid
+        location = URI.parse(Dor::Config.fedora.safeurl.sub(/\/*$/,'/')).merge("objects/#{pid}").to_s
+        reg_response = dor_params.dup.merge({ :location => location, :pid => pid })
+      end
+      
+      private
+      def ids_to_hash(ids)
+        if ids.nil?
+          nil
+        else
+          Hash[Array(ids).collect { |id| id.split(/:/) }]
+        end
+      end
+    end
+    
+  end
+
+end