fhir_client 3.0.2 → 3.0.3

data/lib/fhir_client/ext/bundle.rb

@@ -1,5 +1,5 @@
 module FHIR
-  class Bundle
+  module BundleExtras
     def self_link
       link.select { |n| n.relation == 'self' }.first
     end
@@ -28,15 +28,35 @@ module FHIR
     end
 
     def each(&block)
-      iteration = @entry.map(&:resource).each(&block)
-      iteration += next_bundle.each(&block) if next_bundle
-      iteration
+      iterator = @entry.map(&:resource).each(&block)
+      if next_bundle
+        next_iterator = next_bundle.each(&block)
+        Enumerator.new do |y|
+          iterator.each { |r| y << r }
+          next_iterator.each { |r| y << r }
+        end
+      else
+        iterator
+      end
     end
 
     def next_bundle
-      # TODO: test this
       return nil unless client && next_link.try(:url)
       @next_bundle ||= client.parse_reply(self.class, client.default_format, client.raw_read_url(next_link.url))
     end
   end
 end
+
+module FHIR
+  class Bundle
+    include FHIR::BundleExtras
+  end
+end
+
+module FHIR
+  module DSTU2
+    class Bundle
+      include FHIR::BundleExtras
+    end
+  end
+end

data/lib/fhir_client/ext/model.rb

@@ -1,112 +1,137 @@
 module FHIR
-  class Model
-    cattr_accessor :client, instance_accessor: false
+  module ModelExtras
 
-    def client
-      @@client
+    def self.included base
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
     end
 
-    def client=(client)
-      @@client = client
+    module InstanceMethods
+      def client
+        FHIR::Model.client
+      end
 
-      # Ensure the client-setting cascades to all child models
-      instance_values.each do |_key, values|
-        Array.wrap(values).each do |value|
-          next unless value.is_a?(FHIR::Model)
-          next if value.client == client
-          value.client = client
-        end
+      def client=(client)
+        FHIR::Model.client = client
       end
-    end
 
-    def self.read(id, client = @@client)
-      handle_response client.read(self, id)
-    end
+      def vread(version_id)
+        self.class.vread(id, version_id, client)
+      end
 
-    def self.read_with_summary(id, summary, client = @@client)
-      handle_response client.read(self, id, client.default_format, summary)
-    end
+      def create
+        handle_response client.create(self)
+      end
 
-    def self.vread(id, version_id, client = @@client)
-      handle_response client.vread(self, id, version_id)
-    end
+      def conditional_create(params)
+        handle_response client.conditional_create(self, params)
+      end
 
-    def self.resource_history(client = @@client)
-      handle_response client.resource_history(self)
-    end
+      def update
+        handle_response client.update(self, id)
+      end
 
-    def self.resource_history_as_of(last_update, client = @@client)
-      handle_response client.resource_history_as_of(self, last_update)
-    end
+      def conditional_update(params)
+        handle_response client.conditional_update(self, id, params)
+      end
 
-    def self.resource_instance_history(id, client = @@client)
-      handle_response client.resource_instance_history(self, id)
-    end
+      def destroy
+        handle_response client.destroy(self.class, id) unless id.nil?
+        nil
+      end
 
-    def self.resource_instance_history_as_of(id, last_update, client = @@client)
-      handle_response client.resource_instance_history_as_of(self, id, last_update)
-    end
+      def resolve(reference)
+        if reference.contained?
+          contained.detect { |c| c.id == reference.id }
+        else
+          reference.read
+        end
+      end
 
-    def self.search(params = {}, client = @@client)
-      handle_response client.search(self, search: { parameters: params })
+      private
+      def handle_response(response)
+        raise ClientException.new "Server returned #{response.code}.", response if response.code.between?(400, 599)
+        response.resource
+      end
     end
 
-    def self.create(model, client = @@client)
-      model = new(model) unless model.is_a?(self)
-      handle_response client.create(model)
-    end
+    module ClassMethods
+ 
+      def client
+        FHIR::Model.client
+      end
 
-    def self.conditional_create(model, params, client = @@client)
-      model = new(model) unless model.is_a?(self)
-      handle_response client.conditional_create(model, params)
-    end
+      def client=(client)
+        FHIR::Model.client = client
+      end
 
-    def self.all(client = @@client)
-      handle_response client.read_feed(self)
-    end
+      def read(id, client = self.client)
+        handle_response client.read(self, id)
+      end
 
-    def vread(version_id)
-      self.class.vread(id, version_id, client)
-    end
+      def read_with_summary(id, summary, client = self.client)
+        handle_response client.read(self, id, client.default_format, summary)
+      end
 
