Merge pull request #108 from fhir-crucible/headers_update

Update Headers

Author: arscan

lib/fhir_client.rb

@@ -13,6 +13,7 @@
 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'

lib/fhir_client/client.rb

@@ -26,6 +26,10 @@ class Client
     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.
     #
@@ -37,10 +41,15 @@ def initialize(base_service_url, default_format: FHIR::Formats::ResourceFormat::
       @base_service_url = base_service_url
       FHIR.logger.info "Initializing client with #{@base_service_url}"
       @use_format_param = false
-      @exception_class = ClientException
+      @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
 
@@ -78,6 +87,20 @@ def use_dstu2
                         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)
@@ -259,7 +282,7 @@ def try_conformance_formats(default_format)
       @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)
@@ -283,17 +306,15 @@ def try_conformance_formats(default_format)
     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)
       @base_service_url + resource_url(options)
     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)
@@ -359,8 +380,10 @@ def base_path(path)
     # 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
@@ -394,7 +417,7 @@ def request_patch_payload(patchset, format)
 
     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)
@@ -404,10 +427,10 @@ def scrubbed_response_headers(result)
       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
@@ -583,7 +606,7 @@ def patch(path, patchset, headers)
       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

lib/fhir_client/resource_address.rb

@@ -6,46 +6,83 @@ class ResourceAddress
       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 = {}

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