fhir_client 1.6.3 → 1.6.7

data/lib/fhir_client/resource_format.rb

@@ -0,0 +1,11 @@
+module FHIR
+  module Formats
+    class ResourceFormat
+      RESOURCE_XML = 'application/fhir+xml'.freeze
+      RESOURCE_JSON = 'application/fhir+json'.freeze
+
+      RESOURCE_XML_DSTU2 = 'application/xml+fhir'.freeze
+      RESOURCE_JSON_DSTU2 = 'application/json+fhir'.freeze
+    end
+  end
+end

data/lib/{sections → fhir_client/sections}/crud.rb

@@ -1,11 +1,10 @@
 module FHIR
   module Sections
     module Crud
-
       #
       # Read the current state of a resource.
       #
-      def read(klass, id, format=@default_format, summary=nil, options = {})
+      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)
@@ -17,7 +16,7 @@ module FHIR
       #
       # Read a resource bundle (an XML ATOM feed)
       #
-      def read_feed(klass, format=@default_format)
+      def read_feed(klass, format = @default_format)
         options = { resource: klass, format: format }
         reply = get resource_url(options), fhir_headers(options)
         reply.resource = parse_reply(klass, format, reply)
@@ -28,8 +27,8 @@ module FHIR
       #
       # 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} }
+      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
@@ -49,22 +48,22 @@ module FHIR
       #
       # 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 = @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)
+      def conditional_update(resource, id, search_params, format = @default_format)
         options = {
-          :search => {
-            :flag => false,
-            :compartment => nil,
-            :parameters => {}
+          search: {
+            flag: false,
+            compartment: nil,
+            parameters: {}
           }
         }
-        searchParams.each do |key,value|
+        search_params.each do |key, value|
           options[:search][:parameters][key] = value
         end
         base_update(resource, id, options, format)
@@ -87,13 +86,13 @@ module FHIR
       #
       # Partial update using a patchset (PATCH)
       #
-      def partial_update(klass, id, patchset, options={}, format=@default_format)
+      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 format == FHIR::Formats::ResourceFormat::RESOURCE_XML
           options[:format] = FHIR::Formats::PatchFormat::PATCH_XML
           options[:Accept] = format
-        elsif (format == FHIR::Formats::ResourceFormat::RESOURCE_JSON)
+        elsif format == FHIR::Formats::ResourceFormat::RESOURCE_JSON
           options[:format] = FHIR::Formats::PatchFormat::PATCH_JSON
           options[:Accept] = format
         end
@@ -107,7 +106,7 @@ module FHIR
       #
       # Delete the resource with the given ID.
       #
-      def destroy(klass, id=nil, options={})
+      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
@@ -118,17 +117,17 @@ 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, 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)
+      def conditional_create(resource, if_none_exist_parameters, format = @default_format)
         query = ''
-        ifNoneExistParameters.each do |key,value|
-          query += "#{key.to_s}=#{value.to_s}&"
+        if_none_exist_parameters.each do |key, value|
+          query += "#{key}=#{value}&"
         end
         query = query[0..-2] # strip off the trailing ampersand
         options = {}
@@ -145,16 +144,16 @@ module FHIR
         options[:resource] = resource.class
         options[:format] = format
         reply = post resource_url(options), resource, fhir_headers(options)
-        if [200,201].include? reply.code
+        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
+            reply.resource = if type.include?('xml') && !reply.body.empty?
+                               resource.class.from_xml(reply.body)
+                             elsif type.include?('json') && !reply.body.empty?
+                               resource.class.from_fhir_json(reply.body)
+                             else
+                               resource # just send back the submitted resource
+                             end
           else
             resource.id = FHIR::ResourceAddress.pull_out_id(resource.class.name.demodulize, reply.response[:headers]['location'])
             reply.resource = resource # don't know the content type, so return the resource provided
@@ -167,7 +166,6 @@ module FHIR
         reply.resource_class = resource.class
         reply
       end
-
     end
   end
 end

data/lib/{sections → fhir_client/sections}/feed.rb

@@ -1,13 +1,12 @@
 module FHIR
   module Sections
     module Feed
