CCHIT-xds-facade 0.1.1

data/lib/xds/mtom_xop_request.rb

@@ -0,0 +1,29 @@
+module XDS
+  class MTOMXopRequest < XdsRequest
+    
+    def execute
+        client = create_client
+        parts = get_parts.to_java(Part)         
+        post = PostMethod.new(endpoint_uri)
+
+        ent = XdsRequestEntity.new(parts, post.get_params)
+        ent.type="application/xop+xml"
+        ent.start=parts[0].id
+        ent.start_info="application/soap+xml"
+        ent.action=@header.action
+        
+        post.set_request_entity(ent)
+        post.content_chunked=true
+        client.executeMethod(post)
+        post      
+    end
+     
+       
+   def get_parts
+     raise "Impement me"
+   end
+    
+  end
+  
+  
+end

data/lib/xds/provide_and_register_document_set_b.rb

@@ -0,0 +1,29 @@
+require 'base64'
+module XDS
+  class ProvideAndRegisterDocumentSetB < XdsRequest
+
+  
+      def initialize(service_url,metadata,document)
+           super(service_url,"urn:ihe:iti:2007:ProvideAndRegisterDocumentSet-b")
+           @metadata = metadata
+           @document = document
+       end                    
+
+
+       def to_soap_body(builder, attributes={}) 
+       @metadata.id = "urn:uid:#{UUID.new.generate}" unless @metadata.id  
+       builder.soapenv(:Body, attributes) do
+         builder.xdsb(:ProvideAndRegisterDocumentSetRequest,"xmlns:lcm"=>"urn:oasis:names:tc:ebxml-regrep:xsd:lcm:3.0",
+                                                           "xmlns:rim"=>"urn:oasis:names:tc:ebxml-regrep:xsd:rim:3.0",
+                                                           "xmlns:xdsb"=>"urn:ihe:iti:xds-b:2007") do 
+             builder.lcm(:SubmitObjectsRequest) do
+               @metadata.to_soap(builder)
+             end
+
+             builder.xdsb(:Document, Base64.b64encode(@document),"id"=>@metadata.id)
+
+         end
+       end
+     end            
+  end
+end

data/lib/xds/provide_and_register_document_set_b_xop.rb

@@ -0,0 +1,58 @@
+module XDS
+  require 'base64'
+  class ProvideAndRegisterDocumentSetBXop < MTOMXopRequest
+  
+     def initialize(service_url,metadata,document)
+           super(service_url,"urn:ihe:iti:2007:ProvideAndRegisterDocumentSet-b")
+           @metadata = metadata
+           @document = document
+       end                    
+
+     
+       def to_soap_body(builder, attributes={}) 
+       @metadata.id = "urn:uid:#{UUID.new.generate}" unless @metadata.id  
+       builder.soapenv(:Body, attributes) do
+         builder.xdsb(:ProvideAndRegisterDocumentSetRequest,"xmlns:lcm"=>"urn:oasis:names:tc:ebxml-regrep:xsd:lcm:3.0",
+                                                           "xmlns:rim"=>"urn:oasis:names:tc:ebxml-regrep:xsd:rim:3.0",
+                                                           "xmlns:xdsb"=>"urn:ihe:iti:xds-b:2007") do 
+             builder.lcm(:SubmitObjectsRequest) do
+                 
+                 @metadata.to_soap(builder)
+               
+             end
+             builder.xdsb(:Document, {"id"=>@metadata.id}, Base64.b64encode(@document) ) 
+         end
+       end
+     end                 
+  
+     
+     
+    def execute
+        post = super
+        XDS::ProvideAndRegisterDocumentSetBXopResponse.new(self,post)     
+    end
+    
+    def get_parts
+      body_part =  XdsPart.new("body", to_soap)
+      body_part.char_set="UTF-8"
+      body_part.id = get_body_part_id
+      body_part.set_content_type(%{application/xop+xml; type="application/soap+xml"})
+      [body_part]
+      #document_part = XdsPart.new("document",@document.to_s)   
+     # document_part.char_set="UTF-8"
+     # document_part.id=get_document_part_id       
+     # [body_part,document_part]
+    end
+    
+    private 
+    
+     def get_document_part_id
+        @document_part_id ||= "urn:uid:#{UUID.new.generate}"
+     end
+      
+    def get_body_part_id
+      @body_part_id ||= "urn:uid:#{UUID.new.generate}"
+    end  
+  end
+  
+end

