fhir_client 3.0.7 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e672a83cc2c6d38d9b7b907e593fcee05ecead0a75320f79a8a65627deff0df7
-  data.tar.gz: 79219638d996eaa08b9ec7b38957da73eb1e6e5c5d26b428480178ee2e939fc4
+  metadata.gz: 0652e0b08ba87a20e874e73ea62fca47611c6d3631681f6d9b6316e1a3e08528
+  data.tar.gz: 3980e902188d8fa627f8c9a8c72fb010ecffbc3c8fb056bd5a3a78cc50aebe05
 SHA512:
-  metadata.gz: 904a33c45ee559acfbc0372435c9ee31e76412ef840d3616ae6f8e584aa9381d8a43cb81d937a3818891a82fe26ca5acbcaa74778602bbbe42c01c78d2e7ea35
-  data.tar.gz: ad3ec868c7c139105890e4091e1780efffb30649df4b7e63a5fbc8ed599dcfa249cfac2d7b84f12236712a32ec4d69b4a58c5d8fb1891330a6fc30907dfddae2
+  metadata.gz: b2f783cbbd33c2a437d6c45ea01ce3ba7aa60ca277d18b2dcb7dd0e09fcd037e854f1b6fd1be3d6487c296ef129280d3bbca2cbe2aa85fa5e0ac6d7e86bdfbaf
+  data.tar.gz: eb13cd8355a0116d1b30043231881a7748fa164c39a5b2075f2d5517f99f353934d4b14121e056b0e0117077e3c070a28b5edf3f256792993e5614499c824956

data/.travis.yml

@@ -1,9 +1,9 @@
 language: ruby
 rvm:
-  - 2.2
   - 2.3
   - 2.4
   - 2.5
+  - 2.6
 before_install:
   - gem update --system
   - gem install bundler

data/README.md

@@ -84,6 +84,15 @@ patient = FHIR::DSTU2::Patient.read('example')
 patient = client.read(FHIR::DSTU2::Patient, 'example').resource
 ```
 
+### Configuration
+
+You can specify additional properties for the `client`:
+
+```ruby
+client.additional_headers = {Prefer: 'return=representation'}
+client.proxy = 'https://your-proxy.com/'
+```
+
 ### CRUD Examples
 ```ruby
 # read an existing patient with id "example"

data/fhir_client.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'rest-client', '~> 2.0'
   spec.add_dependency 'tilt', '>= 1.1'
 
-  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'webmock'

data/lib/fhir_client.rb

@@ -13,6 +13,7 @@ end
 require_relative 'fhir_client/client'
 require_relative 'fhir_client/resource_address'
 require_relative 'fhir_client/resource_format'
+require_relative 'fhir_client/return_preferences'
 require_relative 'fhir_client/patch_format'
 require_relative 'fhir_client/client_exception'
 require_relative 'fhir_client/version'

data/lib/fhir_client/client.rb

@@ -23,6 +23,12 @@ module FHIR
     attr_accessor :fhir_version
     attr_accessor :cached_capability_statement
     attr_accessor :additional_headers
+    attr_accessor :proxy
+    attr_accessor :exception_class
+
+    attr_accessor :use_accept_header
+    attr_accessor :use_accept_charset
+    attr_accessor :use_return_preference
 
     # Call method to initialize FHIR client. This method must be invoked
     # with a valid base server URL prior to using the client.
@@ -31,12 +37,19 @@ module FHIR
     # @param default_format Default Format Mime type
     # @return
     #
-    def initialize(base_service_url, default_format: FHIR::Formats::ResourceFormat::RESOURCE_XML)
+    def initialize(base_service_url, default_format: FHIR::Formats::ResourceFormat::RESOURCE_XML, proxy: nil)
       @base_service_url = base_service_url
       FHIR.logger.info "Initializing client with #{@base_service_url}"
       @use_format_param = false
+      @use_accept_header = true
+      @use_accept_charset = true
       @default_format = default_format
       @fhir_version = :stu3
+      @use_return_preference = false
+      @return_preference = FHIR::Formats::ReturnPreferences::REPRESENTATION
+      @exception_class = ClientException
+      @proxy = proxy
+
       set_no_auth
     end
 
@@ -74,6 +87,20 @@ module FHIR
                         end
     end
 