-
       FORWARD = :next_link
       BACKWARD = :previous_link
       FIRST = :first_link
       LAST = :last_link
 
-      def next_page(current, page=FORWARD)
+      def next_page(current, page = FORWARD)
         bundle = current.resource
         link = bundle.method(page).call
         return nil unless link
@@ -16,8 +15,6 @@ module FHIR
         reply.resource_class = current.resource_class
         reply
       end
-
-
     end
   end
 end

data/lib/{sections → fhir_client/sections}/history.rb

@@ -15,13 +15,13 @@ module FHIR
       # 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 last_update
       # @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);
+      # public <T extends Resource> AtomFeed history(Calendar last_update, Class<T> resourceClass, String id);
+      # public <T extends Resource> AtomFeed history(DateAndTime last_update, Class<T> resourceClass, String id);
 
       def history(options)
         reply = get resource_url(options), fhir_headers(options).except(:history)
@@ -36,43 +36,42 @@ module FHIR
       #
       # @param resourceClass
       # @param id
-      # @param lastUpdate
+      # @param last_update
       # @return
       #
-      def resource_instance_history_as_of(klass, id, lastUpdate)
-        history(resource: klass, id: id, history:{since: lastUpdate})
+      def resource_instance_history_as_of(klass, id, last_update)
+        history(resource: klass, id: id, history: { since: last_update })
       end
 
       def resource_instance_history(klass, id)
-        history(resource: klass, id: id, history:{})
+        history(resource: klass, id: id, history: {})
       end
 
       def resource_history(klass)
-        history(resource: klass, history:{})
+        history(resource: klass, history: {})
       end
 
-      def resource_history_as_of(klass, lastUpdate)
-        history(resource: klass, history:{since: lastUpdate})
+      def resource_history_as_of(klass, last_update)
+        history(resource: klass, history: { since: last_update })
       end
 
       #
       # Retrieve the update history for all resource types since the start of server records.
       #
       def all_history
-        history(history:{})
+        history(history: {})
       end
 
       #
       # Retrieve the update history for all resource types since a specific last update date/time.
       #
       # Note:
-      # @param lastUpdate
+      # @param last_update
       # @return
       #
-      def all_history_as_of(lastUpdate)
-        history(history:{since: lastUpdate})
+      def all_history_as_of(last_update)
+        history(history: { since: last_update })
       end
-
     end
   end
 end

data/lib/{sections → fhir_client/sections}/operations.rb

@@ -1,7 +1,6 @@
 module FHIR
   module Sections
     module Operations
-
       # DSTU 2 Operations: http://hl7.org/implement/standards/FHIR-Develop/operations.html
 
       # Concept Translation	[base]/ConceptMap/$translate | [base]/ConceptMap/[id]/$translate
@@ -11,34 +10,32 @@ 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)
-        fetch_record(id,startTime,endTime,method,FHIR::Patient,format)
+      def fetch_patient_record(id = nil, startTime = nil, endTime = nil, method = 'GET', format = @default_format)
+        fetch_record(id, [startTime, endTime], method, FHIR::Patient, format)
       end
 
-      def fetch_encounter_record(id=nil, method='GET', format=@default_format)
-        fetch_record(id,nil,nil,method,FHIR::Encounter,format)
+      def fetch_encounter_record(id = nil, method = 'GET', format = @default_format)
+        fetch_record(id, [nil, nil], method, FHIR::Encounter, format)
       end
 
-      def fetch_record(id=nil, startTime=nil, endTime=nil, method='GET', klass=FHIR::Patient, format=@default_format)
+      def fetch_record(id = nil, time = [nil, nil], method = 'GET', klass = FHIR::Patient, format = @default_format)
         options = { resource: klass, format: format, operation: { name: :fetch_patient_record, method: method } }
-        options.deep_merge!({id: id}) if !id.nil?
+        options.deep_merge!(id: id) unless id.nil?
         options[:operation][:parameters] = {} if options[:operation][:parameters].nil?
