dor-services 2.2.4 → 4.4.10

data/lib/dor-services.rb

@@ -1,19 +1,152 @@
-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'
+require 'active_fedora'
+require 'active_support/core_ext/module/attribute_accessors'
+
+module Dor
+  @@registered_classes = {}
+  mattr_reader :registered_classes
+  INDEX_VERSION_FIELD = 'dor_services_version_facet'
+
+  class << self
+
+    def configure *args, &block
+      Dor::Config.configure *args, &block
+    end
+
+    # Load an object and inspect its identityMetadata to figure out what class
+    # to adapt it to. This is necessary when the object is not indexed, or the
+    # index is missing the objectType property.
+    # @param [String] pid The object's PID
+    def load_instance pid
+      ensure_models_loaded!
+      obj = Dor::Abstract.find pid
+      return nil if obj.new_object?
+      object_type = obj.identityMetadata.objectType.first
+      object_class = registered_classes[object_type] || Dor::Item
+      obj.adapt_to(object_class)
+    end
+
+    # Get objectType information from solr and load the correct class the first time,
+    # saving the overhead of using ActiveFedora::Base#adapt_to. It falls back to
+    # Dor.load_instance() if the item is not in the index, or is improperly
+    # indexed.
+    # @param [String] pid The object's PID
+    def find pid, opts={}
+      self.find_all(%{id:"#{pid}"}, opts).first || self.load_instance(pid)
+    end
+
+    def find_all query, opts={}
+      ensure_models_loaded!
+      af_version = Gem::Version.new(ActiveFedora::VERSION)
+      if opts[:lightweight] and af_version < Gem::Version.new('4.0.0.rc9')
+        ActiveFedora.logger.warn("Loading of lightweight objects requires ActiveFedora >= 4.0.0")
+        opts.delete(:lightweight)
+      end
+
+      resp = SearchService.query query, opts
+      resp.docs.collect do |solr_doc|
+        doc_version = solr_doc[INDEX_VERSION_FIELD].first rescue '0.0.0'
+        doc_version = Gem::Version.new(doc_version)
+        object_type = Array(solr_doc[ActiveFedora::SolrService.solr_name('objectType',:string)]).first
+        object_class = registered_classes[object_type] || ActiveFedora::Base
+        if opts[:lightweight] and doc_version >= Gem::Version.new('3.1.0')
+          begin
+            object_class.load_instance_from_solr solr_doc['id'], solr_doc
+          rescue Exception => e
+            ActiveFedora.logger.warn("Exception: '#{e.message}' trying to load #{solr_doc['id']} from solr. Loading from Fedora")
+            load_instance(solr_doc['id'])
+          end
+        else
+          load_instance solr_doc['id']
+        end
+      end
+    end
+
+    def ensure_models_loaded!
+      [Item, Set, Collection, AdminPolicyObject, WorkflowObject]
+    end
+
+    def root
+      File.dirname(__FILE__)
+    end
+  end
+
+  require 'dor/version'
+  require 'dor/config'
+  require 'dor/exceptions'
+
+  # patches, utilities and helpers
+  require 'dor/utils/ng_tidy'
+  require 'dor/utils/solr_doc_helper'
+  require 'dor/utils/utc_date_field_mapper'
+  require 'dor/utils/predicate_patch'
+
+  require 'dor/datastreams/datastream_spec_solrizer'
+
+  require 'druid-tools'
+
+  # datastreams
+  autoload :AdministrativeMetadataDS,  'dor/datastreams/administrative_metadata_ds'
+  autoload :ContentMetadataDS, 'dor/datastreams/content_metadata_ds'
+  autoload :DescMetadataDS,  'dor/datastreams/desc_metadata_ds'
+  autoload :EmbargoMetadataDS, 'dor/datastreams/embargo_metadata_ds'
+  autoload :EventsDS,  'dor/datastreams/events_ds'
+  autoload :IdentityMetadataDS,  'dor/datastreams/identity_metadata_ds'
+  autoload :RoleMetadataDS,  'dor/datastreams/role_metadata_ds'
+  autoload :WorkflowDefinitionDs,  'dor/datastreams/workflow_definition_ds'
+  autoload :WorkflowDs,  'dor/datastreams/workflow_ds'
+  autoload :VersionMetadataDS,  'dor/datastreams/version_metadata_ds'
+  autoload :DefaultObjectRightsDS,  'dor/datastreams/default_object_rights_ds'
+  ::Object.autoload :SimpleDublinCoreDs, 'dor/datastreams/simple_dublin_core_ds'
+
+  # DOR Concerns
+  autoload :Identifiable, 'dor/models/identifiable'
+  autoload :Itemizable, 'dor/models/itemizable'
+  autoload :Processable, 'dor/models/processable'
+  autoload :Governable, 'dor/models/governable'
+  autoload :Describable, 'dor/models/describable'
+  autoload :Publishable, 'dor/models/publishable'
+  autoload :Shelvable, 'dor/models/shelvable'
+  autoload :Embargoable, 'dor/models/embargoable'
+  autoload :Preservable, 'dor/models/preservable'
+  autoload :Assembleable, 'dor/models/assembleable'
+  autoload :Upgradable, 'dor/models/upgradable'
+  autoload :Eventable, 'dor/models/eventable'
+  autoload :Versionable, 'dor/models/versionable'
+  autoload :Contentable, 'dor/models/contentable'
+  autoload :Editable, 'dor/models/editable'
+  autoload :Discoverable, 'dor/models/discoverable'
+
+
+  # ActiveFedora Classes
+  autoload :Abstract, 'dor/models/item'
+  autoload :Item, 'dor/models/item'
+  autoload :Set, 'dor/models/set'
+  autoload :Collection, 'dor/models/collection'
+  autoload :AdminPolicyObject, 'dor/models/admin_policy_object'
+  autoload :WorkflowObject, 'dor/models/workflow_object'
+
+  # Services
+  autoload :SearchService, 'dor/services/search_service'
+  autoload :MetadataService, 'dor/services/metadata_service'
+  autoload :RegistrationService, 'dor/services/registration_service'
+  autoload :SuriService, 'dor/services/suri_service'
+  autoload :WorkflowService, 'dor/services/workflow_service'
+  autoload :DigitalStacksService, 'dor/services/digital_stacks_service'
+  autoload :SdrIngestService, 'dor/services/sdr_ingest_service'
+  autoload :CleanupService, 'dor/services/cleanup_service'
+  autoload :ProvenanceMetadataService, 'dor/services/provenance_metadata_service'
+  autoload :TechnicalMetadataService, 'dor/services/technical_metadata_service'
+  autoload :MergeService, 'dor/services/merge_service'
+
+  # Versioning Classes
+  module Versioning
+    autoload :FileInventoryDifference, 'dor/versioning/file_inventory_difference'
+  end
+
+  # Workflow Classes
+  module Workflow
+    autoload :Graph, 'dor/workflow/graph'
+    autoload :Process, 'dor/workflow/process'
+    autoload :Document, 'dor/workflow/document'
+  end
+end

