health-data-standards 0.7.0 → 0.7.1

data/lib/health-data-standards.rb

@@ -20,9 +20,14 @@ require_relative 'health-data-standards/export/c32'
 require_relative 'health-data-standards/export/ccr'
 require_relative 'health-data-standards/export/csv'
 
+require_relative 'health-data-standards/export/green_c32/entry'
+require_relative 'health-data-standards/export/green_c32/export_generator'
+
+
 require_relative 'health-data-standards/models/entry'
 require_relative 'health-data-standards/models/allergy'
 require_relative 'health-data-standards/models/encounter'
+require_relative 'health-data-standards/models/condition'
 require_relative 'health-data-standards/models/immunization'
 require_relative 'health-data-standards/models/fulfillment_history'
 require_relative 'health-data-standards/models/order_information'
@@ -30,6 +35,8 @@ require_relative 'health-data-standards/models/medication'
 require_relative 'health-data-standards/models/procedure'
 require_relative 'health-data-standards/models/lab_result'
 require_relative 'health-data-standards/models/record'
+require_relative 'health-data-standards/models/provider'
+require_relative 'health-data-standards/models/provider_performance'
 
 require_relative 'health-data-standards/import/c32/section_importer'
 require_relative 'health-data-standards/import/c32/allergy_importer'
@@ -39,4 +46,16 @@ require_relative 'health-data-standards/import/c32/medication_importer'
 require_relative 'health-data-standards/import/c32/procedure_importer'
 require_relative 'health-data-standards/import/c32/result_importer'
 require_relative 'health-data-standards/import/c32/vital_sign_importer'
-require_relative 'health-data-standards/import/c32/patient_importer'
+require_relative 'health-data-standards/import/c32/patient_importer'
+require_relative 'health-data-standards/import/c32/provider_importer'
+
+require_relative 'health-data-standards/import/ccr/patient_importer'
+require_relative 'health-data-standards/import/ccr/provider_importer'
+require_relative 'health-data-standards/import/ccr/section_importer'
+require_relative 'health-data-standards/import/ccr/result_importer'
+require_relative 'health-data-standards/import/ccr/simple_importer'
+require_relative 'health-data-standards/import/ccr/product_importer'
+
+require_relative 'health-data-standards/import/green_c32/section_importer'
+require_relative 'health-data-standards/import/green_c32/result_importer'
+require_relative 'health-data-standards/import/green_c32/condition_importer'

data/lib/health-data-standards/export/ccr.rb

@@ -36,6 +36,7 @@ module HealthDataStandards
             to_ccr_results(xml, patient) 
             to_ccr_procedures(xml, patient)
             to_ccr_encounters(xml, patient)
+            to_ccr_socialhistory(xml, patient)
             
           end
           to_ccr_actors(xml, patient)
@@ -169,14 +170,15 @@ module HealthDataStandards
            #time
            xml.ExactDateTime(convert_to_ccr_time_string(res.time))
          end
-         xml.Description do
-           xml.Text(res.description)
-           code_section(xml, res.codes)
-         end
-         
+                 
          xml.Source
          xml.Test do
            xml.CCRDataObjectID("#{ccr_id}TestResult")
+           xml.Description do
+              xml.Text(res.description)
+              code_section(xml, res.codes)
+          end
+
            xml.Source
            xml.TestResult do
              xml.Value(res.value["scalar"])
@@ -320,6 +322,29 @@ module HealthDataStandards
           end
         end
       end
+      
+      # Builds the XML snippet for the social history section inside the CCR standard
+      #
+      # @return [Builder::XmlMarkup] CCR XML representation of patient data
+      def to_ccr_socialhistory(xml, patient)
+        if patient.social_history.present?
+          xml.SocialHistory do
+            patient.social_history.each_with_index do |history, index|
+              xml.SocialHistoryElement do
+                xml.CCRDataObjectID("SH000#{index + 1}")
+               
+                                    
+                  xml.Description do
+                    xml.Text(history.description)
+                    code_section(xml, history.codes)
+                  end
+                
+               
+              end
+            end
+          end
+        end
+      end
 
       # Builds the XML snippet for a actors section inside the CCR standard
       #