-    def create
-      handle_response client.create(self)
-    end
+      def vread(id, version_id, client = self.client)
+        handle_response client.vread(self, id, version_id)
+      end
 
-    def conditional_create(params)
-      handle_response client.conditional_create(self, params)
-    end
+      def resource_history(client = self.client)
+        handle_response client.resource_history(self)
+      end
 
-    def update
-      handle_response client.update(self, id)
-    end
+      def resource_history_as_of(last_update, client = self.client)
+        handle_response client.resource_history_as_of(self, last_update)
+      end
 
-    def conditional_update(params)
-      handle_response client.conditional_update(self, id, params)
-    end
+      def resource_instance_history(id, client = self.client)
+        handle_response client.resource_instance_history(self, id)
+      end
 
-    def destroy
-      handle_response client.destroy(self.class, id) unless id.nil?
-      nil
-    end
+      def resource_instance_history_as_of(id, last_update, client = self.client)
+        handle_response client.resource_instance_history_as_of(self, id, last_update)
+      end
 
-    def resolve(reference)
-      if reference.contained?
-        contained.detect { |c| c.id == reference.id }
-      else
-        reference.read
+      def search(params = {}, client = self.client)
+        handle_response client.search(self, search: { parameters: params })
+      end
+
+      def create(model, client = self.client)
+        model = new(model) unless model.is_a?(self)
+        handle_response client.create(model)
       end
-    end
 
-    private
+      def conditional_create(model, params, client = self.client)
+        model = new(model) unless model.is_a?(self)
+        handle_response client.conditional_create(model, params)
+      end
+
+      def all(client = self.client)
+        handle_response client.read_feed(self)
+      end
+
+      private
 
-    def self.handle_response(response)
-      raise ClientException.new "Server returned #{response.code}.", response if response.code.between?(400, 599)
-      response.resource
+      def handle_response(response)
+        raise ClientException.new "Server returned #{response.code}.", response if response.code.between?(400, 599)
+        response.resource
+      end
     end
+  end
+end
 
-    def handle_response(response)
-      self.class.handle_response(response)
+module FHIR
+  class Model
+    include FHIR::ModelExtras
+    cattr_accessor :client, instance_accessor: false
+  end
+end
+
+module FHIR
+  module DSTU2
+    class Model
+      include FHIR::ModelExtras
     end
   end
 end

data/lib/fhir_client/ext/reference.rb

@@ -1,10 +1,10 @@
 module FHIR
-  class Reference
+  module ReferenceExtras
     def contained?
       reference.to_s.start_with?('#')
     end
 
-    def id
+    def reference_id
       if contained?
         reference.to_s[1..-1]
       else
@@ -16,13 +16,32 @@ module FHIR
       reference.to_s.split('/').first unless contained?
     end
 
+    def read
+      return if contained? || type.blank? || (id.blank? && reference.blank?)
+      rid = id || reference_id
+      resource_class.read(rid, client)
+    end
+  end
+end
+
+module FHIR
+  class Reference
+    include FHIR::ReferenceExtras
+
     def resource_class
       "FHIR::#{type}".constantize unless contained?
     end
+  end
+end
 
-    def read
-      return if contained? || type.blank? || id.blank?
-      resource_class.read(id, client)
+module FHIR
+  module DSTU2
+    class Reference
+      include FHIR::ReferenceExtras
+      
+      def resource_class
+        "FHIR::DSTU2::#{type}".constantize unless contained?
+      end
     end
   end
 end

data/lib/fhir_client/fhir_api_validation.json

@@ -200,7 +200,7 @@
         "ETag": false,
         "Last-Modified": false
       },
