hqmf-parser 1.0.0

data/lib/hqmf-parser/converter/pass1/document_converter.rb

@@ -0,0 +1,183 @@
+module HQMF
+  # Class for converting an HQMF 1.0 representation to an HQMF 2.0 representation
+  class DocumentConverter
+   
+    BIRTHTIME_CODE_LIST = {'LOINC'=>['21112-8']}
+    
+    def self.convert(json, codes)
+      
+      title = json[:title]
+      description = json[:description]
+      
+      metadata = json[:metadata]
+      metadata.keys.each {|key| metadata[key.to_s] = metadata[key]; metadata.delete(key.to_sym)}
+      
+      id = metadata["NQF_ID_NUMBER"][:value] if metadata["NQF_ID_NUMBER"]
+      attributes = parse_attributes(metadata)
+      hqmf_id = json[:hqmf_id]
+      hqmf_set_id = json[:hqmf_set_id]
+      hqmf_version_number = json[:hqmf_version_number]
+      
+      measure_period = parse_measure_period(json)
+      @data_criteria_converter = DataCriteriaConverter.new(json, measure_period)
+      
+      # source data criteria are the original unmodified v2 data criteria
+      source_data_criteria = []
+      @data_criteria_converter.v2_data_criteria.each {|criteria| source_data_criteria << criteria}
+      
+      # PASS 1
+      @population_criteria_converter = PopulationCriteriaConverter.new(json, @data_criteria_converter)
+      population_criteria = @population_criteria_converter.population_criteria
+      
+      # PASS 2
+      comparison_converter = HQMF::ComparisonConverter.new(@data_criteria_converter)
+      comparison_converter.convert_comparisons(population_criteria)
+
+      # PASS 3
+      # specific_occurrence_converter = HQMF::SpecificOccurrenceConverter.new(@data_criteria_converter)
+      # specific_occurrence_converter.convert_specific_occurrences(population_criteria)
+
+      data_criteria = @data_criteria_converter.final_v2_data_criteria
+      
+      populations = @population_criteria_converter.sub_measures
+      
+      doc = HQMF::Document.new(id, hqmf_id, hqmf_set_id, hqmf_version_number, title, description, population_criteria, data_criteria, source_data_criteria, attributes, measure_period, populations)
+       
+      backfill_patient_characteristics_with_codes(doc, codes)
+      
+      HQMF::DocumentConverter.validate(doc, codes)
+      
+      doc
+      
+    end
+   
+    private
+    
+    def self.parse_attributes(metadata)
+      attributes = []
+      metadata.keys.each do |key|
+        attribute_hash = metadata[key]
+        code = attribute_hash[:code]
+        value = attribute_hash[:value]
+        unit = attribute_hash[:unit]
+        name = attribute_hash[:name]
+        attributes << HQMF::Attribute.new(key,code,value,unit,name)
+      end
+      attributes
+    end
+    
+
+    # patient characteristics data criteria such as GENDER require looking at the codes to determine if the 
+    # measure is interested in Males or Females.  This process is awkward, and thus is done as a separate
+    # step after the document has been converted.
+    def self.backfill_patient_characteristics_with_codes(doc, codes)
+      
+      [].concat(doc.all_data_criteria).concat(doc.source_data_criteria).each do |data_criteria|
+        if (data_criteria.type == :characteristic and !data_criteria.property.nil?)
+          if (codes)
+            value_set = codes[data_criteria.code_list_id]
+            puts "\tno value set for unknown patient characteristic: #{data_criteria.id}" unless value_set
+          else
+            puts "\tno code set to back fill: #{data_criteria.title}"
+            next
+          end
+          
+          if (data_criteria.property == :gender)
+            key = value_set.keys[0]
+            data_criteria.value = HQMF::Coded.new('CD','Administrative Sex',value_set[key].first)
+          else
+            data_criteria.inline_code_list = value_set
+          end
+          
+        elsif (data_criteria.type == :characteristic)
+          if (codes)
+            value_set = codes[data_criteria.code_list_id]
+            if (value_set)
+              # this is looking for a birthdate characteristic that is set as a generic characteristic but points to a loinc code set
+              if (value_set['LOINC'] and value_set['LOINC'].first == '21112-8')
+                data_criteria.definition = 'patient_characteristic_birthdate'
+              end
+              # this is looking for a gender characteristic that is set as a generic characteristic
+              gender_key = (value_set.keys.select {|set| set.start_with? 'HL7'}).first
+              if (gender_key and ['M','F'].include? value_set[gender_key].first) 
+                data_criteria.definition = 'patient_characteristic_gender'
+                data_criteria.value = HQMF::Coded.new('CD','Gender',value_set[gender_key].first)
+              end
+            end
+          end
+
+        end
+      end
+    end
+    
+
+    def self.parse_measure_period(json)
+      
+      # Create a new HQMF::EffectiveTime
+      # @param [Value] low
+      # @param [Value] high
+      # @param [Value] width
+      # ----------
+      # Create a new HQMF::Value
+      # @param [String] type
+      # @param [String] unit
+      # @param [String] value
+      # @param [String] inclusive
+      # @param [String] derived
+      # @param [String] expression
+      
+      low = HQMF::Value.new('TS',nil,'20100101',nil, nil, nil)
+      high = HQMF::Value.new('TS',nil,'20110101',nil, nil, nil)
+      width = HQMF::Value.new('PQ','a','1',nil, nil, nil)
+      
+#      puts ('need to figure out a way to make dates dynamic')
+      
+      HQMF::EffectiveTime.new(low,high,width)
+    end
+    
+    def self.validate(document,codes)
+      puts "\t(#{document.id})document is nil!!!!!!!!!!!" unless document
+      puts "\t(#{document.id})codes are nil!!!!!!!!!!!" unless codes
+      return unless document and codes
+      
+      referenced_oids = document.all_data_criteria.map(&:code_list_id).compact.uniq
+      
+      referenced_oids.each do |oid|
+        value_set = codes[oid]
+        puts "\tDC (#{document.id},#{document.title}): referenced OID could not be found #{oid}" unless value_set
+      end
+      
+      oid_values = document.all_data_criteria.select {|dc| dc.value != nil and dc.value.type == 'CD'}
+      
+      if oid_values.size > 0
+        referenced_oids = (oid_values.map {|dc| dc.value.code_list_id }).compact.uniq
+        referenced_oids.each do |oid|
+          value_set = codes[oid]
+          puts "\tVALUE (#{document.id},#{document.title}): referenced OID could not be found #{oid}" unless value_set
+        end
+      end
+      
+      
+      oid_negation = document.all_data_criteria.select {|dc| dc.negation_code_list_id != nil}
+      if oid_negation.size > 0
+        referenced_oids = (oid_negation.map {|dc| dc.negation_code_list_id}).compact.uniq
+        referenced_oids.each do |oid|
+          value_set = codes[oid]
+          puts "\tNEGATION (#{document.id},#{document.title}): referenced OID could not be found #{oid}" unless value_set
+        end
+      end
+        
+      oid_fields = document.all_data_criteria.select {|dc| dc.field_values != nil}
+      if oid_fields.size > 0
+        referenced_oids = (oid_fields.map{|dc| dc.field_values.map {|key,field| puts "field: #{key} is nil" unless field; field.code_list_id if field != nil and field.type == 'CD'}}).flatten.compact.uniq
+        referenced_oids.each do |oid|
+          value_set = codes[oid]
+          puts "\tFIELDS (#{document.id},#{document.title}): referenced OID could not be found #{oid}" unless value_set
+        end
+      end
+      
+    end
+
+   
+  end  
+end

