health-data-standards 0.7.0 → 0.7.1

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

@@ -0,0 +1,60 @@
+module HealthDataStandards
+  module Import
+    module CCR
+      class ProductImporter < SectionImporter
+        
+        # Traverses that ASTM CCR document passed in using XPath and creates an Array of Entry
+        # objects based on what it finds                          
+        # @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"
+        #        measure definition
+        # @return [Array] will be a list of Entry objects
+        def create_entries(doc)
+          entry_list = []
+          entry_elements = doc.xpath(@entry_xpath)
+          entry_elements.each do |entry_element|
+            entry = Entry.new
+            product = entry_element.at_xpath("./ccr:Product")
+            process_product(product,entry)
+            extract_dates(entry_element, entry)
+            extract_status(entry_element, entry)  
+            if @check_for_usable
+              entry_list << entry if entry.usable?
+            else
+              entry_list << entry
+            end  
+          end
+          entry_list           
+        end
+        
+        # Add the codes from a <Product> block subsection to an Entry
+        def process_product_codes(node, entry)
+          codes = node.xpath("./ccr:Code")
+          if codes.size > 0
+            found_code = true
+             codes.each do |code|
+              normalize_coding_system(code)
+              codetext = code.at_xpath("./ccr:CodingSystem").content
+              entry.add_code(code.at_xpath("./ccr:Value").content, codetext)
+            end
+          end
+        end
+
+        # Special handling for the medications section
+        def process_product (product, entry)
+          productName = product.at_xpath("./ccr:ProductName")
+          brandName = product.at_xpath("./ccr:BrandName")
+          productNameText = productName.at_xpath("./ccr:Text")
+          brandNameText = brandName.at_xpath("./ccr:Text")  if brandName
+          entry.description = productNameText.content
+          process_product_codes(productName, entry) # we throw any codes found within the productName and brandName into the same entry
+          process_product_codes(brandName, entry) if brandName
+        end
+
+
+        def create_product_entries(doc)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require "date"
+require "date/delta"
+
+module HealthDataStandards
+  module Import
+    module CCR
+      class ProviderImporter
+        include Singleton
+
+        # 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)
+
+          # 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
+          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
+
+              end #is a provider
+            end   #is an actor
+              provider
+          end.compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module HealthDataStandards
+  module Import
+    module CCR
+      class ResultImporter < SectionImporter
+        
+        # Traverses that ASTM CCR document passed in using XPath and creates an Array of Entry
+        # objects based on what it finds                          
+        # @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"
+        #        measure definition
+        # @return [Array] will be a list of Entry objects
+        def create_entries(doc)
+          entry_list = []
+          entry_elements = doc.xpath(@entry_xpath)
+          entry_elements.each do |entry_element|
+            # Grab the time and the description from the Result node
+            dummy_entry = Entry.new
+            extract_dates(entry_element, dummy_entry)
+            dummy_entry.description = ""
+            if entry_element.at_xpath("./ccr:Description/ccr:Text")
+              dummy_entry.description = entry_element.at_xpath("./ccr:Description/ccr:Text").content  
+            end
+            # Iterate over embedded tests
+            # Grab the values and the description from the Test nodes
+            # For each test, create an entry with the time from the Result,  the description a concatenation of the Result and Test descriptions, 
+            # and the value from the Test
+
+            tests = entry_element.xpath("./ccr:Test")
+            tests.each do |test|
+              entry = Entry.new
+              entry = dummy_entry.clone   # copies time and description
+              extract_codes(test, entry)
+              extract_value(test, entry)
+              extract_status(test, entry)
+              extract_dates(test, entry)
+              entry.description = dummy_entry.description + ": " + entry.description
+              if @check_for_usable
+                entry_list << entry if entry.usable?
+              else
+                entry_list << entry
+              end   
+            end          
+          end
+          entry_list        
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+module HealthDataStandards
+  module Import
+    module CCR
+    # 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
+        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
+        # @param [String] section_name   name of the section.   There is some section-dependent processing
+        def initialize(entry_xpath,  section_name)
+          @entry_xpath = entry_xpath
+          @section_name = section_name
+          @check_for_usable = true               # Pilot tools will set this to false
+        end
+
+        # normalize_coding_system attempts to simplify analysis of the XML doc by 
+        # normalizing the names of the coding systems. Input is a single "Code" node
+        # 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
+          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
+            
+            if %w(active inactive resolved).include?(status)
+              entry.status = status.to_sym
+            end
+          end
+        end
+
+
+        # Add the codes from a <Code> block to an Entry
+        def extract_codes(parent_element, entry)
+          codes = parent_element.xpath("./ccr:Description/ccr:Code")
+          entry.description = ""
+          if (parent_element.at_xpath("./ccr:Description/ccr:Text") )
+            entry.description = parent_element.at_xpath("./ccr:Description/ccr:Text").content
+          end
+          if codes.size > 0 
+            found_code = true
+            codes.each do |code|
+              normalize_coding_system(code)
+              entry.add_code(code.at_xpath("./ccr:Value").content, code.at_xpath("./ccr:CodingSystem").content)
+            end
+          end
+        end
+
+        # 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
+        end
+
+        def extract_dates(parent_element, entry)
+          datetime = parent_element.at_xpath('./ccr:DateTime')
+          if !datetime
+            return
+          end
+           if datetime.at_xpath('./ccr:ExactDateTime')
+            entry.time = extract_time(datetime.at_xpath('./ccr:ExactDateTime').content)
+          end
+          if datetime.at_xpath('./ccr:ApproximateDateTime')
+            entry.time = extract_time(datetime.at_xpath('./ccr:ApproximateDateTime').content)
+          end
+          if datetime.at_xpath('./ccr:DateTimeRange/ccr:BeginRange')
+            entry.start_time = extract_time(datetime.at_xpath('./ccr:DateTimeRange/ccr:BeginRange').content)
+          end
+          if datetime.at_xpath('./ccr:DateTimeRange/ccr:EndRange')
+            entry.end_time = extract_time(datetime.at_xpath('./ccr:DateTimeRange/ccr:EndRange').content)
+          end
+        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
+            if value
+              entry.set_value(value, unit)
+            end
+          end
+        end   # extract_value
+
+        # Traverses that ASTM CCR document passed in using XPath and creates an Array of Entry
+        # objects based on what it finds                          
+        # @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"
+        #        measure definition
+        # @return [Array] will be a list of Entry objects
+        def create_entries(doc)
+          return nil
+        end
+      end
+
+
+    end       # Importer
+  end
+end         # QME
+
+

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