+    #
+    # Instructs the client to specify the minimal Prefer Header where applicable
+    def use_minimal_preference
+      @use_return_preference = true
+      @return_preference = FHIR::Formats::ReturnPreferences::MINIMAL
+    end
+
+    #
+    # Instructs the client to specify the representation Prefer Header where applicable
+    def use_representation_preference
+      @use_return_preference = true
+      @return_preference = FHIR::Formats::ReturnPreferences::REPRESENTATION
+    end
+
     def versioned_resource_class(klass)
       if @fhir_version == :stu3
         FHIR.const_get(klass)
@@ -102,6 +129,8 @@ module FHIR
       @use_basic_auth = false
       @security_headers = {}
       @client = RestClient
+      @client.proxy = proxy unless proxy.nil?
+      @client
     end
 
     # Set the client to use HTTP Basic Authentication
@@ -113,6 +142,8 @@ module FHIR
       @use_oauth2_auth = false
       @use_basic_auth = true
       @client = RestClient
+      @client.proxy = proxy unless proxy.nil?
+      @client
     end
 
     # Set the client to use Bearer Token Authentication
@@ -123,6 +154,8 @@ module FHIR
       @use_oauth2_auth = false
       @use_basic_auth = true
       @client = RestClient
+      @client.proxy = proxy unless proxy.nil?
+      @client
     end
 
     # Set the client to use OpenID Connect OAuth2 Authentication
@@ -142,6 +175,7 @@ module FHIR
         raise_errors: true
       }
       client = OAuth2::Client.new(client, secret, options)
+      client.connection.proxy(proxy) unless proxy.nil?
       @client = client.client_credentials.get_token
     end
 
@@ -248,7 +282,7 @@ module FHIR
       @default_format = nil
 
       formats.each do |frmt|
-        reply = get 'metadata', fhir_headers(format: frmt)
+        reply = get 'metadata', fhir_headers({accept: "#{frmt}"})
         next unless reply.code == 200
         begin
           @cached_capability_statement = parse_reply(FHIR::CapabilityStatement, frmt, reply)
@@ -272,7 +306,7 @@ module FHIR
     end
 
     def resource_url(options)
-      FHIR::ResourceAddress.new.resource_url(options, @use_format_param)
+      FHIR::ResourceAddress.resource_url(options, @use_format_param)
     end
 
     def full_resource_url(options)
@@ -280,9 +314,7 @@ module FHIR
     end
 
     def fhir_headers(options = {})
-      options.merge!(additional_headers) unless additional_headers.nil?
-
-      FHIR::ResourceAddress.new.fhir_headers(options, @use_format_param)
+      FHIR::ResourceAddress.fhir_headers(options, additional_headers, @default_format, @use_accept_header, @use_accept_charset)
     end
 
     def parse_reply(klass, format, response)
@@ -348,8 +380,10 @@ module FHIR
     # Extract the request payload in the specified format, defaults to XML
     def request_payload(resource, headers)
       if headers
-        format_specified = headers[:format] || headers['format']
-        if format_specified.downcase.include?('xml')
+        format_specified = headers['Content-Type']
+        if format_specified.nil?
+          resource.to_xml
+        elsif format_specified.downcase.include?('xml')
           resource.to_xml
         elsif format_specified.downcase.include?('json')
           resource.to_json
@@ -383,7 +417,7 @@ module FHIR
 
     def clean_headers(headers)
       headers.delete_if { |k, v| (k.nil? || v.nil?) }
-      headers.each_with_object({}) { |(k, v), h| h[k.to_s] = v.to_s; h }
+      FHIR::ResourceAddress.convert_symbol_headers(headers)
     end
 
     def scrubbed_response_headers(result)
@@ -393,10 +427,10 @@ module FHIR
       end
     end
 
-    def get(path, headers)
+    def get(path, headers = {})
       url = Addressable::URI.parse(build_url(path)).to_s
       FHIR.logger.info "GETTING: #{url}"
-      headers = clean_headers(headers)
+      headers = clean_headers(headers) unless headers.empty?
       if @use_oauth2_auth
         # @client.refresh!
         begin
@@ -572,7 +606,7 @@ module FHIR
       url = URI(build_url(path)).to_s
       FHIR.logger.info "PATCHING: #{url}"
       headers = clean_headers(headers)
-      payload = request_patch_payload(patchset, headers['format'])
+      payload = request_patch_payload(patchset, headers['Content-Type'])
       if @use_oauth2_auth
         # @client.refresh!
         begin

data/lib/fhir_client/ext/model.rb

@@ -50,7 +50,7 @@ module FHIR
 
       private
       def handle_response(response)