data/lib/dor/config.rb

@@ -1,45 +1,143 @@
-require 'mod_cons'
+require 'confstruct/configuration'
+require 'rsolr-ext'
+require 'stomp'
+require 'yaml'
 
 module Dor
-  Config = ModCons::Configuration.new(:'Dor::Config')
-
-  Config.declare do
-    fedora do
-      url nil
-      safeurl nil
-      cert_file nil
-      key_file nil
-      key_pass ''
-
-      instance_eval do
-        def client
-          RestClient::Resource.new(
-            self.url,
-            :ssl_client_cert  =>  OpenSSL::X509::Certificate.new(File.read(self.cert_file)),
-            :ssl_client_key   =>  OpenSSL::PKey::RSA.new(File.read(self.key_file), self.key_pass)
-          )
+  class Configuration < Confstruct::Configuration
+    include ActiveSupport::Callbacks
+    define_callbacks :initialize
+    define_callbacks :configure
+
+    def initialize *args
+      super *args
+      run_callbacks(:initialize) { }
+    end
+
+    def configure *args
+      result = self
+      temp_v = $-v
+      $-v = nil
+      begin
+        run_callbacks :configure do
+          result = super(*args)
         end
+      ensure
+        $-v = temp_v
       end
+      Dor::WorkflowService.configure result.workflow.url, :dor_services_url => result.dor_services.url
+      return result
+    end
+
+    def autoconfigure(url, cert_file=Config.ssl.cert_file, key_file=Config.ssl.key_file, key_pass=Config.ssl.key_pass)
+      client = make_rest_client(url, cert_file, key_file, key_pass)
+      config = Confstruct::Configuration.symbolize_hash JSON.parse(client.get :accept => 'application/json')
+      self.configure(config)
+    end
+
+    def sanitize
+      self.dup
+    end
+
+    def make_rest_client(url, cert=Config.ssl.cert_file, key=Config.ssl.key_file, pass=Config.ssl.key_pass)
+      params = {}
+      params[:ssl_client_cert] = OpenSSL::X509::Certificate.new(File.read(cert)) if cert
+      params[:ssl_client_key]  = OpenSSL::PKey::RSA.new(File.read(key), pass) if key
+      RestClient::Resource.new(url, params)
+    end
+
+    def make_solr_connection(add_opts={})
+      opts = Config.solrizer.opts.merge(add_opts).merge(
+        :url => Config.solrizer.url
+      )
+      ::RSolr::Ext.connect(opts)
+    end
+
+    set_callback :initialize, :after do |config|
+      config.deep_merge!({
+        :fedora => {
+          :client => Confstruct.deferred { |c| config.make_rest_client c.url },
+          :safeurl => Confstruct.deferred { |c|
+            begin
+              fedora_uri = URI.parse(config.fedora.url)
+              fedora_uri.user = fedora_uri.password = nil
+              fedora_uri.to_s
+            rescue URI::InvalidURIError
+              nil
+            end
+          }
+        },
+        :sdr => {
+          :rest_client => Confstruct.deferred { |c| config.make_rest_client c.url },
+        },
+        :gsearch => {
+          :rest_client => Confstruct.deferred { |c| config.make_rest_client c.rest_url },
+          :client => Confstruct.deferred { |c| config.make_rest_client c.url }
+        },
+        :stomp => {
+          :connection => Confstruct.deferred { |c| Stomp::Connection.new c.user, c.password, c.host, c.port, true, 5, { 'client-id' => c.client_id }},
+          :client => Confstruct.deferred { |c| Stomp::Client.new c.user, c.password, c.host, c.port }
+        }
+      })
+      true
+    end
+
+    set_callback :configure, :after do |config|
+      config[:stomp][:host] ||= URI.parse(config.fedora.url).host rescue nil
 