data/lib/hqmf-parser/converter/pass1/population_criteria_converter.rb

@@ -0,0 +1,135 @@
+module HQMF
+  # Class for converting an HQMF 1.0 representation to an HQMF 2.0 representation
+  class PopulationCriteriaConverter
+    
+    attr_reader :sub_measures
+    
+    def initialize(doc, data_criteria_converter)
+      @doc = doc
+      @data_criteria_converter = data_criteria_converter
+      @population_criteria_by_id = {}
+      @population_criteria_by_key = {}
+      @population_reference = {}
+      parse()
+      build_sub_measures()
+    end
+    
+    def population_criteria
+      @population_criteria_by_key.values
+    end
+    
+    private 
+    
+    def build_sub_measures()
+      @sub_measures = []
+      ipps = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::IPP}
+      denoms = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::DENOM}
+      nums = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::NUMER}
+      excls = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::DENEX}
+      denexcs = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::EXCEP}
+      
+      if (ipps.size<=1 and denoms.size<=1 and nums.size<=1 and excls.size<=1 and denexcs.size<=1 )
+        @sub_measures << 
+          {
+            HQMF::PopulationCriteria::IPP => HQMF::PopulationCriteria::IPP,
+            HQMF::PopulationCriteria::DENOM => HQMF::PopulationCriteria::DENOM,
+            HQMF::PopulationCriteria::NUMER => HQMF::PopulationCriteria::NUMER,
+            HQMF::PopulationCriteria::EXCEP => HQMF::PopulationCriteria::EXCEP,
+            HQMF::PopulationCriteria::DENEX => HQMF::PopulationCriteria::DENEX
+          }
+      else
+
+        nums.each do |num_id, num|
+          @sub_measures << {HQMF::PopulationCriteria::NUMER => num.id}
+        end
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::DENOM, denoms.values)
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::IPP, ipps.values)
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::DENEX, excls.values)
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::EXCEP, denexcs.values)
+        
+        keep = []
+        @sub_measures.each do |sub|
+          
+          value = sub
+          HQMF::PopulationCriteria::ALL_POPULATION_CODES.each do |type|
+            key = sub[type]
+            if (key)
+              reference_id = @population_reference[key]
+              reference = @population_criteria_by_id[reference_id] if reference_id
+              if (reference)
+                criteria = @population_criteria_by_key[sub[reference.type]]
+                value['stratification'] = criteria.stratification_id if criteria.stratification_id
+                value = nil if (sub[reference.type] != reference.id and criteria.stratification_id.nil?)
+              end
+            end
+          end
+          keep << value if (value)
+        end
+        
+        keep.each_with_index do |sub, i|
+          sub['title'] = "Population #{i+1}"
+          sub['id'] = "Population#{i+1}"
+        end
+        
+        @sub_measures = keep
+        
+      end
+    end
+    
+    def apply_to_submeasures(subs, type, values)
+      new_subs = []
+      subs.each do |sub|
+        values.each do |value|
+          if (sub[type] and sub[type] != value.id)
+            tmp = {}
+            HQMF::PopulationCriteria::ALL_POPULATION_CODES.each do |key|
+              tmp[key] = sub[key] if sub[key]
+            end
+            sub = tmp
+            new_subs << sub
+          end
+          sub[type] = value.id
+        end
+      end
+      subs.concat(new_subs)
+    end
+    
+    def find_sub_measures(type, value)
+      found = []
+      @sub_measures.each do |sub_measure|
+        found << sub_measure if sub_measure[type] and sub_measure[type] == value.id
+      end
+      found
+    end
+
+    def parse()
+      @doc[:logic].each do |key,criteria|
+        @population_criteria_by_key[key] = convert(key.to_s, criteria)
+      end
+    end
+   
+    def convert(key, population_criteria)
+      
+      # @param [String] id
+      # @param [Array#Precondition] preconditions 
+      
+      preconditions = HQMF::PreconditionConverter.parse_preconditions(population_criteria[:preconditions],@data_criteria_converter) 
+      hqmf_id = population_criteria[:hqmf_id] || population_criteria[:id]
+      id = population_criteria[:id]
+      type = population_criteria[:code]
+      reference = population_criteria[:reference]
+      title = population_criteria[:title]
+      
+      criteria = HQMF::Converter::SimplePopulationCriteria.new(key, hqmf_id, type, preconditions, title)
+      # mark the 2.0 simple population criteria as a stratification... this allows us to create the cartesian product for this in the populations
+      criteria.stratification_id = population_criteria[:stratification_id]
+      
+      @population_criteria_by_id[id] = criteria
+      @population_reference[key] = reference
+      
+      criteria
+     
+    end
+   
+  end  
+end