-        options[:operation][:parameters].merge!({start: { type: 'Date', value: startTime}}) if !startTime.nil?
-        options[:operation][:parameters].merge!({end: { type: 'Date', value:endTime}}) if !endTime.nil?
+        options[:operation][:parameters][:start] = { type: 'Date', value: time.first } unless time.first.nil?
+        options[:operation][:parameters][:end] = { type: 'Date', value: time.last } unless time.last.nil?
 
-        if options[:operation][:method]=='GET'
+        if options[:operation][:method] == 'GET'
           reply = get resource_url(options), fhir_headers(options)
         else
           # create Parameters body
-          body = nil
-          if(options[:operation] && options[:operation][:parameters])
+          if options[:operation] && options[:operation][:parameters]
             p = FHIR::Parameters.new
-            options[:operation][:parameters].each do |key,value|
+            options[:operation][:parameters].each do |key, value|
               parameter = FHIR::Parameters::Parameter.new.from_hash(name: key.to_s)
               parameter.method("value#{value[:type]}=").call(value[:value])
               p.parameter << parameter
             end
-            body = p.to_xml
           end
           reply = post resource_url(options), p, fhir_headers(options)
         end
@@ -55,7 +52,7 @@ module FHIR
       # Value Set Expansion	[base]/ValueSet/$expand | [base]/ValueSet/[id]/$expand
       # http://hl7.org/implement/standards/FHIR-Develop/valueset-operations.html#expand
       # The definition of a value set is used to create a simple collection of codes suitable for use for data entry or validation.
-      def value_set_expansion(params={}, format=@default_format)
+      def value_set_expansion(params = {}, format = @default_format)
         options = { resource: FHIR::ValueSet, operation: { name: :value_set_expansion } }
         options.deep_merge!(params)
         terminology_operation(options, format)
@@ -64,51 +61,49 @@ module FHIR
       # Value Set based Validation	[base]/ValueSet/$validate | [base]/ValueSet/[id]/$validate
       # http://hl7.org/implement/standards/FHIR-Develop/valueset-operations.html#validate
       # Validate that a coded value is in the set of codes allowed by a value set.
-      def value_set_code_validation(params={}, format=@default_format)
-        options = { resource: FHIR::ValueSet,  operation: { name: :value_set_based_validation } }
+      def value_set_code_validation(params = {}, format = @default_format)
+        options = { resource: FHIR::ValueSet, operation: { name: :value_set_based_validation } }
         options.deep_merge!(params)
         terminology_operation(options, format)
       end
 
       # Concept Look Up [base]/CodeSystem/$lookup
-      def code_system_lookup(params={}, format=@default_format)
+      def code_system_lookup(params = {}, format = @default_format)
         options = { resource: FHIR::CodeSystem, operation: { name: :code_system_lookup } }
         options.deep_merge!(params)
         terminology_operation(options, format)
       end
 
       # ConceptMap Translation
-      def concept_map_translate(params={}, format=@default_format)
+      def concept_map_translate(params = {}, format = @default_format)
         options = { resource: FHIR::ConceptMap, operation: { name: :concept_map_translate } }
         options.deep_merge!(params)
         terminology_operation(options, format)
       end
 
       # ConceptMap Closure Table Maintenance
-      def closure_table_maintenance(params={}, format=@default_format)
+      def closure_table_maintenance(params = {}, format = @default_format)
         options = { operation: { name: :closure_table_maintenance } }
         options.deep_merge!(params)
-        terminology_operation(options, format)        
+        terminology_operation(options, format)
       end
 
-      def terminology_operation(params={}, format=@default_format)
+      def terminology_operation(params = {}, format = @default_format)
         options = { format: format }
         # params = [id, code, system, version, display, coding, codeableConcept, date, abstract]
         options.deep_merge!(params)
 
-        if options[:operation][:method]=='GET'
+        if options[:operation][:method] == 'GET'
           reply = get resource_url(options), fhir_headers(options)
         else
           # create Parameters body
-          body = nil
-          if(options[:operation] && options[:operation][:parameters])
+          if options[:operation] && options[:operation][:parameters]
             p = FHIR::Parameters.new
-            options[:operation][:parameters].each do |key,value|
+            options[:operation][:parameters].each do |key, value|
               parameter = FHIR::Parameters::Parameter.new.from_hash(name: key.to_s)
               parameter.method("value#{value[:type]}=").call(value[:value])
               p.parameter << parameter
             end