-      config_changed do |fedora|
-        fedora_uri = URI.parse(fedora.url)
-        fedora_uri.user = fedora_uri.password = nil
-        fedora.safeurl fedora_uri.to_s
-        
-        temp_v = $-v
-        $-v = nil
-        begin
-         ::ENABLE_SOLR_UPDATES = false
-         ::Fedora::Repository.register(fedora.url)
-         ::Fedora::Connection.const_set(:SSL_CLIENT_CERT_FILE,fedora.cert_file)
-         ::Fedora::Connection.const_set(:SSL_CLIENT_KEY_FILE,fedora.key_file)
-         ::Fedora::Connection.const_set(:SSL_CLIENT_KEY_PASS,fedora.key_pass)
-        ensure
-         $-v = temp_v
+      [:cert_file, :key_file, :key_pass].each do |key|
+        stack = caller.dup
+        stack.shift while stack[0] =~ %r{(active_support/callbacks|dor/config|dor-services)\.rb}
+        if config.fedora[key].present?
+          ActiveSupport::Deprecation.warn "Dor::Config -- fedora.#{key.to_s} is deprecated. Please use ssl.#{key.to_s} instead.", stack
+          config.ssl[key] = config.fedora[key] unless config.ssl[key].present?
+          config.fedora.delete(key)
         end
       end
