health-data-standards 3.5.3 → 3.6.1

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

@@ -1,135 +0,0 @@
-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
-
-        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
-        # @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)
-          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_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
-
-
-        # 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 rescue nil
-        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)
-          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
-          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

@@ -1,30 +0,0 @@
-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/advance_directive_importer.rb

@@ -1,14 +0,0 @@
-module HealthDataStandards
-  module Import
-    module GreenC32
-      class AdvanceDirectiveImporter < SectionImporter
-        include Singleton
-        
-        def import(ad_xml)
-          generic_import(ad_xml, "advanceDirective")
-        end
-        
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module HealthDataStandards
-  module Import
-    module GreenC32
-      class AllergyImporter < SectionImporter
-        include Singleton
-        
-        def import(allergy_xml)
-          allergy_xml.root.add_namespace_definition('gc32', "urn:hl7-org:greencda:c32")
-          allergy_element = allergy_xml.xpath("./gc32:allergy")
-          allergy = Allergy.new
-          extract_entry(allergy_element, allergy)
-          extract_code(allergy_element, allergy, "./gc32:type", :type)
-          extract_code(allergy_element, allergy, "./gc32:reaction", :reaction)
-          extract_code(allergy_element, allergy, "./gc32:severity", :severity)
-          allergy
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module HealthDataStandards
-  module Import
-    module GreenC32
-      class CareGoalImporter
-        include Singleton
-        
-        def initialize
-        end
-        
-        def import(care_goal_xml)
-          importer = case care_goal_xml.at_xpath("/*").try(:name)
-                     when "medication" then MedicationImporter.instance
-                     when "immunization" then ImmunizationImporter.instance
-                     when "procedure" then ProcedureImporter.instance
-                     when "encounter" then EncounterImporter.instance
-                     when "medicalEquipment" then MedicalEquipmentImporter.instance
-                     else SectionImporter.new
-                     end
-                
-          return importer.import(care_goal_xml)
-        end
-        
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-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_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_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/encounter_importer.rb

@@ -1,33 +0,0 @@
-module HealthDataStandards
-  module Import
-    module GreenC32
-      class EncounterImporter < SectionImporter
-        include Singleton
-        
-        def initialize
-          super
-        end
-        
-        def import(encounter_xml)
-          encounter = Encounter.new
-          encounter_xml.root.add_namespace_definition('gc32', "urn:hl7-org:greencda:c32")
-          encounter_element = encounter_xml.xpath("/gc32:encounter")
-          extract_entry(encounter_element, encounter)
-          extract_code(encounter_element, encounter, "./gc32:dischargeDisposition", :discharge_disposition)
-          extract_code(encounter_element, encounter, "./gc32:admissionType", :admit_type)
-          extract_code(encounter_element, encounter, "./gc32:reasonForVisit", :reason)
-          extract_code(encounter_element, encounter)
-          
-          facility_element = encounter_element.at_xpath("./gc32:facility")
-          if facility_element
-            facility = extract_facility(facility_element)
-            encounter.facility = facility
-          end
-
-          encounter
-        end
-        
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module HealthDataStandards
-  module Import
-    module GreenC32
-      class ImmunizationImporter < SectionImporter
-        include Singleton
-        
-        def import(immunization_xml)
-          immunization_xml.root.add_namespace_definition('gc32', "urn:hl7-org:greencda:c32")
-          immunization_element = immunization_xml.at_xpath("./gc32:immunization")
-          immunization = Immunization.new
-          extract_entry(immunization_element, immunization)
-          extract_time(immunization_element, immunization, "./gc32:effectiveTime")
-          extract_code(immunization_element, immunization, "./gc32:refusalReason")
-          series_number = extract_node_text(immunization_element.at_xpath("./gc32:seriesNumber"))
-          immunization.series_number = series_number.to_i if series_number
-          immunization.refusal_ind = extract_node_attribute(immunization_element, :refused, true)
-          immunization
-        end
-        
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module HealthDataStandards
-  module Import
-    module GreenC32
-      class MedicalEquipmentImporter < SectionImporter
-        include Singleton
-        
-        def initialize
-          super
-          @value = "./gc32:quantity"
-        end
-        
-        def import(me_xml)
-          me_xml.root.add_namespace_definition('gc32', "urn:hl7-org:greencda:c32")
-          me_element = me_xml.at_xpath("./gc32:medicalEquipment")
-          me = MedicalEquipment.new
-          extract_entry(me_element, me)
-          me.manufacturer = extract_node_text(me_element.at_xpath("./gc32:manufacturer")).try(:strip)
-          me
-        end
-        
-       end
-     end
-   end 
-end

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