data/lib/xds/provide_and_register_document_set_b_xop_response.rb

@@ -0,0 +1,45 @@
+module XDS
+  class ProvideAndRegisterDocumentSetBXopResponse 
+    attr_accessor :parts
+    def initialize(request,post)
+      @request = request
+      @parts = MIME::MimeMessageParser.parse(post.get_response_body_as_stream, 
+                                              post.get_response_header("Content-Type").value)
+      parse_response                                        
+    end
+    
+    def status
+      @status
+    end
+    
+    def errors
+      @errors
+    end
+    
+    def success?
+      @status == "urn:oasis:names:tc:ebxml-regrep:ResponseStatusType:Success"
+    end
+    
+    def soap_resp
+      @soap_resp  
+    end
+    
+    private     
+    def parse_response
+      @soap_resp = @parts.first[:content]
+      @response_document = REXML::Document.new(soap_resp)
+      @response_element = REXML::XPath.first(@response_document,"/soapenv:Envelope/soapenv:Body/rs:RegistryResponse",COMMON_NAMESPACES)
+      @status=@response_element.attributes["status"]
+      @errors = REXML::XPath.match(@response_element,"./rs:RegistryErrorList/rs:RegistryError",COMMON_NAMESPACES).collect do |err|
+        {:code_context=>err.attributes["codeContext"],
+           :error_code=>err.attributes["errorCode"],
+           :severity=>err.attributes["severity"] , 
+           :location=>err.attributes["location"],  
+           :text=>err.text
+        }
+      end
+       @slot_list = REXML::XPath.first(@response_element,"/rs:ResponseSlotList",COMMON_NAMESPACES)
+    end
+    
+  end
+end

data/lib/xds/registry_stored_query_request.rb

@@ -0,0 +1,38 @@
+module XDS
+  class RegistryStoredQueryRequest < XdsRequest
+    include Helper
+    
+    def initialize(service_url, query)
+      super(service_url,"urn:ihe:iti:2007:RegistryStoredQuery")
+      @query = query
+    end
+    
+    def execute
+      post = super
+      rsqr = RegistryStoredQueryResponse.new
+      rsqr.parse_soap_response(post.response_body_as_string)
+      if rsqr.request_successful?
+        return rsqr.retrieved_metadata
+      else
+        return nil
+      end
+    end
+    
+    def to_soap_body(builder,body_attributes = {})
+      builder.soapenv(:Body, body_attributes) do
+        builder.query(:AdhocQueryRequest, 'xmlns:query' => "urn:oasis:names:tc:ebxml-regrep:xsd:query:3.0",
+                                          'xmlns:rs' => "urn:oasis:names:tc:ebxml-regrep:xsd:rs:3.0",
+                                          'xmlns' => "urn:oasis:names:tc:ebxml-regrep:xsd:rim:3.0") do
+          builder.query(:ResponseOption, 'returnComposedObjects' => "true", 'returnType' => "LeafClass")
+          # Currently hardcoded to FindDocuments
+          builder.AdhocQuery('id' => "urn:uuid:14d4debf-8f97-4251-9a74-a90016b0af0d") do
+            @query.each_pair do |slot_name, values|
+              packed_values = values.kind_of?(Array) ? values : [values]
+              create_slot(builder, slot_name, packed_values)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xds/registry_stored_query_response.rb

@@ -0,0 +1,31 @@
+module XDS
+  class RegistryStoredQueryResponse
+    attr_reader :retrieved_metadata
+    
+    def initialize
+      @retrieved_metadata = []
+      @request_successful = false
+    end
+    
+    def request_successful?
+      @request_successful
+    end
+    
+    def parse_soap_response(soap_xml)
+      doc = REXML::Document.new(StringIO.new(soap_xml))
+      status = REXML::XPath.first(doc, 
+                  '/soapenv:Envelope/soapenv:Body/query:AdhocQueryResponse/@status',
+                  COMMON_NAMESPACES)
+      if status.to_s.eql?('urn:oasis:names:tc:ebxml-regrep:ResponseStatusType:Success')
+        @request_successful = true
+        REXML::XPath.each(doc, 
+                    '/soapenv:Envelope/soapenv:Body/query:AdhocQueryResponse/rim:RegistryObjectList/rim:ExtrinsicObject',
+                    COMMON_NAMESPACES) do |eo|
+          metadata = Metadata.new
+          metadata.load_from_extrinsic_object(eo)
+          @retrieved_metadata << metadata
+        end
+      end
+    end
+  end
+end

