cqm-parsers 0.1.0

data/lib/qrda-import/base-importers/demographics_importer.rb

@@ -0,0 +1,47 @@
+module QRDA
+  module Cat1
+    module DemographicsImporter
+      def get_demographics(patient, doc)
+        # effective_date = doc.at_xpath('/cda:ClinicalDocument/cda:effectiveTime')['value']
+        # patient.effective_time = HL7Helper.timestamp_to_integer(effective_date)
+        patient_role_element = doc.at_xpath('/cda:ClinicalDocument/cda:recordTarget/cda:patientRole')
+        patient_element = patient_role_element.at_xpath('./cda:patient')
+        # patient.title = patient_element.at_xpath('cda:name/cda:title').try(:text)
+        patient.givenNames = [patient_element.at_xpath('cda:name/cda:given').text]
+        patient.familyName = patient_element.at_xpath('cda:name/cda:family').text
+        patient.birthDatetime = Time.parse(patient_element.at_xpath('cda:birthTime')['value']).utc
+        pcbd = QDM::PatientCharacteristicBirthdate.new
+        pcbd.birthDatetime = patient.birthDatetime
+        pcbd.dataElementCodes = [{ code: '21112-8', codeSystem: 'LOINC' }]
+        patient.dataElements << pcbd
+
+        pcs = QDM::PatientCharacteristicSex.new
+        gender_code = patient_element.at_xpath('cda:administrativeGenderCode')['code']
+        pcs.dataElementCodes = [{ code: gender_code, codeSystem: 'AdministrativeGender' }]
+        patient.dataElements << pcs
+
+        # TODO: Investigate what of this HDS import codes needs to be addressed in this qrda parser.
+        # gender_node = patient_element.at_xpath('cda:administrativeGenderCode')
+        # patient.gender = gender_node['code']
+        # id_node = patient_role_element.at_xpath('./cda:id')
+        # patient.medical_record_number = id_node['extension']
+        
+        # parse race, ethnicity, and spoken language
+        # race_node = patient_element.at_xpath('cda:raceCode')
+        # patient.race = { 'code' => race_node['code'], 'codeSystem' => 'CDC Race' } if race_node
+        # ethnicity_node = patient_element.at_xpath('cda:ethnicGroupCode')
+        # patient.ethnicity = {'code' => ethnicity_node['code'], 'codeSystem' => 'CDC Race'} if ethnicity_node
+        # marital_status_node = patient_element.at_xpath("./cda:maritalStatusCode")
+        # patient.marital_status = {code: marital_status_node['code'], code_set: "HL7 Marital Status"} if marital_status_node
+        # ra_node = patient_element.at_xpath("./cda:religiousAffiliationCode")
+        # patient.religious_affiliation = {code: ra_node['code'], code_set: "Religious Affiliation"} if ra_node
+        # languages = patient_element.search('languageCommunication').map {|lc| lc.at_xpath('cda:languageCode')['code'] }
+        # patient.languages = languages unless languages.empty?
+        
+        # patient.addresses = patient_role_element.xpath("./cda:addr").map { |addr| import_address(addr) }
+        # patient.telecoms = patient_role_element.xpath("./cda:telecom").map { |tele| import_telecom(tele) }
+        
+      end
+    end
+  end
+end

data/lib/qrda-import/base-importers/medication_importer.rb

@@ -0,0 +1,22 @@
+module QRDA
+  module Cat1
+    class MedicationImporter < SectionImporter
+  
+      def initialize(entry_finder = nil)
+        super(entry_finder)
+        @code_xpath = "./cda:consumable/cda:manufacturedProduct/cda:manufacturedMaterial/cda:code"
+        @relevant_period_xpath = "./cda:effectiveTime"
+        @author_datetime_xpath = "./cda:author/cda:time"
+        @dosage_xpath = "./cda:doseQuantity"
+        @route_xpath = "./cda:routeCode"
+      end
+
+      def create_entry(entry_element, nrh = NarrativeReferenceHandler.new)
+        medication = super
+        medication.dosage = extract_scalar(entry_element, @dosage_xpath)
+        medication.route = code_if_present(entry_element.at_xpath(@route_xpath))
+        medication
+      end
+    end
+  end
+end