data/lib/hqmf-parser/converter/pass1/precondition_converter.rb

@@ -0,0 +1,164 @@
+module HQMF
+  # Class for converting an HQMF 1.0 representation to an HQMF 2.0 representation
+  class PreconditionConverter
+    
+    def self.parse_preconditions(source,data_criteria_converter)
+
+      # preconditions = []
+      # source.each do |precondition|
+      #   preconditions << HQMF::PreconditionConverter.parse_precondition(precondition,data_criteria_converter)
+      # end
+      # 
+      # preconditions
+      
+      parse_and_merge_preconditions(source,data_criteria_converter)
+    end
+   
+    # converts a precondtion to a hqmf model
+    def self.parse_precondition(precondition,data_criteria_converter)
+      
+      # grab child preconditions, and parse recursively
+      preconditions = parse_and_merge_preconditions(precondition[:preconditions],data_criteria_converter) if precondition[:preconditions] || []
+      
+      preconditions_from_restrictions = HQMF::PreconditionExtractor.extract_preconditions_from_restrictions(precondition[:restrictions], data_criteria_converter)
+      
+      # driv preconditions are preconditions that are the children of an expression
+      driv_preconditions = []
+      preconditions_from_restrictions.delete_if {|element| driv_preconditions << element if element.is_a? HQMF::Converter::SimpleRestriction and element.operator.type == 'DRIV'}
+      
+      apply_restrictions_to_comparisons(preconditions, preconditions_from_restrictions) unless preconditions_from_restrictions.empty?
+
+      conjunction_code = convert_logical_conjunction(precondition[:conjunction])
+
+      if (precondition[:expression])
+        # this is for things like COUNT
+        type = precondition[:expression][:type]
+        operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, HQMF::Converter::SimpleOperator.parse_value(precondition[:expression][:value]))
+        children = []
+        if driv_preconditions and !driv_preconditions.empty?
+          children = driv_preconditions.map(&:preconditions).flatten
+        end
+        
+        reference = nil
+        # take the conjunction code from the parent precondition
+        
+        restriction = HQMF::Converter::SimpleRestriction.new(operator, nil, children)
+        
+        comparison_precondition = HQMF::Converter::SimplePrecondition.new(nil,[restriction],reference,conjunction_code, false)
+        comparison_precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+        comparison_precondition.subset_comparison = true
+        preconditions << comparison_precondition
+      end
+      
+      reference = nil
+      
+      negation = precondition[:negation]
+      
+      
+      if (precondition[:comparison])
+        preconditions ||= []
+        comparison_precondition = HQMF::PreconditionExtractor.convert_comparison_to_precondition(precondition[:comparison],data_criteria_converter)
+        preconditions << comparison_precondition
+      end
+
+
+      if (precondition[:subset])
+        # this is for things like FIRST on preconditions
+        type = precondition[:subset]
+        operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, nil)
+        children = preconditions
+        
+        reference = nil
+        # take the conjunction code from the parent precondition
+        
+        restriction = HQMF::Converter::SimpleRestriction.new(operator, nil, children)
+        
+        comparison_precondition = HQMF::Converter::SimplePrecondition.new(nil,[restriction],reference,conjunction_code, false)
+        comparison_precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+        preconditions = [comparison_precondition]
+      end
+
+      
+      HQMF::Converter::SimplePrecondition.new(nil,preconditions,reference,conjunction_code, negation)
+      
+    end
+
+    def self.get_comparison_preconditions(preconditions)
+      comparisons = []
+      preconditions.each do |precondition|
+        if (precondition.comparison? and !precondition.subset_comparison)
+          comparisons << precondition
+        elsif(precondition.has_preconditions?)
+          comparisons.concat(get_comparison_preconditions(precondition.preconditions))
+        else
+          raise "precondition with no comparison or children... not valid"
+        end
+      end
+      comparisons
+    end
+
+    def self.apply_restrictions_to_comparisons(preconditions, restrictions)
+      comparisons = get_comparison_preconditions(preconditions)
+      raise "no comparisons to apply restriction to" if comparisons.empty?
+      comparisons.each do |comparison|
+        comparison.preconditions.concat(restrictions)
+      end
+    end
+    
+    private 
+    
+    
+    def self.parse_and_merge_preconditions(source,data_criteria_converter)
+      return [] unless source and source.size > 0
+      preconditions_by_conjunction = {}
+      source.each do |precondition|
+        parsed = HQMF::PreconditionConverter.parse_precondition(precondition,data_criteria_converter)
+        preconditions_by_conjunction[parsed.conjunction_code] ||= []
+        preconditions_by_conjunction[parsed.conjunction_code]  << parsed
+      end
+      
+      merge_precondtion_conjunction_groups(preconditions_by_conjunction)
+    end
+    
+    def self.merge_precondtion_conjunction_groups(preconditions_by_conjunction)
+      joined = []
+      preconditions_by_conjunction.each do |conjunction_code, preconditions|
+        sub_conditions = []
+        negated_conditions = []
+        preconditions.each do |precondition|
+          unless (precondition.negation)
+            sub_conditions.concat precondition.preconditions if precondition.preconditions
+          else
+            negated_conditions.concat precondition.preconditions if precondition.preconditions
+          end
+        end
+        
+        if (!sub_conditions.empty?)
+          # if we have negated conditions, add them to a new precondition of the same conjunction that is negated
+          if (!negated_conditions.empty?)
+            sub_conditions << HQMF::Converter::SimplePrecondition.new(nil,negated_conditions,nil,conjunction_code, true)
+          end
+          joined << HQMF::Converter::SimplePrecondition.new(nil,sub_conditions,nil,conjunction_code, false)
+        elsif (!negated_conditions.empty?)
+          joined << HQMF::Converter::SimplePrecondition.new(nil,negated_conditions,nil,conjunction_code, true)
+        end
+        
+      end
+      joined
+    end
+    
+    def self.convert_logical_conjunction(code)
+      case code
+        when 'OR'
+          HQMF::Precondition::AT_LEAST_ONE_TRUE
+        when 'AND'
+          HQMF::Precondition::ALL_TRUE
+        else
+          raise "unsupported logical conjunction code conversion: #{code}"
+      end
+      
+    end
+    
+   
+  end  
+end