CCHIT-xds-facade 0.1.1

data/lib/mime/mime_message_parser.rb

@@ -0,0 +1,52 @@
+module MIME
+  # The constructor for MimeTokenStream that takes a MimeEntityConfig is
+  # protected. We need to pass in a new config becuse the default one
+  # has a max line length of 1000. Since we will be getting SOAP repsonses
+  # with out new lines, we will easily exceed that. This class produces
+  # a MimeTokenStream with a longer max line length
+  class FixedMimeTokenStream < org.apache.james.mime4j.parser.MimeTokenStream
+    def initialize()
+      config = MimeEntityConfig.new
+      config.max_line_len = 4096
+      super(config)
+    end
+  end
+  
+  class MimeMessageParser
+    
+    # Parses a mime message and returns an array of hashes for each part of the message
+    # The hash will contain the following:
+    # * <tt>:content_type</tt> - The content type of the message part
+    # * <tt>:content_id</tt> - The id of the content (useful for dealing with MTOM/XOP)
+    # * <tt>:content</tt> - The actual content of the message as a String
+    def self.parse(input_stream, content_type)
+      parts = []
+      mts = FixedMimeTokenStream.new()
+      mts.parse_headless(input_stream, content_type)
+      current_message = {}
+      until(mts.state == MimeTokenStream::T_END_OF_STREAM)
+        case mts.state
+        when MimeTokenStream::T_FIELD
+          if mts.field_name.eql?('Content-Type')
+            current_message[:content_type] = mts.field_value.strip
+          end
+          if mts.field_name.eql?('Content-ID')
+            current_message[:content_id] = mts.field_value.strip
+          end
+        when MimeTokenStream::T_BODY
+          reader = java.io.LineNumberReader.new(mts.reader)
+          content = ''
+          while (line = reader.readLine)
+            content << line
+            content << "\n"
+          end
+          current_message[:content] = content
+          parts << current_message
+          current_message = {}
+        end
+        mts.next
+      end
+      parts
+    end
+  end
+end

data/lib/xds-facade.rb

@@ -0,0 +1,77 @@
+if RUBY_PLATFORM =~ /java/
+  require 'rubygems'
+  require 'builder'
+  require 'uuid'
+  require 'java'
+  require 'activesupport'
+  require 'rexml/document'
+  
+  require File.expand_path(File.dirname(__FILE__) + '/commons-codec-1.3.jar')
+  require File.expand_path(File.dirname(__FILE__) + '/commons-logging-1.1.1.jar')
+  require File.expand_path(File.dirname(__FILE__) + '/commons-httpclient-3.1.jar')
+  require File.expand_path(File.dirname(__FILE__) + '/apache-mime4j-0.5.jar')
+  
+  import "org.apache.commons.httpclient.HttpClient"
+  import "org.apache.commons.httpclient.methods.PostMethod"
+  import "org.apache.commons.httpclient.methods.StringRequestEntity"
+  import "org.apache.commons.httpclient.methods.multipart.MultipartRequestEntity"
+  import "org.apache.commons.httpclient.methods.multipart.Part"
+  import "org.apache.commons.httpclient.methods.multipart.StringPart"
+  import "org.apache.commons.httpclient.methods.multipart.FilePart"
+  import "org.apache.james.mime4j.parser.MimeTokenStream"
+  import "org.apache.james.mime4j.parser.MimeEntityConfig"
+  import "org.apache.commons.httpclient.util.EncodingUtil"
+  
+  require File.expand_path(File.dirname(__FILE__) + '/mime/mime_message_parser')
+
+  require File.expand_path(File.dirname(__FILE__) + '/xds/helper')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/xds_header')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/xds_request')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/mtom_xop_request')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/author')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/coded_attribute')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/metadata')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/source_patient_info')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/xds_part')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/xds_request_entity')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/provide_and_register_document_set_b')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/provide_and_register_document_set_b_xop')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/provide_and_register_document_set_b_xop_response')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/retrieve_document_set_request')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/retrieve_document_set_response')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/registry_stored_query_request')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/registry_stored_query_response')
+  require File.expand_path(File.dirname(__FILE__) + '/xds/affinity_domain_config')
+  
+else
+  warn "xds-facade is only for use with JRuby"
+end
+
+module XDS
+  COMMON_NAMESPACES = {'xdsb' => "urn:ihe:iti:xds-b:2007", 
+                       'soapenv' =>"http://www.w3.org/2003/05/soap-envelope",
+                       'wsa' => "http://www.w3.org/2005/08/addressing",
+                       'rs' => "urn:oasis:names:tc:ebxml-regrep:xsd:rs:3.0",
+                       'xop' => "http://www.w3.org/2004/08/xop/include",
+                       'query' => "urn:oasis:names:tc:ebxml-regrep:xsd:query:3.0",
+                       'rim' => 'urn:oasis:names:tc:ebxml-regrep:xsd:rim:3.0'}
+
+    
+ PROXY_CONFIG = begin
+     proxy_config = {}
+     host = ENV['xds_proxy'] || ENV['http_proxy']
+     if host
+         host.try(:gsub!, "http://", "")
+         host.try(:gsub!, "https://", "")
+     end
+     if host 
+        host = host.split(":")
+        proxy_config = {:host=>host[0],:port=>(host.length>1)?host[1].to_i : 80}        
+     end
+      proxy_config
+    end                       
+          
+  def self.proxy_config    
+       XDS::PROXY_CONFIG 
+  end                     
+end

