fhir_client 1.0.1

data/lib/sections/operations.rb

@@ -0,0 +1,118 @@
+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
+
+      # Closure Table Maintenance	[base]/$closure
+
+      # 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)
+      end
+
+      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)
+        options = { resource: klass, format: format, operation: { name: :fetch_patient_record, method: method } }
+        options.deep_merge!({id: id}) if !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?
+
+        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])
+            p = FHIR::Parameters.new
+            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
+
+        reply.resource = parse_reply(FHIR::Bundle, format, reply)
+        reply.resource_class = options[:resource]
+        reply
+      end
+
+      # Build Questionnaire	[base]/Profile/$questionnaire | [base]/Profile/[id]/$questionnaire
+
+      # Populate Questionnaire	[base]/Questionnaire/$populate | [base]/Questionnaire/[id]/$populate
+
+      # 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)
+        options = { resource: FHIR::ValueSet, operation: { name: :value_set_expansion } }
+        options.deep_merge!(params)
+        terminology_operation(options, format)
+      end
+
+      # 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 } }
+        options.deep_merge!(params)
+        terminology_operation(options, format)
+      end
+
+      # Concept Look Up [base]/CodeSystem/$lookup
+      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
+
+      #
+      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
+
+      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'
+          reply = get resource_url(options), fhir_headers(options)
+        else
+          # create Parameters body
+          body = nil
+          if(options[:operation] && options[:operation][:parameters])
+            p = FHIR::Parameters.new
+            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
+
+        reply.resource = parse_reply(options[:resource], format, reply)
+        reply.resource_class = options[:resource]
+        reply
+      end
+
+      # Batch Mode Validation	[base]/ValueSet/$batch
+
+    end
+  end
+end

data/lib/sections/search.rb

@@ -0,0 +1,53 @@
+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_bundle)
+        options.merge!({ resource: klass, format: format })
+
+        if options[:search] && options[:search][:flag]
+          reply = post resource_url(options), nil, fhir_headers(options)
+        else
+          reply = 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_bundle)
+        options.merge!({ resource: klass, id: id, format: format })
+        #if options[:search][:flag]
+        if options[:search] && options[:search][:flag]
+          reply = post resource_url(options), nil, fhir_headers(options)
+        else
+          reply = 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_bundle)
+        options.merge!({ format: format })
+        if options[:search] && options[:search][:flag]
+          reply = post resource_url(options), nil, fhir_headers(options)
+        else
+          reply = 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/tags.rb

@@ -0,0 +1,64 @@
+module FHIR
+  module Sections
+    module Tags
+      #
+      # 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 [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 [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
+      #
+      # public <T extends Resource> List<AtomCategory> createTags(List<AtomCategory> tags, Class<T> resourceClass, String id);
+
+      #
+      # 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);
+    end
+  end
+end

data/lib/sections/transactions.rb

@@ -0,0 +1,83 @@
+module FHIR
+  module Sections
+    module Transactions
+
+      attr_accessor :transaction_bundle
+
+      def begin_transaction
+        @transaction_bundle = FHIR::Bundle.new
+        @transaction_bundle.type = 'transaction'
+        @transaction_bundle.entry ||= []
+        @transaction_bundle
+      end
+
+      def begin_batch
+        @transaction_bundle = FHIR::Bundle.new
+        @transaction_bundle.type = 'batch'
+        @transaction_bundle.entry ||= []
+        @transaction_bundle
+      end
+
+      # syntactic sugar for add_batch_request
+      # @param method one of ['GET','POST','PUT','DELETE']
+      # @param url relative path, such as 'Patient/123'. Do not include the [base]
+      # @param resource The resource if a POST or PUT
+      def add_transaction_request(method, url, resource=nil, if_none_exist=nil)
+        add_batch_request(method, url, resource, if_none_exist)
+      end
+
+      def add_batch_request(method, url, resource=nil, if_none_exist=nil)
+        request = FHIR::Bundle::Entry::Request.new
+        if FHIR::Bundle::Entry::Request::METADATA['method']['valid_codes'].values.first.include?(method.upcase)
+          request.local_method = method.upcase 
+        else
+          request.local_method = 'POST'
+        end
+        request.ifNoneExist = if_none_exist if !if_none_exist.nil?
+        if url.nil? && !resource.nil?
+          options = Hash.new
+          options[:resource] = resource.class
+          options[:id] = resource.id if request.local_method != 'POST'
+          request.url = resource_url(options)
+          request.url = request.url[1..-1] if request.url.starts_with?('/')
+        else
+          request.url = url
+        end
+
+        entry = FHIR::Bundle::Entry.new
+        entry.resource = resource
+        entry.request = request
+
+        @transaction_bundle.entry << entry
+        entry
+      end
+
+      # syntactic sugar for end_batch
+      def end_transaction(format=@default_format)
+        end_batch(format)
+      end
+
+      # submit the batch/transaction to the server
+      # @param format
+      # @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)
+        begin
+          if(format.downcase.include?('xml'))
+            reply.resource = FHIR::Xml.from_xml(reply.body)
+          else
+            reply.resource = FHIR::Json.from_json(reply.body)
+          end
+        rescue Exception => e 
+          reply.resource = nil
+        end
+        reply.resource_class = reply.resource.class
+        reply
+      end
+
+    end
+  end
+end
+

