health-data-standards 0.7.1 → 0.8.0

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

@@ -49,13 +49,11 @@ module HealthDataStandards
 
         def extract_facility(parent_element, encounter)
           participant_element = parent_element.at_xpath("./cda:participant[@typeCode='LOC']/cda:participantRole[@classCode='SDLOC']")
-          encounter.facility = {}
           if (participant_element)
-            encounter.facility['organizationName'] = participant_element.at_xpath("./cda:playingEntity/cda:name").try(:text)
-            addresses = participant_element.xpath("./cda:addr").try(:map) {|ae| import_address(ae)}
-            encounter.facility['addresses'] = addresses
-            telecoms = participant_element.xpath("./cda:telecom").try(:map) {|te| import_telecom(te)}
-            encounter.facility['telcoms'] = telecoms
+            org = Organization.new(name: participant_element.at_xpath("./cda:playingEntity/cda:name").try(:text))
+            org.addresses = participant_element.xpath("./cda:addr").try(:map) {|ae| import_address(ae)}
+            org.telecoms = participant_element.xpath("./cda:telecom").try(:map) {|te| import_telecom(te)}
+            encounter.facility = org
           end
         end
     

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

@@ -63,7 +63,7 @@ module HealthDataStandards
             if @check_for_usable
               medication_list << medication if medication.usable?
             else
-              medication_list << medication_list
+              medication_list << medication
             end
           end
           medication_list
@@ -80,10 +80,6 @@ module HealthDataStandards
               actor_element = fh_element.at_xpath('./cda:performer')
               if actor_element
                 fulfillment_history.provider = import_actor(actor_element)
-                addr_element = actor_element.at_xpath("./cda:assignedEntity/cda:addr")
-                if addr_element
-                  fulfillment_history.dispensing_pharmacy_location = import_address(addr_element)
-                end
               end
               hl7_timestamp = fh_element.at_xpath('./cda:effectiveTime').try(:[], 'value')
               fulfillment_history.dispense_date = HL7Helper.timestamp_to_integer(hl7_timestamp) if hl7_timestamp

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

@@ -0,0 +1,23 @@
+module HealthDataStandards
+  module Import
+    module C32
+      class OrganizationImporter < SectionImporter
+        include Singleton
+        
+        def initialize
+          
+        end
+        
+        def extract_organization(org_element)
+          return unless org_element
+          org = Organization.new
+          org.name = org_element.at_xpath("./name").try(:text)
+          org.addresses = org_element.xpath("./cda:addr").map { |addr| import_address(addr) }
+          org.telecoms = org_element.xpath("./cda:telecom").map { |tele| import_telecom(tele) }
+          org
+        end
+        
+      end
+    end
+  end
+end

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

@@ -59,10 +59,7 @@ module HealthDataStandards
           @section_importers[:results] = ResultImporter.new
           @section_importers[:vital_signs] = VitalSignImporter.new
           @section_importers[:medications] = MedicationImporter.new