data/lib/xds/affinity_domain_config.rb

@@ -0,0 +1,42 @@
+module XDS
+  class AffinityDomainConfig
+    CODE_TYPE_NAME_TO_CODED_ATTRIBUTE = {
+      'classCode' => :class_code,
+      'confidentialityCode' => :confidentiality_code,
+      'formatCode' => :format_code,
+      'healthcareFacilityTypeCode' => :healthcare_facility_type_code,
+      'practiceSettingCode' => :practice_setting_code,
+      'typeCode' => :type_code
+    }
+    
+    def initialize(config_file)
+      config_doc = REXML::Document.new(File.new(config_file, 'r'))
+      @code_types = {}
+      config_doc.root.elements.each('CodeType') do |code_type|
+        code_type_name = code_type.attributes['name']
+        if CODE_TYPE_NAME_TO_CODED_ATTRIBUTE[code_type_name]
+          attribute_type = CODE_TYPE_NAME_TO_CODED_ATTRIBUTE[code_type_name]
+          @code_types[attribute_type] = [] unless @code_types[attribute_type]
+          code_type.elements.each('Code') do |code|
+            code_value = code.attributes['code']
+            display_name = code.attributes['display']
+            coding_scheme = code.attributes['codingScheme']
+            @code_types[attribute_type] << CodedAttribute.new(attribute_type, code_value, display_name, coding_scheme)
+          end
+        end
+      end
+    end
+    
+    def coded_attribute(attribute_type, code)
+      if @code_types[attribute_type]
+        @code_types[attribute_type].find() {|ca| ca.code.eql?(code)}
+      end
+    end
+    
+    def select_options(attribute_type)
+      if @code_types[attribute_type]
+        @code_types[attribute_type].map {|ca| [ca.display_name, ca.code]}
+      end
+    end
+  end
+end

data/lib/xds/author.rb

@@ -0,0 +1,33 @@
+module XDS
+  class Author
+    include XDS::Helper
+    CLASSIFICATION_SCHEME = 'urn:uuid:93606bcf-9494-43ec-9b4e-a7748d1a838d'
+    
+    attr_accessor :institution, :person, :role, :specialty
+    
+    def initialize(institution="",person="", role="",specialty="")
+        @institution = institution
+        @person = person
+        @role=role
+        @specialty=specialty
+    end
+    
+    def to_soap(builder, object_id)
+      create_classification(builder,CLASSIFICATION_SCHEME,object_id,"") do |build|
+        create_slot(builder,'authorInstitution', [@institution])
+        create_slot(builder,'authorPerson', @person)
+        create_slot(builder,'authorRole', @role)
+        create_slot(builder,'authorSpecialty', @specialty)
+      end
+    end
+    
+    def from_extrinsic_object(eo_node)
+      with_classification(eo_node, CLASSIFICATION_SCHEME) do |classification|
+        @institution = get_slot_value(classification, 'authorInstitution')
+        @person = get_slot_value(classification, 'authorPerson')
+        @role = get_slot_value(classification, 'authorRole')
+        @specialty = get_slot_value(classification, 'authorSpecialty')
+      end
+    end
+  end
+end

