cqm-parsers 0.1.0

data/lib/hqmf-parser/2.0/document_helpers/doc_population_helper.rb

@@ -0,0 +1,173 @@
+module HQMF2
+  # Handles generation of populations for the main document
+  class DocumentPopulationHelper
+    include HQMF2::Utilities
+
+    def initialize(entry, doc, document, id_generator, reference_ids = {})
+      @entry = entry
+      @doc = doc
+      remove_population_preconditions(@doc)
+      @document = document
+      @id_generator = id_generator
+      @reference_ids = reference_ids
+      @populations = []
+      @population_criteria = []
+      @stratifications = []
+      @ids_by_hqmf_id = {}
+      @population_counters = {}
+    end
+
+    # If a precondition references a population, remove it
+    def remove_population_preconditions(doc)
+      # population sections
+      pop_ids = doc.xpath("//cda:populationCriteriaSection/cda:component[@typeCode='COMP']/*/cda:id",
+                          HQMF2::Document::NAMESPACES)
+      # find the population entries and get their ids
+      pop_ids.each do |p_id|
+        doc.xpath("//cda:precondition[./cda:criteriaReference/cda:id[@extension='#{p_id['extension']}' and @root='#{p_id['root']}']]",
+                  HQMF2::Document::NAMESPACES).remove
+      end
+    end
+
+    # Returns the population descriptions and criteria found in this document
+    def extract_populations_and_criteria
+      has_observation = extract_observations
+      document_populations = @doc.xpath('cda:QualityMeasureDocument/cda:component/cda:populationCriteriaSection',
+                                        HQMF2::Document::NAMESPACES)
+      # Sort the populations based on the id/extension, since the populations may be out of order; there doesn't seem to
+      # be any other way that order is indicated in the HQMF
+      document_populations = document_populations.sort_by do |pop|
+        pop.at_xpath('cda:id/@extension', HQMF2::Document::NAMESPACES).try(:value)
+      end
+      number_of_populations = document_populations.length
+      document_populations.each_with_index do |population_def, population_index|
+        population = {}
+        handle_base_populations(population_def, population)
+
+        id_def = population_def.at_xpath('cda:id/@extension', HQMF2::Document::NAMESPACES)
+        population['id'] = id_def ? id_def.value : "Population#{population_index}"
+        title_def = population_def.at_xpath('cda:title/@value', HQMF2::Document::NAMESPACES)
+        population['title'] = title_def ? title_def.value : "Population #{population_index}"
+
+        population['OBSERV'] = 'OBSERV' if has_observation
+        @populations << population
+        handle_stratifications(population_def, number_of_populations, population, id_def, population_index)
+      end
+
+      # Push in the stratification populations after the unstratified populations
+      @populations.concat(@stratifications)
+      [@populations, @population_criteria]
+    end
+
+    # Extracts the measure observations, will return true if one exists
+    def extract_observations
+      has_observation = false
+      # look for observation data in separate section but create a population for it if it exists
+      observation_section = @doc.xpath('/cda:QualityMeasureDocument/cda:component/cda:measureObservationSection',
+                                       HQMF2::Document::NAMESPACES)
+      unless observation_section.empty?
+        observation_section.xpath('cda:definition', HQMF2::Document::NAMESPACES).each do |criteria_def|
+          criteria_id = 'OBSERV'
+          criteria = PopulationCriteria.new(criteria_def, @document, @id_generator)
+          criteria.type = 'OBSERV'
+          # This section constructs a human readable id.  The first IPP will be IPP, the second will be IPP_1, etc.
+          # This allows the populations to be more readable.  The alternative would be to have the hqmf ids in the
+          # populations, which would work, but is difficult to read the populations.
+          if @ids_by_hqmf_id["#{criteria.hqmf_id}"]
+            criteria.create_human_readable_id(@ids_by_hqmf_id[criteria.hqmf_id])
+          else
+            criteria.create_human_readable_id(population_id_with_counter(criteria_id))
+            @ids_by_hqmf_id["#{criteria.hqmf_id}"] = criteria.id
+          end
+
+          @population_criteria << criteria
+          has_observation = true
+        end
+      end
+      has_observation
+    end
+
+    # Builds populations based an a predfined set of expected populations
+    def handle_base_populations(population_def, population)
+      {
+        HQMF::PopulationCriteria::IPP => 'initialPopulationCriteria',
+        HQMF::PopulationCriteria::DENOM => 'denominatorCriteria',
+        HQMF::PopulationCriteria::NUMER => 'numeratorCriteria',
+        HQMF::PopulationCriteria::NUMEX => 'numeratorExclusionCriteria',
+        HQMF::PopulationCriteria::DENEXCEP => 'denominatorExceptionCriteria',
+        HQMF::PopulationCriteria::DENEX => 'denominatorExclusionCriteria',
+        HQMF::PopulationCriteria::MSRPOPL => 'measurePopulationCriteria',
+        HQMF::PopulationCriteria::MSRPOPLEX => 'measurePopulationExclusionCriteria'
+      }.each_pair do |criteria_id, criteria_element_name|
+        criteria_def = population_def.at_xpath("cda:component[cda:#{criteria_element_name}]", HQMF2::Document::NAMESPACES)
+        if criteria_def
+          build_population_criteria(criteria_def, criteria_id, population)
+        end
+      end
+    end
+
+    # Generate the stratifications of populations, if any exist
+    def handle_stratifications(population_def, number_of_populations, population, id_def, population_index)
+      # handle stratifications (EP137, EP155)
+      stratifier_criteria_xpath = "cda:component/cda:stratifierCriteria[not(cda:component/cda:measureAttribute/cda:code[@code  = 'SDE'])]/.."
+      population_def.xpath(stratifier_criteria_xpath, HQMF2::Document::NAMESPACES)
+        .each_with_index do |criteria_def, criteria_def_index|
+        # Skip this Stratification if any precondition doesn't contain any preconditions
+        next unless PopulationCriteria.new(criteria_def, @document, @id_generator)
+                    .preconditions.all? { |prcn| prcn.preconditions.length > 0 }
+        index = number_of_populations + ((population_index - 1) * criteria_def.xpath('./*/cda:precondition').length) +
+                criteria_def_index
+        criteria_id = HQMF::PopulationCriteria::STRAT
+        stratified_population = population.dup
+        stratified_population['stratification'] = criteria_def.at_xpath('./*/cda:id/@root').try(:value) ||
+                                                  "#{criteria_id}-#{criteria_def_index}"
+        build_population_criteria(criteria_def, criteria_id, stratified_population)
+
+        stratified_population['id'] = id_def ? "#{id_def.value} - Stratification #{criteria_def_index + 1}" : "Population#{index}"
+        title_def = population_def.at_xpath('cda:title/@value', HQMF2::Document::NAMESPACES)
+        stratified_population['title'] = title_def ? "#{title_def.value} - Stratification #{criteria_def_index + 1}" : "Population #{index}"
+        @stratifications << stratified_population
+      end
+    end
+
+    # Method to generate the criteria defining a population
+    def build_population_criteria(criteria_def, criteria_id, population)
+      criteria = PopulationCriteria.new(criteria_def, @document, @id_generator)
+
+      # check to see if we have an identical population criteria.
+      # this can happen since the hqmf 2.0 will export a DENOM, NUMER, etc for each population, even if identical.
+      # if we have identical, just re-use it rather than creating DENOM_1, NUMER_1, etc.
+      identical = @population_criteria.select { |pc| pc.to_model.hqmf_id == criteria.to_model.hqmf_id }
+
+      @reference_ids.concat(criteria.to_model.referenced_data_criteria)
+
+      if identical.empty?
+        # this section constructs a human readable id.  The first IPP will be IPP, the second will be IPP_1, etc.
+        # This allows the populations to be more readable.  The alternative would be to have the hqmf ids in the
+        # populations, which would work, but is difficult to read the populations.
+        if @ids_by_hqmf_id["#{criteria.hqmf_id}-#{population['stratification']}"]
+          criteria.create_human_readable_id(@ids_by_hqmf_id["#{criteria.hqmf_id}-#{population['stratification']}"])
+        else
+          criteria.create_human_readable_id(population_id_with_counter(criteria_id))
+          @ids_by_hqmf_id["#{criteria.hqmf_id}-#{population['stratification']}"] = criteria.id
+        end
+
+        @population_criteria << criteria
+        population[criteria_id] = criteria.id
+      else
+        population[criteria_id] = identical.first.id
+      end
+    end
+
+    # Returns a unique id for a given population (increments the id if already present)
+    def population_id_with_counter(criteria_id)
+      if @population_counters[criteria_id]
+        @population_counters[criteria_id] += 1
+        "#{criteria_id}_#{@population_counters[criteria_id]}"
+      else
+        @population_counters[criteria_id] = 0
+        criteria_id
+      end
+    end
+  end
+end