data/lib/xds/retrieve_document_set_request.rb

@@ -0,0 +1,66 @@
+module XDS
+  class RetrieveDocumentSetRequest < MTOMXopRequest
+    
+    def initialize(service_url, doc_ids = [])
+      super(service_url,"urn:ihe:iti:2007:RetrieveDocumentSet")
+      @doc_ids = doc_ids
+    end
+    
+    def add_ids_to_request(repository_unique_id, document_unique_id)
+      @doc_ids << {:repository_unique_id => repository_unique_id,
+                   :document_unique_id => document_unique_id}
+    end
+    
+    # Returns an array of hashes, with a hash for each document returned.
+    # The hash will contain
+    # * <tt>:repository_unique_id</tt> - The Repository Unique Id for the document
+    # * <tt>:document_unique_id</tt> - The Document Unique Id for the document
+    # * <tt>:content</tt> - The document as a String
+    def execute
+      post = super
+      parts = MIME::MimeMessageParser.parse(post.get_response_body_as_stream, 
+                                            post.get_response_header("Content-Type").value)
+      rdsr = XDS::RetrieveDocumentSetResponse.new
+      rdsr.parse_soap_response(parts.first[:content])
+      if rdsr.request_successful?
+        docs = []
+        rdsr.retrieved_documents.each do |rd|
+          # hacky yes!, if rd has a content_id that means the response sent the document back as a separate entry in the multipart doc
+          # else it sent it back as a base64 encoded string that has already been parsed by the rd object and set in :content of the returned hash
+          part = rd[:content_id] ? parts.find {|candidate_part| candidate_part[:content_id].eql?('<' + rd[:content_id] + '>')} : rd
+          doc = {}
+          doc[:repository_unique_id] = rd[:repository_unique_id]
+          doc[:document_unique_id] = rd[:document_unique_id]
+          doc[:content] = part[:content]
+          docs << doc
+        end
+        
+        return docs
+      else
+        return false
+      end
+    end
+    
+    def get_parts
+     body_part =  XdsPart.new("body", to_soap)
+     body_part.char_set="UTF-8"
+     body_part.id = UUID.new.generate
+     body_part.set_content_type(%{application/xop+xml; type="application/soap+xml"})   
+     [body_part]
+    end
+    
+    
+    def to_soap_body(builder,body_attributes = {})
+      builder.soapenv(:Body, body_attributes) do
+        builder.RetrieveDocumentSetRequest('xmlns' => "urn:ihe:iti:xds-b:2007") do
+          @doc_ids.each do |doc_id|
+            builder.DocumentRequest do
+              builder.RepositoryUniqueId(doc_id[:repository_unique_id])
+              builder.DocumentUniqueId(doc_id[:document_unique_id])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xds/retrieve_document_set_response.rb

@@ -0,0 +1,41 @@
+module XDS
+  class RetrieveDocumentSetResponse
+    require 'base64'
+    attr_reader :retrieved_documents
+    
+    def initialize
+      @retrieved_documents = []
+      @request_successful = false
+    end
+    
+    def request_successful?
+      @request_successful
+    end
+    
+    def parse_soap_response(soap_xml)
+      doc = REXML::Document.new(StringIO.new(soap_xml))
+      status = REXML::XPath.first(doc, 
+                  '/soapenv:Envelope/soapenv:Body/xdsb:RetrieveDocumentSetResponse/rs:RegistryResponse/@status',
+                  COMMON_NAMESPACES)
+      if status.to_s.eql?('urn:oasis:names:tc:ebxml-regrep:ResponseStatusType:Success')
+        @request_successful = true
+        REXML::XPath.each(doc, 
+                    '/soapenv:Envelope/soapenv:Body/xdsb:RetrieveDocumentSetResponse/xdsb:DocumentResponse',
+                    COMMON_NAMESPACES) do |dr|
+          doc = {}
+          # need to check for include or whether the doc is just embedded in the soap message
+          inc = dr.elements['xdsb:Document/xop:Include']
+          #Nuke the 'cid:' from the front of the content id since it doesn't show up in the mime message headers
+          if inc
+           doc[:content_id] = dr.elements['xdsb:Document/xop:Include'].attributes['href'].to_s.sub('cid:', '') if dr.elements['xdsb:Document/xop:Include']
+          else
+           doc[:content] = Base64.decode64(dr.elements['xdsb:Document'].text)
+          end
+          doc[:repository_unique_id] = dr.elements['xdsb:RepositoryUniqueId'].text
+          doc[:document_unique_id] = dr.elements['xdsb:DocumentUniqueId'].text
+          @retrieved_documents << doc
+        end
+      end
+    end
+  end
+end