-        raise ClientException.new "Server returned #{response.code}.", response if response.code.between?(400, 599)
+        raise client.exception_class.new "Server returned #{response.code}.", response if response.code.between?(400, 599)
         response.resource
       end
     end
@@ -66,59 +66,59 @@ module FHIR
       end
 
       def read(id, client = self.client)
-        handle_response client.read(self, id)
+        handle_response client.exception_class, client.read(self, id)
       end
 
       def read_with_summary(id, summary, client = self.client)
-        handle_response client.read(self, id, client.default_format, summary)
+        handle_response client.exception_class, client.read(self, id, client.default_format, summary)
       end
 
       def vread(id, version_id, client = self.client)
-        handle_response client.vread(self, id, version_id)
+        handle_response client.exception_class, client.vread(self, id, version_id)
       end
 
       def resource_history(client = self.client)
-        handle_response client.resource_history(self)
+        handle_response client.exception_class, client.resource_history(self)
       end
 
       def resource_history_as_of(last_update, client = self.client)
-        handle_response client.resource_history_as_of(self, last_update)
+        handle_response client.exception_class, client.resource_history_as_of(self, last_update)
       end
 
       def resource_instance_history(id, client = self.client)
-        handle_response client.resource_instance_history(self, id)
+        handle_response client.exception_class, client.resource_instance_history(self, id)
       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)
+        handle_response client.exception_class, client.resource_instance_history_as_of(self, id, last_update)
       end
 
       def search(params = {}, client = self.client)
-        handle_response client.search(self, search: { parameters: params })
+        handle_response client.exception_class, 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)
+        handle_response client.exception_class, client.create(model)
       end
 
       def conditional_create(model, params, client = self.client)
         model = new(model) unless model.is_a?(self)
-        handle_response client.conditional_create(model, params)
+        handle_response client.exception_class, client.conditional_create(model, params)
       end
 
       def partial_update(id, patchset, options = {})
-        handle_response client.partial_update(self, id, patchset, options)
+        handle_response client.exception_class, client.partial_update(self, id, patchset, options)
       end
 
       def all(client = self.client)
-        handle_response client.read_feed(self)
+        handle_response client.exception_class, client.read_feed(self)
       end
 
       private
 
-      def handle_response(response)
-        raise ClientException.new "Server returned #{response.code}.", response if response.code.between?(400, 599)
+      def handle_response(exception_class, response)
+        raise exception_class.new "Server returned #{response.code}.", response if response.code.between?(400, 599)
         response.resource
       end
     end

data/lib/fhir_client/ext/reference.rb

@@ -59,7 +59,7 @@ module FHIR
       if relative? || reference == client.full_resource_url(resource: resource_class, id: reference_id)
         read_client = client
       else
-        read_client = FHIR::Client.new base_uri, default_format: client.default_format
+        read_client = FHIR::Client.new base_uri, default_format: client.default_format, proxy: client.proxy
       end
       resource_class.read(reference_id, read_client)
     end
@@ -69,7 +69,7 @@ module FHIR
       if relative? || reference == client.full_resource_url(resource: resource_class, id: reference_id)
         read_client = client
       else
-        read_client = FHIR::Client.new base_uri, default_format: client.default_format
+        read_client = FHIR::Client.new base_uri, default_format: client.default_format, proxy: client.proxy
       end
       resource_class.vread(reference_id, version_id, read_client)
     end

data/lib/fhir_client/resource_address.rb

@@ -6,46 +6,83 @@ module FHIR
       format: 'application/fhir+xml'
     }.freeze
 