data/lib/qrda-import/base-importers/section_importer.rb

@@ -0,0 +1,196 @@
+module QRDA
+  module Cat1
+    class SectionImporter
+      attr_accessor :check_for_usable, :status_xpath, :code_xpath
+
+      def initialize(entry_finder)
+        @entry_finder = entry_finder
+        @code_xpath = "./cda:code"
+        @entry_id_map = {}
+        @check_for_usable = true
+        @entry_class = QDM::DataElement
+      end
+
+      # Traverses an HL7 CDA document passed in 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 "cda" namespace registered to "urn:hl7-org:v3"
+      #        measure definition
+      # @return [Array] will be a list of Entry objects
+      def create_entries(doc, nrh = NarrativeReferenceHandler.new)
+        entry_list = []
+        @entry_id_map = {}
+        entry_elements = @entry_finder.entries(doc)
+        entry_elements.each do |entry_element|
+          entry = create_entry(entry_element, nrh)
+          if @check_for_usable
+            entry_list << entry if usable_entry?(entry)
+          else
+            entry_list << entry
+          end
+        end
+        [entry_list, @entry_id_map]
+      end
+
+      def usable_entry?(entry)
+        entry.dataElementCodes.present?
+      end
+
+      def create_entry(entry_element, _nrh = NarrativeReferenceHandler.new)
+        entry = @entry_class.new
+        @entry_id_map[extract_id(entry_element, "./cda:id")] ||= []
+        @entry_id_map[extract_id(entry_element, "./cda:id")] << entry.id
+        entry.dataElementCodes = extract_codes(entry_element, @code_xpath)
+        extract_dates(entry_element, entry)
+        if @result_xpath
+          entry.result = extract_result_values(entry_element)
+        end
+        extract_reason_or_negation(entry_element, entry)
+        entry
+      end
+
+      private
+
+      def extract_id(parent_element, id_xpath)
+        id_element = parent_element.at_xpath(id_xpath)
+        return unless id_element
+        identifier = CDAIdentifier.new
+        identifier.root = id_element['root']
+        identifier.extension = id_element['extension']
+        identifier
+      end
+
+      def extract_codes(coded_element, code_xpath)
+        code_list = []
+        code_elements = coded_element.xpath(code_xpath)
+        code_elements.each do |code_element|
+          code_list << code_if_present(code_element)
+          translations = code_element.xpath('cda:translation')
+          translations.each do |translation|
+            code_list << code_if_present(translation)
+          end
+        end
+        code_list.compact
+      end
+
+      def code_if_present(code_element)
+        return unless code_element && code_element['codeSystem'] && code_element['code']
+        QDM::Code.new(code_element['code'], HQMF::Util::CodeSystemHelper.code_system_for(code_element['codeSystem']))
+      end
+
+      def extract_dates(parent_element, entry)
+        entry.authorDatetime = extract_time(parent_element, @author_datetime_xpath) if @author_datetime_xpath
+        entry.relevantPeriod = extract_interval(parent_element, @relevant_period_xpath) if @relevant_period_xpath
+        entry.prevalencePeriod = extract_interval(parent_element, @prevalence_period_xpath) if @prevalence_period_xpath
+      end
+
+      def extract_interval(parent_element, interval_xpath)
+        if parent_element.at_xpath("#{interval_xpath}/@value")
+          low_time = DateTime.parse(parent_element.at_xpath(interval_xpath)['value'])
+          high_time = DateTime.parse(parent_element.at_xpath(interval_xpath)['value'])
+        end
+        if parent_element.at_xpath("#{interval_xpath}/cda:low")
+          low_time = DateTime.parse(parent_element.at_xpath("#{interval_xpath}/cda:low")['value'])
+        end
+        if parent_element.at_xpath("#{interval_xpath}/cda:high")
+          high_time = if parent_element.at_xpath("#{interval_xpath}/cda:high")['value']
+                        DateTime.parse(parent_element.at_xpath("#{interval_xpath}/cda:high")['value'])
+                      else
+                        DateTime.new(9999,1,1)
+                      end
+        end
+        if parent_element.at_xpath("#{interval_xpath}/cda:center")
+          low_time = Time.parse(parent_element.at_xpath("#{interval_xpath}/cda:center")['value'])
+          high_time = Time.parse(parent_element.at_xpath("#{interval_xpath}/cda:center")['value'])
+        end
+        QDM::Interval.new(low_time, high_time).shift_dates(0)
+      end
+
+      def extract_time(parent_element, datetime_xpath)
+        DateTime.parse(parent_element.at_xpath(datetime_xpath)['value']) if parent_element.at_xpath("#{datetime_xpath}/@value")
+      end
+
+      def extract_result_values(parent_element)
+        result = []
+        parent_element.xpath(@result_xpath).each do |elem|
+          result << extract_result_value(elem)
+        end
+        result.size > 1 ? result : result.first 
+      end
+
+      def extract_result_value(value_element)
+        return unless value_element && !value_element['nullFlavor']
+        value = value_element['value']
+        if value.present?
+          return value.strip.to_i if (value_element['unit'] == "1" || value_element['unit'].nil?)
+          return QDM::Quantity.new(value.strip.to_i, value_element['unit'])
+        elsif value_element['code'].present?
+          return code_if_present(value_element)
+        end
+      end
+
+      # extracts the reason or negation data. if an element is negated and the code has a null flavor, a random code is assigned for calculation
+      # coded_parent_element is the 'parent' element when the coded is nested (e.g., medication order)
+      def extract_reason_or_negation(parent_element, entry, coded_parent_element = nil)
+        coded_parent_element ||= parent_element
+        reason_element = parent_element.at_xpath("./cda:entryRelationship[@typeCode='RSON']/cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.24.3.88']/cda:value | ./cda:entryRelationship[@typeCode='RSON']/cda:act[cda:templateId/@root='2.16.840.1.113883.10.20.1.27']/cda:code")
+        negation_indicator = parent_element['negationInd']
+        if reason_element
+          if negation_indicator.eql?('true')
+            entry.negationRationale = code_if_present(reason_element)
+          else
+            entry.reason = code_if_present(reason_element)
+          end
+        end
+        extract_negated_code(coded_parent_element, entry)
+      end
+
+      def extract_negated_code(coded_parent_element, entry)
+        code_elements = coded_parent_element.xpath(@code_xpath)
+        code_elements.each do |code_element|
+          if code_element['nullFlavor'] == 'NA' && code_element['sdtc:valueSet']
+            entry.dataElementCodes = [{ code: code_element['sdtc:valueSet'], codeSystem: 'NA_VALUESET' }]
+          end
+        end
+      end
+
+      def extract_scalar(parent_element, scalar_xpath)
+        scalar_element = parent_element.at_xpath(scalar_xpath)
+        return unless scalar_element
+        QDM::Quantity.new(scalar_element['value'].to_i, scalar_element['unit'])
+      end
+
+      def extract_components(parent_element)
+        component_elements = parent_element.xpath(@components_xpath)
+        components = []
+        component_elements&.each do |component_element|
+          component = QDM::Component.new
+          component.code = code_if_present(component_element.at_xpath('./cda:code'))
+          component.result = extract_result_value(component_element.at_xpath('./cda:value'))
+          components << component
+        end
+        components
+      end
+
+      def extract_facility(parent_element, entry)
+        facility_element = parent_element.at_xpath(@facility_xpath)
+        return unless facility_element
+        facility = QDM::FacilityLocation.new
+        participant_element = facility_element.at_xpath("./cda:participantRole[@classCode='SDLOC']/cda:code")
+        facility.code = code_if_present(participant_element)
+        facility.locationPeriod = extract_interval(facility_element, './cda:time')
+        entry.facilityLocations = [facility]
+      end
+
+      def extract_related_to(parent_element)
+        related_to_elements = parent_element.xpath(@related_to_xpath)
+        related_ids = []
+        related_to_elements.each do |related_to_element|
+          related_ids << extract_id(related_to_element, './sdtc:id')
+        end
+        related_ids
+      end
+
+    end
+  end
+end