@@ -0,0 +1,30 @@
+module HealthDataStandards
+  module Import
+    module CCR
+      class SimpleImporter < SectionImporter
+        # Traverses that ASTM CCR document passed in using XPath and creates an Array of Entry
+        # objects based on what it finds                          
+        # @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"
+        #        measure definition
+        # @return [Array] will be a list of Entry objects
+        def create_entries(doc)
+          entry_list = []
+          entry_elements = doc.xpath(@entry_xpath)
+          entry_elements.each do |entry_element|
+            entry = Entry.new
+            extract_codes(entry_element, entry)
+            extract_dates(entry_element, entry)
+            extract_status(entry_element, entry)  
+            if @check_for_usable
+              entry_list << entry if entry.usable?
+            else
+              entry_list << entry
+            end             
+          end
+          entry_list              
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module HealthDataStandards
+  module Import
+    module GreenC32
+      class ConditionImporter < SectionImporter
+        include Singleton
+        
+        def initialize
+          super
+        end
+        
+        def import(condition_xml)
+          condition_xml.root.add_namespace_definition('gc32', "urn:hl7-org:greencda:c32")
+          
+          condition_element = condition_xml.xpath("./gc32:condition")
+          
+          condition = Condition.new
+          
+          extract_entry(condition_element, condition)
+          extract_name(condition_element, condition)
+          extract_interval(condition_element, condition)
+          extract_cause_of_death(condition_element, condition)
+          extract_type(condition_element, condition)
+          condition
+        end
+        
+        private
+        
+        def extract_type(condition_xml, condition)
+          type = condition_xml.xpath("./gc32:type").first
+          condition.type = extract_node_text(type)
+        end
+        
+        def extract_name(condition_xml, condition)
+          name = condition_xml.xpath("./gc32:name").first
+          condition.name = extract_node_text(name)
+        end
+        
+        def extract_cause_of_death(condition_xml, condition)
+          condition.cause_of_death = extract_node_attribute(condition_xml, "causeOfDeath")
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module HealthDataStandards
+  module Import
+    module GreenC32
+      class PatientImporter
+        include Singleton
+            
+        def initialize
+          @importers[:results] = ResultImporter.new
+        end
+        
+      end
+    end
+  end
+end