data/lib/hqmf-parser/2.0/document_helpers/doc_utilities.rb

@@ -0,0 +1,131 @@
+module HQMF2
+  # Utilities used by the document parser to handle generic tasks
+  module DocumentUtilities
+    # Create grouper data criteria for encapsulating variable data criteria
+    # and update document data criteria list and references map
+    def handle_variable(data_criteria, collapsed_source_data_criteria)
+
+      if data_criteria.is_derived_specific_occurrence_variable
+        data_criteria.handle_derived_specific_occurrence_variable
+        extract_source_data_criteria(data_criteria)
+        return
+      end
+
+      tmp_id = data_criteria.id
+
+      grouper_data_criteria = data_criteria.extract_variable_grouper
+      return unless grouper_data_criteria
+      @data_criteria_references[data_criteria.id] = data_criteria
+      @data_criteria_references[grouper_data_criteria.id] = grouper_data_criteria
+
+      # create a source data criteria for the grouping data critera we just created
+      sdc = SourceDataCriteriaHelper.strip_non_sc_elements(grouper_data_criteria)
+      @source_data_criteria << sdc
+      
+      # check if the original source has been collapsed when generating the SDC list (we need to reference the collapsed version in the sdc list)
+      if collapsed_source_data_criteria[tmp_id]
+        data_criteria.instance_variable_set(:@source_data_criteria, collapsed_source_data_criteria[tmp_id])
+      else
+        # check if we need to add _source suffix (most source data criteria are segmented with '_source' suffixes)
+        data_criteria_sdc = find(@source_data_criteria, :id, "#{tmp_id}_source") 
+        if data_criteria_sdc
+          data_criteria.instance_variable_set(:@source_data_criteria, data_criteria_sdc.id)
+          data_criteria_sdc.instance_variable_set(:@variable, false)
+        # if it's not a derived data criteria then we may need to strip off temporal references, fields, etc as a new source data criteria
+        elsif !['derived', 'satisfies_any', 'satisfies_all'].include?(data_criteria.definition)
+          extract_source_data_criteria(data_criteria)
+        end
+      end
+
+      @data_criteria << grouper_data_criteria
+    end
+
+    def extract_source_data_criteria (data_criteria)
+      # check if we have temporal references other non-SDC elements on this data criteria.
+      # if we do, we need to create a new SDC to reference
+      if !SourceDataCriteriaHelper.already_stripped?(data_criteria)
+        candidate_sdc = SourceDataCriteriaHelper.strip_non_sc_elements(data_criteria.clone)
+        candidate_sdc.instance_variable_set(:@id, "#{candidate_sdc.id}_source")
+        candidate_sdc.instance_variable_set(:@source_data_criteria, candidate_sdc.id)
+
+        existing_candidate = SourceDataCriteriaHelper.find_existing_source_data_criteria(@source_data_criteria, candidate_sdc)
+        if existing_candidate
+          candidate_sdc = existing_candidate
+        else
+          @source_data_criteria << candidate_sdc
+          # Specific occurrence variables need a copy of the source in the data criteria to display variable results
+          @data_criteria << candidate_sdc if data_criteria.is_derived_specific_occurrence_variable
+        end
+
+        data_criteria.instance_variable_set(:@source_data_criteria, candidate_sdc.id)
+      end
+    end
+
+    # Checks if one data criteria is covered by another (has all the appropriate elements of)
+    def criteria_covered_by_criteria?(dc)
+      @reference_ids.uniq
+
+      base_criteria_defs = %w(patient_characteristic_ethnicity patient_characteristic_gender patient_characteristic_payer patient_characteristic_race)
+      to_reject = true
+      # don't reject if anything refers directly to this criteria
+      to_reject &&= @reference_ids.index(dc.id).nil?
+      # don't reject if it is a "base" criteria (no references but must exist)
+      to_reject &&= !base_criteria_defs.include?(dc.definition)
+      # keep referral occurrence
+      to_reject &&= dc.specific_occurrence_const.nil? ||
+                    dc.code_list_id != '2.16.840.1.113883.3.464.1003.101.12.1046'
+      to_reject && !@data_criteria.detect do |dc2|
+        similar_criteria = true
+        similar_criteria &&= dc != dc2 # Don't check against itself
+        similar_criteria &&= dc.code_list_id == dc2.code_list_id # Ensure code list ids are the same
+        similar_criteria && detect_criteria_covered_by_criteria(dc, dc2)
+      end.nil? # don't reject unless there is a similar element
+    end
+
+    # Check if one data criteria contains the others information by checking that one has everything the other has
+    # (or more)
+    def detect_criteria_covered_by_criteria(data_criteria, check_criteria)
+      base_checks = true
+
+      # Check whether basic features are the same
+      base_checks &&= data_criteria.definition == check_criteria.definition # same definition
+      base_checks &&= data_criteria.status == check_criteria.status # same status
+      # same children
+      base_checks &&= data_criteria.children_criteria.sort.join(',') == check_criteria.children_criteria.sort.join(',')
+      # Ensure it doesn't contain basic elements that should not be removed
+      base_checks &&= !data_criteria.variable # Ensure it's not a variable
+      base_checks &&= data_criteria.derivation_operator.nil? # Ensure it doesn't have a derivation operator
+      base_checks &&= data_criteria.subset_operators.empty? # Ensure it doesn't have a subset operator
+      # Ensure it doesn't have Temporal References
+      base_checks &&= data_criteria.temporal_references.nil? || data_criteria.temporal_references.empty?
+
+      base_checks && complex_coverage(data_criteria, check_criteria)
+    end
+
+    # Check elements that do not already exist; else, if they do, check if those elements are the same
+    # in a different, potentially matching, data criteria
+    def complex_coverage(data_criteria, check_criteria)
+      same_value = data_criteria.value.nil? ||
+                   data_criteria.value.try(:to_model).try(:to_json) == check_criteria.value.try(:to_model).try(:to_json)
+
+      same_field_values = same_field_values_check(data_criteria, check_criteria)
+
+      same_negation_values = data_criteria.negation_code_list_id.nil? ||
+                             data_criteria.negation_code_list_id == check_criteria.negation_code_list_id
+
+      same_value && same_negation_values && same_field_values
+    end
+    
+    def same_field_values_check(data_criteria, check_criteria)
+      empty = data_criteria.field_values.nil? || data_criteria.field_values.empty?
+      # Ignore STATUS (and ORDINAL for CMS172v5)
+      # The meaning of status has changed over time. Laboratory test and procedure now use status differently.
+      # This change is causing superficial discrepencies between the simplexml and hqmf regarding STATUS.
+      dc_filtered = data_criteria.field_values.except('STATUS').except('ORDINAL')
+      cc_filtered = check_criteria.field_values.except('STATUS').except('ORDINAL')
+      left = dc_filtered.nil? || dc_filtered.empty? ? nil : dc_filtered.try(:to_json)
+      right = cc_filtered.nil? || cc_filtered.empty? ? nil : cc_filtered.try(:to_json)
+      return empty || left == right
+    end
+  end
+end