data/lib/sections/validate.rb

@@ -0,0 +1,49 @@
+module FHIR
+  module Sections
+    module Validate
+      #
+      # Validate resource payload.
+      # 
+      # @param resourceClass
+      # @param resource
+      # @param id
+      # @return
+      #
+      # public <T extends Resource> AtomEntry<OperationOutcome> validate(Class<T> resourceClass, T resource, String id);
+      def validate(resource, options={}, format=@default_format)
+        options.merge!({ resource: resource.class, validate: true, format: format })
+        params = FHIR::Parameters.new
+        add_resource_parameter(params,'resource',resource)
+        add_parameter(params,'profile','Uri',options[:profile_uri]) if !options[:profile_uri].nil?
+        post resource_url(options), params, fhir_headers(options)
+      end
+
+      def validate_existing(resource, id, options={}, format=@default_format)
+        options.merge!({ resource: resource.class, id: id, validate: true, format: format })
+        params = FHIR::Parameters.new
+        add_resource_parameter(params,'resource',resource)
+        add_parameter(params,'profile','Uri',options[:profile_uri]) if !options[:profile_uri].nil?
+        post resource_url(options), params, fhir_headers(options)
+      end
+
+
+      private
+      def add_parameter(params,name,type,value)
+        params.parameter ||= []
+        parameter = FHIR::Parameters::Parameter.new.from_hash(name: name)
+        parameter.method("value#{type}=").call(value)
+        params.parameter << parameter
+      end
+
+      def add_resource_parameter(params, name,resource)
+        params.parameter ||= []
+        parameter = FHIR::Parameters::Parameter.new.from_hash(name: name)
+        parameter.resource = resource
+        params.parameter << parameter
+      end
+
+
+    end
+  end
+end
+

data/lib/tasks/tasks.rake

@@ -0,0 +1,73 @@
+namespace :fhir do
+
+  desc 'console'
+  task :console, [] do |t, args|
+    binding.pry
+  end
+
+  #
+  # Prerequisites & Assumptions:
+  #
+  #  1. Running SMART-on-FHIR (DSTU2 branch) server  [http://example/fhir]
+  #  2. Running OpenID Connect server [http://example:8080/openid-connect-server-webapp]
+  #  3. Configured client under OpenID Connect server:
+  #     a. Create a system scope if necessary. SMART-on-FHIR requires 'fhir_complete' scope.
+  #     b. Add the scope created in (a) to client.
+  #     c. Add the FHIR server URL to the list of allowed redirect URIs (required?)
+  #     d. Ensure client has 'client credentials' grant type
+  #     d. Whitelist the client
+  #  4. 'client_id' and 'client_secret' variables are the name and secret of the client created in (3)
+  #  5. :authorize_url is the authorization endpoint of the OpenID connect server
+  #  6. :token_url is the token endpoint of the OpenID connect server
+  #  
+  desc 'OAuth2 Example'
+  task :oauth2, [:url,:client_id,:client_secret] do |t, args|
+    client = FHIR::Client.new(args.url)
+    client_id = args.client_id
+    client_secret = args.client_secret
+    options = client.get_oauth2_metadata_from_conformance
+    if options.empty?
+      puts 'This server does not support the expected OAuth2 extensions.'
+    else
+      client.set_oauth2_auth(client_id,client_secret,options[:authorize_url],options[:token_url])
+      reply = client.read_feed(FHIR::Patient)
+      puts reply.body
+    end
+  end
+
+  desc 'count all resources for a given server'
+  task :count, [:url] do |t, args|
+    client = FHIR::Client.new(args.url)
+    counts = {}
+    fhir_resources.map do | klass |
+      reply = client.read_feed(klass)
+      counts["#{klass.name.demodulize}"] = reply.resource.total unless reply.resource.nil?
+    end
+    printf "  %-30s %5s\n", 'Resource', 'Count'
+    printf "  %-30s %5s\n", '--------', '-----'
+    counts.each do |key,value|
+      # puts "#{key}  #{value}"
+      printf "  %-30s %5s\n", key, value
+    end
+  end
+
+  desc 'delete all resources for a given server'
+  task :clean, [:url] do |t, args|
+    client = FHIR::Client.new(args.url)
+    fhir_resources.map do | klass |
+      reply = client.read_feed(klass)
+      while !reply.nil? && !reply.resource.nil? && reply.resource.total > 0
+        reply.resource.entry.each do |entry|
+          client.destroy(klass,entry.resource.id) unless entry.resource.nil?
+        end
+        reply = client.read_feed(klass)
+      end
+    end
+    Rake::Task['fhir:count'].invoke(args.url)
+  end
+
+  def fhir_resources
+    Mongoid.models.select {|c| c.name.include?('FHIR') && !c.included_modules.find_index(FHIR::Resource).nil?}
+  end
+
+end