-    DEFAULT_CHARSET = 'UTF-8'.freeze
-
-    def fhir_headers(options, use_format_param = false)
-      options = DEFAULTS.merge(options)
-
-      format = options[:format] || FHIR::Formats::ResourceFormat::RESOURCE_XML
-      fhir_headers = {
-        'User-Agent' => 'Ruby FHIR Client',
-        'Content-Type' => format + ';charset=' + DEFAULT_CHARSET,
-        'Accept-Charset' => DEFAULT_CHARSET
-      }
-      # remove the content-type header if the format is 'xml' or 'json' because
-      # even those are valid _format parameter options, they are not valid MimeTypes.
-      fhir_headers.delete('Content-Type') if %w(xml json).include?(format.downcase)
-
-      if options[:category]
-        # options[:category] should be an Array of FHIR::Tag objects
-        tags = {
-          'Category' => options[:category].collect(&:to_header).join(',')
-        }
-        fhir_headers.merge!(tags)
-        options.delete(:category)
+    DEFAULT_CHARSET = 'utf-8'.freeze
+    DEFAULT_CONTENT_TYPE = 'application/fhir+xml'.freeze # time to default to json?
+
+    #
+    # Normalize submitted header key value pairs
+    #
+    # 'content-type', 'Content-Type', and :content_type would all represent the content-type header
+    #
+    # Assumes symbols like :content_type to be "content-type"
+    # if for some odd reason the Header string representation contains underscores it would need to be specified
+    # as a string (i.e. options {"Underscore_Header" => 'why not hyphens'})
+    # Note that servers like apache or nginx consider that invalid anyways and drop them
+    # http://httpd.apache.org/docs/trunk/new_features_2_4.html
+    # http://nginx.org/en/docs/http/ngx_http_core_module.html#underscores_in_headers
+    def self.normalize_headers(to_be_normalized, to_symbol = true, capitalized = false)
+      to_be_normalized.inject({}) do |result, (key, value)|
+        key = key.to_s.downcase.split(/-|_/)
+        key.map!(&:capitalize) if capitalized
+        key = to_symbol ? key.join('_').to_sym : key.join('-')
+        result[key] = value.to_s
+        result
       end
+    end
 
-      if use_format_param
-        fhir_headers.delete('Accept')
-        options.delete('Accept')
-        options.delete(:accept)
-      else
-        fhir_headers['Accept'] = format
+    def self.convert_symbol_headers headers
+      headers.inject({}) do |result, (key, value)|
+        if key.is_a? Symbol
+          key = key.to_s.split(/_/).map(&:capitalize).join('-')
+        end
+        result[key] = value.to_s
+        result
       end
+    end
 
-      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')
+    # Returns normalized HTTP Headers
+    # header key value pairs can be supplied with keys specified as symbols or strings
+    # keys will be normalized to symbols.
+    # e.g. the keys :accept, "accept", and "Accept" all represent the Accept HTTP Header
+    # @param [Hash] options key value pairs for the http headerx
+    # @return [Hash] The normalized FHIR Headers
+    def self.fhir_headers(headers = {}, additional_headers = {}, format = DEFAULT_CONTENT_TYPE, use_accept_header = true, use_accept_charset = true)
+      # normalizes header names to be case-insensitive
+      # See relevant HTTP RFCs:
+      # https://tools.ietf.org/html/rfc2616#section-4.2
+      # https://tools.ietf.org/html/rfc7230#section-3.2
+      #
+      # https://tools.ietf.org/html/rfc7231#section-5.3.2
+      # optional white space before and
+      # https://tools.ietf.org/html/rfc2616#section-3.4
+      # utf-8 is case insensitive
+      #
+      headers ||= {}
+      additional_headers ||= {}
+
+      fhir_headers = {user_agent: 'Ruby FHIR Client'}
+
+      fhir_headers[:accept_charset] =  DEFAULT_CHARSET if use_accept_charset
+
+      # https://www.hl7.org/fhir/DSTU2/http.html#mime-type
+      # could add option for ;charset=#{DEFAULT_CHARSET} in accept header
+      fhir_headers[:accept] = "#{format}" if use_accept_header
+
+      # maybe in a future update normalize everything to symbols
+      # Headers should be case insensitive anyways...
+      #headers = normalize_headers(headers) unless headers.empty?
+      #
+      fhir_headers = convert_symbol_headers(fhir_headers)
+      headers = convert_symbol_headers(headers)
+
+      # supplied headers will always be used, e.g. if @use_accept_header is false
+      # ,but an accept header is explicitly supplied then it will be used (or override the existing)
+      fhir_headers.merge!(headers) unless headers.empty?
+      fhir_headers.merge!(additional_headers)
       fhir_headers
     end
 
-    def resource_url(options, use_format_param = false)
+    def self.resource_url(options, use_format_param = false)
       options = DEFAULTS.merge(options)
 
       params = {}

data/lib/fhir_client/return_preferences.rb

@@ -0,0 +1,8 @@
+module FHIR
+  module Formats
+    module ReturnPreferences
+      MINIMAL = 'return=minimal'.freeze
+      REPRESENTATION = 'return=representation'.freeze
+    end
+  end
+end

data/lib/fhir_client/sections/crud.rb

@@ -4,11 +4,47 @@ module FHIR
       #
       # Read the current state of a resource.
       #