data/lib/health-data-standards/export/green_c32/entry.rb

@@ -0,0 +1,15 @@
+module HealthDataStandards
+  module Export
+    module GreenC32
+      module Entry
+        include TemplateHelper
+        
+        def export(object, object_type)
+          self.template_format = "gc32"
+          render(partial: object_type, locals: {object_type => object})
+        end
+        extend self
+      end
+    end
+  end
+end

data/lib/health-data-standards/export/green_c32/export_generator.rb

@@ -0,0 +1,23 @@
+module HealthDataStandards
+  module Export
+    module GreenC32
+      # Module that will create objects that can be used to export GreenCDA sections
+      module ExportGenerator
+        # Creates an object that can be used to export objects into GreenCDA.
+        # @example Creating an results exporter
+        #   exporter = ExportGenerator.create_exporter_for(:result)
+        #   exporter.export(result) # => Returns GreenCDA XML in a String
+        # @param [Symbol] section the section to create the exporter for
+        # @return [Object] that has an export method
+        def create_exporter_for(section)
+          object = Object.new
+          object.define_singleton_method(:export) do |section_instance|
+            HealthDataStandards::Export::GreenC32::Entry.export(section_instance, section)
+          end
+          object
+        end
+        extend self
+      end
+    end
+  end
+end

data/lib/health-data-standards/export/template_helper.rb

@@ -16,7 +16,6 @@ module HealthDataStandards
       end
 
       def render(params)
-        #binding.pry
         erb = nil
         if params[:template]
           erb = template(params[:template])

data/lib/health-data-standards/import/c32/condition_importer.rb

@@ -0,0 +1,66 @@
+module HealthDataStandards
+  module Import
+    module C32
+      class ConditionImporter < SectionImporter
+        
+        def initialize
+          @entry_xpath = "//cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.1.11']"
+          @code_xpath = "./cda:code"
+          @description_xpath = "./cda:code/cda:originalText/cda:reference[@value] | ./cda:text/cda:reference[@value] "
+        end
+        
+        def create_entries(doc, id_map = {})
+          @id_map = id_map
+          condition_list = []
+          entry_elements = doc.xpath(@entry_xpath)
+          
+          entry_elements.each do |entry_element|
+            condition = Condition.new
+            
+            extract_codes(entry_element, condition)
+            extract_dates(entry_element, condition)
+            extract_description(entry_element, condition, id_map)
+            
+            condition.diagnosis_priority = extract_code(entry_element, "???")
+            
+            condition.problem_date = extract_code(entry_element, 
+              "./cda:entryRelationship[@typeCode='SUBJ']/cda:observation[@classCode='OBS']/cda.effectiveTime")
+              
+            condition.problem_type = extract_code(entry_element, 
+              "./cda:entryRelationship[@typeCode='SUBJ']/cda:observation[@classCode='OBS']")
+              
+            condition.problem_name = extract_code(entry_element, "./cda:text")
+
+            condition.problem_code = extract_code(entry_element, 
+              "./cda:entryRelationship[@typeCode='SUBJ']/cda:observation[@classCode='OBS']/cda:code[@code='11450-4']/cda:value[@codeSystem='2.16.840.1.113883.96']")
+            
+            condition.age_at_onset = extract_code(entry_element, "???")
+            
+            extract_cause_of_death(entry_element, condition)
+            
+            condition.problem_status = extract_code(entry_element,
+              "./cda:entryRelationship[@typeCode='SUBJ']/cda:observation[@classCode='OBS']/cda:statusCode[@code='completed']")
+
+            condition_list << condition
+          end
+          
+          condition_list
+        end
+        
+        private
+        
+        def extract_cause_of_death(parent_element, condition)
+          cause_of_death_element = parent_element.at_xpath("???")
+          
+          if cause_of_death_element
+            condition.cause_of_death = {}
+            
+            condition.cause_of_death[:time_of_death] = cause_of_death_element.xpath("???")
+            condition.cause_of_death[:age_at_death] = cause_of_death_element.xpath("???")
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/health-data-standards/import/c32/provider_importer.rb