data/lib/xds/source_patient_info.rb

@@ -0,0 +1,52 @@
+module XDS
+  class SourcePatientInfo
+    include XDS::Helper
+    # These fields will need to be entered in HL7v2 format by the user
+    attr_accessor :source_patient_identifier, :name, :gender, :date_of_birth, :address
+  
+    def initialize(args={})
+        @source_patient_identifier = args[:source_patient_identifier] || ""
+        @name = args[:name] || ""
+        @gender = args[:gender] || ""
+        @date_of_birth = args[:date_of_birth] || ""
+        @address = args[:address]
+    end
+  
+    def to_soap(builder)         
+        create_slot(builder,"sourcePatientInfo",value_list)
+    end
+    
+    def from_extrinsic_object(eo_node)
+      patient_values = get_slot_values(eo_node, 'sourcePatientInfo')
+      @source_patient_identifier = match_and_strip(patient_values, 'PID-3')
+      @name = match_and_strip(patient_values, 'PID-5')
+      @gender = match_and_strip(patient_values, 'PID-8')
+      @date_of_birth = match_and_strip(patient_values, 'PID-7')
+      @address = match_and_strip(patient_values, 'PID-11')
+    end
+    
+    def value_list
+      ["PID-3|#{@source_patient_identifier}", 
+          "PID-5|#{@name}",
+          "PID-8|#{@gender}",
+          "PID-7|#{@date_of_birth}",
+          "PID-11|#{@address}"]
+          
+    end
+
+    def match_and_strip(slot_values, pid_segment)
+      slot_value = slot_values.find {|field_value| field_value.match("^#{pid_segment}\\|.*")}
+      if slot_value
+        md = slot_value.match("^#{pid_segment}\\|(.+)")
+        if md
+          return md[1]
+        else
+          return nil
+        end
+      else
+        return nil
+      end
+    end
+
+  end
+end

data/lib/xds/xds_header.rb

@@ -0,0 +1,26 @@
+module XDS
+  class XdsHeader 
+     def self.new_message_id()
+        "urn:uuid:#{UUID.new.generate}"      
+     end
+
+     attr_accessor :action
+     attr_accessor :endpoint_uri
+     @@namespace= {"xmlns" => "http://www.w3.org/2005/08/addressing"}
+     
+     def initialize(endpoint,action,message_id = XdsHeader.new_message_id)
+       @action = action
+       @endpoint_uri = endpoint
+       @message_id = message_id 
+     end
+     
+     def to_soap(builder)
+       builder.soapenv(:Header) do
+          builder.wsa(:To, @endpoint_uri)
+          builder.wsa(:Action, @action)
+          builder.wsa(:MessageID, @message_id) 
+       end
+     end
+     
+  end
+end

data/lib/xds/xds_part.rb

@@ -0,0 +1,44 @@
+module XDS
+  import "org.apache.commons.httpclient.util.EncodingUtil"
+  CRLF_BYTES = org.apache.commons.httpclient.util.EncodingUtil.getAsciiBytes("\r\n");
+
+  class XdsPart < org.apache.commons.httpclient.methods.multipart.StringPart
+    
+    attr_accessor :id
+    
+    def length
+      super + XDS::CRLF_BYTES.length + org.apache.commons.httpclient.util.EncodingUtil.get_ascii_bytes(get_id).length
+    end
+    
+    
+    def send_id(out)
+      out.write(XDS::CRLF_BYTES)
+      out.write(org.apache.commons.httpclient.util.EncodingUtil.get_ascii_bytes(get_id))     
+    end
+    
+    # /***
+    #    298      * Write all the data to the output stream.
+    #    299      * If you override this method make sure to override 
+    #    300      * #length() as well
+    #    301      * 
+    #    302      * @param out The output stream
+    #    303      * @throws IOException If an IO problem occurs.
+    #    304      */
+    def send( out)   
+     sendStart(out);
+     sendDispositionHeader(out)
+     sendContentTypeHeader(out)
+     send_id(out)
+     sendTransferEncodingHeader(out)
+     
+     sendEndOfHeader(out)
+     sendData(out)
+     sendEnd(out)
+   end
+   
+   private 
+   def get_id
+      "Content-ID: <#{@id}>"
+   end
+  end
+end