data/lib/xds/coded_attribute.rb

@@ -0,0 +1,44 @@
+module XDS
+  class CodedAttribute
+    include XDS::Helper
+    attr_reader :classification_scheme, :code, :display_name, :coding_scheme
+  
+    def initialize(attribute_type, code = nil, display_name = nil, coding_scheme = nil)
+      case attribute_type
+      when :class_code
+        @classification_scheme = 'urn:uuid:41a5887f-8865-4c09-adf7-e362475b143a'
+      when :confidentiality_code
+        @classification_scheme = 'urn:uuid:f4f85eac-e6cb-4883-b524-f2705394840f'
+      when :format_code
+        @classification_scheme = 'urn:uuid:a09d5840-386c-46f2-b5ad-9c3699a4309d'
+      when :healthcare_facility_type_code
+        @classification_scheme = 'urn:uuid:f33fb8ac-18af-42cc-ae0e-ed0b0bdb91e1'
+      when :practice_setting_code
+        @classification_scheme = 'urn:uuid:cccf5598-8b07-4b77-a05e-ae952c785ead'
+      when :type_code
+        @classification_scheme = 'urn:uuid:f0306f51-975f-434e-a61c-c59651d33983'
+      end
+      @code = code
+      @display_name = display_name
+      @coding_scheme=coding_scheme
+    end
+    
+    def to_soap(builder, object_id)      
+      create_classification(builder,@classification_scheme,object_id,@code) do |build|
+        create_slot(build,"codingScheme",@coding_scheme || [])
+        create_name(build,@display_name)        
+      end
+    end
+    
+    def from_extrinsic_object(eo_node)
+      with_classification(eo_node, @classification_scheme) do |classification|
+        @code = classification.attributes['nodeRepresentation']
+        localized_string_node = REXML::XPath.first(classification, 'rim:Name/rim:LocalizedString')
+        if localized_string_node
+          @display_name = localized_string_node.attributes['value']
+        end
+        @coding_scheme = get_slot_value(classification, 'codingScheme')
+      end
+    end
+  end  
+end

data/lib/xds/document_registry_service.rb

@@ -0,0 +1,26 @@
+# Provides an interface to an XDS Document Registry
+class DocumentRegistry
+  
+  
+  def initialize(service_url)
+    @service_url = service_url
+  end
+  
+  def register_document_set_b
+  
+  end
+  
+  # Issues a stored query request to the XDS Document Registry
+  # Will return an Array of XDS::Metadata
+  # <tt>query</tt> - a Hash where the key is the parameter name and value is the value to query against
+  # call-seq:
+  # dr = DocumentRegistry.new(http://yourregistry.com/xdsb)
+  # dr.registery_stored_query({"$XDSDocumentEntryPatientId" => "'93f3f8a6d100463^^^&1.3.6.1.4.1.21367.2005.3.7&ISO'",
+  #                            "$XDSDocumentEntryStatus" => "('urn:oasis:names:tc:ebxml-regrep:StatusType:Approved')"})
+  def registery_stored_query(query)
+    rsqr = XDS::RegistryStoredQueryRequest.new(@service_url, query)
+    rsqr.retrieved_metadata
+  end
+  
+  
+end

data/lib/xds/document_repository_service.rb

@@ -0,0 +1,27 @@
+class DocumentRepositoryService
+  
+  def initialize(service_url, proxy_host = nil, proxy_port=nil)
+    @proxy_host = proxy_host
+    @proxy_port = proxy_port
+    @service_url = service_url
+  end
+  
+  
+  def register_document_set_b
+    
+  end
+    
+  def provide_and_register
+    
+  end
+  
+  
+  def create_retrieve_document_set_request(doc_ids=[])
+    rdr = RetrieveDocumentSetRequest.new(@service_url,doc_ids)
+    rdr.proxy_host = @proxy_host
+    rdr.proxy_port = @proxy_port
+    rdr
+  end
+  
+  
+end

data/lib/xds/helper.rb