@@ -0,0 +1,66 @@
+require "date"
+require "date/delta"
+
+module HealthDataStandards
+  module Import
+    module C32
+      class ProviderImporter
+        include Singleton
+      
+        # Extract Healthcare Providers from C32
+        #
+        # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
+        #        will have the "cda" namespace registered to "urn:hl7-org:v3"
+        # @return [Array] an array of providers found in the document
+        def extract_providers(doc, use_encounters=false)
+          xpath_base = use_encounters ? "//cda:encounter/cda:performer" : "//cda:documentationOf/cda:serviceEvent/cda:performer"
+  
+          performers = doc.xpath(xpath_base)
+
+          providers = performers.map do |performer|
+            provider = {}
+            entity = performer.xpath(performer, "./cda:assignedEntity")
+            name = entity.xpath("./cda:assignedPerson/cda:name")
+            provider[:title]        = extract_data(name, "./cda:prefix")
+            provider[:given_name]   = extract_data(name, "./cda:given[1]")
+            provider[:family_name]  = extract_data(name, "./cda:family")
+            provider[:phone]        = extract_data(entity, "./cda:telecom/@value") { |text| text.gsub("tel:", "") }
+            provider[:organization] = extract_data(entity, "./cda:representedOrganization/cda:name")
+            provider[:specialty]    = extract_data(entity, "./cda:code/@code")
+            time                    = performer.xpath(performer, "./cda:time")
+            provider[:start]        = extract_date(time, "./cda:low/@value")
+            provider[:end]          = extract_date(time, "./cda:high/@value")
+            # NIST sample C32s use different OID for NPI vs C83, support both
+            npi                     = extract_data(entity, "./cda:id[@root='2.16.840.1.113883.4.6' or @root='2.16.840.1.113883.3.72.5.2']/@extension")
+            if Provider.valid_npi?(npi)
+              provider[:npi]        = npi
+            else
+              puts "Warning: Invalid NPI (#{npi})"
+            end
+            provider
+          end
+        end
+      
+        private
+      
+        def extract_date(subject,query)
+          date = extract_data(subject,query)
+          date ? Date.parse(date).to_time.to_i : nil
+        end
+      
+        # Returns nil if result is an empty string, block allows text munging of result if there is one
+        def extract_data(subject, query)
+          result = subject.xpath(query).text
+          if result == ""
+            nil
+          elsif block_given?
+            yield(result)
+          else
+            result
+          end
+        end
+      
+      end
+    end
+  end
+end

data/lib/health-data-standards/import/c32/section_importer.rb

@@ -136,6 +136,8 @@ module HealthDataStandards
         
         def import_actor(actor_element)
           actor_hash = {}
+          npi = actor_element.xpath("./cda:assignedEntity/cda:id[@root='2.16.840.1.113883.4.6' or @root='2.16.840.1.113883.3.72.5.2']/@extension")
+          actor_hash[:npi] = npi if npi
           addresses = actor_element.xpath("./cda:assignedEntity/cda:addr").try(:map) {|ae| import_address(ae)}
           telecoms = actor_element.xpath("./cda:assignedEntity/cda:telecom").try(:map) {|te| import_telecom(te)}
           person_element = actor_element.at_xpath("./cda:assignedEntity/cda:assignedPerson")

data/lib/health-data-standards/import/ccr/patient_importer.rb

