health-data-standards 0.7.1 → 0.8.0

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

@@ -0,0 +1,20 @@
+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)
+          allergy.type = extract_node_text(allergy_element.at_xpath("./gc32: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/condition_importer.rb

@@ -10,16 +10,15 @@ module HealthDataStandards
         
         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
         

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

@@ -0,0 +1,42 @@
+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)
+          extract_facility(encounter_element, encounter)
+          
+          free_text = encounter_element.xpath("./gc32:freeText").first
+
+          if free_text
+            encounter.free_text = free_text.content
+          end
+          
+          encounter
+        end
+        
+        def extract_facility(encounter_element, encounter)
+          facility_element = encounter_element.xpath("./gc32:facility").first
+          if facility_element
+            organization = extract_organization(facility_element)
+            encounter.facility = organization
+          end
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+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:administeredDate")
+          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.refusalInd = extract_node_attribute(immunization_element, :refused, true)
+          immunization
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+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.free_text_sig = extract_node_text(med_element.at_xpath("./gc32:freeTextSig"))
+          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/procedure_importer.rb

@@ -0,0 +1,35 @@
+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_type(procedure_element, procedure)
+          
+          procedure
+        end
+        
+        private
+        
+        def extract_type(procedure_xml, procedure)
+          type = procedure_xml.xpath("./gc32:type").first
+          procedure.type = extract_node_text(type)
+        end
+        
+      end
+    end
+  end
+end

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

@@ -2,28 +2,41 @@ module HealthDataStandards
   module Import
     module GreenC32
       class ResultImporter < SectionImporter
+
         include Singleton
         
+        #-------------------------------------------------------------------------------
+
         def initialize
           super
           @range = "./gc32:referenceRange"
           @interpretation = "./gc32:interpretation"
+          @klass = LabResult
+          @base_xpath = "./gc32:result"
         end
         
-        def import(result)
-          result.root.add_namespace_definition('gc32', "urn:hl7-org:greencda:c32")
+        #-------------------------------------------------------------------------------
+
+        def import(result_xml)
+          result_xml.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)))
+          result_element = result_xml.xpath(@base_xpath)
+          lab_result = @klass.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)
+          extract_result(result_element, lab_result)
               
           lab_result
         end
         
+        #-------------------------------------------------------------------------------
+        private
+        #-------------------------------------------------------------------------------
+        
+        def extract_result(result_element, lab_result)
+          extract_entry(result_element, lab_result)
+          extract_code(result_element, lab_result, @interpretation, :interpretation)
+        end
+
       end
     end
   end

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

@@ -37,36 +37,82 @@ module HealthDataStandards
           entry.status = status
         end
         
+        def extract_effective_time(element, entry)
+          if element.at_xpath("./gc32:effectiveTime/gc32:start")
+            extract_interval(element,entry)  
+          else
+            extract_time(element, entry)
+          end
+        end
+        
         def extract_time(element, entry, xpath = "./gc32:effectiveTime", attribute = "time")
-          datetime = element.xpath(xpath).first
+          datetime = element.at_xpath(xpath)
           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")
+        def extract_interval(element, entry, element_name="effectiveTime")
+          extract_time(element, entry, "./gc32:#{element_name}/gc32:start", "start_time")
+          extract_time(element, entry, "./gc32:#{element_name}/gc32:end", "end_time")
         end
         
-        def extract_value(element, entry)
-          
-          value_element = element.xpath(@value).first
+        def extract_quantity(element, xpath)
+          value_element = element.at_xpath(xpath)
           
           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
-
+          return {} unless node_value
+          
+          {'scalar' => node_value, "unit" => node_units}
+        end
+        
+        def extract_value(element, entry)
+          entry.value = extract_quantity(element, @value)
         end
         
         def extract_entry(element, entry)
           extract_code(element, entry)
           extract_description(element, entry)
           extract_status(element, entry)
+          extract_value(element, entry)
+          extract_effective_time(element, entry)
         end
         
+        def extract_organization(organization_element)
+          org_id = extract_node_text(organization_element.xpath("./gc32:id"))
+          organization = org_id ? Organization.find_or_create_by(id: org_id) : Organization.new
+          if organization.new_record?
+          else
+            organization.name = extract_node_text(organization_element.xpath("./gc32:name"))
+            organization.addresses = organization_element.xpath("./gc32:address").map { |addr| extract_address(addr)  }
+            organization.telecoms = organization_element.xpath("./gc32:telecom").map { |tele| extract_telecom(tele) }
+            organization.save!
+          end
+          
+          return organization
+        end
+        
+        def extract_address(address_element)
+          address = Address.new
+          address.street = address_element.xpath("./gc32:street").map { |st| extract_node_text(st)  }
+          address.city = extract_node_text(address_element.xpath("./gc32:city"))
+          address.state = extract_node_text(address_element.xpath("./gc32:state"))
+          address.zip = extract_node_text(address_element.xpath("./gc32:postalCode"))
+          address
+        end
+        
+        def extract_telecom(telecom_element)
+          telecom = Telecom.new
+          telecom.use = extract_node_attribute(telecom_element, :type)
+          telecom.value = extract_node_attribute(telecom_element, :value)
+          telecom.preferred = extract_node_attribute(telecom_element, :preferred)
+          telecom
+        end
+        
+        
         private
         
         def build_code(code_element)

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