data/lib/hqmf-parser/2.0/field_value_helper.rb

@@ -0,0 +1,251 @@
+module HQMF2
+  # Generates field values based on understanding of the HQMF 2.1 spec
+  class FieldValueHelper
+    def self.parse_field_values(entry)
+      return if entry.nil?
+      criteria = entry.at_xpath('./cda:actCriteria | ./cda:observationCriteria | ./cda:encounterCriteria |
+                                 ./cda:procedureCriteria | ./cda:supplyCriteria |
+                                 ./cda:substanceAdministrationCriteria | ./cda:grouperCriteria')
+
+      return {} if criteria.nil?
+      fields = {}
+      # Negation is handled in the data criteria parsing class and not as a field value.
+      # Not using the reasonCode element because the QDM HQMF ig states that reason is in an outbound relationship.
+      # parse_dset_cd(criteria.at_xpath('./cda:reasonCode', HQMF2::Document::NAMESPACES), 'REASON', fields) unless
+      # negated.
+      parse_dset_cd(criteria.at_xpath('./cda:priorityCode', HQMF2::Document::NAMESPACES), 'ORDINAL', fields)
+      parse_date_fields(criteria, fields)
+
+      handle_fields_per_criteria(criteria, fields)
+
+      fields
+    end
+
+    def self.handle_fields_per_criteria(criteria, fields)
+      case criteria.name
+      when 'encounterCriteria'
+        parse_encounter_fields(criteria, fields)
+      when 'actCriteria'
+        parse_act_criteria_fields(criteria, fields)
+      when 'observationCriteria'
+        parse_observation_fields(criteria, fields)
+      when 'procedureCriteria'
+        parse_procedure_fields(criteria, fields)
+      when 'supplyCriteria'
+        parse_supply_fields(criteria, fields)
+      when 'substanceAdministrationCriteria'
+        parse_substance_administration_fields(criteria, fields)
+      when 'grouperCriteria'
+        parse_grouper_fields(criteria, fields)
+      end
+    end
+
+    # The next group of "parse_" methods handle extracting values for different types of criteria
+
+    def self.parse_dset_cd(element, field, fields)
+      if element
+        item = element.at_xpath('./cda:item')
+        any = any_flavor(item) || any_flavor(element)
+        fields[field] = AnyValue.new if any
+        fields[field] = Coded.new(item) if item && !any
+      end
+    end
+
+    # The next group of "parse_" methods also first check if the value is of the "ANY" type, and only parse if it isn't
+
+    def self.parse_cd(element, field, fields)
+      any = check_and_set_if_any(element, field, fields)
+      fields[field] = Coded.new(element) if element && !any
+    end
+
+    def self.parse_ts(element, field, fields)
+      any = check_and_set_if_any(element, field, fields)
+      fields[field] = Value.new(element) if element && !any
+    end
+
+    def self.parse_ivl_int(element, field, fields)
+      any = check_and_set_if_any(element, field, fields)
+      fields[field] = Range.new(element) if element && !any
+    end
+
+    def self.parse_cs(element, field, fields)
+      # Only possible result is AnyValue
+      check_and_set_if_any(element, field, fields)
+    end
+
+    def self.parse_pq(element, field, fields)
+      any = check_and_set_if_any(element, field, fields)
+      fields[field] = Range.new(element) if element && !any
+    end
+
+    def self.parse_value(element, field, fields)
+      any = check_and_set_if_any(element, field, fields)
+      fields[field] = DateCriteria.parse_value(element) if element && !any
+    end
+
+    # handle any value
+    def self.parse_any(element, field, fields)
+      any = check_and_set_if_any(element, field, fields)
+      fields[field] = DateCriteria.parse_value(element) if element && !any
+    end
+
+    # Use when checking if the element is a "ANY" type, sets the field key if it is
+    def self.check_and_set_if_any(element, field, fields)
+      any = any_flavor(element)
+      fields[field] = AnyValue.new if any
+      any
+    end
+
+    def self.any_flavor(element)
+      element && (element['flavorId'] == 'ANY.NONNULL' ||
+                  element.at_xpath('@xsi:type', HQMF2::Document::NAMESPACES) == 'ANY')
+    end
+
+    def self.parse_date_fields(entry, fields)
+      # handle embded date fields
+      times = [{ key: 'signeddatetime', field: 'SIGNED_DATETIME', highlow: 'high' },
+               { key: 'startdatetime', field:  'START_DATETIME', highlow: 'low' },
+               { key: 'stopdatetime', field:  'STOP_DATETIME', highlow: 'high' },
+               { key: 'recordeddatetime', field: 'RECORDED_DATETIME', highlow: 'high' }
+              ]
+      times.each do |e|
+        date = entry.at_xpath("cda:participation[@typeCode='AUT']/cda:role/cda:id/cda:item[@extension = '#{e[:key]}']/../../../cda:time")
+        fields[e[:field]] = Range.new(date, 'IVL_PQ') if date
+      end
+
+      # Special case handle effectiveTime element , by default low is start datetime
+      # and high is stop datetime.  This changes for certain elements
+      template_ids = extract_template_ids(entry)
+      low = entry.at_xpath('./cda:effectiveTime/cda:low/..')
+      high = entry.at_xpath('./cda:effectiveTime/cda:high/..')
+
+      fields[low_field_name(template_ids)] = Range.new(low, 'IVL_PQ') if low
+
+      fields[high_field_name(template_ids)] = Range.new(high, 'IVL_PQ') if high
+    end
+
+    # Returns the proper name for the low field given the list of template ids
+    def self.low_field_name(template_ids)
+      if template_ids.include?('2.16.840.1.113883.10.20.28.3.51')
+        'ACTIVE_DATETIME'
+      elsif template_ids.include?('2.16.840.1.113883.10.20.28.3.110') ||
+            template_ids.include?('2.16.840.1.113883.10.20.28.3.116')
+        'ONSET_DATETIME'
+      else
+        'ADMISSION_DATETIME'
+      end
+    end
+
+    # Returns the proper name for the high field given the list of template ids
+    def self.high_field_name(template_ids)
+      if template_ids.include?('2.16.840.1.113883.10.20.28.3.13')
+        'REMOVAL_DATETIME'
+      elsif template_ids.include?('2.16.840.1.113883.10.20.28.3.110') ||
+            template_ids.include?('2.16.840.1.113883.10.20.28.3.116')
+        'ABATEMENT_DATETIME'
+      else
+        'DISCHARGE_DATETIME'
+      end
+    end
+
+    # If type code for this field value is LOC, handle specifics
+    def self.handle_loc(entry, fields)
+      loc = entry.at_xpath("./cda:participation[@typeCode='LOC']/cda:role[@classCode='SDLOC']",
+                           HQMF2::Document::NAMESPACES)
+      return unless loc
+      # does it have an effective time?
+      low = loc.at_xpath('./cda:effectiveTime/cda:low/..')
+      high = loc.at_xpath('./cda:effectiveTime/cda:high/..')
+      code = loc.at_xpath('./cda:code')
+      # looking at the 2.4.0 measure bundle these values are set to null if they exist
+      # so that is what I am doing for now
+      fields['FACILITY_LOCATION_ARRIVAL_DATETIME'] = AnyValue.new if low
+      fields['FACILITY_LOCATION_DEPARTURE_DATETIME'] = AnyValue.new if high
+      fields['FACILITY_LOCATION'] = Coded.new(code) if code
+    end
+
+    # Extract template ids from the given entry
+    def self.extract_template_ids(entry)
+      entry.xpath('./cda:templateId/cda:item', HQMF2::Document::NAMESPACES).collect do |template_def|
+        HQMF2::Utilities.attr_val(template_def, '@root')
+      end
+    end
+
+    # The "parse_"s after this point handle extraction of data criteria based on field names
+
+    def self.parse_act_criteria_fields(_entry, _fields)
+    end
+
+    def self.parse_substance_administration_fields(entry, fields)
+      parse_dset_cd(entry.at_xpath('./cda:methodCode', HQMF2::Document::NAMESPACES), 'METHOD', fields)
+      parse_dset_cd(entry.at_xpath('./cda:approachSiteCode', HQMF2::Document::NAMESPACES),
+                    'ANATOMICAL_APPROACH_SITE', fields)
+      parse_dset_cd(entry.at_xpath('./cda:targetSiteCode', HQMF2::Document::NAMESPACES),
+                    'ANATOMICAL_LOCATION_SITE', fields)
+      parse_cd(entry.at_xpath('./cda:routeCode', HQMF2::Document::NAMESPACES), 'ROUTE', fields)
+      parse_pq(entry.at_xpath('./cda:doseQuantity', HQMF2::Document::NAMESPACES), 'DOSE', fields)
+      parse_pq(entry.at_xpath('./cda:repeatNumber', HQMF2::Document::NAMESPACES), 'REFILLS', fields)
+    end
+
+    def self.parse_observation_fields(entry, fields)
+      parse_dset_cd(entry.at_xpath('./cda:methodCode', HQMF2::Document::NAMESPACES), 'METHOD', fields)
+      parse_dset_cd(entry.at_xpath('./cda:targetSiteCode', HQMF2::Document::NAMESPACES),
+                    'ANATOMICAL_LOCATION_SITE', fields)
+      parse_cd(entry.at_xpath("./cda:participation[@typeCode='SBJ']/cda:role[@classCode='PRS']/cda:code",
+                              HQMF2::Document::NAMESPACES),
+               'RELATIONSHIP', fields)
+      parse_pq(entry.at_xpath("./cda:outboundRelationship[@typeCode='REFV']/cda:observationCriteria/cda:value/cda:high",
+                              HQMF2::Document::NAMESPACES),
+               'REFERENCE_RANGE_HIGH', fields)
+      parse_pq(entry.at_xpath("./cda:outboundRelationship[@typeCode='REFV']/cda:observationCriteria/cda:value/cda:low",
+                              HQMF2::Document::NAMESPACES),
+               'REFERENCE_RANGE_LOW', fields)
+    end
+
+    # Ignoring line limits here as it would be hard to create the deep xPaths with these limits.
+    # rubocop:disable Metrics/LineLength
+    def self.parse_encounter_fields(entry, fields)
+      # Added a check for Principal Diagnosis and Diagnosis. QDM 4.2 Update
+      principal = entry.at_xpath("./cda:outboundRelationship[@typeCode='REFR']/cda:actCriteria/cda:code[@code='52534-5']",
+                                 HQMF2::Document::NAMESPACES)
+      if principal
+        parse_cd(
+          entry.at_xpath(
+            "./cda:outboundRelationship[@typeCode='REFR']/cda:actCriteria/cda:outboundRelationship[@typeCode='SUBJ']/cda:observationCriteria/cda:value",
+            HQMF2::Document::NAMESPACES
+          ), 'PRINCIPAL_DIAGNOSIS', fields)
+      end
+
+      diagnosis = entry.at_xpath("./cda:outboundRelationship[@typeCode='REFR']/cda:actCriteria/cda:code[@code='29308-4']",
+                                 HQMF2::Document::NAMESPACES)
+      if diagnosis
+        parse_cd(
+          entry.at_xpath(
+            "./cda:outboundRelationship[@typeCode='REFR']/cda:actCriteria/cda:outboundRelationship[@typeCode='SUBJ']/cda:observationCriteria/cda:value",
+            HQMF2::Document::NAMESPACES
+          ), 'DIAGNOSIS', fields)
+      end
+
+      parse_pq(entry.at_xpath('./cda:lengthOfStayQuantity', HQMF2::Document::NAMESPACES), 'LENGTH_OF_STAY', fields)
+      parse_cd(entry.at_xpath('./cda:dischargeDispositionCode', HQMF2::Document::NAMESPACES), 'DISCHARGE_STATUS', fields)
+
+      handle_loc(entry, fields)
+    end
+
+    # rubocop:enable Metrics/LineLength
+
+    def self.parse_procedure_fields(entry, fields)
+      parse_dset_cd(entry.at_xpath('./cda:methodCode', HQMF2::Document::NAMESPACES), 'METHOD', fields)
+      parse_dset_cd(entry.at_xpath('./cda:approachSiteCode', HQMF2::Document::NAMESPACES),
+                    'ANATOMICAL_APPROACH_SITE', fields)
+      parse_dset_cd(entry.at_xpath('./cda:targetSiteCode', HQMF2::Document::NAMESPACES),
+                    'ANATOMICAL_LOCATION_SITE', fields)
+    end
+
+    def self.parse_supply_fields(_entry, _fields)
+    end
+
+    def self.parse_grouper_fields(_entry, _fields)
+    end
+  end
+end