@@ -0,0 +1,208 @@
+module HealthDataStandards
+  module Import
+    module CCR
+    # This class is the central location for taking an ASTM CCR XML document and converting it
+    # into the processed form we store in MongoDB. The class does this by running each measure
+    # independently on the XML document
+    #
+    # This class is a Singleton. It should be accessed by calling PatientImporter.instance
+      class PatientImporter
+
+        include Singleton
+        
+        Gender = {"male" => "M", "female" => "F"}
+        
+        # Creates a new PatientImporter with the following XPath expressions used to find content in 
+        # an ASTM CCR
+        #
+        # Encounter entries
+        #    //ccr:Encounters/ccr:Encounter
+        # Procedure entries
+        #    //ccr:Procedures/ccr:Procedure
+        #
+        # Result entries - 
+        #    //ccr:Results/ccr:Result
+        #
+        # Vital sign entries
+        #    //ccr:VitalSigns/ccr:Result
+        #
+        # Medication entries
+        #    //ccr:Medications/ccr:Medication
+        #
+        # Codes for medications are found in the Product sections
+        #    ./ccr:Product
+        #
+        # Condition entries
+        #    //ccr:Problems/ccr:Problem
+        #
+        # Social History entries 
+        #    //ccr:SocialHistory/ccr:SocialHistoryElement
+        #
+        # Care Goal entries
+        #    //ccr:Goals/ccr:Goal
+        #
+        # Allergy entries
+        #    //ccr:Alerts/ccr:Alert
+        #
+        # Immunization entries
+        #    //ccr:Immunizations/ccr:Immunization
+        #
+        # Codes for immunizations are found in the substanceAdministration with the following relative XPath
+        #    ./ccr:Product
+      
+        def initialize (check_usable = true)
+          @measure_importers = {}
+          @section_importers = {}
+          @section_importers[:encounters] = SimpleImporter.new("//ccr:Encounters/ccr:Encounter",:encounters)
+          @section_importers[:procedures] = SimpleImporter.new("//ccr:Procedures/ccr:Procedure",:procedures)
+          @section_importers[:results] = ResultImporter.new("//ccr:Results/ccr:Result",:results)
+          @section_importers[:vital_signs] = ResultImporter.new("//ccr:VitalSigns/ccr:Result",:vital_signs)
+          @section_importers[:medications] = ProductImporter.new("//ccr:Medications/ccr:Medication", :medications)
+          @section_importers[:conditions] = SimpleImporter.new("//ccr:Problems/ccr:Problem",:conditions)
+          @section_importers[:social_history] = SimpleImporter.new("//ccr:SocialHistory/ccr:SocialHistoryElement", :social_history)
+          @section_importers[:care_goals] = SimpleImporter.new("//ccr:Goals/ccr:Goal",:care_goals)
+          @section_importers[:medical_equipment] = ProductImporter.new("//ccr:Equpment/ccr:EquipmentElement",:medical_equipment)
+          @section_importers[:allergies] = SimpleImporter.new("//ccr:Alerts/ccr:Alert",:allergies)
+          @section_importers[:immunizations] = ProductImporter.new("//ccr:Immunizations/ccr:Immunization",:immunizations)
+        end
+
+ 
+        # @param [boolean] value for check_usable_entries...importer uses true, stats uses false 
+        def check_usable(check_usable_entries)
+          @section_importers.each_pair do |section, importer|
+            importer.check_for_usable = check_usable_entries
+          end
+        end
+
+        # Parses a ASTM CCR document and returns a Hash of of the patient.
+        #
+        # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
+        #        will have the "ccr" namespace registered to ""urn:astm-org:CCR""
+        # @return [Hash] a representation of the patient that can be inserted into MongoDB
+        def parse_ccr(doc)
+          ccr_patient = {}
+          entries = create_hash(doc)
+          get_demographics(ccr_patient, doc)
+          process_events(ccr_patient, entries)
+          Record.new(ccr_patient)
+        end
+        # 
+        # # Parses a patient hash containing demographic and event information
+        # #
+        # # @param [Hash] patient_hash patient data
+        # # @return [Hash] a representation of the patient that can be inserted into MongoDB
+        # def parse_hash(patient_hash)
+        #   patient_record = {}
+        #   patient_record['first'] = patient_hash['first']
+        #   patient_record['patient_id'] = patient_hash['patient_id']
+        #   patient_record['last'] = patient_hash['last']
+        #   patient_record['gender'] = patient_hash['gender']
+        #   patient_record['patient_id'] = patient_hash['patient_id']
+        #   patient_record['birthdate'] = patient_hash['birthdate']
+        #   patient_record['race'] = patient_hash['race']
+        #   patient_record['ethnicity'] = patient_hash['ethnicity']
+        #   patient_record['languages'] = patient_hash['languages']
+        #   patient_record['addresses'] = patient_hash['addresses']
+        #   event_hash = {}
+        #   patient_hash['events'].each do |key, value|
+        #     event_hash[key.intern] = parse_events(value)
+        #   end
+        #   process_events(patient_record, event_hash)
+        # end
+
+        # Adds the entries and denormalized measure information to the patient_record.
+        # Each Entry will be converted to a Hash and stored in an Array under the appropriate
+        # section key, such as medications. Measure information is listed under the measures
+        # key which has a Hash value. The Hash has the measure id as a key, and the denormalized
+        # measure information as a value
+        #
+        # @param patient_record - Hash with basic patient demographic information
+        # @entries - Hash of entries with section names a keys and an Array of Entry values
+        def process_events(patient_record, entries)
+          patient_record['measures'] = {}
+          @measure_importers.each_pair do |measure_id, importer|
+            patient_record['measures'][measure_id] = importer.parse(entries)
+          end
+
+
+          entries.each_pair do |key, value|
+            patient_record[key] = value.map do |e|
+              if e.usable?
+                e.to_hash
+              else
+                nil
+              end
+            end.compact
+          end
+          patient_record
+        end
+
+        # # Parses a list of event hashes into an array of Entry objects
+        # #
+        # # @param [Array] event_list list of event hashes
+        # # @return [Array] array of Entry objects
+        # def parse_events(event_list)
+        #   event_list.collect do |event|
+        #     if event.class==String.class
+        #       # skip String elements in the event list, patient randomization templates
+        #       # introduce String elements to simplify tailing-comma handling when generating
+        #       # JSON using ERb
+        #       nil
+        #     else
+        #       QME::Importer::Entry.from_event_hash(event)
+        #     end
+        #   end.compact
+        # end
+
+        # Adds a measure to run on a CCR that is passed in
+        #
+        # @param [MeasureBase] measure an Class that can extract information from a CCR that is necessary
+        #        to calculate the measure
+        def add_measure(measure_id, importer)
+          @measure_importers[measure_id] = importer
+        end
+
+        # Create a simple representation of the patient from an ASTM CCR
+        #
+        # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
+        #        will have the "ccr" namespace registered to ""urn:astm-org:CCR""
+        # @return [Hash] a represnetation of the patient with symbols as keys for each section
+        def create_hash(doc, check_usable_entries = false)
+          ccr_patient = {}
+          @section_importers.each_pair do |section, importer|
+            importer.check_for_usable = check_usable_entries
+            ccr_patient[section] = importer.create_entries(doc)
+          end
+          ccr_patient
+        end
+
+        # Inspects a CCR document and populates the patient Hash with first name, last name
+        # birth date and gender.
+        #
+        # @param [Hash] patient A hash that is used to represent the patient
+        # @param [Nokogiri::XML::Node] doc The CCR document parsed by Nokogiri
+        def get_demographics(patient, doc)
+          patientID = doc.at_xpath('//ccr:ContinuityOfCareRecord/ccr:Patient/ccr:ActorID').content
+          patientActor = doc.at_xpath("//ccr:ContinuityOfCareRecord/ccr:Actors/ccr:Actor[ccr:ActorObjectID = \"#{patientID}\"]")
+          patient['first'] = patientActor.at_xpath('./ccr:Person/ccr:Name/ccr:CurrentName/ccr:Given').content
+          patient['last'] = patientActor.at_xpath('./ccr:Person/ccr:Name/ccr:CurrentName/ccr:Family').content
+          birthdate = patientActor.at_xpath('./ccr:Person//ccr:DateOfBirth/ccr:ExactDateTime | ./ccr:Person//ccr:DateOfBirth/ccr:ApproximateDateTime')
+          patient['birthdate'] = Time.iso8601(birthdate).to_i
+          
+          gender_string = patientActor.at_xpath('./ccr:Person/ccr:Gender/ccr:Text').content.downcase
+          patient['gender'] =  Gender[gender_string.downcase]
+          
+          #race_node = doc.at_xpath('/ccr:placeholder')    #how do you find this?
+          patient['race'] = nil
+          #ethnicity_node = doc.at_xpath()
+          patient['ethnicity'] = nil
+
+          # languages = doc.at_xpath()
+          patient['languages'] = nil
+ 
+          patient['medical_record_number'] = patientID
+        end
+      end
+    end
+  end
+end