-          @section_importers[:conditions] = SectionImporter.new("//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.103']/cda:entry/cda:act/cda:entryRelationship/cda:observation",
-          "./cda:value",
-          "./cda:entryRelationship/cda:observation[cda:templateId/@root='2.16.840.1.1 13883.10.20.1.50']/cda:value",
-          "./cda:text/cda:reference[@value]")
+          @section_importers[:conditions] = ConditionImporter.new
           @section_importers[:social_history] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.19']")
           @section_importers[:care_goals] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.1.25']")
           @section_importers[:medical_equipment] = SectionImporter.new("//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.128']/cda:entry/cda:supply",

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

@@ -1,47 +1,62 @@
 require "date"
-require "date/delta"
+# require "date/delta"
 
 module HealthDataStandards
   module Import
     module C32
-      class ProviderImporter
+      class ProviderImporter < SectionImporter
+        
+        
+        def initialize
+          
+        end
+        
         include Singleton
-      
+        include ProviderImportUtils
         # 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)
+        def extract_providers(doc)
+          performers = doc.xpath("//cda:documentationOf/cda:serviceEvent/cda:performer")
+          performers.map do |performer|
+            provider_perf = extract_provider_data(performer, true)
+            ProviderPerformance.new(start_date: provider_perf.delete(:start), end_date: provider_perf.delete(:end), provider: find_or_create_provider(provider_perf))
+          end
+        end
 
-          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")
+        private
+      
+        def extract_provider_data(performer, use_dates=true)
+          provider = {}
+          entity = performer.xpath("./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[:organization] = OrganizationImporter.instance.extract_organization(entity.at_xpath("./cda:representedOrganization"))
+          provider[:specialty]    = extract_data(entity, "./cda:code/@code")
+          time                    = performer.xpath(performer, "./cda:time")
+          
+          if use_dates
             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
+          
+          # 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")
+          provider[:addresses] = performer.xpath("./cda:assignedEntity/cda:addr").try(:map) {|ae| import_address(ae)}
+          provider[:telecoms] = performer.xpath("./cda:assignedEntity/cda:telecom").try(:map) {|te| import_telecom(te)}
+          
+          provider[:npi] = npi if Provider.valid_npi?(npi)
+          provider
+        end
+        
+        def find_or_create_provider(provider_hash)
+          provider = Provider.first(conditions: {npi: provider_hash[:npi]}) if provider_hash[:npi]
+          provider ||= Provider.create(provider_hash)
         end
-      
-        private
       
         def extract_date(subject,query)
           date = extract_data(subject,query)
@@ -53,8 +68,6 @@ module HealthDataStandards
           result = subject.xpath(query).text
           if result == ""
             nil
-          elsif block_given?
-            yield(result)
           else
             result
           end

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

@@ -135,54 +135,33 @@ module HealthDataStandards
         end
         
         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")
-          if person_element
-            actor_hash['person'] = import_person(person_element)
-            actor_hash['person']['addresses'] = addresses
-            actor_hash['person']['telecoms'] = telecoms
-          end
-          organization_element = actor_element.at_xpath("./cda:assignedEntity/cda:assignedOrganization")
-          if organization_element
-            actor_hash['organization'] = import_organization(organization_element)
-          end
-
-          actor_hash
+          return ProviderImporter.instance.extract_provider(actor_element)
         end
 
-        def import_person(person_element)
-          person_hash = {}
-          name_element = person_element.at_xpath("./cda:name")
-          person_hash['name'] = name_element.try(:text)
-          person_hash['first'] = name_element.at_xpath("./cda:given").try(:text)
-          person_hash['last'] = name_element.at_xpath("./cda:family").try(:text)
-          person_hash
-        end
+        # def import_person(person_element)
+        #   person_hash = {}
+        #   name_element = person_element.at_xpath("./cda:name")
+        #   person_hash['name'] = name_element.try(:text)
+        #   person_hash['first'] = name_element.at_xpath("./cda:given").try(:text)
+        #   person_hash['last'] = name_element.at_xpath("./cda:family").try(:text)
+        #   person_hash
+        # end
 
         def import_address(address_element)
-          address_hash = {}
-          address_hash['streetAddress'] = [address_element.at_xpath("./cda:streetAddressLine").try(:text)]
-          address_hash['city'] = address_element.at_xpath("./cda:city").try(:text)
-          address_hash['stateOrProvince'] = address_element.at_xpath("./cda:state").try(:text)
-          address_hash['zip'] = address_element.at_xpath("./cda:postalCode").try(:text)
-          address_hash['country'] = address_element.at_xpath("./cda:country").try(:text)
-          address_hash
+          address = Address.new
+          address.street = [address_element.at_xpath("./cda:streetAddressLine").try(:text)]
+          address.city = address_element.at_xpath("./cda:city").try(:text)
+          address.state = address_element.at_xpath("./cda:state").try(:text)
+          address.zip = address_element.at_xpath("./cda:postalCode").try(:text)
+          address.country = address_element.at_xpath("./cda:country").try(:text)
+          address
         end
 
         def import_telecom(telecom_element)
-          telecom_hash = {}
-          telecom_hash['value'] = telecom_element['value']
-          telecom_hash['use'] = telecom_element['use']
-          telecom_hash
-        end
-
-        def import_organization
-          # TODO: Implement when the Patient API has an implementation of
-          # organization
+          tele = Telecom.new
+          tele.value = telecom_element['value']
+          tele.use = telecom_element['use']
+          tele
         end
 
         def extract_code(parent_element, code_xpath, code_system=nil)

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

@@ -1,3 +1,5 @@
+require "time"
+
 module HealthDataStandards
   module Import
     module CCR
@@ -61,7 +63,7 @@ module HealthDataStandards
           @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[:medical_equipment] = ProductImporter.new("//ccr:Equipment/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
@@ -79,10 +81,10 @@ module HealthDataStandards
         # @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)
+        def parse_ccr(doc, patient_id_xpath="//ccr:ContinuityOfCareRecord/ccr:Patient/ccr:ActorID")
           ccr_patient = {}
           entries = create_hash(doc)
-          get_demographics(ccr_patient, doc)
+          get_demographics(ccr_patient, doc, patient_id_xpath)
           process_events(ccr_patient, entries)
           Record.new(ccr_patient)
         end
@@ -181,21 +183,36 @@ module HealthDataStandards
         #
         # @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}\"]")
+        def get_demographics(patient, doc, patient_id_xpath)
+          patientActorID = doc.at_xpath("//ccr:ContinuityOfCareRecord/ccr:Patient/ccr:ActorID").content
+          patientActor = doc.at_xpath("//ccr:ContinuityOfCareRecord/ccr:Actors/ccr:Actor[ccr:ActorObjectID = \"#{patientActorID}\"]")
+          patientID = patientActor.at_xpath(patient_id_xpath).try(:content)
+          patientID ||= patientActorID
+
           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
+          patient['birthdate'] = Time.parse(birthdate.content).to_i if birthdate
           
           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
+          race = doc.at_xpath('//ccr:SocialHistory/ccr:SocialHistoryElement[./ccr:Type/ccr:Text = "Race"]/ccr:Description/ccr:Code[./ccr:CodingSystem = "CDC-RE"]/ccr:Value')
+          ethnicity = doc.at_xpath('//ccr:SocialHistory/ccr:SocialHistoryElement[./ccr:Type/ccr:Text = "Ethnicity"]/ccr:Description/ccr:Code[./ccr:CodingSystem = "CDC-RE"]/ccr:Value')
+          
+          if ethnicity
+            patient[:ethnicity] = {"code" => ethnicity.text, "codeSystem" => 'CDC-RE'}
+          end
+         
+          
+          if race
+             patient[:race] = {"code" => race.text, "codeSystem" => 'CDC-RE'}
+          end
+
+         
+         
           #ethnicity_node = doc.at_xpath()
-          patient['ethnicity'] = nil
+          
 
           # languages = doc.at_xpath()
           patient['languages'] = nil

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

@@ -1,60 +1,48 @@
 require "date"
-require "date/delta"
+# require "date/delta"
 
 module HealthDataStandards
   module Import
     module CCR
       class ProviderImporter
         include Singleton
+        include ProviderImportUtils
 
         # Extract Healthcare Providers from 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 [Array] an array of providers found in the document
-        def extract_providers(doc)
+        
+        def create_provider(actor)
+        # Differentiate care providers by content of this field
+          provider = {}
+          if actor.at_xpath('./ccr:Person/ccr:Name/ccr:CurrentName/ccr:Given')
+            provider[:given_name] = extract_data(actor, './ccr:Person/ccr:Name/ccr:CurrentName/ccr:Given')
+            provider[:family_name] = extract_data(actor, './ccr:Person/ccr:Name/ccr:CurrentName/ccr:Family')
+            provider[:specialty] = extract_data(actor, './ccr:Specialty/ccr:Text')
+          end
+          
+          provider[:specialty] = extract_data(actor, './ccr:Specialty/ccr:Text')
 
-          # Providers are identified as the 'Source' for entries in the CCR.   Sources can also include the patient, relatives, insurance companies, etc
-          actorIDs = doc.xpath("//ccr:Source/ccr:Actor/ccr:ActorID")
-          uniqueActorIDs = {}
-          actorIDs.each do |actorID|
-            uniqueActorIDs[actorID.content] = actorID.content
+          
+          npi_ids = actor.at_xpath("./ccr:IDs[ccr:Type/ccr:Text = \"NPI\"]")
+          if npi_ids
+            npi_id = npi_ids.at_xpath("./ccr:ID")
+            npi = npi_id.content
+            provider[:npi] = npi if Provider.valid_npi?(npi)
           end
-          actorIDs = uniqueActorIDs.keys
-          providers = actorIDs.map do |actorID|
-            provider = nil
-            actor = doc.at_xpath("//ccr:ContinuityOfCareRecord/ccr:Actors/ccr:Actor[ccr:ActorObjectID = \"#{actorID}\"]")
-            if(actor)
-              # Differentiate care providers by content of this field
-              if actor.at_xpath("./ccr:Source/ccr:Actor/ccr:ActorRole/ccr:Text") && 
-                 actor.at_xpath("./ccr:Source/ccr:Actor/ccr:ActorRole/ccr:Text").content.downcase =~ /care provider/
-                provider = {}
-                if actor.at_xpath('./ccr:Person/ccr:Name/ccr:CurrentName/ccr:Given')
-                  provider[:given_name] = actor.at_xpath('./ccr:Person/ccr:Name/ccr:CurrentName/ccr:Given').content
-                  provider[:family_name] = actor.at_xpath('./ccr:Person/ccr:Name/ccr:CurrentName/ccr:Family').content
-                end
-                if actor.at_xpath('./ccr:Specialty/ccr:Text')
-                  provider[:specialty]    = actor.at_xpath('./ccr:Specialty/ccr:Text').content
-                end
-                if actor.at_xpath("ccr:Telephone/ccr:Value")
-                  provider[:phone] = actor.at_xpath("ccr:Telephone/ccr:Value").content
-                end
-                # Not clear precisely how NPI would be specified
-                npi_ids = actor.at_xpath("./ccr:IDs[ccr:Type/ccr:Text = \"NPI\"]")
-                if npi_ids
-                  npi_id = npi_ids.at_xpath("./ccr:ID")
-                  npi = npi_id.content
-                  if Provider.valid_npi?(npi)
-                    provider[:npi] = npi
-                  else
-                    puts "Warning: Invalid NPI (#{npi})"
-                  end   #valid NPI
-                end #has NPI
+          
+          # binding.pry
+          find_or_create_provider(provider)
+        end
+        
+        
+        def extract_providers(doc)
 
-              end #is a provider
-            end   #is an actor
-              provider
-          end.compact
+          # Providers are identified as the 'Source' for entries in the CCR.   Sources can also include the patient, relatives, insurance companies, etc
+          provider_elements = doc.xpath("//ccr:ContinuityOfCareRecord/ccr:Actors/ccr:Actor[ccr:IDs/ccr:Type/ccr:Text=\"NPI\"]")
+          provider_elements.map { |pv| ProviderPerformance.new(provider: create_provider(pv)) }
         end
       end
     end

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

@@ -4,6 +4,29 @@ module HealthDataStandards
     # Class that can be used to create an importer for a section of a ASTM CCR document. It usually
     # operates by selecting all CCR entries in a section and then creates entries for them.
       class SectionImporter
+
+        CODE_SYSTEM_MAP = {
+          "lnc"       => "LOINC",
+          "loinc"     => "LOINC",
+          "cpt"       => "CPT",
+          "cpt-4"     => "CPT",
+          "sct"       => "SNOMED-CT",
+          "snomedct"  => "SNOMED-CT",
+          "snomed-ct" => "SNOMED-CT",
+          "rxnorm"    => "RxNorm",
+          "i9cdx"     => "ICD-9-CM",
+          "icd-9-cm"  => "ICD-9-CM",
+          "icd9-cm"   => "ICD-9-CM",
+           "icd9"      => "ICD-9-CM",
+          "icd10-cm"   => "ICD-9-CM",
+          "icd10"      => "ICD-9-CM",
+          "cvx"        => "CVX",
+          "hcpcs"      => "HCPCS",
+          "cdc"        => "CDC-RE",
+          "CDC"        => "CDC-RE",
+          "cdc-re"     => "CDC-RE"
+
+        }
         attr_accessor :check_for_usable
         # Creates a new SectionImporter
         # @param [String] entry_xpath An XPath expression that can be used to find the desired entries
@@ -19,37 +42,23 @@ module HealthDataStandards
         # in the tree, and the side effect is to edit the CodingSystem subnode.
         # @param [String] code  - Input is a single "Code" node
         def normalize_coding_system(code)
-          lookup = {
-            "lnc"       => "LOINC",
-            "loinc"     => "LOINC",
-            "cpt"       => "CPT",
-            "cpt-4"     => "CPT",
-            "snomedct"  => "SNOMED-CT",
-            "snomed-ct" => "SNOMED-CT",
-            "rxnorm"    => "RxNorm",
-            "icd9-cm"   => "ICD-9-CM",
-            "icd9"      => "ICD-9-CM",
-            "icd10-cm"   => "ICD-9-CM",
-            "icd10"      => "ICD-9-CM",
-            "cvx"        => "CVX",
-            "hcpcs"      => "HCPCS"
-
-          }
-          codingsystem = lookup[code.xpath('./ccr:CodingSystem')[0].content.downcase]
-          if(codingsystem)
-            code.xpath('./ccr:CodingSystem')[0].content = codingsystem
+          coding_system = code.xpath('./ccr:CodingSystem')[0].content.downcase
+          coding_system_value = CODE_SYSTEM_MAP[coding_system]
+          if(coding_system_value)
+            code.xpath('./ccr:CodingSystem')[0].content = coding_system_value
           end
         end
 
         def extract_status(parent_element, entry)
           status_element = parent_element.at_xpath('./ccr:Status')
           if status_element
-            status = parent_element.at_xpath('./ccr:Status/ccr:Text').content.downcase
-            
+            status_text = parent_element.at_xpath('./ccr:Status/ccr:Text')
+            return unless status_text
+            status = status_text.content.downcase
             if %w(active inactive resolved).include?(status)
               entry.status = status.to_sym
             end
-          end
+          end                                          
         end
 
 
@@ -72,7 +81,7 @@ module HealthDataStandards
         # Time is supposed to be in iso8601, but seems like we need to handle simple YYYY-MM-DD as well
         def extract_time(datetime)
           return unless datetime
-          Time.parse(datetime).to_i
+          Time.parse(datetime).to_i rescue nil
         end
 
         def extract_dates(parent_element, entry)
@@ -95,10 +104,12 @@ module HealthDataStandards
         end
 
         def extract_value(parent_element, entry)
-          value_element = parent_element.at_xpath('./ccr:TestResult')
-          if value_element
-            value = value_element.at_xpath('./ccr:Value').content
-            unit = value_element.at_xpath('./ccr:Units/ccr:Unit').content
+          result_element = parent_element.at_xpath('./ccr:TestResult')
+          if result_element
+            value_element = result_element.at_xpath('./ccr:Value')
+            value = value_element ? value_element.content : nil
+            unit_element = result_element.at_xpath('./ccr:Units/ccr:Unit')
+            unit = unit_element ? unit_element.content : nil
             if value
               entry.set_value(value, unit)
             end