fhir_client 1.0.1

data/lib/model/tag.rb

@@ -0,0 +1,57 @@
+module FHIR
+  class Tag
+    # Each Tag is part of an HTTP header named "Category" with three parts: term, scheme, and label.
+    # Each Tag can be in an individual "Category" header, or they can all be concatentated (with comma
+    # separation) inside a single "Category" header. 
+
+    # Term is a URI:
+    #   General tags: 
+    #     Bundle / FHIR Documents: "http://hl7.org/fhir/tag/document"
+    #     Bundle / FHIR Messages:  "http://hl7.org/fhir/tag/message" 
+    #   Profile tags: URL that references a profile resource.
+    attr_accessor :term
+
+    # Scheme is a URI:
+    #   "http://hl7.org/fhir/tag"           A general tag
+    #   "http://hl7.org/fhir/tag/profile"   A profile tag - a claim that the Resource conforms to the profile identified in the term
+    #   "http://hl7.org/fhir/tag/security"  A security label
+    attr_accessor :scheme
+
+    # Label is an OPTIONAL human-readable label for the tag for use when displaying in end-user applications
+    attr_accessor :label
+
+    def to_header
+      s = "#{term}; scheme=#{scheme}"
+      s += "; label=#{label}" if !label.nil?
+      s
+    end
+
+    # Parses a string named "header" and returns a Tag object.
+    def self.parse_tag(header)
+      h = FHIR::Tag.new
+      regex = /\s*;\s*/
+      tokens = header.strip.split(regex)
+      h.term = tokens.shift
+      tokens.each do |token|
+        if !token.strip.index('scheme').nil?
+          token.strip =~ %r{(?<=scheme)(\s*)=(\s*)([\".:_\-\/\w]+)}
+          h.scheme = $3
+        elsif !token.strip.index('label').nil?
+          token.strip =~ %r{(?<=label)(\s*)=(\s*)([\".:_\-\/\w\s]+)}
+          h.label = $3
+        end
+      end
+      h
+    end
+
+    # Parses a string named "header" and returns an Array of Tag objects.
+    def self.parse_tags(header)
+      tags = []
+      regex = /\s*,\s*/
+      tokens = header.strip.split(regex)
+      tokens.each { |token| tags << FHIR::Tag.parse_tag(token) }
+      tags
+    end
+
+  end
+end

data/lib/patch_format.rb

@@ -0,0 +1,10 @@
+module FHIR
+  module Formats
+    class PatchFormat
+
+      PATCH_XML = "application/xml-patch+xml"
+      PATCH_JSON = "application/json-patch+json"
+
+    end
+  end
+end

data/lib/resource_address.rb

@@ -0,0 +1,133 @@
+module FHIR
+  class ResourceAddress
+
+    DEFAULTS = {
+      id: nil,
+      resource: nil,
+      format: 'application/xml+fhir',
+    }
+
+    DEFAULT_CHARSET = 'UTF-8'
+
+    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 ['xml','json'].include?(format.downcase)
+
+      if(options[:category])
+        # options[:category] should be an Array of FHIR::Tag objects
+        tags = {
+          'Category' => options[:category].collect { |h| h.to_header }.join(',')
+        }
+        fhir_headers.merge!(tags)
+        options.delete(:category)
+      end
+
+      if use_format_param
+        fhir_headers.delete('Accept')
+        options.delete('Accept')
+        options.delete(:accept)
+      else
+        fhir_headers['Accept'] = format
+      end
+
+      fhir_headers.merge!(options) unless options.empty?
+      fhir_headers[:operation] = options[:operation][:name] if options[:operation] && options[:operation][:name]
+      fhir_headers
+    end
+
+    def resource_url(options, use_format_param=false)
+      options = DEFAULTS.merge(options)
+
+      params = {}
+      url = ""
+      # handle requests for resources by class or string; useful for testing nonexistent resource types
+      url += "/#{ options[:resource].try(:name).try(:demodulize) || options[:resource].split("::").last }" if options[:resource]
+      url += "/#{options[:id]}" if options[:id]
+      url += "/$validate" if options[:validate]
+
+      if(options[:operation])
+        opr = options[:operation]
+        p = opr[:parameters]
+        p = p.each{|k,v|p[k]=v[:value]} if p
+        params.merge!(p) if p && opr[:method]=='GET'
+
+        if (opr[:name] == :fetch_patient_record)
+          url += "/$everything"
+        elsif (opr[:name] == :value_set_expansion)
+          url += "/$expand"
+        elsif (opr  && opr[:name]== :value_set_based_validation)
+          url += "/$validate-code"
+        elsif (opr  && opr[:name]== :code_system_lookup)
+          url += "/$lookup"
+        elsif (opr  && opr[:name]== :concept_map_translate)
+          url += "/$translate"
+        end
+      end
+
+      if (options[:history])
+        history = options[:history]
+        url += "/_history/#{history[:id]}"
+        params[:_count] = history[:count] if history[:count]
+        params[:_since] = history[:since].iso8601 if history[:since]
+      end
+
+      if(options[:search])
+        search_options = options[:search]
+        url += '/_search' if search_options[:flag]
+        url += "/#{search_options[:compartment]}" if search_options[:compartment]
+
+        if search_options[:parameters]
+          search_options[:parameters].each do |key,value|
+            params[key.to_sym] = value
+          end
+        end
+      end
+
+      # options[:params] is simply appended at the end of a url and is used by testscripts
+      url += options[:params] if options[:params]
+
+      if(options[:summary])
+        params[:_summary] = options[:summary]
+      end
+
+      if use_format_param && options[:format]
+        params[:_format] = options[:format]
+      end
+
+      uri = Addressable::URI.parse(url)
+      # params passed in options takes precidence over params calculated in this method
+      # for use by testscript primarily
+      uri.query_values = params unless options[:params] && options[:params].include?("?")
+      uri.normalize.to_str
+    end
+
+    # Get the resource ID out of the URL (e.g. Bundle.entry.response.location)
+    def self.pull_out_id(resourceType,url)
+      id = nil
+      if !resourceType.nil? && !url.nil?
+        token = "#{resourceType}/"
+        start = url.index(token) + token.length
+        t = url[start..-1]
+        stop = (t.index("/") || 0)-1
+        stop = -1 if stop.nil?
+        id = t[0..stop]
+      end
+      id
+    end
+
+    def self.append_forward_slash_to_path(path)
+      path += '/' unless path.last == '/'
+      path
+    end
+
+  end
+end

data/lib/resource_format.rb

@@ -0,0 +1,10 @@
+module FHIR
+  module Formats
+    class ResourceFormat
+
+      RESOURCE_XML = "application/xml+fhir"
+      RESOURCE_JSON = "application/json+fhir"
+
+    end
+  end
+end

data/lib/sections/crud.rb

@@ -0,0 +1,170 @@
+module FHIR
+  module Sections
+    module Crud
+
+      #
+      # 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)
+        options[:summary] = summary if summary
+        reply = get resource_url(options), fhir_headers(options)
+        reply.resource = parse_reply(klass, format, reply)
+        reply.resource_class = klass
+        reply
+      end
+
+      #
+      # Read a resource bundle (an XML ATOM feed)
+      #
+      def read_feed(klass, format=@default_format_bundle)
+        options = { resource: klass, format: format }
+        reply = get resource_url(options), fhir_headers(options)
+        reply.resource = parse_reply(klass, format, reply)
+        reply.resource_class = klass
+        reply
+      end
+
+      #
+      # Read the state of a specific version of the resource
+      #
+      def vread(klass, id, version_id, format=@default_format)
+        options = { resource: klass, id: id, format: format, history: {id: version_id} }
+        reply = get resource_url(options), fhir_headers(options)
+        reply.resource = parse_reply(klass, format, reply)
+        reply.resource_class = klass
+        reply
+      end
+
+      def raw_read(options)
+        reply = get resource_url(options), fhir_headers(options)
+        reply.body
+      end
+
+      def raw_read_url(url)
+        reply = get url, fhir_headers({})
+        reply.body
+      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)
+        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, searchParams, format=@default_format)
+        options = {
+          :search => {
+            :flag => false,
+            :compartment => nil,
+            :parameters => {}
+          }
+        }
+        searchParams.each do |key,value|
+          options[:search][:parameters][key] = value
+        end
+        base_update(resource, id, options, format)
+      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)
+        options = {} if options.nil?
+        options[:resource] = resource.class
+        options[:format] = format
+        options[:id] = id
+        reply = put resource_url(options), resource, fhir_headers(options)
+        reply.resource = parse_reply(resource.class, format, reply)
+        reply.resource_class = resource.class
+        reply
+      end
+
+      #
+      # 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
+        
+        if (format == FHIR::Formats::ResourceFormat::RESOURCE_XML)
+          options[:format] = FHIR::Formats::PatchFormat::PATCH_XML
+          options[:Accept] = format
+        elsif (format == FHIR::Formats::ResourceFormat::RESOURCE_JSON)
+          options[:format] = FHIR::Formats::PatchFormat::PATCH_JSON
+          options[:Accept] = format
+        end
+
+        reply = patch resource_url(options), patchset, fhir_headers(options)
+        reply.resource = parse_reply(klass, format, reply)
+        reply.resource_class = klass
+        reply
+      end
+
+      #
+      # Delete the resource with the given ID.
+      #
+      def destroy(klass, id=nil, options={})
+        options = { resource: klass, id: id, format: nil }.merge options
+        reply = delete resource_url(options), fhir_headers(options)
+        reply.resource_class = klass
+        reply
+      end
+
+      #
+      # 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)
+      end
+
+      #
+      # Conditionally create a new resource with a server assigned id.
+      #
+      def conditional_create(resource, ifNoneExistParameters, format=@default_format)
+        query = ''
+        ifNoneExistParameters.each do |key,value|
+          query += "#{key.to_s}=#{value.to_s}&"
+        end
+        query = query[0..-2] # strip off the trailing ampersand
+        options = {}
+        options['If-None-Exist'] = query
+        base_create(resource, options, format)
+      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)
+        options = {} if options.nil?
+        options[:resource] = resource.class
+        options[:format] = format
+        reply = post resource_url(options), resource, fhir_headers(options)
+        if [200,201].include? reply.code
+          type = reply.response[:headers][:content_type]
+          if !type.nil?
+            if type.include?('xml') && !reply.body.empty?
+              reply.resource = resource.class.from_xml(reply.body)
+            elsif type.include?('json') && !reply.body.empty?
+              reply.resource = resource.class.from_fhir_json(reply.body)
+            else
+              reply.resource = resource # just send back the submitted resource
+            end
+          else
+            reply.resource = resource # don't know the content type, so return the resource provided
+          end
+        else
+          reply.resource = resource # just send back the submitted resource
+        end
+        reply.resource_class = resource.class
+        reply
+      end
+
+    end
+  end
+end

data/lib/sections/feed.rb

@@ -0,0 +1,23 @@
+module FHIR
+  module Sections
+    module Feed
+
+      FORWARD = :next_link
+      BACKWARD = :previous_link
+      FIRST = :first_link
+      LAST = :last_link
+
+      def next_page(current, page=FORWARD)
+        bundle = current.resource
+        link = bundle.method(page).call
+        return nil unless link
+        reply = get strip_base(link.url), fhir_headers
+        reply.resource = parse_reply(current.resource_class, @default_format_bundle, reply)
+        reply.resource_class = current.resource_class
+        reply
+      end
+
+
+    end
+  end
+end

data/lib/sections/history.rb

@@ -0,0 +1,78 @@
+module FHIR
+  module Sections
+    module History
+      #
+      # Create a new resource with a server assigned id. Return the newly created
+      # resource with the id the server assigned. Associates tags with newly created resource.
+      # 
+      # @param resourceClass
+      # @param resource
+      # @return
+      #
+      # public <T extends Resource> AtomEntry<OperationOutcome> create(Class<T> resourceClass, T resource, List<AtomCategory> tags);
+      
+      #
+      # Retrieve the update history for a resource with given id since last update time. 
+      # Last update may be null TODO - ensure this is the case.
+      # 
+      # @param lastUpdate
+      # @param resourceClass
+      # @param id
+      # @return
+      #
+      # public <T extends Resource> AtomFeed history(Calendar lastUpdate, Class<T> resourceClass, String id);
+      # public <T extends Resource> AtomFeed history(DateAndTime lastUpdate, Class<T> resourceClass, String id);
+      
+      def history(options)
+        reply = get resource_url(options), fhir_headers(options).except(:history)
+        reply.resource = parse_reply(options[:resource], @default_format_bundle, reply)
+        reply.resource_class = options[:resource]
+        reply
+      end
+
+      #
+      # Retrieve the entire update history for a resource with the given id.
+      # Last update may be null TODO - ensure this is the case.
+      # 
+      # @param resourceClass
+      # @param id
+      # @param lastUpdate
+      # @return
+      #
+      def resource_instance_history_as_of(klass, id, lastUpdate)
+        history(resource: klass, id: id, history:{since: lastUpdate})
+      end
+
+      def resource_instance_history(klass, id)
+        history(resource: klass, id: id, history:{})
+      end
+
+      def resource_history(klass)
+        history(resource: klass, history:{})
+      end
+
+      def resource_history_as_of(klass, lastUpdate)
+        history(resource: klass, history:{since: lastUpdate})
+      end
+      
+      #
+      # Retrieve the update history for all resource types since the start of server records.
+      # 
+      def all_history
+        history(history:{})
+      end
+
+      #
+      # Retrieve the update history for all resource types since a specific last update date/time.
+      # 
+      # Note: 
+      # @param lastUpdate
+      # @return
+      #
+      def all_history_as_of(lastUpdate)
+        history(history:{since: lastUpdate})
+      end
+
+    end
+  end
+end