data/lib/health-data-standards/import/green_c32/result_importer.rb

@@ -0,0 +1,30 @@
+module HealthDataStandards
+  module Import
+    module GreenC32
+      class ResultImporter < SectionImporter
+        include Singleton
+        
+        def initialize
+          super
+          @range = "./gc32:referenceRange"
+          @interpretation = "./gc32:interpretation"
+        end
+        
+        def import(result)
+          result.root.add_namespace_definition('gc32', "urn:hl7-org:greencda:c32")
+          
+          result_element = result.xpath("./gc32:result")
+          lab_result = LabResult.new(reference_range: extract_node_text(result_element.xpath(@range)))
+          
+          extract_entry(result_element, lab_result)
+          extract_time(result_element, lab_result)
+          extract_value(result_element, lab_result)
+          extract_code(result_element, lab_result, @interpretation, :interpretation)
+              
+          lab_result
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+require "time"
+
+module HealthDataStandards
+  module Import
+    module GreenC32
+      class SectionImporter
+        
+        def initialize
+          @description = "./gc32:code/gc32:originalText"
+          @status = "./gc32:status"
+          @value = "./gc32:value"
+        end
+        
+        def extract_code(element, entry, xpath="./gc32:code", attribute=:codes)
+          
+          code_element = element.xpath(xpath).first
+
+          return unless code_element
+
+          codes = build_code(code_element)
+          
+          code_element.xpath("./gc32:translation").each do |trans|
+            codes.merge!(build_code(trans))
+          end
+          
+          entry.send("#{attribute}=", codes)
+        end
+        
+        def extract_description(element, entry)
+          description = element.xpath(@description).first
+          entry.description = extract_node_text(description)
+        end
+        
+        def extract_status(element, entry)
+          status = extract_node_text(element.xpath(@status).first)
+          return unless status
+          entry.status = status
+        end
+        
+        def extract_time(element, entry, xpath = "./gc32:effectiveTime", attribute = "time")
+          datetime = element.xpath(xpath).first
+          return unless datetime && !datetime.inner_text.empty?
+          entry.send("#{attribute}=", Time.parse(datetime.inner_text).to_i)
+        end
+        
+        def extract_interval(element, entry)
+          extract_time(element, entry, "./gc32:effectiveTime/gc32:start", "start_time")
+          extract_time(element, entry, "./gc32:effectiveTime/gc32:end", "end_time")
+        end
+        
+        def extract_value(element, entry)
+          
+          value_element = element.xpath(@value).first
+          
+          return unless value_element
+          
+          node_value = extract_node_attribute(value_element, "amount", true)
+          node_units = extract_node_attribute(value_element, "unit")
+          
+          entry.value = {'scalar' => node_value, "unit" => node_units} if node_value
+
+        end
+        
+        def extract_entry(element, entry)
+          extract_code(element, entry)
+          extract_description(element, entry)
+          extract_status(element, entry)
+        end
+        
+        private
+        
+        def build_code(code_element)
+          code_system_oid = extract_node_attribute(code_element, "codeSystem")
+          code = extract_node_attribute(code_element, "code")
+          code_system = HealthDataStandards::Util::CodeSystemHelper.code_system_for(code_system_oid)
+          {code_system => [code]}
+        end
+        
+        def extract_node_attribute(node, attribute_name, to_num=false)
+          return if node.nil? || (node.respond_to?(:empty?) && node.empty?)
+          attribute = node.attribute(attribute_name.to_s)
+          value = attribute ? attribute.value : nil
+          return unless value && value != ""
+          to_num ? value.to_f : value
+        end
+        
+        def extract_node_text(node)
+          node ? node.inner_text : nil
+        end
+      end
+    end
+  end
+end