@@ -0,0 +1,18 @@
+module HealthDataStandards
+  module Import
+    module GreenC32
+      class SocialHistoryImporter < SectionImporter
+        include Singleton
+        
+        def import(sh_xml)
+          sh_xml.root.add_namespace_definition('gc32', "urn:hl7-org:greencda:c32")
+          sh_element = sh_xml.at_xpath("./gc32:socialHistory")
+          sh = SocialHistory.new
+          extract_entry(sh_element, sh)
+          extract_code(sh_element, sh, "./gc32:type", :type)
+          sh
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module HealthDataStandards
+  module Import
+    module GreenC32
+      # This really needs to get refactored to share code with result importer
+      class VitalSignImporter < ResultImporter
+
+        include Singleton
+        
+        #-------------------------------------------------------------------------------
+
+        def initialize
+          super
+          @range = "./gc32:referenceRange"
+          @klass = VitalSign
+          @base_xpath = "./gc32:vitalSign"
+        end
+
+      end
+    end
+  end
+end

data/lib/health-data-standards/import/hdata/metadata_importer.rb

@@ -0,0 +1,82 @@
+module HealthDataStandards
+  module Import
+    module Hdata
+      class MetadataImporter
+        include Singleton
+        
+        def import(meta_xml)
+          meta_xml.root.add_namespace_definition("hrf-md", Metadata::NS)
+          meta_element = meta_xml.at_xpath("./hrf-md:DocumentMetadata")
+          return unless meta_element
+          
+          meta = Metadata::Base.new
+          
+          extract_metadata(meta_element, meta)
+
+          meta
+        end
+        
+        def extract_metadata(meta_element, meta)
+          meta.mime_types = meta_element.xpath("./hrf-md:MediaType").map { |media| media.text }
+          meta.confidentiality = meta_element.at_xpath("./hrf-md:Confidentiality").try(:text)
+          meta.pedigrees = meta_element.xpath("./hrf-md:PedigreeInfo").map { |ped| extract_pedigree(ped) }
+          creation_el = meta_element.at_xpath("./hrf-md:RecordDate/hrf-md:CreatedDateTime")
+          meta.original_creation_time = Time.parse(creation_el.text) if creation_el
+          meta.linked_documents = meta_element.xpath("./hrf-md:LinkedDocuments/hrf-md:Link").map {|l| extract_link_info(l)}
+          copied_elements = meta_element.xpath("./hrf-md:RecordDate/hrf-md:Copied/hrf-md:CopiedInfo")
+          meta.copied_dates = copied_elements.map { |cp| extract_change_info(cp) }
+          modified_elements = meta_element.xpath("./hrf-md:RecordDate/hrf-md:Modified/hrf-md:ModifiedInfo")
+          meta.modified_dates = modified_elements.map { |md| extract_change_info(md) }
+          meta
+        end
+        
+        def extract_pedigree(pedi_el)
+          return unless pedi_el
+          
+          author = extract_author(pedi_el)
+          organization = pedi_el.at_xpath("./hrf-md:Organization")
+          
+          ped = Metadata::Pedigree.new(author: author,
+                             organization: organization.try(:content))
+                              
+          source_pedigree_els = pedi_el.xpath("./hrf-md:Source/hrf-md:PedigreeInfo")
+          ped.source_pedigrees = source_pedigree_els.map { |ped_el| extract_pedigree(ped_el) }
+          ped.derived = pedi_el.attribute("derived")# == "true" ? true : false
+          # ped.signature = pedi_el.at_xpath("./hrf-md:Signature/")
+          
+          source_doc_els = pedi_el.xpath("./hrf-md:Source/hrf-md:Document")
+          ped.source_documents = source_doc_els.map { |doc_el| extract_link_info(doc_el) }
+          
+          ped
+        end
+        
+        def extract_author(pedi_el)
+          return unless pedi_el
+          author = pedi_el.at_xpath("./hrf-md:Author")
+          return unless author
+          Metadata::Author.new(name: author.try(:content), 
+                               type: author.attribute('typeCode').try("content"), 
+                               role: author.attribute('role').try("content"))
+        end
+        
+        def extract_link_info(link_info_el)
+          return unless link_info_el
+          target_el = link_info_el.at_xpath("./hrf-md:Target")
+          return unless target_el
+          Metadata::LinkInfo.new(uri: target_el.content, 
+                       extension: target_el.attribute("TargetExtension").try(:content))
+        end
+        
+        def extract_change_info(change_info_el)
+          return unless change_info_el
+          change_info = Metadata::ChangeInfo.new
+          change_info.timestamp = change_info_el.at_xpath("./hrf-md:ChangeDateTime").try("content")
+          change_info.pedigree = extract_pedigree(change_info_el.at_xpath("./hrf-md:PedigreeInfo"))
+          change_info_el
+          change_info
+        end
+        
+      end
+    end
+  end
+end