@@ -1,68 +0,0 @@
-module HealthDataStandards
-  module Import
-    module GreenC32
-      class MedicationImporter < SectionImporter
-        include Singleton
-        
-        def import(med_xml)
-          med_xml.root.add_namespace_definition('gc32', "urn:hl7-org:greencda:c32")
-          med_element = med_xml.at_xpath("./gc32:medication")
-          medication = Medication.new
-          extract_entry(med_element, medication)
-          extract_interval(med_element, medication, "administrationTiming")
-          extract_administration_timing(med_element, medication)
-          medication.dose = extract_quantity(med_element, "./gc32:dose")
-          extract_med_code_attribute(med_element, medication, :type, :typeOfMedication)
-          extract_med_code_attribute(med_element, medication, :statusOfMedication)
-          extract_med_code_attribute(med_element, medication, :route)
-          extract_med_code_attribute(med_element, medication, :site)
-          extract_dose_restriction(med_element, medication)
-          extract_med_code_attribute(med_element, medication, :indication)
-          extract_med_code_attribute(med_element, medication, :productForm)
-          extract_med_code_attribute(med_element, medication, :vehicle)
-          extract_med_code_attribute(med_element, medication, :reaction)
-          extract_med_code_attribute(med_element, medication, :deliveryMethod)
-          medication.fulfillment_instructions = extract_node_text(med_element.at_xpath("./gc32:patientInstructions"))
-          medication.dose_indicator = extract_node_text(med_element.at_xpath("./gc32:doseIndicator"))
-          medication.fulfillment_history = extract_fulfillment_history(med_element)
-          medication.order_information = extract_order_information(med_element)
-          medication
-        end
-        
-        def extract_administration_timing(element,entry)
-          entry.administration_timing = {"period" => extract_quantity(element, "./gc32:administrationTiming/gc32:period"), 
-                                         "institutionSpecified" => extract_node_attribute(element.at_xpath("./gc32:administrationTiming"), :institutionSpecified)}
-        end
-        
-        def extract_dose_restriction(element, entry)
-          dose_element = element.at_xpath("./gc32:doseRestriction")
-          entry.dose_restriction = {"numerator" => extract_quantity(dose_element, "./gc32:numerator"), "denominator" => extract_quantity(dose_element,"./gc32:denominator")}
-        end
-        
-        def extract_fulfillment_history(med_element)
-          med_element.xpath("./gc32:fulfillmentHistory").map do |fh_doc|
-            fh = FulfillmentHistory.new(quantityDispensed: extract_quantity(fh_doc, "./gc32:quantityDispensed"))
-            fh.prescription_number = extract_node_text(fh_doc.at_xpath("./gc32:prescriptionUmber"))
-            extract_time(fh_doc, fh,  "./gc32:dispenseDate", :dispense_date)
-            fh
-          end
-        end
-        
-        def extract_order_information(med_element)
-          med_element.xpath("./gc32:orderInformation").map do |oi_doc|
-            oi = OrderInformation.new(fills: extract_node_attribute(oi_doc, :fills, true), orderNumber: extract_node_attribute(oi_doc, :orderNumber))
-            extract_time(oi_doc, oi, "./gc32:orderDateTime", :order_date_time)
-            extract_time(oi_doc, oi, "./gc32:expiresDateTime", :order_expiration_date_time)
-            oi
-          end
-        end
-        
-        def extract_med_code_attribute(doc, med, attribute, mongo_attribute_name=nil)
-          mongo_attribute_name ||= attribute
-          extract_code(doc, med, "./gc32:#{attribute}", mongo_attribute_name)
-        end
-        
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-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/procedure_importer.rb

@@ -1,27 +0,0 @@
-module HealthDataStandards
-  module Import
-    module GreenC32
-      class ProcedureImporter < SectionImporter
-        
-        include Singleton
-        
-        def initialize
-          super
-        end
-        
-        def import(procedure_xml)
-          procedure_xml.root.add_namespace_definition('gc32', "urn:hl7-org:greencda:c32")
-          
-          procedure_element = procedure_xml.xpath("./gc32:procedure")
-          
-          procedure = Procedure.new
-          
-          extract_entry(procedure_element, procedure)
-          extract_code(procedure_element, procedure, xpath="./gc32:site", attribute=:site)
-          procedure
-        end
-
-      end
-    end
-  end
-end