data/lib/qrda-import/cda_identifier.rb

@@ -0,0 +1,19 @@
+require 'mongoid'
+
+class CDAIdentifier
+  include Mongoid::Document
+  include Mongoid::Attributes::Dynamic
+
+  field :root, type: String
+  field :extension, type: String
+  embedded_in :cda_identifiable, polymorphic: true
+
+  def ==(other)
+    return unless other.respond_to?(:root) && other.respond_to?(:extension)
+    root == other.root && extension == other.extension
+  end
+
+  def hash
+    "#{root}#{extension}".hash
+  end
+end

data/lib/qrda-import/data-element-importers/adverse_event_importer.rb

@@ -0,0 +1,23 @@
+module QRDA
+  module Cat1
+    class AdverseEventImporter < SectionImporter
+      def initialize(entry_finder = QRDA::Cat1::EntryFinder.new("./cda:entry/cda:observation[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.146']"))
+        super(entry_finder)
+        @code_xpath = './cda:entryRelationship/cda:observation/cda:value'
+        @author_datetime_xpath = './cda:author/cda:time'
+        @relevant_period_xpath = './cda:effectiveTime'
+        @severity_xpath = "./cda:entryRelationship/cda:observation[cda:templateId/@root = '2.16.840.1.113883.10.20.22.4.8']/cda:value"
+        @facility_xpath = "./cda:participant[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.100']"
+        @entry_class = QDM::AdverseEvent
+      end
+
+      def create_entry(entry_element, nrh = NarrativeReferenceHandler.new)
+        adverse_event = super
+        adverse_event.severity = code_if_present(entry_element.at_xpath(@severity_xpath))
+        extract_facility(entry_element, adverse_event)
+        adverse_event
+      end
+
+    end
+  end
+end