-      def read(klass, id, format = @default_format, summary = nil, options = {})
-        options = { resource: klass, id: id, format: format }.merge(options)
+      def read(klass, id, format = nil, summary = nil, options = {})
+        options = { resource: klass, id: id, format: format || @default_format}.merge(options)
         options[:summary] = summary if summary
-        reply = get resource_url(options), fhir_headers(options)
-        reply.resource = parse_reply(klass, format, reply)
+        headers = { accept: "#{format}" } if format
+        reply = get resource_url(options), fhir_headers(headers)
+        reply.resource = parse_reply(klass, format || @default_format, reply)
+        reply.resource_class = klass
+        reply
+      end
+
+      #
+      # Conditionally Read the resource if it has been modified since the supplied date
+      #
+      # See If-Modified-Since RRC 7232 https://tools.ietf.org/html/rfc7232#section-3.3 and
+      # See HTTP-date https://tools.ietf.org/html/rfc7231#section-7.1.1.1
+      #
+      # @param klass the FHIR Resource class
+      # @param id the resource id
+      # @param since_date the date
+      def conditional_read_since(klass, id, since_date, options = {})
+
+        options = { resource: klass, id: id}.merge(options)
+        headers = { if_modified_since: since_date }
+        reply = get resource_url(options), fhir_headers(headers)
+        reply.resource = parse_reply(klass, @default_format, reply)
+        reply.resource_class = klass
+        reply
+      end
+
+      #
+      # Conditionally Read the resource based on the provided ETag
+      #
+      # @param klass the FHIR Resource class
+      # @param id the resource id
+      # @param version_id the version_id used for the ETag
+      def conditional_read_version(klass, id, version_id, options = {})
+
+        options = { resource: klass, id: id}.merge(options)
+        headers = { if_none_match: "W/#{version_id}" }
+        reply = get resource_url(options), fhir_headers(headers)
+        reply.resource = parse_reply(klass, @default_format, reply)
         reply.resource_class = klass
         reply
       end
@@ -16,9 +52,12 @@ module FHIR
       #
       # Read a resource bundle (an XML ATOM feed)
       #
-      def read_feed(klass, format = @default_format)
-        options = { resource: klass, format: format }
-        reply = get resource_url(options), fhir_headers(options)
+      #
+      def read_feed(klass, format = nil)
+        headers = { accept: "#{format}" } if format
+        format ||= @default_format
+        options = { resource: klass, format: format}
+        reply = get resource_url(options), fhir_headers(headers)
         reply.resource = parse_reply(klass, format, reply)
         reply.resource_class = klass
         reply
@@ -27,33 +66,36 @@ module FHIR
       #
       # Read the state of a specific version of the resource
       #
-      def vread(klass, id, version_id, format = @default_format)
+      def vread(klass, id, version_id, format = nil)
+        headers = { accept: "#{format}" } if format
+        format ||= @default_format
         options = { resource: klass, id: id, format: format, history: { id: version_id } }
-        reply = get resource_url(options), fhir_headers(options)
+        reply = get resource_url(options), fhir_headers(headers)
         reply.resource = parse_reply(klass, format, reply)
         reply.resource_class = klass
         reply
       end
 
       def raw_read(options)
-        get resource_url(options), fhir_headers(options)
+        get resource_url(options), fhir_headers
       end
 
-      def raw_read_url(url, format = @default_format)
-        get url, fhir_headers(format: format)
+      def raw_read_url(url, format = nil)
+        headers = { accept: "#{format}" } if format
+        get url, fhir_headers(headers)
       end
 
       #
       # Update an existing resource by its id or create it if it is a new resource, not present on the server
       #
-      def update(resource, id, format = @default_format)
+      def update(resource, id, format = nil)
         base_update(resource, id, nil, format)
       end
 
       #
       # Update an existing resource by its id or create it if it is a new resource, not present on the server
       #