@@ -0,0 +1,81 @@
+module XDS
+  module Helper
+    
+    
+    def create_extrinsic_object(builder,id,mime_type,object_type, &block)    
+      builder.ExtrinsicObject("id"=>id,"mimeType"=>mime_type,"objectType"=>object_type) do 
+        yield builder if block_given?
+      end
+    end
+    
+    def create_external_identifier(builder,id,reg_object,scheme, value, &block)
+      
+      builder.ExternalIdentifier("id"=>id,"registryObject"=>reg_object,"identificationScheme"=>scheme,"value"=>value) do
+        yield builder if block_given?
+      end
+    end
+    
+    def create_name(builder,name,&block)
+      builder.Name do
+       create_localized_string(builder,name)
+        yield builder if block_given?
+      end
+    end
+    
+    def create_localized_string(builder,value)
+       builder.LocalizedString("value"=>value)
+    end
+    
+    def create_slot(builder, name, value_list=[])
+      builder.Slot({"name"=>name}) do
+        builder.ValueList do
+          value_list.each do |val|
+            builder.Value(val)
+          end
+        end
+      end
+    end
+    
+    def create_classification(builder,scheme, classified_object,node_rep ,id=UUID.new.generate,&block)
+      builder.Classification("classificationScheme"=>scheme, 
+                             "classifiedObject"=>classified_object,
+                             "nodeRepresentation"=>node_rep,
+                             "id"=>id) do
+                      
+          yield builder if block_given?
+      end
+    end
+    
+    def with_classification(eo_node, classification_scheme, &block)
+      if block_given?
+        classification = REXML::XPath.first(eo_node, "rim:Classification[@classificationScheme='#{classification_scheme}']", {'rim' => 'urn:oasis:names:tc:ebxml-regrep:xsd:rim:3.0'})
+        if classification
+          yield classification
+        end
+      end
+    end
+    
+    def get_slot_value(eo_node, slot_name)
+      value_node = REXML::XPath.first(eo_node, "rim:Slot[@name='#{slot_name}']/rim:ValueList/rim:Value", {'rim' => 'urn:oasis:names:tc:ebxml-regrep:xsd:rim:3.0'})
+      if value_node
+        return value_node.text
+      else
+        return nil
+      end
+    end
+    
+    def get_slot_values(eo_node, slot_name)
+      value_nodes = REXML::XPath.match(eo_node, "rim:Slot[@name='#{slot_name}']/rim:ValueList/rim:Value", {'rim' => 'urn:oasis:names:tc:ebxml-regrep:xsd:rim:3.0'})
+      if value_nodes
+        return value_nodes.map {|n| n.text}
+      else
+        return nil
+      end
+    end
+    
+    def get_external_identifier_value(eo_node, scheme)
+      ei_node = REXML::XPath.first(eo_node, "rim:ExternalIdentifier[@identificationScheme='#{scheme}']", {'rim' => 'urn:oasis:names:tc:ebxml-regrep:xsd:rim:3.0'})
+      ei_node.attributes['value'] if ei_node
+    end
+  end
+end

data/lib/xds/metadata.rb