-      "body": { "types": ["CapabilityStatement"] }
+      "body": { "types": ["CapabilityStatement","Conformance"] }
     }
   },{      
     "interaction": "transaction",

data/lib/fhir_client/model/client_reply.rb

@@ -46,10 +46,13 @@ module FHIR
     attr_accessor :response
     attr_accessor :resource # a FHIR resource
     attr_accessor :resource_class # class of the :resource
+    attr_accessor :fhir_version
 
-    def initialize(request, response)
+    def initialize(request, response, client)
       @request = request
       @response = response
+      @fhir_version = :stu3
+      @fhir_version = client.fhir_version
     end
 
     def code
@@ -154,10 +157,14 @@ module FHIR
         if body_rules['types']
           body_type_match = false
           begin
-            content = FHIR.from_contents(body)
+            content = if @fhir_version == :stu3
+                        FHIR.from_contents(body)
+                      else
+                        FHIR::DSTU2.from_contents(body)
+                      end
             body_rules['types'].each do |type|
               body_type_match = true if content.resourceType == type
-              body_type_match = true if type == 'Resource' && FHIR::RESOURCES.include?(content.resourceType)
+              body_type_match = true if type == 'Resource' && validate_resource(content.resourceType)
             end
           rescue
             FHIR.logger.warn "ClientReply was unable to validate response body: #{body}"
@@ -174,6 +181,15 @@ module FHIR
       errors
     end
 
-    private :validate_headers, :validate_body
+    def validate_resource(resource_type)
+      if @fhir_version == :stu3
+        return true if FHIR::RESOURCES.include?(resource_type)
+      else
+        return true if FHIR::DSTU2::RESOURCES.include?(resource_type)
+      end
+      false
+    end
+
+    private :validate_headers, :validate_body, :validate_resource
   end
 end

data/lib/fhir_client/resource_address.rb

@@ -40,6 +40,8 @@ module FHIR
 
       fhir_headers.merge!(options) unless options.empty?
       fhir_headers[:operation] = options[:operation][:name] if options[:operation] && options[:operation][:name]
+      fhir_headers.delete('id')
+      fhir_headers.delete('resource')
       fhir_headers
     end
 

data/lib/fhir_client/sections/crud.rb

@@ -36,13 +36,11 @@ module FHIR
       end
 
       def raw_read(options)
-        reply = get resource_url(options), fhir_headers(options)
-        reply.body
+        get resource_url(options), fhir_headers(options)
       end
 
-      def raw_read_url(url)
-        reply = get url, fhir_headers({})
-        reply.body
+      def raw_read_url(url, format = @default_format)
+        get url, fhir_headers(format: format)
       end
 
       #
@@ -89,10 +87,10 @@ module FHIR
       def partial_update(klass, id, patchset, options = {}, format = @default_format)
         options = { resource: klass, id: id, format: format }.merge options
 
-        if format == FHIR::Formats::ResourceFormat::RESOURCE_XML
+        if [FHIR::Formats::ResourceFormat::RESOURCE_XML, FHIR::Formats::ResourceFormat::RESOURCE_XML_DSTU2].include?(format)
           options[:format] = FHIR::Formats::PatchFormat::PATCH_XML
           options[:Accept] = format
-        elsif format == FHIR::Formats::ResourceFormat::RESOURCE_JSON
+        elsif [FHIR::Formats::ResourceFormat::RESOURCE_JSON, FHIR::Formats::ResourceFormat::RESOURCE_JSON_DSTU2].include?(format)
           options[:format] = FHIR::Formats::PatchFormat::PATCH_JSON
           options[:Accept] = format
         end
@@ -119,8 +117,8 @@ module FHIR
       # Create a new resource with a server assigned id. Return the newly created
       # resource with the id the server assigned.
       #
-      def create(resource, format = @default_format)
-        base_create(resource, nil, format)
+      def create(resource, options = {}, format = @default_format)
+        base_create(resource, options, format)
       end
 
       #
@@ -150,9 +148,17 @@ module FHIR
           type = reply.response[:headers].detect{|x, _y| x.downcase=='content-type'}.try(:last)
           if !type.nil?
             reply.resource = if type.include?('xml') && !reply.body.empty?
-                               FHIR::Xml.from_xml(reply.body)
+                               if @fhir_version == :stu3
+                                 FHIR::Xml.from_xml(reply.body)
+                               else
+                                 FHIR::DSTU2::Xml.from_xml(reply.body)
+                               end
                              elsif type.include?('json') && !reply.body.empty?
-                               FHIR::Json.from_json(reply.body)
+                               if @fhir_version == :stu3
+                                 FHIR::Json.from_json(reply.body)
+                               else
+                                 FHIR::DSTU2::Json.from_json(reply.body)
+                               end
                              else
                                resource # just send back the submitted resource
                              end

data/lib/fhir_client/sections/history.rb

@@ -24,8 +24,9 @@ module FHIR
       # public <T extends Resource> AtomFeed history(DateAndTime last_update, Class<T> resourceClass, String id);
 
       def history(options)
+        options = {format: @default_format}.merge(options)
         reply = get resource_url(options), fhir_headers(options).except(:history)
-        reply.resource = parse_reply(options[:resource], @default_format, reply)
+        reply.resource = parse_reply(options[:resource], options[:format], reply)
         reply.resource_class = options[:resource]
         reply
       end