-      def conditional_update(resource, id, search_params, format = @default_format)
+      def conditional_update(resource, id, search_params, format = nil)
         options = {
           search: {
             flag: false,
@@ -67,15 +109,29 @@ module FHIR
         base_update(resource, id, options, format)
       end
 
+      #
+      # Version Aware Update using version_id
+      # prevents Lost Update Problem https://www.w3.org/1999/04/Editing/
+      # @param resource the FHIR resource object
+      # @param id the resource id
+      def version_aware_update(resource, id, version_id, format = nil, options = {})
+        base_update(resource, id, options, format, {if_match: "W/#{version_id}"})
+      end
+
       #
       # Update an existing resource by its id or create it if it is a new resource, not present on the server
       #
-      def base_update(resource, id, options, format)
+      def base_update(resource, id, options, format = nil, headers = nil)
+        headers ||= {}
+        headers[:accept] = "#{format}" if format
+        format ||= @default_format
+        headers[:content_type] =  "#{format}"
+        headers[:prefer] = @return_preference if @use_return_preference
         options = {} if options.nil?
         options[:resource] = resource.class
         options[:format] = format
         options[:id] = id
-        reply = put resource_url(options), resource, fhir_headers(options)
+        reply = put resource_url(options), resource, fhir_headers(headers)
         reply.resource = parse_reply(resource.class, format, reply) if reply.body.present?
         reply.resource_class = resource.class
         reply
@@ -84,18 +140,20 @@ module FHIR
       #
       # Partial update using a patchset (PATCH)
       #
-      def partial_update(klass, id, patchset, options = {}, format = @default_format)
-        options = { resource: klass, id: id, format: format }.merge options
-
+      def partial_update(klass, id, patchset, options = {}, format = nil)
+        headers = {}
+        headers[:accept] =  "#{format}" if format
+        format ||= @default_format
+        options = { resource: klass, id: id, format: format}.merge options
         if [FHIR::Formats::ResourceFormat::RESOURCE_XML, FHIR::Formats::ResourceFormat::RESOURCE_XML_DSTU2].include?(format)
           options[:format] = FHIR::Formats::PatchFormat::PATCH_XML
-          options[:Accept] = format
+          headers[:content_type] =  "#{FHIR::Formats::PatchFormat::PATCH_XML}"
         elsif [FHIR::Formats::ResourceFormat::RESOURCE_JSON, FHIR::Formats::ResourceFormat::RESOURCE_JSON_DSTU2].include?(format)
           options[:format] = FHIR::Formats::PatchFormat::PATCH_JSON
-          options[:Accept] = format
+          headers[:content_type] =  "#{FHIR::Formats::PatchFormat::PATCH_JSON}"
         end
-
-        reply = patch resource_url(options), patchset, fhir_headers(options)
+        headers[:prefer] = @return_preference if @use_return_preference
+        reply = patch resource_url(options), patchset, fhir_headers(headers)
         reply.resource = parse_reply(klass, format, reply)
         reply.resource_class = klass
         reply
@@ -106,9 +164,7 @@ module FHIR
       #
       def destroy(klass, id = nil, options = {})
         options = { resource: klass, id: id, format: @default_format }.merge options
-        headers = fhir_headers(options)
-        headers.delete('Content-Type')
-        reply = delete resource_url(options), headers
+        reply = delete resource_url(options), fhir_headers
         reply.resource_class = klass
         reply
       end
@@ -117,33 +173,38 @@ 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, options = {}, format = @default_format)
+      def create(resource, options = {}, format = nil)
         base_create(resource, options, format)
       end
 
       #
       # Conditionally create a new resource with a server assigned id.
       #
-      def conditional_create(resource, if_none_exist_parameters, format = @default_format)
+      def conditional_create(resource, if_none_exist_parameters, format = nil)
         query = ''
         if_none_exist_parameters.each do |key, value|
           query += "#{key}=#{value}&"
         end
         query = query[0..-2] # strip off the trailing ampersand
-        options = {}
-        options['If-None-Exist'] = query
-        base_create(resource, options, format)
+        header = {if_none_exist: query}
+        base_create(resource, options, format, header)
       end
 
       #
       # Create a new resource with a server assigned id. Return the newly created
       # resource with the id the server assigned.
       #
-      def base_create(resource, options, format)
+      def base_create(resource, options, format = nil, additional_header = {})
+        headers = {}
+        headers[:accept] = "#{format}" if format
+        format ||= @default_format
+        headers = {content_type: "#{format}"}
+        headers[:prefer] = @return_preference if @use_return_preference
+        headers.merge!(additional_header)
         options = {} if options.nil?
         options[:resource] = resource.class
-        options[:format] = format
-        reply = post resource_url(options), resource, fhir_headers(options)
+        options[:format] = format || @default_format
+        reply = post resource_url(options), resource, fhir_headers(headers)
         if [200, 201].include? reply.code
           type = reply.response[:headers].detect{|x, _y| x.downcase=='content-type'}.try(:last)
           if !type.nil?

data/lib/fhir_client/sections/feed.rb

@@ -10,7 +10,7 @@ module FHIR
         bundle = current.resource
         link = bundle.method(page).call
         return nil unless link
-        reply = get strip_base(link.url), fhir_headers(format: @default_format)
+        reply = get strip_base(link.url), fhir_headers
         reply.resource = parse_reply(current.resource_class, @default_format, reply)
         reply.resource_class = current.resource_class
         reply

data/lib/fhir_client/sections/history.rb

@@ -25,7 +25,7 @@ module FHIR
 
       def history(options)
         options = {format: @default_format}.merge(options)
-        reply = get resource_url(options), fhir_headers(options).except(:history)
+        reply = get resource_url(options), fhir_headers
         reply.resource = parse_reply(options[:resource], options[:format], reply)
         reply.resource_class = options[:resource]
         reply

data/lib/fhir_client/sections/operations.rb

@@ -10,15 +10,19 @@ module FHIR
       # Fetch Patient Record	[base]/Patient/$everything | [base]/Patient/[id]/$everything
       # http://hl7.org/implement/standards/FHIR-Develop/patient-operations.html#everything
       # Fetches resources for a given patient record, scoped by a start and end time, and returns a Bundle of results
-      def fetch_patient_record(id = nil, startTime = nil, endTime = nil, method = 'GET', format = @default_format)
+      def fetch_patient_record(id = nil, startTime = nil, endTime = nil, method = 'GET', format = nil)
         fetch_record(id, [startTime, endTime], method, versioned_resource_class('Patient'), format)
       end
 
-      def fetch_encounter_record(id = nil, method = 'GET', format = @default_format)
+      def fetch_encounter_record(id = nil, method = 'GET', format = nil)
         fetch_record(id, [nil, nil], method, versioned_resource_class('Encounter'), format)
       end
 
-      def fetch_record(id = nil, time = [nil, nil], method = 'GET', klass = versioned_resource_class('Patient'), format = @default_format)
+      def fetch_record(id = nil, time = [nil, nil], method = 'GET', klass = versioned_resource_class('Patient'), format = nil)
+        headers = {}
+        headers[:accept] =  "#{format}" if format
+        format ||= @default_format
+        headers[:content_type] = format
         options = { resource: klass, format: format, operation: { name: :fetch_patient_record, method: method } }
         options.deep_merge!(id: id) unless id.nil?
         options[:operation][:parameters] = {} if options[:operation][:parameters].nil?
@@ -26,7 +30,7 @@ module FHIR
         options[:operation][:parameters][:end] = { type: 'Date', value: time.last } unless time.last.nil?
 
         if options[:operation][:method] == 'GET'
-          reply = get resource_url(options), fhir_headers(options)
+          reply = get resource_url(options), fhir_headers
         else
           # create Parameters body
           if options[:operation] && options[:operation][:parameters]
@@ -37,7 +41,7 @@ module FHIR
               p.parameter << parameter
             end
           end
-          reply = post resource_url(options), p, fhir_headers(options)
+          reply = post resource_url(options), p, fhir_headers(headers)
         end
 
         reply.resource = parse_reply(versioned_resource_class('Bundle'), format, reply)
@@ -95,11 +99,14 @@ module FHIR
 
       def terminology_operation(params = {}, format = @default_format)
         options = { format: format }
+        headers = {}
+        headers[:accept] =  "#{format}" if format
+        format ||= @default_format
         # params = [id, code, system, version, display, coding, codeableConcept, date, abstract]
         options.deep_merge!(params)
 
         if options[:operation][:method] == 'GET'
-          reply = get resource_url(options), fhir_headers(options)
+          reply = get resource_url(options), fhir_headers(headers)
         else
           # create Parameters body
           if options[:operation] && options[:operation][:parameters]
@@ -110,7 +117,8 @@ module FHIR
               p.parameter << parameter
             end
           end
-          reply = post resource_url(options), p, fhir_headers(options)
+          headers[:content_type] = "#{format}"
+          reply = post resource_url(options), p, fhir_headers(headers)
         end
 
         reply.resource = parse_reply(options[:resource], format, reply)
@@ -124,7 +132,8 @@ module FHIR
         add_resource_parameter(params, 'resource', resource)
         add_parameter(params, 'onlyCertainMatches', 'Boolean', options[:onlyCertainMatches]) unless options[:onlyCertainMatches].nil?
         add_parameter(params, 'count', 'Integer', options[:matchCount]) if options[:matchCount].is_a?(Integer)
-        post resource_url(options), params, fhir_headers(options)
+        post resource_url(options), params, fhir_headers({content_type: "#{format || @default_format}",
+                                                          accept: "#{format || @default_format}"})
       end
 
       #
@@ -139,18 +148,24 @@ module FHIR
 
       def validate(resource, options = {}, format = @default_format)
         options.merge!(resource: resource.class, validate: true, format: format)
+        headers = {}
+        headers[:accept] =  "#{format}" if format
+        headers[:content_type] = "#{format}"
         params = versioned_resource_class('Parameters').new
         add_resource_parameter(params, 'resource', resource)
         add_parameter(params, 'profile', 'Uri', options[:profile_uri]) unless options[:profile_uri].nil?
-        post resource_url(options), params, fhir_headers(options)
+        post resource_url(options), params, fhir_headers(headers)
       end
 
       def validate_existing(resource, id, options = {}, format = @default_format)
         options.merge!(resource: resource.class, id: id, validate: true, format: format)
+        headers = {}
+        headers[:accept] =  "#{format}" if format
+        headers[:content_type] = "#{format}"
         params = versioned_resource_class('Parameters').new
         add_resource_parameter(params, 'resource', resource)
         add_parameter(params, 'profile', 'Uri', options[:profile_uri]) unless options[:profile_uri].nil?
-        post resource_url(options), params, fhir_headers(options)
+        post resource_url(options), params, fhir_headers(headers)
       end
 
       private

data/lib/fhir_client/sections/search.rb

@@ -13,9 +13,9 @@ module FHIR
         options[:format] = format
 
         reply = if options[:search] && options[:search][:flag]
-                  post resource_url(options), nil, fhir_headers(options)
+                  post resource_url(options), nil, fhir_headers({content_type: 'application/x-www-form-urlencoded'})
                 else
-                  get resource_url(options), fhir_headers(options)
+                  get resource_url(options), fhir_headers
                 end
         # reply = get resource_url(options), fhir_headers(options)
         reply.resource = parse_reply(klass, format, reply)
@@ -27,9 +27,9 @@ module FHIR
         options.merge!(resource: klass, id: id, format: format)
         # if options[:search][:flag]
         reply = if options[:search] && options[:search][:flag]
-                  post resource_url(options), nil, fhir_headers(options)
+                  post resource_url(options), nil, fhir_headers({content_type: 'application/x-www-form-urlencoded'})
                 else
-                  get resource_url(options), fhir_headers(options)
+                  get resource_url(options), fhir_headers
                 end
         reply.resource = parse_reply(klass, format, reply)
         reply.resource_class = klass
@@ -39,9 +39,9 @@ module FHIR
       def search_all(options = {}, format = @default_format)
         options[:format] = format
         reply = if options[:search] && options[:search][:flag]
-                  post resource_url(options), nil, fhir_headers(options)
+                  post resource_url(options), nil, fhir_headers({content_type: 'application/x-www-form-urlencoded'})
                 else
-                  get resource_url(options), fhir_headers(options)
+                  get resource_url(options), fhir_headers
                 end
         reply.resource = parse_reply(nil, format, reply)
         reply.resource_class = nil

data/lib/fhir_client/sections/transactions.rb

@@ -61,8 +61,10 @@ module FHIR
       # @return FHIR::ClientReply
       #
       def end_batch(format = @default_format)
-        options = { format: format, 'Prefer' => 'return=representation' }
-        reply = post resource_url(options), @transaction_bundle, fhir_headers(options)
+        headers = {prefer: FHIR::Formats::ReturnPreferences::REPRESENTATION}
+        headers[:content_type] =  "#{format}"
+        options = { format: format}
+        reply = post resource_url(options), @transaction_bundle, fhir_headers(headers)
         begin
           reply.resource = if format.downcase.include?('xml')
                              versioned_resource_class('Xml').from_xml(reply.body)

data/lib/fhir_client/version.rb

@@ -1,5 +1,5 @@
 module FHIR
   class Client
-    VERSION = '3.0.7'
+    VERSION = '3.1.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fhir_client
 version: !ruby/object:Gem::Version
-  version: 3.0.7
+  version: 3.1.0
 platform: ruby
 authors:
 - Andre Quina
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-10 00:00:00.000000000 Z
+date: 2019-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -144,14 +144,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -256,6 +256,7 @@ files:
 - lib/fhir_client/patch_format.rb
 - lib/fhir_client/resource_address.rb
 - lib/fhir_client/resource_format.rb
+- lib/fhir_client/return_preferences.rb
 - lib/fhir_client/sections/crud.rb
 - lib/fhir_client/sections/feed.rb
 - lib/fhir_client/sections/history.rb