@@ -0,0 +1,179 @@
+module XDS
+  class Metadata
+    
+    EXTERNAL_ID_SCHEMES={:patient_id=> {:scheme=>'urn:uuid:58a6f841-87b3-4a3e-92fd-a8ffeff98427',
+                                     :value=>'XDSDocumentEntry.patientId'},
+                         :unique_id=>{:scheme=>'urn:uuid:2e82c1f6-a085-4c72-9da3-8640a32e42ab',
+                                      :value=>'XDSDocumentEntry.uniqueId'}
+                         }
+    include XDS::Helper
+    
+    attr_accessor :author
+    attr_accessor :availability_status
+    attr_accessor :class_code
+    attr_accessor :confidentiality_code
+    attr_accessor :creation_time
+    attr_accessor :format_code
+    attr_accessor :healthcare_facility_type_code
+    attr_accessor :language_code
+    attr_accessor :mime_type
+    attr_accessor :patient_id
+    attr_accessor :practice_setting_code
+    attr_accessor :service_start_time, :service_stop_time
+    attr_accessor :size
+    attr_accessor :source_patient_id
+    attr_accessor :source_patient_info
+    attr_accessor :type_code
+    attr_accessor :unique_id
+    attr_accessor :uri
+    attr_accessor :version_info
+    attr_accessor :id
+    attr_accessor :ss_unique_id
+    attr_accessor :source_id
+    attr_accessor :repository_unique_id
+    
+
+    def to_soap(builder)
+      @id="urn:uid:#{UUID.new.generate}" unless @id
+
+      builder.RegistryObjectList("xmlns"=>"urn:oasis:names:tc:ebxml-regrep:xsd:rim:3.0") do 
+         create_extrinsic_object(builder,@id,@mime_type,"urn:uuid:7edca82f-054d-47f2-a032-9b2a5b5186c1") do
+          
+          create_slot(builder,'languageCode', @language_code) if @language_code
+          create_slot(builder,'creationTime', @creation_time) if @creation_time
+          create_slot(builder,'serviceStartTime', @service_start_time) if @service_start_time     
+          create_slot(builder,'serviceStopTime', @service_stop_time)  if @service_stop_time
+
+          create_slot(builder,'sourcePatientId', @source_patient_id) if @source_patient_id
+          @source_patient_info.try(:to_soap, builder)
+          
+          @version_info.to_soap(builder) if @version_info
+          @author.try(:to_soap, builder, @id)       
+          @class_code.try(:to_soap, builder, @id) 
+          @confidentiality_code.try(:to_soap, builder, @id)     
+          @format_code.try(:to_soap, builder, @id) 
+          @healthcare_facility_type_code.try(:to_soap, builder, @id)         
+          
+          @practice_setting_code.try(:to_soap, builder, @id)
+          
+          @type_code.try(:to_soap, builder, @id)
+
+          external_identifier(builder,:patient_id)
+          external_identifier(builder,:unique_id)
+        end
+       
+        builder.RegistryPackage(:id=>"ss01",:objectType=>"urn:oasis:names:tc:ebxml-regrep:ObjectType:RegistryObject:RegistryPackage") do
+          create_slot(builder,"submissionTime",Time.now.strftime('%Y%m%d'))
+     
+          create_classification(builder,"urn:uuid:aa543740-bdda-424e-8c96-df4873be8500","ss01","Initial evaluation","cl01") do
+            create_slot(builder,"codingScheme","Connect-a-thon contentTypeCodes")
+            create_name(builder,"Initial evaluation")
+          end
+              
+          create_external_identifier(builder,"ss_ei_01","ss01","urn:uuid:96fdda7c-d067-4183-912e-bf5ee74998a8",ss_unique_id)  do |build|
+            create_name(builder,"XDSSubmissionSet.uniqueId")
+          end
+          
+          create_external_identifier(builder,"ss_ei_02","ss01","urn:uuid:554ac39e-e3fe-47fe-b233-965d2a147832",source_id)  do |build|
+            create_name(builder,"XDSSubmissionSet.sourceId")
+          end
+          
+          create_external_identifier(builder,"ss_ei_03","ss01","urn:uuid:58a6f841-87b3-4a3e-92fd-a8ffeff98427",@source_patient_info.source_patient_identifier)  do |build|
+            create_name(builder,"XDSDocumentEntry.patientId")
+          end
+          
+          create_external_identifier(builder,"ss_ei_04","ss01","urn:uuid:6b5aea1a-874d-4603-a4bc-96a0a7b38446",@source_patient_info.source_patient_identifier)  do |build|
+            create_name(builder,"XDSSubmissionSet.patientId")
+          end
+          
+          
+        end
+        builder.Classification(:id=>"ss01_class_id",:classificationScheme=>"urn:uuid:a54d6aa5-d40d-43f9-88c5-b4633d873bdd",:classificationNode=>"urn:uuid:a54d6aa5-d40d-43f9-88c5-b4633d873bdd",:classifiedObject=>"ss01")
+        
+        
+       builder.Association(:id=>"ass_01",:associationType=>"urn:oasis:names:tc:ebxml-regrep:AssociationType:HasMember",:sourceObject=>"ss01",:targetObject=>@id) do
+            create_slot(builder,"SubmissionSetStatus","Original")
+        end
+      end
+    end
+    
+    def load_from_extrinsic_object(eo_node)
+      @author = Author.new
+      @author.from_extrinsic_object(eo_node)
+      @availability_status = CodedAttribute.new(:availability_status)
+      @availability_status.from_extrinsic_object(eo_node)
+      @class_code = CodedAttribute.new(:class_code)
+      @class_code.from_extrinsic_object(eo_node)
+      @confidentiality_code = CodedAttribute.new(:confidentiality_code)
+      @confidentiality_code.from_extrinsic_object(eo_node)
+      
+      
+      @creation_time = get_slot_value(eo_node, 'creationTime')
+
+      @format_code = CodedAttribute.new(:format_code)
+      @format_code.from_extrinsic_object(eo_node)
+      @healthcare_facility_type_code = CodedAttribute.new(:healthcare_facility_type_code)
+      @healthcare_facility_type_code.from_extrinsic_object(eo_node)
+      @language_code = CodedAttribute.new(:language_code)
+      @language_code.from_extrinsic_object(eo_node)
+      
+      @mime_type = eo_node.attributes['mimeType']
+      
+      @patient_id = get_external_identifier_value(eo_node, EXTERNAL_ID_SCHEMES[:patient_id][:scheme])
+      
+      @practice_setting_code = CodedAttribute.new(:practice_setting_code)
+      @practice_setting_code.from_extrinsic_object(eo_node)
+      
+
+      @service_start_time = get_slot_value(eo_node, 'serviceStartTime')
+      @service_stop_time = get_slot_value(eo_node, 'serviceStopTime')
+
+      @source_patient_info = SourcePatientInfo.new
+      @source_patient_info.from_extrinsic_object(eo_node)
+      
+      @size = get_slot_value(eo_node, 'size')
+      @source_pateint_id = get_slot_value(eo_node, 'sourcePatientId')
+      @type_code = CodedAttribute.new(:type_code)
+      @type_code.from_extrinsic_object(eo_node)
+      @unique_id = get_external_identifier_value(eo_node, EXTERNAL_ID_SCHEMES[:unique_id][:scheme])
+      @uri = get_slot_value(eo_node, 'URI')
+      @repository_unique_id = get_slot_value(eo_node,"repositoryUniqueId")
+    end
+
+    def from_hash(hash, affinity_domain_config)
+      if hash['author']
+        @author = Author.new(hash['author']['institution'], hash['author']['person'], hash['author']['role'], hash['author']['specialty'])
+      end
+      @availibility_status = hash['availibility_status']
+      @class_code = affinity_domain_config.coded_attribute(:class_code, hash['class_code'])
+      @confidentiality_code = affinity_domain_config.coded_attribute(:confidentiality_code, hash['confidentiality_code'])
+      @creation_time = hash['creation_time']
+      @format_code = affinity_domain_config.coded_attribute(:format_code, hash['format_code'])
+      @healthcare_facility_type_code = affinity_domain_config.coded_attribute(:healthcare_facility_type_code, hash['healthcare_facility_type_code'])
+      @language_code = affinity_domain_config.coded_attribute(:language_code, hash['language_code'])
+      @mime_type = hash['mime_type']
+      @patient_id = hash['patient_id']
+      @practice_setting_code = affinity_domain_config.coded_attribute(:practice_setting_code, hash['practice_setting_code'])
+      @service_start_time = hash['service_start_time']
+      @service_stop_time = hash['service_stop_time']
+      @source_pateint_id = hash['source_pateint_id']
+      @source_patient_info = SourcePatientInfo.new(hash['source_patient_info']) if hash['source_patient_info']
+      @type_code = affinity_domain_config.coded_attribute(:type_code, hash['type_code'])
+      @unique_id = hash['unique_id']
+      @uri = hash['uri']
+      @version_info = hash['version_info']
+      @ss_unique_id = hash['ss_unique_id']
+      @source_id = hash['source_id']
+      @repository_unique_id = hash['repository_unique_id']
+    end
+
+    def external_identifier(builder,name)
+      ei_params = EXTERNAL_ID_SCHEMES[name]
+      if ei_params
+        create_external_identifier(builder,"urn:uid:#{UUID.new.generate}",@id,ei_params[:scheme],self.send(name))  do |build|
+          create_name(builder,ei_params[:value])
+        end
+      end
+    end
+ end
+end