+
+      if ActiveFedora.respond_to?(:configurator)
+        if config.solrizer.url.present?
+          ActiveFedora::SolrService.register
+          ActiveFedora::SolrService.instance.instance_variable_set :@conn, self.make_solr_connection
+        end
+      else
+        ActiveFedora::RubydoraConnection.connect self.fedora_config if self.fedora.url.present?
+        if self.solrizer.url.present?
+          ActiveFedora::SolrService.register config.solrizer.url, config.solrizer.opts
+          conn = ActiveFedora::SolrService.instance.conn.connection
+          if config.ssl.cert_file.present?
+            conn.use_ssl = true
+            conn.cert = OpenSSL::X509::Certificate.new(File.read(config.ssl.cert_file))
+            conn.key = OpenSSL::PKey::RSA.new(File.read(config.ssl.key_file),config.ssl.key_pass) if config.ssl.key_file.present?
+            conn.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+        end
+        ActiveFedora.init
+        ActiveFedora.fedora_config_path = File.expand_path('../../../config/dummy.yml', __FILE__)
+      end
+    end
+
+    # Act like an ActiveFedora.configurator
+
+    def init *args; end
+
+    def fedora_config
+      fedora_uri = URI.parse(self.fedora.url)
+      connection_opts = { :url => self.fedora.safeurl, :user => fedora_uri.user, :password => fedora_uri.password }
+      connection_opts[:ssl_client_cert] = OpenSSL::X509::Certificate.new(File.read(self.ssl.cert_file)) if self.ssl.cert_file.present?
+      connection_opts[:ssl_client_key] = OpenSSL::PKey::RSA.new(File.read(self.ssl.key_file),self.ssl.key_pass) if self.ssl.key_file.present?
+      connection_opts
+    end
+
+    def solr_config
+      { :url => self.solrizer.url }
+    end
+
+    def predicate_config
+      YAML.load(File.read(File.expand_path('../../../config/predicate_mappings.yml',__FILE__)))
     end
   end
-    
-end
 
+  Config = Configuration.new(YAML.load(File.read(File.expand_path('../../../config/config_defaults.yml', __FILE__))))
+  ActiveFedora.configurator = Config if ActiveFedora.respond_to?(:configurator)
+end

data/lib/dor/datastreams/administrative_metadata_ds.rb

@@ -0,0 +1,84 @@
+module Dor
+class AdministrativeMetadataDS < ActiveFedora::OmDatastream 
+
+  set_terminology do |t|
+    t.root :path => 'administrativeMetadata', :index_as => [:not_searchable]
+    t.metadata_format :path => 'descMetadata/format'
+    t.metadata_source :path => 'descMetadata/source'
+    t.descMetadata do
+      t.source
+      t.format
+    end
+    # Placeholders for existing defined stanzas to be fleshed out as needed
+    t.contact :index_as => [:not_searchable]
+    t.rights :index_as => [:not_searchable]
+    t.relationships :index_as => [:not_searchable]
+    t.registration :index_as => [:not_searchable] do
+      t.agreementId
+      t.itemTag
+      t.workflow_id :path => 'workflow/@id', :index_as => [:facetable]
+      t.default_collection :path => 'collection/@id', :index_as => [:facetable]
+    end
+    t.workflow :path => 'registration/workflow'
+    t.deposit :index_as => [:not_searchable]
+    
+    t.accessioning :index_as => [:not_searchable] do
+      t.workflow_id :path => 'workflow/@id', :index_as => [:facetable]
+    end
+
+    t.preservation :index_as => [:not_searchable]
+    t.dissemination :index_as => [:not_searchable] do
+      t.harvester
+      t.releaseDelayLimit
+    end
+  end
+  define_template :default_collection do |xml|
+  xml.administrativeMetadata{
+    xml.registration{
+      xml.collection(:id => '')
+    }
+  }
+  end
+  define_template :agreementId do |xml|
+    xml.administrativeMetadata {
+      xml.registration{
+        xml.agreementId
+      }
+    }
+  end
+  define_template :metadata_format do |xml|
+     xml.descMetadata{
+       xml.format
+     }
+  
+   end
+   define_template :metadata_source do |xml|
+      xml.administrativeMetadata{
+      xml.descMetadata{
+       xml.source
+       }
+     }
+  end
+   define_template :registration do |xml|
+      xml.administrativeMetadata {
+        xml.registration{
+          xml.workflow(:id=> '')
+        }
+      }
+    end
+    define_template :default_collection do |xml|
+        xml.administrativeMetadata {
+          xml.registration{
+            xml.collection
+        }
+        }
+      end
+      def self.xml_template
+        Nokogiri::XML::Builder.new do |xml|
+          xml.administrativeMetadata{
+          }
+        end.doc
+      end
+end
+
+end