data/lib/qrda-import/data-element-importers/allergy_intolerance_importer.rb

@@ -0,0 +1,21 @@
+module QRDA
+  module Cat1
+    class AllergyIntoleranceImporter < SectionImporter
+      def initialize(entry_finder = QRDA::Cat1::EntryFinder.new("./cda:entry/cda:observation[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.147']"))
+        super(entry_finder)
+        @code_xpath = './cda:participant/cda:participantRole/cda:playingEntity/cda:code'
+        @author_datetime_xpath = "./cda:author/cda:time"
+        @prevalence_period_xpath = "./cda:effectiveTime"
+        @severity_xpath = "./cda:entryRelationship/cda:observation[cda:templateId/@root = '2.16.840.1.113883.10.20.22.4.8']/cda:value"
+        @entry_class = QDM::AllergyIntolerance
+      end
+
+      def create_entry(entry_element, nrh = NarrativeReferenceHandler.new)
+        allergy_intolerance = super
+        allergy_intolerance.severity = code_if_present(entry_element.at_xpath(@severity_xpath))
+        allergy_intolerance
+      end
+
+    end
+  end
+end

data/lib/qrda-import/data-element-importers/assessment_performed_importer.rb

@@ -0,0 +1,23 @@
+module QRDA
+  module Cat1
+    class AssessmentPerformedImporter < SectionImporter
+      def initialize(entry_finder = QRDA::Cat1::EntryFinder.new("./cda:entry/cda:observation[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.144']"))
+        super(entry_finder)
+        @code_xpath = './cda:code'
+        @author_datetime_xpath = "./cda:author/cda:time"
+        @result_xpath = "./cda:value | ./cda:entryRelationship[@typeCode='REFR']/cda:observation/cda:value"
+        @method_xpath = './cda:methodCode'
+        @components_xpath = "./cda:entryRelationship/cda:observation[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.149']"
+        @entry_class = QDM::AssessmentPerformed
+      end
+
+      def create_entry(entry_element, nrh = NarrativeReferenceHandler.new)
+        assessment_performed = super
+        assessment_performed.method = code_if_present(entry_element.at_xpath(@method_xpath))
+        assessment_performed.components = extract_components(entry_element)
+        assessment_performed
+      end
+
+    end
+  end
+end

data/lib/qrda-import/data-element-importers/communication_from_patient_to_provider_importer.rb

@@ -0,0 +1,18 @@
+module QRDA
+  module Cat1
+    class CommunicationFromPatientToProviderImporter < SectionImporter
+      def initialize(entry_finder = QRDA::Cat1::EntryFinder.new("./cda:entry/cda:act[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.2']"))
+        super(entry_finder)
+        @code_xpath = './cda:code'
+        @author_datetime_xpath = "./cda:author/cda:time"
+        @entry_class = QDM::CommunicationFromPatientToProvider
+      end
+
+      def create_entry(entry_element, nrh = NarrativeReferenceHandler.new)
+        communication_from_patient_to_provider = super
+        communication_from_patient_to_provider
+      end
+
+    end
+  end
+end