-            body = p.to_xml
           end
           reply = post resource_url(options), p, fhir_headers(options)
         end
@@ -119,7 +114,6 @@ module FHIR
       end
 
       # Batch Mode Validation	[base]/ValueSet/$batch
-
     end
   end
 end

data/lib/fhir_client/sections/search.rb

@@ -0,0 +1,52 @@
+module FHIR
+  module Sections
+    module Search
+      #
+      # Search a set of resources of a given type.
+      #
+      # @param klass The type of resource to be searched.
+      # @param options A hash of options used to construct the search query.
+      # @return FHIR::ClientReply
+      #
+      def search(klass, options = {}, format = @default_format)
+        options[:resource] = klass
+        options[:format] = format
+
+        reply = if options[:search] && options[:search][:flag]
+                  post resource_url(options), nil, fhir_headers(options)
+                else
+                  get resource_url(options), fhir_headers(options)
+                end
+        # reply = get resource_url(options), fhir_headers(options)
+        reply.resource = parse_reply(klass, format, reply)
+        reply.resource_class = klass
+        reply
+      end
+
+      def search_existing(klass, id, options = {}, format = @default_format)
+        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)
+                else
+                  get resource_url(options), fhir_headers(options)
+                end
+        reply.resource = parse_reply(klass, format, reply)
+        reply.resource_class = klass
+        reply
+      end
+
+      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)
+                else
+                  get resource_url(options), fhir_headers(options)
+                end
+        reply.resource = parse_reply(nil, format, reply)
+        reply.resource_class = nil
+        reply
+      end
+    end
+  end
+end

data/lib/{sections → fhir_client/sections}/tags.rb

@@ -2,50 +2,50 @@ module FHIR
   module Sections
     module Tags
       #
-      # Get a list of all tags on server 
-      # 
+      # Get a list of all tags on server
+      #
       # GET [base]/_tags
       #
       # public List<AtomCategory> getAllTags();
 
       #
-      # Get a list of all tags used for the nominated resource type 
-      # 
+      # Get a list of all tags used for the nominated resource type
+      #
       # GET [base]/[type]/_tags
       #
       # public <T extends Resource> List<AtomCategory> getAllTagsForResourceType(Class<T> resourceClass);
 
       #
-      # Get a list of all tags affixed to the nominated resource. This duplicates the HTTP header entries 
-      # 
+      # Get a list of all tags affixed to the nominated resource. This duplicates the HTTP header entries
+      #
       # GET [base]/[type]/[id]/_tags
       #
       # public <T extends Resource> List<AtomCategory> getTagsForResource(Class<T> resource, String id);
 
       #
       # Get a list of all tags affixed to the nominated version of the resource. This duplicates the HTTP header entries
-      # 
+      #
       # GET [base]/[type]/[id]/_history/[vid]/_tags
       #
       # public <T extends Resource> List<AtomCategory> getTagsForResourceVersion(Class<T> resource, String id, String versionId);
 
       #
       # Remove all tags in the provided list from the list of tags for the nominated resource
-      # 
+      #
       # DELETE [base]/[type]/[id]/_tags
       #
       # //public <T extends Resource> boolean deleteTagsForResource(Class<T> resourceClass, String id);
 
       #
       # Remove tags in the provided list from the list of tags for the nominated version of the resource
-      # 
+      #
       # DELETE [base]/[type]/[id]/_history/[vid]/_tags
       #
       # public <T extends Resource> List<AtomCategory> deleteTags(List<AtomCategory> tags, Class<T> resourceClass, String id, String version);
 
       #
       # Affix tags in the list to the nominated resource
-      # 
+      #
       # POST [base]/[type]/[id]/_tags
       # @return
       #
@@ -53,9 +53,9 @@ module FHIR
 
       #
       # Affix tags in the list to the nominated version of the resource
-      # 
+      #
       # POST [base]/[type]/[id]/_history/[vid]/_tags
-      # 
+      #
       # @return
       #
       # public <T extends Resource> List<AtomCategory> createTags(List<AtomCategory> tags, Class<T> resourceClass, String id, String version);