data/lib/dor/datastreams/content_metadata_ds.rb

@@ -0,0 +1,337 @@
+module Dor
+  class ContentMetadataDS < ActiveFedora::OmDatastream 
+    include Upgradable
+    include SolrDocHelper
+
+    set_terminology do |t|
+      t.root :path => 'contentMetadata', :index_as => [:not_searchable]
+      t.contentType :path => '/contentMetadata/@type', :index_as => [:not_searchable]
+      t.resource(:index_as => [:not_searchable]) do
+        t.id_ :path => { :attribute => 'id' }
+        t.sequence :path => { :attribute => 'sequence' }#, :data_type => :integer
+        t.type_ :path => { :attribute => 'type' }, :index_as => [:displayable]
+        t.attribute(:path => 'attr', :index_as => [:not_searchable]) do
+          t.name :path => { :attribute => 'name' }, :index_as => [:not_searchable]
+        end
+        t.file(:index_as => [:not_searchable]) do
+          t.id_ :path => { :attribute => 'id' }
+          t.mimeType :path => { :attribute => 'mimeType' }, :index_as => [:displayable]
+          t.dataType :path => { :attribute => 'dataType' }, :index_as => [:displayable]
+          t.size :path => { :attribute => 'size' }, :index_as => [:displayable]#, :data_type => :long
+          t.shelve :path => { :attribute => 'shelve' }, :index_as => [:not_searchable]#, :data_type => :boolean
+          t.publish :path => { :attribute => 'publish' }, :index_as => [:not_searchable]#, :data_type => :boolean
+          t.preserve :path => { :attribute => 'preserve' }, :index_as => [:not_searchable]#, :data_type => :boolean
+          t.checksum do
+            t.type_ :path => { :attribute => 'type' }
+          end
+        end
+        t.shelved_file(:path => 'file', :attributes => {:shelve=>'yes'}, :index_as => [:not_searchable]) do
+          t.id_ :path => { :attribute => 'id' }, :index_as => [:displayable, :searchable]
+        end
+      end
+      t.shelved_file_id :proxy => [:resource, :shelved_file, :id], :index_as => [:displayable, :searchable]
+    end
+
+    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
+    def add_file(file, resource_name)
+      xml=self.ng_xml
+      resource_nodes = xml.search('//resource[@id=\''+resource_name+'\']')
+      if resource_nodes.length==0
+        raise 'resource doesnt exist.'
+      end
+      node=resource_nodes.first
+      file_node=Nokogiri::XML::Node.new('file',xml)
+      file_node['id']=file[:name]
+      file_node['shelve']=file[:shelve] ? file[:shelve] : ''
+      file_node['publish']=file[:publish] ? file[:publish] : ''
+      file_node['preserve']=file[:preserve] ? file[:preserve] : ''
+      node.add_child(file_node)
+
+      if file[:md5]
+        checksum_node=Nokogiri::XML::Node.new('checksum',xml)
+        checksum_node['type']='md5'
+        checksum_node.content=file[:md5]
+        file_node.add_child(checksum_node)
+      end
+      if file[:sha1]
+        checksum_node=Nokogiri::XML::Node.new('checksum',xml)
+        checksum_node['type']='sha1'
+        checksum_node.content=file[:sha1]
+        file_node.add_child(checksum_node)
+      end
+      if file[:size]
+        file_node['size']=file[:size]
+      end
+      if file[:mime_type]
+        file_node['mimetype']=file[:mime_type]
+      end
+      self.content=xml.to_s
+      self.save
+    end
+
+    def add_resource(files,resource_name, position,type="file") 
+      xml=self.ng_xml
+      if xml.search('//resource[@id=\''+resource_name+'\']').length>0
+        raise 'resource '+resource_name+' already exists'
+      end
+      node=nil
+
+      max=-1
+      xml.search('//resource').each do |node|
+        if node['sequence'].to_i>max
+          max=node['sequence'].to_i
+        end
+      end
+      #renumber all of the resources that will come after the newly added one
+      while max>position do
+        node=xml.search('//resource[@sequence=\'' + position + '\']')
+        if node.length>0
+          node=node.first
+          node[sequence]=max+1
+        end
+        max=max-1
+      end
+      node=Nokogiri::XML::Node.new('resource',xml)
+      node['sequence']=position.to_s
+      node['id']=resource_name
+      node['type']=type
+      files.each do |file|
+        file_node=Nokogiri::XML::Node.new('file',xml)
+        file_node['shelve']=file[:shelve] ? file[:shelve] : ''
+        file_node['publish']=file[:publish] ? file[:publish] : ''
+        file_node['preserve']=file[:preserve] ? file[:preserve] : ''
+        file_node['id']=file[:name]
+        node.add_child(file_node)
+
+        if not file[:md5].nil?
+          checksum_node=Nokogiri::XML::Node.new('checksum',xml)
+          checksum_node['type']='md5'
+          checksum_node.content=file[:md5]
+          file_node.add_child(checksum_node)
+        end
+        if not file[:sha1].nil?
+          checksum_node=Nokogiri::XML::Node.new('checksum',xml)
+          checksum_node['type']='sha1'
+          checksum_node.content=file[:sha1]
+          file_node.add_child(checksum_node)
+        end
+        if file[:size]
+          file_node['size']=file[:size]
+        end
+      end    
+      xml.search('//contentMetadata').first.add_child(node)
+      self.content=xml.to_s
+      self.save
+    end
+
+    def remove_resource resource_name
+      xml=self.ng_xml
+      position=-1
+
+      resources=xml.search('//resource[@id=\''+resource_name+'\']')
+      if resources.length!=1
+        raise 'Resource is missing or duplicated!'
+      end
+      position=resources.first['sequence']
+      resources.first.remove
+      position=position.to_i+1
+      while true
+        res=xml.search('//resource[@sequence=\''+position.to_s+'\']')
+        if(res.length==0)
+          break
+        end
+        res['sequence']=position.to_s
+        position=position+1
+      end
+      self.content=xml.to_s
+      self.save
+    end
+
+    def remove_file file_name
+      xml=self.ng_xml
+      xml.search('//file[@id=\''+file_name+'\']').each do |node|
+        node.remove
+      end
+      self.content=xml.to_s
+      self.save
+    end
+    def update_attributes file_name, publish, shelve, preserve
+      xml=self.ng_xml
+      file_node=xml.search('//file[@id=\''+file_name+'\']').first
+      file_node['shelve']=shelve
+      file_node['publish']=publish
+      file_node['preserve']=preserve
+      self.content=xml.to_s
+      self.save
+    end
+    def update_file file, old_file_id
+      xml=self.ng_xml
+      file_node=xml.search('//file[@id=\''+old_file_id+'\']').first
+      file_node['id']=file[:name]
+      if not file[:md5].nil?
+        checksum_node=xml.search('//file[@id=\''+old_file_id+'\']/checksum[@type=\'md5\']').first
+        if checksum_node.nil?
+          checksum_node=Nokogiri::XML::Node.new('checksum',xml)
+          file_node.add_child(checksum_node)
+        end
+        checksum_node['type']='md5'
+        checksum_node.content=file[:md5]
+      end
+      if not file[:sha1].nil?
+        checksum_node=xml.search('//file[@id=\''+old_file_id+'\']/checksum[@type=\'sha1\']').first
+        if checksum_node.nil?
+          checksum_node=Nokogiri::XML::Node.new('checksum',xml)
+          file_node.add_child(checksum_node)
+        end
+        checksum_node['type']='sha1'
+        checksum_node.content=file[:sha1]
+      end
+      if file[:size]
+        file_node['size']=file[:size]
+      end
+      if file[:shelve]
+        file_node['shelve']=file[:shelve]
+      end
+      if file[:preserve]
+        file_node['preserve']=file[:preserve]
+      end
+      if file[:publish]
+        file_node['publish']=file[:publish]
+      end
+      self.content=xml.to_s
+      self.save
+    end
+    # Terminology-based solrization is going to be painfully slow for large
+    # contentMetadata streams. Just select the relevant elements instead.
+    def to_solr(solr_doc=Hash.new, *args)
+      doc = self.ng_xml
+      if doc.root['type']
+        shelved_file_count=0
+        content_file_count=0
+        resource_type_counts={}
+        resource_count=0
+        preserved_size=0
+        first_shelved_image=nil
+        add_solr_value(solr_doc, "content_type", doc.root['type'], :string, [:facetable])
+        doc.xpath('contentMetadata/resource').sort { |a,b| a['sequence'].to_i <=> b['sequence'].to_i }.each do |resource|
+          resource_count+=1
+          if(resource['type'])
+            if resource_type_counts[resource['type']]
+              resource_type_counts[resource['type']]+=1        	
+            else
+              resource_type_counts[resource['type']]=1
+            end
+          end
+          resource.xpath('file').each do |file|
+            content_file_count+=1
+            if file['shelve'] == 'yes'
+              shelved_file_count+=1
+              if first_shelved_image.nil? and file['id'].match(/jp2$/)
+                first_shelved_image=file['id']
+              end
+            end
+            if file['preserve'] == 'yes'
+              preserved_size += file['size'].to_i
+            end
+          end
+        end
+        add_solr_value(solr_doc, "content_file_count", content_file_count.to_s, :string, [:searchable, :displayable])
+        add_solr_value(solr_doc, "shelved_content_file_count", shelved_file_count.to_s, :string, [:searchable, :displayable])
+        add_solr_value(solr_doc, "resource_count", resource_count.to_s, :string, [:searchable, :displayable])
+        add_solr_value(solr_doc, "preserved_size", preserved_size.to_s, :string, [:searchable, :displayable])
+        resource_type_counts.each do |key, count|
+          add_solr_value(solr_doc, key+"_resource_count", count.to_s, :string, [:searchable, :displayable])
+        end
+        if not first_shelved_image.nil?
+          add_solr_value(solr_doc, "first_shelved_image", first_shelved_image, :string, [:displayable])
+        end
+      end
+      solr_doc
+    end
+    def rename_file old_name, new_name
+      xml=self.ng_xml
+      file_node=xml.search('//file[@id=\''+old_name+'\']').first
+      file_node['id']=new_name
+      self.content=xml.to_s
+      self.save
+    end
+
+    def update_resource_label resource_name, new_label
+      xml=self.ng_xml
+      resource_node=xml.search('//resource[@id=\''+resource_name+'\']')
+      if(resource_node.length!=1)
+        raise 'Resource not found or duplicate found.'
+      end
+      labels=xml.search('//resource[@id=\''+resource_name+'\']/label')
+      if(labels.length==0)
+        #create a label
+        label_node = Nokogiri::XML::Node.new('label',xml)
+        label_node.content=new_label
+        resource_node.first.add_child(label_node)
+      else
+        labels.first.content=new_label
+      end
+    end
+    def update_resource_type resource, new_type
+      xml=self.ng_xml
+      resource_node=xml.search('//resource[@id=\''+resource_name+'\']')
+      if(resource_node.length!=1)
+        raise 'Resource not found or duplicate found.'
+      end
+      resource_node.first['type']=new_type
+    end
+
+    def move_resource resource_name, new_position
+      xml=self.ng_xml
+      file_node=xml.search('//resource[@id=\''+resource_name+'\']')
+      if(file_node.length!=1)
+        raise 'Resource not found or duplicate found.'
+      end
+      position=file_node.first['sequence'].to_i
+      #is the resource being moved earlier in the sequence or later?
+      new_position=new_position.to_i
+      if new_position>position
+        counter=position
+        while true
+          if counter == position
+            break
+          end
+          item=xml.search('/resource[@id=\''+counter.to_s+'\']').first
+          counter=counter+1
+          item['sequence']=counter.to_s
+        end
+      else
+        counter=position
+        while true
+          if counter == new_position
+            break
+          end
+          item=xml.search('/resource[@id=\''+counter.to_s+'\']').first
+          counter=counter-1
+          item['sequence']=counter.to_s
+        end
+      end
+    end
+    #Set the content type to and the resource types for all resources
+    #@param type [String] the new content type, ex book
+    #@param resource_type [String] the new type for all resources, ex book
+    def set_content_type old_type, old_resource_type, new_type, new_resource_type
+      xml=self.ng_xml
+      xml.search('/contentMetadata[@type=\''+old_type+'\']').each do |node|
+        node['type']=new_type
+        xml.search('//resource[@type=\''+old_resource_type+'\']').each do |resource|
+          resource['type']=new_resource_type
+        end
+      end
+      self.content=xml.to_s
+    end
+  end
+
+end