data/lib/qrda-import/data-element-importers/communication_from_provider_to_patient_importer.rb

@@ -0,0 +1,18 @@
+module QRDA
+  module Cat1
+    class CommunicationFromProviderToPatientImporter < SectionImporter
+      def initialize(entry_finder = QRDA::Cat1::EntryFinder.new("./cda:entry/cda:act[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.3']"))
+        super(entry_finder)
+        @code_xpath = './cda:code'
+        @author_datetime_xpath = "./cda:author/cda:time"
+        @entry_class = QDM::CommunicationFromProviderToPatient
+      end
+
+      def create_entry(entry_element, nrh = NarrativeReferenceHandler.new)
+        communication_from_provider_to_patient = super
+        communication_from_provider_to_patient
+      end
+
+    end
+  end
+end

data/lib/qrda-import/data-element-importers/communication_from_provider_to_provider_importer.rb

@@ -0,0 +1,20 @@
+module QRDA
+  module Cat1
+    class CommunicationFromProviderToProviderImporter < SectionImporter
+      def initialize(entry_finder = QRDA::Cat1::EntryFinder.new("./cda:entry/cda:act[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.4']"))
+        super(entry_finder)
+        @code_xpath = './cda:code'
+        @author_datetime_xpath = "./cda:author/cda:time"
+        @related_to_xpath = "./sdtc:inFulfillmentOf1/sdtc:actReference"
+        @entry_class = QDM::CommunicationFromProviderToProvider
+      end
+
+      def create_entry(entry_element, nrh = NarrativeReferenceHandler.new)
+        communication_from_provider_to_provider = super
+        communication_from_provider_to_provider.relatedTo = extract_related_to(entry_element)
+        communication_from_provider_to_provider
+      end
+
+    end
+  end
+end

data/lib/qrda-import/data-element-importers/device_applied_importer.rb

@@ -0,0 +1,23 @@
+module QRDA
+  module Cat1
+    class DeviceAppliedImporter < SectionImporter
+      def initialize(entry_finder = QRDA::Cat1::EntryFinder.new("./cda:entry/cda:procedure[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.7']"))
+        super(entry_finder)
+        @code_xpath = './cda:participant/cda:participantRole/cda:playingDevice/cda:code'
+        @author_datetime_xpath = "./cda:author/cda:time"
+        @relevant_period_xpath = "./cda:effectiveTime"
+        @anatomical_location_site_xpath = "./cda:targetSiteCode"
+        @anatomical_approach_site_xpath = "./cda:approachSiteCode"
+        @entry_class = QDM::DeviceApplied
+      end
+
+      def create_entry(entry_element, nrh = NarrativeReferenceHandler.new)
+        device_applied = super
+        device_applied.anatomicalLocationSite = code_if_present(entry_element.at_xpath(@anatomical_location_site_xpath))
+        device_applied.anatomicalApproachSite = code_if_present(entry_element.at_xpath(@anatomical_approach_site_xpath))
+        device_applied
+      end
+
+    end
+  end
+end

data/lib/qrda-import/data-element-importers/device_order_importer.rb

@@ -0,0 +1,18 @@
+module QRDA
+  module Cat1
+    class DeviceOrderImporter < SectionImporter
+      def initialize(entry_finder = QRDA::Cat1::EntryFinder.new("./cda:entry/cda:act[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.130']"))
+        super(entry_finder)
+        @code_xpath = "./cda:entryRelationship/cda:supply[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.9']/cda:participant/cda:participantRole/cda:playingDevice/cda:code"
+        @author_datetime_xpath = "./cda:entryRelationship/cda:supply[cda:templateId/@root = '2.16.840.1.113883.10.20.24.3.9']/cda:author/cda:time"
+        @entry_class = QDM::DeviceOrder
+      end
+
+      def create_entry(entry_element, nrh = NarrativeReferenceHandler.new)
+        device_order = super
+        device_order
+      end
+
+    end
+  end
+end